sortie-dogs 0.13.14 → 0.13.16

package/README.md

@@ -19,8 +19,8 @@ evidence-backed result, not more agents for their own sake.
 [![Node.js](https://img.shields.io/node/v/sortie-dogs)](https://www.npmjs.com/package/sortie-dogs)
 [![MIT License](https://img.shields.io/npm/l/sortie-dogs)](LICENSE)
 
-**Current release: [v0.13.14](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.14)**
-· [Release notes](docs/release-v0.13.14.md)
+**Current release: [v0.13.16](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.16)**
+· [Release notes](docs/release-v0.13.16.md)
 
 [Quick start](#quick-start) · [Workflow](#mission-workflow) · [Models](#default-models) ·
 [Measured results](#measured-results) · [Configuration](#configuration) · [Documentation](#documentation)
@@ -57,7 +57,7 @@ Use an existing Codex CLI signed in with **ChatGPT**. On Windows, PowerShell **7
 available; POSIX uses bash. Sortie does not install Codex, start login or use a metered API fallback.
 
 ```sh
-npm install --save-dev sortie-dogs@0.13.14
+npm install --save-dev sortie-dogs@0.13.16
 npx --no-install sortie-dogs codex init .
 ```
 
@@ -86,7 +86,7 @@ bridge. [Codex guide: SDK, permissions, progress, resume and manifest route](doc
 Use **OpenCode V2**. In the target project:
 
 ```sh
-npm install --save-dev sortie-dogs@0.13.14
+npm install --save-dev sortie-dogs@0.13.16
 npx --no-install sortie-dogs init .
 ```
 
@@ -188,7 +188,7 @@ known expense. Official local evaluation and leaderboard acceptance are separate
 **8/23 (34.8%)**, versus v0.12.25's 7/23; all seven prior resolutions retained, no empty patches or
 official evaluation errors. [Fixed conditions, stopped-run accounting and costs](docs/benchmarks/swebench-lite-history.md#v0131-dev23-2026-09-30).
 
-All scores belong to their fixed candidates, **not v0.13.14**. SWE-bench remains an optional
+All scores belong to their fixed candidates, **not v0.13.16**. SWE-bench remains an optional
 measurement, not a release gate. Different budgets, models and conditions are not controlled comparisons.
 
 ## Configuration
@@ -211,7 +211,7 @@ Install the desired package version and rerun **your host's** initializer:
 
 An OpenCode config-local bridge may resolve a separate package; npm-global update alone does not
 update it. [Global/update instructions](docs/configuration.md#global-availability).
-The current Mission asset marker is `0.13.14-mission-recovery-v1`; the unchanged Codex skill marker is
+The current Mission asset marker is `0.13.16-practical-continuity-v1`; the unchanged Codex skill marker is
 `0.13.11-codex-skill-v2`. Installed markers alone do not prove a running host reloaded the new version.
 
 There is no supported uninstall command. Remove the dependency and only known Sortie-owned paths;
@@ -227,7 +227,7 @@ follow the [manual removal guide](docs/uninstall.md), never delete the entire `.
   [SWE-bench history](docs/benchmarks/swebench-lite-history.md) · [Historical local case study](docs/benchmark-reference.md).
 - **Development:** [Testing](docs/testing.md) · [CLI testing](docs/cli-testing.md) ·
   [Windows tests](docs/windows-tests.md) · [Release routine](docs/release-batch.md).
-- **Releases:** [v0.13.14](docs/release-v0.13.14.md) · [v0.13.13](docs/release-v0.13.13.md) · [v0.13.12](docs/release-v0.13.12.md) · [v0.13.11](docs/release-v0.13.11.md) · [v0.13.10](docs/release-v0.13.10.md) ·
+- **Releases:** [v0.13.16](docs/release-v0.13.16.md) · [v0.13.15](docs/release-v0.13.15.md) · [v0.13.14](docs/release-v0.13.14.md) · [v0.13.13](docs/release-v0.13.13.md) · [v0.13.12](docs/release-v0.13.12.md) · [v0.13.11](docs/release-v0.13.11.md) · [v0.13.10](docs/release-v0.13.10.md) ·
   [v0.13.9](docs/release-v0.13.9.md) · [All GitHub releases](https://github.com/zufall-upon/Sortie-dogs/releases).
 
 ## Community

package/dist/asset-version.d.ts

@@ -3,6 +3,6 @@
  * installed project marker without importing every asset body.
  */
 export declare const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export declare const V010_RUNTIME_ASSET_VERSION = "0.13.14-mission-recovery-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.16-practical-continuity-v1";
 export declare const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION | typeof CODEX_SKILL_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,5 +3,5 @@
  * installed project marker without importing every asset body.
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export const V010_RUNTIME_ASSET_VERSION = "0.13.14-mission-recovery-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.16-practical-continuity-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";

package/dist/core/goal-bound.d.ts

@@ -51,6 +51,19 @@ export interface GoalEvidence {
             readonly scratch_paths: readonly string[];
             readonly protected_paths: readonly string[];
             readonly environment: Readonly<Record<string, string | null>>;
+            readonly incidental_control_paths?: readonly string[];
+            readonly toolchain?: {
+                readonly directory: string;
+                readonly commands: readonly string[];
+                readonly executables: readonly {
+                    readonly name: string;
+                    readonly path: string | null;
+                    readonly realpath: string | null;
+                    readonly sha256: string | null;
+                    readonly mode?: number;
+                    readonly runtime?: string;
+                }[];
+            };
         };
     };
     readonly execution: {

package/dist/core/goal-bound.js

@@ -72,7 +72,17 @@ export function validGoalEvidence(value, state) {
             Array.isArray(protectedBinding.freshness.scratch_paths) && protectedBinding.freshness.scratch_paths.every(text) &&
             Array.isArray(protectedBinding.freshness.protected_paths) && protectedBinding.freshness.protected_paths.every(text) &&
             protectedBinding.freshness.environment !== null && typeof protectedBinding.freshness.environment === "object" &&
-            !Array.isArray(protectedBinding.freshness.environment) && Object.values(protectedBinding.freshness.environment).every(value => value === null || typeof value === "string")));
+            !Array.isArray(protectedBinding.freshness.environment) && Object.values(protectedBinding.freshness.environment).every(value => value === null || typeof value === "string") &&
+            (protectedBinding.freshness.incidental_control_paths === undefined || Array.isArray(protectedBinding.freshness.incidental_control_paths) &&
+                protectedBinding.freshness.incidental_control_paths.every(text)) &&
+            (protectedBinding.freshness.toolchain === undefined || protectedBinding.freshness.toolchain !== null &&
+                typeof protectedBinding.freshness.toolchain === "object" && text(protectedBinding.freshness.toolchain.directory) &&
+                Array.isArray(protectedBinding.freshness.toolchain.commands) && protectedBinding.freshness.toolchain.commands.every(commandText) &&
+                Array.isArray(protectedBinding.freshness.toolchain.executables) && protectedBinding.freshness.toolchain.executables.every(executable => executable !== null && typeof executable === "object" && text(executable.name) &&
+                (executable.path === null || text(executable.path)) && (executable.realpath === null || text(executable.realpath)) &&
+                (executable.sha256 === null || HASH.test(executable.sha256)) &&
+                (executable.mode === undefined || Number.isSafeInteger(executable.mode) && executable.mode >= 0) &&
+                (executable.runtime === undefined || text(executable.runtime))))));
     const matches = criteria.length > 0 && criteria.length === value.measurement.criterion_ids.length &&
         criteria.every((criterion) => criterion.target === value.measurement.target &&
             criterion.entrypoint === value.measurement.entrypoint && criterion.workload === value.measurement.workload &&
@@ -206,7 +216,7 @@ export function reduceGoalFlight(records) {
                 state = { ...state, no_progress_results: 0, replan_required: false, replan_used: false };
                 replanRevision = null;
             }
-            requireState(state.phase === "active" && !state.replan_required, "transition", "Dispatch requires terminal handling or one bounded replan.");
+            requireState(state.phase === "active" && (!state.replan_required || state.replan_used), "transition", "Dispatch requires an active goal and the initial no-progress diagnosis.");
             requireState(state.budget !== null && state.consumed_units + state.outstanding_reservations.length < state.budget.max_units, "budget", "Goal unit budget exhausted.");
             requireState(state.budget.time_ms === null || (state.consumed_time_ms !== null && state.consumed_time_ms < state.budget.time_ms), "budget", "Goal time budget is exhausted or usage is unknown.");
             requireState(state.budget.cost_usd === null || (state.consumed_cost_usd !== null && state.consumed_cost_usd < state.budget.cost_usd), "budget", "Goal cost budget is exhausted or usage is unknown.");
@@ -342,7 +352,7 @@ export function reduceGoalFlight(records) {
                 event.receipt.terminal_revision === state.revision && event.receipt.acceptance_fingerprint === state.acceptance_fingerprint &&
                 event.receipt.unit_ids.every((id) => state.unit_ids.includes(id)) && event.receipt.session_ids.every((id) => state.session_ids.includes(id)) &&
                 event.receipt.evidence_refs.every((id) => state.evidence_refs.includes(id)) &&
-                (event.receipt.status !== "succeeded" || (event.receipt.stop_reason === "completed" && allAccepted && !state.replan_required)) &&
+                (event.receipt.status !== "succeeded" || (event.receipt.stop_reason === "completed" && allAccepted)) &&
                 (event.receipt.status !== "stopped" || event.receipt.stop_reason !== "completed"), "transition", "Terminal receipt is not bound to settled goal state.");
             state = { ...state, phase: event.receipt.status === "succeeded" ? "terminal" : "stopped",
                 stop_reason: event.receipt.stop_reason, tickets: [], receipt: event.receipt };

package/dist/core/operator-mission.d.ts

@@ -236,6 +236,8 @@ export interface OperatorMission {
     consultations?: MissionConsultation[];
     /** Host-observed current-Mission Worker attempts; only an implementation failure followed by a failed remediation can qualify for Rescue. */
     attempts?: MissionAttempt[];
+    /** Native mutating-tool observations, not inference from a role name or a write estimate. */
+    sourceAuthors?: string[];
     /** One bounded Astra Rescue per eligible unit; validation, independent review and root acceptance remain separate. */
     rescue?: MissionTerminalRescue;
     /** A cancelled run replaced by a later real user turn; never reuse its acceptance or evidence. */

package/dist/core/operator-mission.js

@@ -755,7 +755,8 @@ export async function missionAcceptanceSummary(mission, run, operators, observe)
         interpretation: "Compare original requests with the submitted candidate and actual evidence. Historical PASS is not current PASS. Inspect concrete gaps, not routine archive searches or full source rereads. Existing completion and Review guards still apply." };
 }
 export function missionReviewIndependent(mission, child) {
-    return child !== undefined && !(mission.corrections ?? []).some(correction => correction.author === child);
+    return child !== undefined && !mission.sourceAuthors?.includes(child) &&
+        !(mission.corrections ?? []).some(correction => correction.author === child);
 }
 export function missionPacket(mission, run) {
     const predecessor = run && mission.runID !== run.runID && (mission.supersededRunID === run.runID || run.phase === "cancelled") ? run : undefined;

package/dist/core/operator-runtime.js

@@ -791,10 +791,17 @@ export class OperatorRuntime {
             if (JSON.stringify(commands) === JSON.stringify(unit.unit.validation) &&
                 JSON.stringify(directories) === JSON.stringify(priorDirectories))
                 return state;
-            // This changes only the check recipe, not the admitted Task, contract or spend.
-            // Keep every prior attempt, but require actual native proof after registration.
-            const now = new Date().toISOString();
-            unit.reviewerCorrection.validationRegisteredAt = Object.fromEntries(commands.map(command => [command, now]));
+            // Keep unaffected native checks in this admission. Only a new command or a
+            // changed execution directory needs proof after this registration repair.
+            const registeredAt = { ...unit.reviewerCorrection.validationRegisteredAt }, now = new Date().toISOString();
+            const previousCommands = new Set(unit.unit.validation.map(normalizeCommand));
+            for (const command of commands) {
+                if (!previousCommands.has(command) ||
+                    resolve(this.projectRoot, directories[command] ?? ".") !== resolve(this.projectRoot, priorDirectories[command] ?? ".")) {
+                    registeredAt[command] = now;
+                }
+            }
+            unit.reviewerCorrection.validationRegisteredAt = registeredAt;
             if (unit.directExecution)
                 unit.directExecution.validationCwd = directories;
             state.units[state.units.indexOf(unit)] = { ...unit, unit: { ...unit.unit, validation: commands, validation_cwd: directories } };

package/dist/core/validate-worktree-parallel.js

@@ -1,11 +1,11 @@
-import { normalizeWorktreeScopePath, worktreeScopesOverlap } from "./worktree-scope.js";
+import { normalizeWorktreeScopePath, worktreeScopesConflict } from "./worktree-scope.js";
 const MESSAGES = {
     duplicate: "Task, worktree, branch, and artifact identities must be unique.",
     unknownDependency: "Dependency must name another task in this contract.",
     cycle: "Dependency graph must be acyclic.",
     mode: "Mode, worker bound, and task count are inconsistent.",
     path: "Scope and changed paths must be normalized repository-relative paths.",
-    overlap: "Parallel tasks must not have write/write or read/write scope overlap.",
+    overlap: "Parallel tasks must not have overlapping write scopes. Exploratory reads are concurrent.",
     artifact: "Commit artifact must match its task, base, and declared write scope.",
     failure: "Failure task and fallback must satisfy the fixed failure policy.",
 };
@@ -99,8 +99,7 @@ export function validateWorktreeParallelContract(contract) {
                 const right = entries[rightIndex];
                 if (right.scopes === undefined)
                     continue;
-                const overlaps = left.scopes.write.some((path) => [...right.scopes.write, ...right.scopes.read].some((other) => worktreeScopesOverlap(path, other))) ||
-                    right.scopes.write.some((path) => left.scopes.read.some((other) => worktreeScopesOverlap(path, other)));
+                const overlaps = worktreeScopesConflict(left.scopes, right.scopes);
                 if (overlaps)
                     diagnostics.push(issue("WTP006_SCOPE_OVERLAP", `/tasks/${right.index}/scope`, MESSAGES.overlap));
             }

package/dist/core/worktree-scope.js

@@ -18,6 +18,7 @@ export function worktreeScopesOverlap(left, right) {
     return left === "**" || right === "**" || left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
 }
 export function worktreeScopesConflict(left, right) {
-    return left.write.some((path) => [...right.write, ...right.read].some((other) => worktreeScopesOverlap(path, other))) ||
-        right.write.some((path) => left.read.some((other) => worktreeScopesOverlap(path, other)));
+    // Exploration is not an exclusive resource. Validation checks input freshness;
+    // write ownership alone prevents concurrent mutation of the same target.
+    return left.write.some((path) => right.write.some((other) => worktreeScopesOverlap(path, other)));
 }

package/dist/plugin/fast-lane.js

@@ -391,6 +391,11 @@ export class FastLaneController {
             const retry = lineValue(prompt, "fallback_retry");
             const basis = fallbackBasis(prompt);
             const prompts = phase === "initial" ? candidate.initialPrompts : candidate.verificationPrompts;
+            // Prompt registration precedes native execution. Seeing it again can mean an
+            // unstarted dispatch retry or continuation of the same retained Reviewer.
+            // Native call ownership joins active work; this lineage cache is not a retry grant.
+            if (retry === undefined && (candidate.initialPrompts.has(basis) || candidate.verificationPrompts.has(basis)))
+                return;
             if (phase === "initial" && candidate.verificationPrompts.size > 0) {
                 throw new FastLaneDeniedError("REVIEW_PHASE_INVALID");
             }
@@ -410,8 +415,6 @@ export class FastLaneController {
                 candidate.fallbackRetries.add(`${phase}\0${basis}`);
             }
             else {
-                if (prompts.has(basis))
-                    throw new FastLaneDeniedError("CONSULTATION_RETRY_INVALID");
                 if (phase === "initial" && candidate.initialPrompts.size > 0) {
                     throw new FastLaneDeniedError("REVIEW_PHASE_INVALID");
                 }

package/dist/plugin/index.d.ts

@@ -20,6 +20,7 @@ export interface OpenCodePluginInput {
     /** Native background Job ownership, persisted by the V2 adapter. */
     nativeBackground?: {
         awaiting(sessionID: string): Promise<boolean>;
+        reconcile?(sessionID: string): Promise<void>;
     };
     /** V2 adapter can project and restore native session-scoped correction permissions. */
     reviewerCorrectionPermissions?: boolean;
@@ -66,6 +67,15 @@ export interface OpenCodeHooks {
     reviewerCorrectionSessions?: (sessionID: string) => Promise<readonly string[]>;
     /** Internal adapter transport; retains the existing profile owner across reload. */
     backgroundOwner?: (callID: string, restore?: Record<string, unknown>) => Record<string, unknown> | undefined;
+    /** Read-only recovery of a retained host result; never repeats Task settlement or validation. */
+    backgroundResult?: (parent: string, callID: string, child: string, promptID?: string) => Promise<string | undefined>;
+    /** Native transport joins an already-running Task instead of submitting a duplicate prompt. */
+    nativeTaskJoin?: (callID: string, consume?: boolean) => {
+        sessionID: string;
+        callID: string;
+        output?: string;
+        status?: "running" | "completed";
+    } | undefined;
     event?: (input: {
         event: OpenCodeEvent;
     }) => Promise<void>;

package/dist/plugin/index.js

@@ -1366,7 +1366,7 @@ export const SortieDogsPlugin = async (input, options) => {
             ? await input.runtimeBridge?.missionDispatchCall?.(authorization.rootSessionID, toolInput.sessionID, authorization.taskID) : undefined);
         const correction = correcting && dispatchCallID && members
             ? { taskID: authorization.taskID, dispatchCallID, commands: members } : undefined;
-        const admittedSnapshot = await protectedSnapshot(authorization).catch(() => undefined);
+        const admittedSnapshot = await protectedSnapshot(authorization, { directory, command: args.command }).catch(() => undefined);
         if (admittedSnapshot === undefined)
             return;
         const root = goalRoot(owner);
@@ -2316,14 +2316,12 @@ export const SortieDogsPlugin = async (input, options) => {
         if (state.phase === "terminal" || state.receipt !== null) {
             throw new Error("SORTIE_GOAL_CONTROL_DENIED: terminal");
         }
-        if (state.replan_required) {
-            if (state.replan_used) {
-                await terminalGoal(sessionID, "stop_no_progress", "stopped");
-                throw new Error("SORTIE_GOAL_CONTROL_DENIED: stop_no_progress");
-            }
+        if (state.replan_required && !state.replan_used) {
             state = await ledger.appendGoal({ kind: "goal.replanned", at: new Date().toISOString(),
                 goal_id: state.goal_id, revision: state.revision, reason: "no-progress" });
         }
+        // No-progress is diagnostic, not another implicit execution budget. Useful
+        // repair can continue within the same explicit unit/time/cost limits below.
         if (state.budget !== null && state.consumed_units + state.outstanding_reservations.length >= state.budget.max_units) {
             await terminalGoal(sessionID, "stop_budget", "stopped");
             throw budgetDenied("units");
@@ -5025,8 +5023,7 @@ export const SortieDogsPlugin = async (input, options) => {
                 for (const [ownerSessionID, authorization] of sessionAuthorizations) {
                     if (ownerSessionID === sessionID || authorization.suspended)
                         continue;
-                    for (const [requested, held, access] of [[writeScopes, authorization.writeScopes, "write/write"],
-                        [writeScopes, authorization.readScopes, "write/read"], [readScopes, authorization.writeScopes, "read/write"]]) {
+                    for (const [requested, held, access] of [[writeScopes, authorization.writeScopes, "write/write"]]) {
                         for (const left of requested)
                             for (const right of held) {
                                 if (conflicts.length < 8 && writeScopesOverlap([left], [right])) {

package/dist/plugin/mission-review.js

@@ -12,7 +12,7 @@ import { taskChildSessionID } from "./task-result-repair.js";
 import { normalizeManifestScope } from "../core/path.js";
 import { declaredArtifacts } from "./declared-artifacts.js";
 import { canonicalDeclaredValidationMembers, normalizeCommand } from "./gate.js";
-import { currentSnapshotProtection, isRuntimeControlPath, refreshProtectedSnapshot, snapshotScratchExclusion, validationInputSnapshot } from "./protected-snapshot.js";
+import { currentSnapshotProtection, isRuntimeControlPath, refreshProtectedSnapshot, snapshotControlExclusion, snapshotScratchExclusion, validationInputSnapshot } from "./protected-snapshot.js";
 const exec = promisify(execFile);
 const notRepository = (error) => /fatal: not a git repository \(or (?:any of the parent directories|any parent up to mount point [^\r\n)]+)\)(?:: \.git)?/u
     .test(String(error.stderr ?? ""));
@@ -113,6 +113,8 @@ export function reviewerCorrectionValidation(validation, child, history, notBefo
     const declared = validation.map(normalizeCommand);
     if (!Number.isFinite(notBefore))
         return { ready: false, reason: "mission-review-correction-validation-admission-unavailable" };
+    if (!declared.length)
+        return { ready: false, reason: "mission-review-correction-validation-missing", nextOccurrence: 0 };
     const attempts = [];
     const seen = new Set();
     let editedAt = notBefore;
@@ -150,56 +152,88 @@ export function reviewerCorrectionValidation(validation, child, history, notBefo
         }
     }
     const matched = [];
-    let complete;
-    let previousEnd = notBefore, overlap = false, failed;
-    for (const attempt of attempts.sort((a, b) => a.started - b.started || a.completed - b.completed)) {
-        // Bound native checks are compared with their actual input bytes below. A later
-        // report/cache write is not itself a source change. Unbound history stays conservative.
-        if (!checks && attempt.started < editedAt)
-            continue;
-        const commands = canonicalDeclaredValidationMembers(attempt.command, declared, matched.length % declared.length);
-        if (!commands || !validationDirectoryMatches(commands, attempt.directory, directory, directories) ||
-            commands.some(command => registeredAt?.[command] !== undefined &&
-                (!Number.isFinite(Date.parse(registeredAt[command])) || attempt.started < Date.parse(registeredAt[command]))))
-            continue;
-        if (attempt.started < previousEnd) {
-            complete = undefined;
-            matched.length = 0;
+    // Registration repairs replace only affected recipes. Retain the ordered actual
+    // occurrences of unchanged checks and join the changed checks after their own
+    // registration, rather than making an inserted/corrected command rerun its neighbors.
+    const groups = new Map();
+    for (const [occurrence, command] of declared.entries()) {
+        const registration = checks && registeredAt ? registeredAt[command] ?? "" : "";
+        const group = groups.get(registration) ?? [];
+        group.push(occurrence);
+        groups.set(registration, group);
+    }
+    const complete = [];
+    let incomplete;
+    for (const occurrences of groups.values()) {
+        const required = occurrences.map(index => declared[index]);
+        const partial = [];
+        let completed;
+        let previousEnd = notBefore, overlap = false, failed;
+        for (const attempt of attempts.sort((a, b) => a.started - b.started || a.completed - b.completed)) {
+            // Bound native checks are compared with their actual input bytes below. A later
+            // report/cache write is not itself a source change. Unbound history stays conservative.
+            if (!checks && attempt.started < editedAt)
+                continue;
+            const recorded = registeredAt && checks?.find(check => check.callID === attempt.callID && check.childSessionID === child);
+            const commands = recorded
+                ? canonicalDeclaredValidationMembers(attempt.command, recorded.command)
+                : canonicalDeclaredValidationMembers(attempt.command, declared, occurrences[partial.length % required.length] ?? 0);
+            if (!commands || recorded && JSON.stringify(commands) !== JSON.stringify(recorded.command))
+                continue;
+            const members = commands.flatMap((command, member) => required.includes(command) &&
+                validationDirectoryMatches([command], attempt.directory, directory, directories) &&
+                (registeredAt?.[command] === undefined || Number.isFinite(Date.parse(registeredAt[command])) &&
+                    attempt.started >= Date.parse(registeredAt[command])) ? [{ command, member }] : []);
+            if (!members.length || !registeredAt && members.length !== commands.length)
+                continue;
+            if (attempt.started < previousEnd) {
+                completed = undefined;
+                partial.length = 0;
+                failed = undefined;
+                overlap = true;
+                previousEnd = Math.max(previousEnd, attempt.completed);
+                continue;
+            }
+            previousEnd = attempt.completed;
+            if (members[0].command !== required[partial.length] || partial.length === required.length)
+                partial.length = 0;
             failed = undefined;
-            overlap = true;
-            previousEnd = Math.max(previousEnd, attempt.completed);
-            continue; // A later complete ordered retry can recover in this same admission.
-        }
-        previousEnd = attempt.completed;
-        if (commands[0] !== declared[matched.length] || matched.length === declared.length)
-            matched.length = 0;
-        failed = undefined;
-        // A failed && chain cannot infer any member success (including commands before its failure).
-        if (attempt.exit !== 0) {
-            complete = undefined;
-            matched.length = 0;
-            failed = { command: commands, outcome: "fail", exitCode: attempt.exit };
-            continue;
-        }
-        for (const [member, command] of commands.entries()) {
-            if (command !== declared[matched.length]) {
-                matched.length = 0;
-                if (command !== declared[0])
-                    continue;
+            // A failed && chain proves no member, even if earlier members could have passed.
+            if (attempt.exit !== 0) {
+                completed = undefined;
+                partial.length = 0;
+                failed = { command: commands, outcome: "fail", exitCode: attempt.exit };
+                continue;
             }
-            matched.push({ callID: attempt.callID, member, occurrence: matched.length });
-            if (matched.length === declared.length) {
-                complete = [...matched];
-                overlap = false;
+            for (const { member, command } of members) {
+                if (command !== required[partial.length]) {
+                    partial.length = 0;
+                    if (command !== required[0])
+                        continue;
+                }
+                partial.push({ callID: attempt.callID, member, occurrence: occurrences[partial.length] });
+                if (partial.length === required.length) {
+                    completed = [...partial];
+                    overlap = false;
+                }
             }
         }
+        if (failed)
+            return { ready: false, reason: `mission-review-correction-validation-failed:${failed.command.join(" && ")}`, failure: failed, nextOccurrence: occurrences[0] };
+        if (!completed) {
+            const next = occurrences[partial.length] ?? occurrences[0];
+            if (!incomplete || next < incomplete.nextOccurrence)
+                incomplete = { ready: false,
+                    reason: overlap && !partial.length ? "mission-review-correction-validation-order:overlap"
+                        : `mission-review-correction-validation-missing:${declared[next]}`, nextOccurrence: next };
+        }
+        else
+            complete.push(...completed);
+        matched.push(...partial);
     }
-    if (failed)
-        return { ready: false, reason: `mission-review-correction-validation-failed:${failed.command.join(" && ")}`, failure: failed, nextOccurrence: 0 };
-    if (overlap && !matched.length)
-        return { ready: false, reason: "mission-review-correction-validation-order:overlap", nextOccurrence: 0 };
-    if (!complete)
-        return { ready: false, reason: `mission-review-correction-validation-missing:${declared[matched.length]}`, nextOccurrence: matched.length };
+    if (incomplete)
+        return incomplete;
+    complete.sort((a, b) => a.occurrence - b.occurrence);
     for (const item of complete) {
         const command = declared[item.occurrence];
         const check = checks?.find(check => check.callID === item.callID && check.childSessionID === child);
@@ -394,14 +428,32 @@ export async function completedMissionReviewPrompts(mission, profile, root, requ
 export async function missionReviewSource(directory, run, evidence = [], baseline, priorScope, displayBaseline = baseline) {
     const scope = missionReviewScope(priorScope, run);
     const bindings = scope.validationBindings ?? [];
-    const protection = bindings.some(binding => binding.freshness) ? await currentSnapshotProtection(directory, scope) : [];
+    const manifestScope = (path) => path === "." ? `${resolve(directory)}/**` : path;
+    const protection = await currentSnapshotProtection(directory, { read: scope.read.map(manifestScope), write: scope.write.map(manifestScope) });
     const scratch = bindings.map(binding => ({ binding, excludes: snapshotScratchExclusion(binding, protection) }));
+    const controls = bindings.map(binding => ({ binding, excludes: snapshotControlExclusion(directory, binding, protection) }));
+    const scopes = [...scope.read, ...scope.write].map(path => resolve(directory, normalizeManifestScope(manifestScope(path)).path));
+    const broadOutput = scope.write.some(path => resolve(directory, normalizeManifestScope(manifestScope(path)).path) === resolve(directory));
+    const explicit = [...scopes, ...protection].filter(path => path !== resolve(directory));
+    const related = (root, path) => {
+        const rest = relative(root, path);
+        return rest === "" || rest !== ".." && !rest.startsWith(`..${sep}`) && !isAbsolute(rest);
+    };
     const excluded = (path) => {
         const absolute = resolve(directory, path);
         const covers = (binding) => [...binding.source_paths, ...binding.candidate_paths].some(root => {
             const rest = relative(resolve(directory, root), absolute);
             return rest === "" || (rest !== ".." && !rest.startsWith(`..${sep}`) && !isAbsolute(rest));
         });
+        const first = path.replaceAll("\\", "/").split("/")[0];
+        const config = (process.platform === "win32" ? first.toLowerCase() : first) === ".opencode";
+        if (broadOutput && (config || isRuntimeControlPath(path)) && !explicit.some(root => related(root, absolute) || related(absolute, root))) {
+            // An old snapshot cannot silently acquire the new config exclusion. Review
+            // uses the same saved recipe when bindings exist, including mixed old/new proof.
+            if (!config || !bindings.length || controls.some(item => covers(item.binding) && item.excludes(absolute)) &&
+                !controls.some(item => covers(item.binding) && !item.excludes(absolute)))
+                return true;
+        }
         return scratch.some(item => item.excludes(absolute)) &&
             !scratch.some(item => covers(item.binding) && !item.excludes(absolute));
     };
@@ -507,16 +559,16 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
             local.push(scoped || ".");
     }
     const toolInput = scope.read.some(path => normalizeManifestScope(path).path.startsWith(TOOL_ENVIRONMENT));
-    const scopes = [...local, ...(toolInput ? [] : [`:(exclude)${TOOL_ENVIRONMENT}`])];
+    const gitScopes = [...local, ...(toolInput ? [] : [`:(exclude)${TOOL_ENVIRONMENT}`])];
     const git = async (args) => (await exec("git", args, { cwd: directory, maxBuffer: 8 * 1024 * 1024 })).stdout;
     let names = "", ignored = "", repository = true, scopedDiff = "";
     const untracked = new Set(), currentFiles = new Set();
     try {
         if (local.length) {
-            names = await git(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...scopes]);
-            for (const path of (await git(["ls-files", "-z", "--others", "--exclude-standard", "--", ...scopes])).split("\0").filter(Boolean))
+            names = await git(["ls-files", "-z", "--cached", "--others", "--exclude-standard", "--", ...gitScopes]);
+            for (const path of (await git(["ls-files", "-z", "--others", "--exclude-standard", "--", ...gitScopes])).split("\0").filter(Boolean))
                 untracked.add(path);
-            ignored = await git(["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--", ...scopes]);
+            ignored = await git(["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--", ...gitScopes]);
         }
     }
     catch (error) {
@@ -530,9 +582,6 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
             if (walked.has(path) || excluded(path))
                 return;
             walked.add(path);
-            if (local.includes(".") && isRuntimeControlPath(path) && !local.some(scope => scope !== "." &&
-                (path === scope || path.startsWith(`${scope}/`))))
-                return;
             if (!toolInput && (path === TOOL_ENVIRONMENT || path.startsWith(`${TOOL_ENVIRONMENT}/`)))
                 return;
             const absolute = resolve(directory, path);
@@ -592,7 +641,7 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
     if (repository && local.length && displayBaseline) {
         // HEAD-only diffs are empty once the author commits. Display the original mission delta
         // or the focused correction delta without changing the full fingerprint basis.
-        const changed = (await git(["diff", "--name-only", "-z", "--no-ext-diff", displayBaseline, "--", ...scopes]))
+        const changed = (await git(["diff", "--name-only", "-z", "--no-ext-diff", displayBaseline, "--", ...gitScopes]))
             .split("\0").filter(path => path && !excluded(path));
         const shown = changed.slice(0, 16);
         const heading = changed.length ? `Changed since ${displayBaseline === baseline ? "mission" : "correction"} baseline (${displayBaseline}; ${changed.length} paths):\n` : "";
@@ -615,7 +664,7 @@ export async function missionReviewSource(directory, run, evidence = [], baselin
         omitted.push(...changed.slice(shown.length));
     }
     else if (repository && local.length) {
-        diff = await currentGitDiff(git, scopes);
+        diff = await currentGitDiff(git, gitScopes);
     }
     const unchanged = diff.length === 0;
     let excerpt = selected + diff;

package/dist/plugin/native-background.d.ts

@@ -14,15 +14,18 @@ export interface NativeBackgroundDispatch {
     launched: boolean;
     terminal?: "succeeded" | "failed" | "interrupted";
     settled?: boolean;
+    /** Host-reconciled output for this exact native invocation, not another completion prompt. */
+    result?: string;
 }
 /** Lifecycle transport for native Jobs, not a scheduler. The host owns execution and wakeup. */
 export declare class NativeBackgroundLifecycle {
     private readonly context;
     private readonly settle;
     private readonly owner?;
+    private readonly recoverResult?;
     private readonly operations;
     private readonly restored;
-    constructor(context: OpenCodeV2Context, settle: (dispatch: NativeBackgroundDispatch, text: string) => Promise<void>, owner?: ((callID: string, restore?: ObjectValue) => ObjectValue | undefined) | undefined);
+    constructor(context: OpenCodeV2Context, settle: (dispatch: NativeBackgroundDispatch, text: string) => Promise<string | void>, owner?: ((callID: string, restore?: ObjectValue) => ObjectValue | undefined) | undefined, recoverResult?: ((parent: string, callID: string, child: string, promptID?: string) => Promise<string | undefined>) | undefined);
     private serial;
     private read;
     private write;
@@ -31,6 +34,8 @@ export declare class NativeBackgroundLifecycle {
     launched(parent: string, callID: string, child: string | undefined, running: boolean): Promise<boolean>;
     awaiting(sessionID: string): Promise<boolean>;
     reconcile(parent: string): Promise<void>;
+    /** Add provenance beside its existing native notification, without editing history or waking the parent again. */
+    project(parent: string, messages: readonly unknown[]): Promise<unknown[]>;
     /** Restore accounting before a resumed child produces further tool observations. */
     resume(sessionID: string): Promise<void>;
     checkpoint(sessionID: string): Promise<void>;