Classify Edge launch targets for runtime denial probes

Context

Parent #17533 owns the second blocking AgentOS extraction proof. Its runtime-denial half must execute every eligible Host-Edge launch target while refusing Cloud packages, but it must not blind-import an entrypoint that starts work, exits, or waits forever merely because static custody says edge.

Vega explicitly separated this H2 receipt from his composition lane: registry-owned runtime-probe eligibility is claimable; the isolated fixture and final instrumentErrors/topologyFindings composer remain with #17533's owner.

Live source at origin/dev@6f0b6619c8 corrects the count in that handoff. collectScriptModules() currently derives 74 unique launch targets; joining them to the reconciled #17525 registry yields 45 Edge targets, not the earlier 38-target snapshot. The population must therefore stay derived rather than become another count authority.

The current registry also groups 95 script-module identities under one Edge custody override. A group-level eligibility flag would silently classify 50 modules that are not in the runtime-probe population. Eligibility needs its own identity-scoped authority.

Structure evidence: the full npm run --silent ai:structure-map -- --files --loc succeeds at the current head. The owning siblings are ai/scripts/diagnostics/agentOsExtractionInventory.{mjs,json} and test/playwright/unit/ai/scripts/diagnostics/agentOsExtractionInventory.spec.mjs; this ticket introduces no new .mjs placement.

The Problem

The existing runtime denial instrument proves real package resolution by importing an explicit target in a child process under module.register() denial. That is correct for a known import-safe target such as ai/services.host.mjs. It is unsafe as a blanket loop over executable scripts:

• a module may run its CLI at top level rather than behind an entrypoint guard;
• import may schedule eager singleton lifecycle work;
• the module may call process.exit(), spawn a daemon, acquire a lock, or wait on external state;
• an arbitrary non-zero exit can then masquerade as Cloud-package denial unless the composer already knows the target is eligible.

Static closure already recognizes this repository's import-safe guard while walking module facts, but guard syntax alone is not the runtime-probe contract. A guarded module can still import eager services, and an unguarded module may be a pure declarative entrypoint. The judgment must be explicit, source-owned, and drift-checked.

Today the inventory records custody but has no authority saying which derived Edge launch targets may be eagerly evaluated by proof 2. The only alternatives are silent omission or blind execution; both make AC-5 vacuous.

The Architectural Reality

• agentOsExtractionInventory.json is the #17525 custody authority; this child extends it rather than creating a second registry.
• collectScriptModules() already returns the exact launch-root identities and the derived script-module population.
• Preliminary reconciliation already joins each module to its explicit Edge/Cloud/shared custody before root/workflow/subprocess suggestions are built.
• Eligibility is a second axis over only the unique Edge launch-target population. It does not change disposition.
• #17533's final runtime composer consumes the eligibility result; this child does not run the denial proof or decide its controls.
• The existing inventory spec owns missing/stale/duplicate/same-count mutation resistance and remains the correct test home.

The Fix

Extend the existing inventory and registry in place:

1. Add a dedicated identity-scoped runtimeProbeEligibility authority to agentOsExtractionInventory.json. Each entry names exactly one script-module identity, eligible or ineligible, a non-empty source anchor, and a specific reason.
2. Derive the governed population from unique launchRoots[].rel identities whose reconciled script-module disposition is edge. Never hard-code the current count.
3. Reconcile eligibility bidirectionally against that derived set. Missing, stale, duplicate, invalid-status, missing-source, and missing-reason entries are distinct errors. An eligibility row for an Edge module that is not a launch target is stale, not extra coverage.
4. Attach the accepted eligibility and reason to the corresponding machine-readable script row (or a deterministic sibling receipt section) without altering custody/disposition.
5. Emit total/eligible/ineligible counts plus exact identities in deterministic JSON/human output so #17533 can consume the authority without rereading the raw registry.
6. Add mutation arms for a newly added Edge launch target, a removed target, duplicate identity, invalid status, and a same-count identity substitution.
7. Preserve import safety: this child performs static/registry reconciliation only. It must not import or execute candidate scripts while classifying them.

Contract Ledger Matrix

Decision Record impact

Depends on ADR 0040 / PR #17624 and ADR 0039's paired static/runtime evidence contract. It does not amend either record.

Decision Record

Not needed. This is one evidence leaf under the topology and proof contracts already recorded by #17502 and #17533.

Discussion Criteria Mapping

Acceptance Criteria

• The governed population is derived from unique current launch targets whose reconciled script-module custody is Edge; no literal target count is an authority.
• Every governed identity has exactly one explicit eligible or ineligible registry judgment with a source anchor and specific reason; no status is inferred from filename or guard syntax.
• Eligibility for non-launch-target modules is rejected as stale authority, even when those modules are Edge-owned.
• Missing, stale, duplicate, invalid-status, missing-source, and missing-reason rows RED independently with the exact identity.
• Adding a new Edge launch target and replacing one target with another at the same total both RED until the registry is updated.
• The deterministic receipt exposes exact eligibility identities/reasons and eligible/ineligible totals without changing custody disposition.
• The implementation does not import or execute candidate scripts and introduces no parallel registry or probe implementation.
• The focused inventory unit spec and the current-tree exhaustive receipt pass; the resulting receipt is linked on #17533 for the runtime composer.

Out of Scope

• H1 manifest-authority promotion for outside-tree launch roots and package dependencies;
• building the isolated Edge-root / nested-Cloud fixture;
• executing the runtime denial hook or interpreting denial controls;
• composing instrumentErrors / topologyFindings or naming successor blockers;
• moving files, changing package topology, or authorizing relocation;
• changing any script solely to make it probe-eligible.

Avoided Traps

• Group-level flag on the 95 Edge modules: over-classifies modules outside the launch-target population.
• Hard-coded 38/45 count: converts a measured snapshot into a second authority.
• Guard-syntax inference: confuses one static pattern with eager-evaluation safety.
• Blind import to discover safety: executes the risk the registry exists to prevent.
• eligible by default: makes new launch targets invisible to the proof gate.
• Fold into #17533's composer: re-couples a clean authority receipt to fixture/runtime implementation and blocks parallel progress.

Related

Parent: #17533. Proof 1 / registry owner: #17525 / PR #17530. Decision record: #17502 / PR #17624. Epic: #17500.

Origin Session ID: 01a02ead-f0db-7b30-b4e2-54189808ab54

Retrieval Hint: AgentOS runtime probe eligibility Edge launch targets blind import #17533 H2