@open-agent-toolkit/cli 0.2.77 → 0.3.0

package/assets/skills/oat-review-receive-remote/SKILL.md

@@ -5,7 +5,7 @@ disable-model-invocation: true
 user-invocable: true
 allowed-tools: Read, Write, Bash, Glob, Grep, AskUserQuestion
 metadata:
-  version: 1.3.1
+  version: 1.3.2
 ---
 
 # Remote Review Receive (Ad-hoc GitHub PR)
@@ -71,8 +71,8 @@ Normalize every finding to this shape:
 
 ```yaml
 finding:
-  id: "C1" | "I1" | "M1" | "m1"
-  severity: critical | important | medium | minor
+  id: "C1" | "H1" | "M1" | "L1"
+  severity: critical | high | medium | low
   title: string
   file: string | null
   line: number | null
@@ -86,9 +86,9 @@ finding:
 Severity conventions:
 
 - `critical`: Broken behavior, security risk, or missing P0 requirement.
-- `important`: Missing P1 requirement, major robustness issue.
+- `high`: Missing P1 requirement, major robustness issue.
 - `medium`: Meaningful but non-blocking quality/maintainability issue.
-- `minor`: Cosmetic/style/documentation issue.
+- `low`: Cosmetic/style/documentation issue.
 
 ## Process
 
@@ -126,16 +126,16 @@ For each item in JSON:
 
 - Capture `type` (`review_comment`, `issue_comment`, `review`).
 - Map location fields (`path`, `line`) when present.
-- Use comment body + context to assign severity (`critical`, `important`, `medium`, `minor`).
-- Treat `CHANGES_REQUESTED` review state as a strong hint toward `important+`, not an automatic override.
+- Use comment body + context to assign severity (`critical`, `high`, `medium`, `low`).
+- Treat `CHANGES_REQUESTED` review state as a strong hint toward `high+`, not an automatic override.
 - Normalize into the shared findings model.
 
 ID assignment per severity bucket:
 
 - Critical: `C1`, `C2`, ...
-- Important: `I1`, `I2`, ...
+- High: `H1`, `H2`, ...
 - Medium: `M1`, `M2`, ...
-- Minor: `m1`, `m2`, ...
+- Low: `L1`, `L2`, ...
 
 ### Step 4: Present Findings Overview and Triage
 
@@ -146,21 +146,21 @@ Before triage prompts, output:
 
 Disposition options per finding:
 
-- `convert` (default for critical/important/medium/minor)
+- `convert` (default for critical/high/medium/low)
 - `defer`
 - `dismiss`
 
 Rules:
 
-- Require concrete rationale for `defer`/`dismiss` at any severity, including minor. Small findings are usually cheaper to fix inline than to track as backlog items, so a minor `defer` must be justified just like any other deferral.
-- For any deferral (minor included), require a concrete reason (duplicate, dependency, explicit out-of-scope follow-up, risky churn).
+- Require concrete rationale for `defer`/`dismiss` at any severity, including low. Small findings are usually cheaper to fix inline than to track as backlog items, so a low `defer` must be justified just like any other deferral.
+- For any deferral (low included), require a concrete reason (duplicate, dependency, explicit out-of-scope follow-up, risky churn).
 
 ### Step 5: Generate Standalone Task List
 
 Task entry format:
 
 ```markdown
-- [ ] [important] Add null-guard in OAuth callback parser (`packages/auth/src/callback.ts:142`) - Validate provider payload before dereference.
+- [ ] [high] Add null-guard in OAuth callback parser (`packages/auth/src/callback.ts:142`) - Validate provider payload before dereference.
 ```
 
 Output modes:

package/assets/skills/oat-wave-execute/SKILL.md

@@ -6,7 +6,7 @@ disable-model-invocation: false
 user-invocable: true
 allowed-tools: Read, Write, Edit, Bash, Grep, Glob, Task
 metadata:
-  version: 1.9.4
+  version: 1.9.5
 ---
 
 # Execute a Wave of External Plans
@@ -181,7 +181,7 @@ excluded from groups) — never mid-run. **Reconciliation contract:** when recon
 reveals a stale plan premise, the reconciliation must be NON-NARROWING (WHERE
 the work happens may change; WHAT must be true may not), recorded exactly once
 in the Drift Refresh Record with pointer-only references elsewhere — a
-reconciliation that waives a source-plan requirement is a plan-gate Important
+reconciliation that waives a source-plan requirement is a plan-gate High
 (wave-4 evidence).
 
 Recon is delegated; the Drift Refresh Record entries and any reconciliation

package/assets/skills/recon/SKILL.md

@@ -6,7 +6,7 @@ disable-model-invocation: true
 user-invocable: true
 allowed-tools: Read, Write, Glob, Grep, Bash, AskUserQuestion, Agent, mcp__*
 metadata:
-  version: 1.1.3
+  version: 1.1.5
 ---
 
 # Recon
@@ -127,8 +127,8 @@ Use the complete mode policy from `references/profiles.md` and
 `scripts/lib/routing.mjs`. Map manifest wave modes to the worker's closed
 assignment vocabulary: `redundant-gather` to `gather`;
 `semantic-verification` and `redundant-verification` to `verify`; `adversarial`
-and `contradiction-resolution` to `adversary`; and only `reconciliation` to
-`reconcile`. The remaining modes keep their same-named assignment. All lanes
+and `contradiction-resolution` to `adversary`. The remaining worker modes keep
+their same-named assignment; reconciliation is controller-owned. All lanes
 within one launch are a homogeneous wave. Select each wave independently; a
 stronger wave never raises unrelated waves' targets or effort.
 
@@ -164,9 +164,14 @@ task class and class floor. Preserve provider, route, role, model, effort,
 reasoning mode, and service tier as separate provider-native axes. A null axis
 means the adapter exposes no independently requested control; never translate
 effort between harnesses or normalize an opaque selector. Prefer the canonical
-`recon-worker` role. If that role is unavailable, plan the generic role with the
-complete worker contract as a visible generic role fallback before approval. A
-fallback after approval is forbidden.
+`recon-worker` role only when the current live Task catalog exposes it. A
+materialized `.cursor/agents/recon-worker.md` file proves installation, not that
+the current Cursor Task catalog can launch the role. If the role is absent from
+that observed catalog, plan the generic role with the complete worker contract
+as a visible generic role fallback before approval. A fallback after approval
+is forbidden. Every Cursor recon leaf, including that generic fallback, must be
+launched as a background task so a new parent-chat message cannot turn parent
+turn interruption into an apparent worker crash.
 
 Prepare a `schemaVersion: 2` draft manifest. Its execution object contains a
 complete inherited `target`, limits, waves, conditions, and later the approval.
@@ -218,7 +223,8 @@ result. If any approved axis cannot be satisfied, stop with a
 launch nothing. Never substitute a different axis to make the launch fit.
 
 Launch each wave through the dispatch dependency with exactly the approved
-axes. Immediately before each launch, check the constructed target through the
+axes. On Cursor, launch both the custom worker role and the pre-approved generic
+fallback in the background. Immediately before each launch, check the constructed target through the
 same production helper used by preview:
 
 ```bash
@@ -235,13 +241,22 @@ approved `waveId` and `laneId`. This structured identity is required for
 conditional and non-conditional lanes alike; prose is descriptive, not
 identity.
 
+Worker completion is decided from the approved-path artifact before interpreting
+a later provider transport error. When the artifact's identity, closed schema,
+bytes, and digest validate, the lane is complete; a subsequent stream-close or
+RPC error is recorded as a non-material diagnostic and never triggers a
+replacement launch. Missing or invalid output remains a terminal `PASS_FAILED`
+outcome with no retry or replacement.
+
 Run the passes in this order:
 
 1. `map` and `gather` workers write unique dossiers under `raw/dossiers/`.
    Thorough runs complete their independent `redundant-gather` wave here too.
 2. `compile` writes a candidate canonical claim ledger. A thorough candidate
    directly references a complete dossier from every approved primary and
-   redundant gather lane before any review brief is created.
+   redundant gather lane before any review brief is created. Every display
+   excerpt is an exact contiguous substring of its cited source, apart from the
+   declared `redacted-exact` representation; paraphrase is invalid evidence.
 3. Source preflight: run `scripts/validate-artifact.mjs` on the candidate
    manifest and ledger, then reopen every declared source and evidence locator
    with the checks in `scripts/validate-packet.mjs`. Resolve source roots to
@@ -251,23 +266,26 @@ Run the passes in this order:
    manifest and ledger pair validates.
 4. Profile-required `verify`, `adversary`, and `coverage` workers consume only
    immutable selectively blind briefs created by
-   `scripts/create-review-brief.mjs` at unique paths.
+   `scripts/create-review-brief.mjs` at unique paths. Each review-producing
+   wave has exactly one lane; partition source or question fan-out in the
+   applicable gather wave instead.
 5. Evaluate each predeclared evidence condition only after its completed
    predecessor artifacts exist. Record exactly one root-authored condition
    outcome. A triggered `contradiction-resolution` wave runs once as an
    `adversary` evidence assignment; a not-triggered or unresolved wave supplies
    no artifact. Accepted failure, cancellation, timeout, or missing output never
    authorizes replacement work.
-6. Standard and thorough execute exactly one terminal `reconciliation` wave,
-   mapped to `reconcile`, after required review evidence and any triggered
-   contradiction investigation. It writes a new candidate ledger without
-   mutating the prior ledger.
-
-If `reconciliation-needs-judgment` is foreseeable, select an adequate target
-for that one terminal wave before approval. If it appears after approval and
-the approved target is inadequate, preserve completed evidence and return an
-explicit unresolved, out-of-envelope gap for renewed approval or a new run.
-Never mutate the target, launch a second reconciliation, or substitute a
+6. Standard and thorough run one deterministic controller reconciliation after
+   required review evidence and any triggered contradiction investigation. The
+   controller invokes `scripts/reconcile-ledger.mjs` once using the manifest's
+   `execution.reconciliation` paths and literal producer
+   `controller:reconcile-ledger-v1`, validates both candidate outputs, copies
+   the exact ledger bytes to a packet-contained temporary file, and atomically
+   renames it to `claims.json`. No reconciliation worker is dispatched.
+
+If reconciliation requires new semantic judgment, preserve completed evidence
+and return an explicit unresolved caller-owned gap. Never mutate the target or
+substitute a
 contradiction search for synthesis.
 
 Use `references/worker-contract.md` for every assignment. Never allow two

package/assets/skills/recon/references/packet-contract.md

@@ -125,18 +125,21 @@ condition contains `conditionId`, `destinationWaveId`, `afterWaveIds`, one of
 `insufficient-evidence` or `unresolved-material-challenge`, and
 `maxActivations: 1`. Each conditional destination is a uniquely identified
 `contradiction-resolution` evidence wave, has exactly one condition, appears
-after every named predecessor and before the one terminal reconciliation, and
+after every named predecessor and before controller reconciliation, and
 owns unique lane IDs and write roots. Conversely, every wave marked
 `conditional: true` must be the destination of exactly one activating condition;
 dead conditional waves are invalid. Quick permits no conditional wave;
-standard permits one and thorough two. The profile's 4/10/20 adaptive-lane cap
+standard and thorough each permit one. The profile's 4/10/20 evidence-lane cap
 counts `gather`, `semantic-verification`, `adversarial`, `coverage`,
 `redundant-gather`, `redundant-verification`, and
 `contradiction-resolution` when those modes are permitted by the profile.
-Every permitted mode outside that counted set is fixed at exactly one lane:
-`map` and `compile` for quick, plus terminal `reconciliation` for standard and
-thorough. The resulting total lane maxima are 6/13/23, and concurrency remains
-capped at 4/6/8.
+Only `gather` and `redundant-gather` may partition a wave across multiple lanes.
+Every typed review wave and every permitted mode outside the counted set is
+fixed at exactly one lane, including `map` and `compile`. The resulting
+worker-lane maxima are 6/12/22, and concurrency remains capped at 4/6/8.
+Each review lane's approved write root must contain the corresponding fixed
+path in `execution.reconciliation`; a different approved root is invalid before
+launch.
 
 Triggered dispositions require exact complete same-run artifacts from every
 approved predecessor and concrete typed predicate evidence from those same-run
@@ -150,17 +153,14 @@ no achieved pass. Accepted failed, cancelled, timed-out, or missing predecessor
 work cannot activate replacement work. Required profile passes remain required
 regardless of conditional annotations.
 
-`reconciliation-needs-judgment` is a controller escalation outcome, never a
-condition predicate. Foreseeable judgment changes the one terminal target before
-approval. A need discovered later preserves completed work and records an
-unresolved out-of-envelope gap until renewed approval or a new run; it never
-mutates the approved target or launches a second reconciliation.
+`reconciliation-needs-judgment` is a caller-owned unresolved outcome, never a
+condition predicate or target escalation. The controller preserves completed
+work and records the gap; it never dispatches reconciliation work.
 
-The controller maps the ten manifest wave modes onto the worker contract's
-seven assignment modes: redundant gathering uses `gather`; semantic and
+The controller maps the nine manifest wave modes onto the worker contract's
+six assignment modes: redundant gathering uses `gather`; semantic and
 redundant verification use `verify`; adversarial and contradiction-resolution
-use `adversary`; and only terminal reconciliation uses `reconcile`. This mapping
-does not change the approved manifest mode used for artifact and pass checks.
+use `adversary`. Reconciliation is not a worker mode or approval target.
 
 Approval is `{ type: "explicit-user-approval", approvedAt }`. It is valid only
 for the exact proposal shown in the same uninterrupted controller flow. Resume,
@@ -183,7 +183,6 @@ complete typed artifacts of the same run:
 | `semantic-verification`    | a `recon.review-result` with kind `semantic`                              |
 | `adversarial`              | a `recon.review-result` with kind `adversarial`                           |
 | `coverage`                 | a `recon.review-result` with kind `coverage`                              |
-| `reconciliation`           | a `recon.review-result` with kind `reconciliation`                        |
 | `redundant-gather`         | a complete `gather` dossier owned by the approved `redundant-gather` wave |
 | `redundant-verification`   | a `recon.review-result` with kind `redundant-verification`                |
 | `contradiction-resolution` | a `recon.review-result` with kind `contradiction-resolution`              |
@@ -191,11 +190,11 @@ complete typed artifacts of the same run:
 `quick` requires `map` and `gather`; the canonical ledger itself is the
 compile result, so an approved `compile` lane needs no separate artifact, and
 locator validation is performed by the validator.
-`standard` adds `semantic-verification`, `adversarial`, `coverage`, and
-`reconciliation`. `thorough` adds `redundant-gather` and
+`standard` adds `semantic-verification`, `adversarial`, and `coverage`, then
+requires the manifest-bound controller reconciliation. `thorough` adds `redundant-gather` and
 `redundant-verification`. A predeclared conditional
 `contradiction-resolution` evidence pass may feed the same mandatory terminal
-reconciliation when its predicate triggers; it is not a second terminal pass.
+controller reconciliation when its predicate triggers.
 
 Thorough routing completes `redundant-gather` before `compile`. The compiled
 ledger must directly reference by exact path and digest at least one complete
@@ -346,17 +345,21 @@ branch; source ineligibility never bypasses persistence safety.
   claim/evidence associations, coverage findings, unresolved issues, and
   completion status. Every new evidence record has at least one exact
   association, and an association cannot name evidence absent from that result
-  or a claim without a disposition in that result. Reconciliation results
-  replace the brief reference with prior-ledger/revision, additions/removals,
-  exact transitions, and coverage-disposition bindings. Coverage findings are
-  closed records bound to affected claims and exact manifest gaps. Accepted
-  material gaps require a legal downgrade for every affected claim; a resolved
-  finding instead names exact typed evidence. Non-material coverage gaps
-  downgrade verified claims and transition provisional claims to unresolved,
-  while existing supported claims remain supported without verified promotion.
-  Thorough redundant verification and contradiction resolution are
-  claim-bearing typed review results, not raw dossiers: they bind immutable
-  briefs, claim dispositions, and explicit affected-contradiction dispositions.
+  or a claim without a disposition in that result.
+
+Every `unresolvedIssues` member is a string. Review results are closed objects:
+unknown fields and object-valued issue entries are invalid.
+Reconciliation results replace the brief reference with prior-ledger/revision,
+additions/removals, exact transitions, and coverage-disposition bindings.
+Coverage findings are closed records bound to affected claims and exact
+manifest gaps. Accepted
+material gaps require a legal downgrade for every affected claim; a resolved
+finding instead names exact typed evidence. Non-material coverage gaps
+downgrade verified claims and transition provisional claims to unresolved,
+while existing supported claims remain supported without verified promotion.
+Thorough redundant verification and contradiction resolution are
+claim-bearing typed review results, not raw dossiers: they bind immutable
+briefs, claim dispositions, and explicit affected-contradiction dispositions.
 
 Create immutable mode-specific review projections with
 `scripts/create-review-brief.mjs`. Verification briefs expose only claim

package/assets/skills/recon/references/profiles.md

@@ -28,19 +28,20 @@ claims are sufficient.
 Use for load-bearing evidence that needs independent semantic challenge.
 
 - Required: quick topology plus selectively blind semantic verification,
-  adversarial review, coverage review, and reconciliation.
-- Adaptive evidence lanes: `gather`, `semantic-verification`, `adversarial`,
+  adversarial review, coverage review, and deterministic controller reconciliation.
+- Counted evidence lanes: `gather`, `semantic-verification`, `adversarial`,
   `coverage`, and any predeclared `contradiction-resolution`; hard cap 10
-  across those counted modes. Required `map`, `compile`, and terminal
-  `reconciliation` waves are fixed at exactly one lane each, so the total
-  maximum is 13 lanes.
+  across those modes. `gather` may partition work across lanes. Every typed
+  review wave, plus required `map` and `compile`, is fixed at exactly one lane,
+  so the total maximum is 12 worker lanes.
+  One deterministic controller reconciliation follows.
 - Maximum concurrency: 6.
 - Assurance ceiling: `verified` only after exact locator validation, affirmative
   independent semantic review, no unresolved material challenge, and adequate
   coverage.
 - Conditional work: at most one predeclared `contradiction-resolution`
   evidence wave for a material challenge, followed when triggered or not by
-  the same one mandatory terminal reconciliation.
+  the same one mandatory controller reconciliation.
 
 ## thorough
 
@@ -51,17 +52,19 @@ reopening and verification.
   redundant verification for load-bearing claims. Redundant gathering finishes
   before compilation, and every completed primary or redundant gather lane is
   represented in the compiled ledger inputs before review briefs are created.
-- Adaptive evidence lanes: the standard counted modes plus `redundant-gather`
+- Counted evidence lanes: the standard counted modes plus `redundant-gather`
   and `redundant-verification`; hard cap 20 across those counted modes.
-  Required `map`, `compile`, and terminal `reconciliation` waves are fixed at
-  exactly one lane each, so the total maximum is 23 lanes.
+  `gather` and `redundant-gather` may partition work across lanes. Every typed
+  review wave, plus required `map` and `compile`, is fixed at exactly one lane,
+  so the total maximum is 22 worker lanes.
+  One deterministic controller reconciliation follows.
 - Maximum concurrency: 8.
 - Assurance ceiling: `verified` only for claims affirmed by the required
   independent passes and left without unresolved material challenge.
-- Conditional work: optionally predeclare up to two condition-bound
-  `contradiction-resolution` evidence waves within the manifest's hard cap.
-  Each runs only when its approved predicate triggers; both branches feed
-  exactly one mandatory terminal reconciliation.
+- Conditional work: optionally predeclare one condition-bound
+  `contradiction-resolution` evidence wave within the manifest's hard cap. It
+  runs only when its approved predicate triggers; both branches feed exactly
+  one mandatory controller reconciliation.
 
 ## Planning Rules
 
@@ -69,8 +72,8 @@ reopening and verification.
 2. Classify required and conditional waves before target preparation.
 3. Classify the actual bounded assignment. Citation reopening, explicit
    inventory comparison, counterexample search, and mechanical dossier
-   compilation can remain economical; judgment-bearing interpretation or
-   reconciliation may require a stronger independently approved wave.
+   compilation can remain economical. Reconciliation is deterministic
+   controller work; new semantic judgment is a caller-owned unresolved gap.
 4. Resolve and explain each wave's exact provider-native target and unsupported
    controls without cross-harness normalization.
 5. Reduce lanes when scope is small; never invent work to fill a profile cap.

package/assets/skills/recon/references/worker-contract.md

@@ -21,7 +21,7 @@ Reject an incomplete or contradictory assignment before reading sources. Never
 request credentials, mutate an investigated source, broaden scope, or choose an
 alternate write path.
 
-The manifest's ten wave modes map to the worker's closed seven-mode vocabulary:
+The manifest's nine wave modes map to the worker's closed six-mode vocabulary:
 
 | Manifest wave mode         | Worker assignment mode |
 | -------------------------- | ---------------------- |
@@ -31,7 +31,6 @@ The manifest's ten wave modes map to the worker's closed seven-mode vocabulary:
 | `semantic-verification`    | `verify`               |
 | `adversarial`              | `adversary`            |
 | `coverage`                 | `coverage`             |
-| `reconciliation`           | `reconcile`            |
 | `redundant-gather`         | `gather`               |
 | `redundant-verification`   | `verify`               |
 | `contradiction-resolution` | `adversary`            |
@@ -47,17 +46,16 @@ wave target; the worker neither selects nor upgrades it.
 - `gather`: inspect assigned sources and emit source-grounded findings with
   typed locators, minimal display excerpts, uncertainty, and contradictions.
 - `compile`: consume only designated dossiers and create a provisional claim
-  ledger candidate. Deduplicate without inventing evidence.
+  ledger candidate. Deduplicate without inventing evidence. Display excerpts
+  must be exact contiguous source substrings, except for the explicit
+  `redacted-exact` representation; never paraphrase an excerpt.
 - `verify`: consume an immutable verification brief, reopen only its declared
   sources, test locators and claim semantics, and report claim dispositions.
 - `adversary`: consume scope, questions, and provisional statements only; seek
   counterevidence, unsupported inference, and missing alternatives.
 - `coverage`: compare declared scope and questions with ledger coverage without
   reading gatherer reasoning.
-- `reconcile`: apply review dispositions and contradiction outcomes to a new
-  ledger candidate. Preserve prior revisions and never invent evidence.
-
-No other mode is valid.
+  No other mode is valid.
 
 ## Output Contract
 
@@ -83,11 +81,93 @@ Persist minimal excerpts only. Detect and redact secret spans before writing;
 never persist the secret or its sensitive-span digest. Finish by returning the
 artifact path and compact outcome only.
 
+Before returning, run the supplied deterministic validator against the sole
+unpromoted `writePath`. Correct an invalid candidate within the same accepted
+task and validate again. A terminal invalid candidate is `PASS_FAILED`; it does
+not authorize controller retry or replacement.
+
+Closed review-result examples (all omitted arrays are still required as shown):
+
+```json
+{
+  "kind": "recon.review-result",
+  "schemaVersion": 1,
+  "id": "review-semantic",
+  "runId": "run-1",
+  "reviewKind": "semantic",
+  "reviewerLane": "lane-semantic",
+  "status": "complete",
+  "brief": {
+    "path": "reviews/briefs/verify.json",
+    "digest": "sha256:0000000000000000000000000000000000000000000000000000000000000000"
+  },
+  "permittedInputs": [],
+  "excludedInputs": [],
+  "dispositions": [],
+  "newEvidence": [],
+  "evidenceAssociations": [],
+  "coverageFindings": [],
+  "unresolvedIssues": []
+}
+```
+
+```json
+{
+  "kind": "recon.review-result",
+  "schemaVersion": 1,
+  "id": "review-adversarial",
+  "runId": "run-1",
+  "reviewKind": "adversarial",
+  "reviewerLane": "lane-adversarial",
+  "status": "complete",
+  "brief": {
+    "path": "reviews/briefs/adversary.json",
+    "digest": "sha256:0000000000000000000000000000000000000000000000000000000000000000"
+  },
+  "permittedInputs": [],
+  "excludedInputs": [],
+  "dispositions": [],
+  "newEvidence": [],
+  "evidenceAssociations": [],
+  "coverageFindings": [],
+  "unresolvedIssues": []
+}
+```
+
+```json
+{
+  "kind": "recon.review-result",
+  "schemaVersion": 1,
+  "id": "review-coverage",
+  "runId": "run-1",
+  "reviewKind": "coverage",
+  "reviewerLane": "lane-coverage",
+  "status": "complete",
+  "brief": {
+    "path": "reviews/briefs/coverage.json",
+    "digest": "sha256:0000000000000000000000000000000000000000000000000000000000000000"
+  },
+  "permittedInputs": [],
+  "excludedInputs": [],
+  "dispositions": [],
+  "newEvidence": [],
+  "evidenceAssociations": [],
+  "coverageFindings": [],
+  "unresolvedIssues": []
+}
+```
+
 The controller validates the candidate against `packet-contract.md` with the
 bundled deterministic artifact validator. A validation failure quarantines the
 candidate; it never authorizes the worker to rewrite a shared artifact, retry,
 or launch a replacement.
 
+For an accepted launch, the approved-path artifact is authoritative over the
+return transport. If its identity, schema, bytes, and digest validate, a later
+stream-close diagnostic is non-material and the lane is complete. Missing or
+invalid output remains terminal `PASS_FAILED`; neither outcome authorizes a
+replacement launch.
+
 ## Invariants
 
 - Read only the assignment's allowed inputs using its source-read authority.

package/assets/skills/recon/scripts/create-review-brief.mjs

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 
-import { realpathSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname, relative, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
 
 import { canonicalJson, hashFile } from './lib/canonical-json.mjs';
+import { isDirectExecution } from './lib/cli-entry.mjs';
 import { issue, isObject, validateArtifactShape } from './lib/contracts.mjs';
 import { assertSafeOutputPath } from './lib/safe-path.mjs';
 
@@ -442,29 +441,7 @@ async function main(argv) {
   process.stdout.write(`${JSON.stringify(reference, null, 2)}\n`);
 }
 
-/**
- * Direct invocation, compared as canonical paths on both sides. Comparing a raw
- * `process.argv[1]` against `import.meta.url` makes this script a silent no-op
- * that exits 0 whenever the skill is reached through a symlinked install root,
- * and canonicalizing only one side has the same effect under
- * `--preserve-symlinks-main`, which keeps the link in `import.meta.url`.
- * A path that cannot be canonicalized is not a module Node loaded as the entry
- * point, so a thrown `realpathSync` means "not invoked directly" and returns
- * `false`; it never masks a direct run.
- */
-function isDirectInvocation(invokedPath) {
-  if (!invokedPath) return false;
-  try {
-    return (
-      realpathSync(fileURLToPath(import.meta.url)) ===
-      realpathSync(resolve(invokedPath))
-    );
-  } catch {
-    return false;
-  }
-}
-
-if (isDirectInvocation(process.argv[1])) {
+if (isDirectExecution(import.meta.url)) {
   main(process.argv.slice(2)).catch((error) => {
     process.stderr.write(`${error instanceof Error ? error.message : error}\n`);
     process.exitCode = 1;

package/assets/skills/recon/scripts/lib/cli-entry.mjs

@@ -0,0 +1,21 @@
+import { realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * Compare canonical paths on both sides so direct execution works through a
+ * symlinked install root, including with `--preserve-symlinks-main`. A path
+ * that cannot be canonicalized is not the loaded entry module, so resolution
+ * failure returns false without masking a direct run.
+ */
+export function isDirectExecution(moduleUrl, entryPath = process.argv[1]) {
+  if (!entryPath) return false;
+  try {
+    return (
+      realpathSync(fileURLToPath(moduleUrl)) ===
+      realpathSync(resolve(entryPath))
+    );
+  } catch {
+    return false;
+  }
+}