sortie-dogs 0.13.15 → 0.13.17

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.15](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.15)**
-· [Release notes](docs/release-v0.13.15.md)
+**Current release: [v0.13.17](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.17)**
+· [Release notes](docs/release-v0.13.17.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.15
+npm install --save-dev sortie-dogs@0.13.17
 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.15
+npm install --save-dev sortie-dogs@0.13.17
 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.15**. SWE-bench remains an optional
+All scores belong to their fixed candidates, **not v0.13.17**. 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.15-native-identity-v1`; the unchanged Codex skill marker is
+The current Mission asset marker is `0.13.17-handoff-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.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) ·
+- **Releases:** [v0.13.17](docs/release-v0.13.17.md) · [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.15-native-identity-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.17-handoff-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.15-native-identity-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.17-handoff-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

@@ -224,7 +224,11 @@ export class OperatorMissionRuntime {
             continuity: { notes: state.continuity?.notes, sources, progress: state.progress,
                 attempts: (state.attempts ?? []).map(({ runID, unitID, status, failure, resultClass, childSessionID }) => ({ run_id: runID, unit_id: unitID, status, failure, result_class: resultClass, session_id: childSessionID })),
                 execution: state.execution,
-                guidance: "Current original_requests/requirements govern; older plans remain historical. Continue from known decisions, environment, completed work and failures. Read snapshot JSON entries by message/call IDs only for a relevant gap. Recheck mutable facts when needed or conflicting; do not repeat unchanged setup/investigation merely because ownership changed. Historical results are not fresh formal validation or new authority." } };
+                source_authors: state.sourceAuthors ?? [],
+                corrections: (state.corrections ?? []).map(({ initialPrompt: _prompt, inlineReview: _inline, ...correction }) => correction),
+                retained_review: state.review ? { run_id: state.review.runID, verdict: state.review.verdict,
+                    mode: state.review.mode, author: state.review.child, result: state.review.result, self_recheck: state.review.selfRecheck } : null,
+                guidance: "Current original_requests/requirements govern; older plans remain historical. Continue from known decisions, environment, completed work, retained findings and failures. A new plan or author does not resolve findings or turn self-recheck into independent approval. Read snapshot JSON entries by message/call IDs only for a relevant gap. Recheck mutable facts when needed or conflicting; do not repeat unchanged setup/investigation/checks merely because ownership changed. Successful evidence remains with its actual author/call and input bindings; historical results are not new authority." } };
     }
     async load(file) {
         try {
@@ -755,7 +759,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;
@@ -803,14 +808,14 @@ export function missionPacket(mission, run) {
                 ? "Operator: use acceptance_summary to compare the submitted candidate with the verbatim original requests and actual evidence, inspect concrete gaps only, then complete_mission if satisfied. Do not routinely search archives or reread all source. Historical PASS is not current PASS. Report remaining evidence gaps; they are not a review PASS."
                 : run?.phase === "awaiting-acceptance" && mission.corrections?.some(item => item.runID === run.runID && item.status === "ready") && !reviewAccepted
                     ? mission.corrections.find(item => item.runID === run.runID)?.selfRecheck?.unresolvedFindings.length
-                        ? "Known Major/Medium findings remain after self-recheck. Call repair_review for the SAME original correction owner; do not dispatch another Reviewer or accept unresolved Medium. Retain original requirements and cumulative spend."
+                        ? "Known Major/Medium findings remain after self-recheck. Correct them with repair_review (reuse the author by default, or select an available Reviewer), or plan_units for Worker/direct execution. Retain findings, original requirements and cumulative spend; unresolved Medium is not acceptance."
                         : mission.corrections.find(item => item.runID === run.runID)?.selfRecheck?.residualMajor
                             ? "A concrete reachable Major risk remains after native author self-recheck. Call review_mission for a DIFFERENT Reviewer of the correction, retained findings and relevant impact; dispatch the exact returned Task if not already active. No fresh Worker or unchanged validation is required."
-                            : "Correction ready; call review_mission for the SAME native author to explicitly self-recheck the retained findings, relevant impact and original requirements. Only a concrete reachable Major risk remaining after self-recheck requires a DIFFERENT Reviewer. Known Major/Medium defects still require correction. Do not restart unchanged checks or investigation; CORRECTION_READY alone is not acceptance."
+                            : "Correction ready; reuse the native author for explicit self-recheck or select an independent Reviewer with review_mission when useful. Remaining authorized implementation may proceed with plan_units without acceptance. Known Major/Medium defects still require correction. Do not restart unchanged checks or investigation; CORRECTION_READY alone is not acceptance."
                     : mission.kind === "operation" && operationStatus === "running"
                         ? "The declared operation is already running. Inspect its native shell/progress; do not start another Worker or run. Wait for a terminal result, or report the existing run as blocked if its completion cannot be observed."
                         : run?.phase === "awaiting-decision" && mission.corrections?.some(item => item.runID === run.runID && item.status === "failed")
-                            ? "Correction validation or native execution failed. Call repair_review for a new admission in the SAME original Reviewer's native session; fix its own regression, rerun inherited checks and retain the commit/clean boundary and cumulative spend. Do not use ordinary retry, Rescue or a fresh Worker replan. Failure is never acceptance."
+                            ? "Correction validation or native execution failed. Reuse its context with repair_review, select another available Reviewer, or plan_units for Worker/direct correction. Retain findings, affected checks, requested delivery and cumulative spend. Failure is never acceptance."
                             : run?.phase === "awaiting-decision" ? (run.units.some(unit => unit.dispatchDenial)
                                 ? "Coordinator: inspect units[].dispatch_denial before changing the plan. Correct only its diagnosed cause; do not repeat an unchanged refused Task or replan for a host-state mismatch. Report an unresolved runtime mismatch with the loaded runtime identity; preserve requirements and cumulative spend."
                                 : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && !unit.normalRemediationUsed)
@@ -821,8 +826,8 @@ export function missionPacket(mission, run) {
                                 : run?.phase === "awaiting-acceptance" && !operationComplete
                                     ? `Requested operation is ${operationStatus}. Continue the actual operation or report its blocker; auxiliary checks and review disposition cannot complete it.`
                                     : run?.phase === "awaiting-acceptance" ? (reviewAccepted
-                                        ? "Coordinator: review permits submission. Retain advisory review notes; do not repeat passed validation or review for evidence formatting. Operator performs final acceptance against the original requirements."
-                                        : "Coordinator: correct known Major/Medium findings, then obtain explicit native author self-recheck (different Reviewer only for residual concrete Major risk), or initial independent review, then submit_mission. Operator compares all requirements with source/evidence before complete_mission.")
+                                        ? "Coordinator: review permits submission, not completion of remaining implementation. Continue authorized remaining work with plan_units, or submit when the original requirements are met. Retain review notes; do not repeat passed validation or review for evidence formatting. Operator final acceptance remains separate."
+                                        : "Coordinator: correct known Major/Medium findings, then obtain native author self-recheck or useful independent review (required for concrete residual Major risk). Remaining authorized implementation can proceed without submission/acceptance. Operator compares all requirements with source/evidence before complete_mission.")
                                         : "Coordinator: continue the next useful unit within original requirements. Return only a completion candidate, user-only decision, or scope/budget extension." };
 }
 /** Models forward a short capability, never recopy the host's evidence hashes and source packet. */

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

@@ -280,6 +280,8 @@ export declare class OperatorRuntime {
     private file;
     /** Exact persisted source for read-only status projections. */
     statePath(root: string): string;
+    /** Stable detail source for a settled run replaced by Mission replanning. */
+    replanArchivePath(state: OperatorState): string;
     /** Read-only lineage projection. Never imports archived evidence into current acceptance. */
     acceptanceHistory(state: OperatorState, missionRunIDs: readonly string[]): Promise<{
         status: "available" | "unavailable";

package/dist/core/operator-runtime.js

@@ -276,6 +276,10 @@ export class OperatorRuntime {
     }
     /** Exact persisted source for read-only status projections. */
     statePath(root) { return this.file(root); }
+    /** Stable detail source for a settled run replaced by Mission replanning. */
+    replanArchivePath(state) {
+        return `${this.file(state.rootSessionID)}.${state.runID}.${state.sequence}.archive`;
+    }
     /** Read-only lineage projection. Never imports archived evidence into current acceptance. */
     async acceptanceHistory(state, missionRunIDs) {
         const runs = [];
@@ -791,10 +795,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 } };
@@ -871,14 +882,12 @@ export class OperatorRuntime {
             if (!previous || previous.runID !== mission.replaceRunID || ["cancelled", "completed"].includes(previous.phase)) {
                 throw new Error("mission-replan-run-mismatch");
             }
-            if (previous.units.some(unit => unit.reviewerCorrection) && !mission.reviewerCorrection) {
-                throw new Error("mission-review-correction-owner-continuation-required");
-            }
-            if (previous.units.some(unit => unit.status === "running") || (previous.gitLifecycle !== null && !mission.reviewerCorrection))
+            // Completed correction/Git metadata is history, not a live writer lease.
+            // The plugin reconciles actual native executions before replacing this run.
+            if (previous.units.some(unit => unit.status === "running"))
                 throw new Error("mission-replan-worker-still-active");
-            const failedContinuation = previous.phase === "awaiting-decision" && previous.units.every(unit => unit.status === "failed" && unit.reviewerCorrection?.author === mission.reviewerCorrection?.author);
+            const failedContinuation = previous.phase === "awaiting-decision" && previous.units.every(unit => unit.status === "failed" && unit.reviewerCorrection);
             if (mission.reviewerCorrection && ((!failedContinuation && (previous.phase !== "awaiting-acceptance" || previous.units.some(unit => unit.status !== "succeeded"))) ||
-                previous.units.some(unit => unit.reviewerCorrection && unit.reviewerCorrection.author !== mission.reviewerCorrection.author) ||
                 plan.units.length !== 1 || plan.acceptance.length !== previous.acceptance.length ||
                 previous.acceptance.some((text, i) => text !== plan.acceptance[i]) ||
                 JSON.stringify(plan.acceptance_proof) !== JSON.stringify(previous.acceptanceProof) ||
@@ -1159,10 +1168,11 @@ export class OperatorRuntime {
                     await handle.close();
                 }
             }
-            if ((superseding || replanning) && previous) {
+            if ((superseding || replanning || previous?.phase === "completed") && previous) {
                 // A crash before the state switch may leave a checkpoint while the old run later advances.
                 // Sequence-qualified replan snapshots keep that history without blocking a subsequent correction.
-                const archive = `${this.file(root)}.${previous.runID}${replanning ? `.${previous.sequence}` : ""}.archive`;
+                const archive = replanning || previous.phase === "completed" ? this.replanArchivePath(previous)
+                    : `${this.file(root)}.${previous.runID}.archive`;
                 try {
                     const handle = await open(archive, "wx", 0o600);
                     created.push(archive);
@@ -1316,8 +1326,6 @@ export class OperatorRuntime {
             return args.task_id === expected.task_id && args.subagent_type === expected.subagent_type &&
                 args.description === expected.description && args.prompt === expected.prompt;
         }
-        if (unit.reviewerCorrection && (args.model !== undefined || args.variant !== undefined))
-            return false;
         if (unit.reviewerCorrection ? args.task_id !== unit.reviewerCorrection.author : args.task_id !== undefined && args.task_id !== "")
             return false;
         if (args.subagent_type !== unit.task.subagent_type || args.description !== unit.task.description)

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/gate.d.ts

@@ -70,6 +70,10 @@ export declare function normalizeCommand(command: string): string;
 export declare function canonicalDeclaredValidationSequence(command: string, declared: ReadonlySet<string>): string | undefined;
 /** Preserve ordered members (including repeats) without splitting quoted text or substring matching. */
 export declare function canonicalDeclaredValidationMembers(command: string, declared: ReadonlySet<string> | readonly string[], occurrence?: number): string[] | undefined;
+/** Observation only, never shell authority. A successful native && chain can prove
+ * its exact declared tail after diagnostics/empty-directory cleanup. The caller
+ * must retain the real exit and the snapshot captured BEFORE the whole command. */
+export declare function canonicalObservedValidationMembers(command: string, declared: ReadonlySet<string> | readonly string[], occurrence?: number): string[] | undefined;
 /** Unbound sessions may invoke only tools whose complete input is known to be read-only. */
 export declare function isKnownReadOnlyTool(tool: string, args: unknown, additionalReadOnlyTools?: ReadonlySet<string>): boolean;
 /** Canonical scopes let sibling worker bindings reject equal or ancestor ownership. */

package/dist/plugin/gate.js

@@ -997,6 +997,40 @@ export function canonicalDeclaredValidationMembers(command, declared, occurrence
     };
     return sequence(0);
 }
+/** Observation only, never shell authority. A successful native && chain can prove
+ * its exact declared tail after diagnostics/empty-directory cleanup. The caller
+ * must retain the real exit and the snapshot captured BEFORE the whole command. */
+export function canonicalObservedValidationMembers(command, declared, occurrence = 0) {
+    const exact = canonicalDeclaredValidationMembers(command, declared, occurrence);
+    if (exact)
+        return exact;
+    const syntax = scanShellSyntax(command, "posix");
+    // Do not infer a tail through comments, expansions, redirection, subshells or
+    // shell-state changes. Unsupported observations leave existing authority alone.
+    if (syntax.unsafeExpansion || syntax.activeBrace || /[\\#$()<>`]/u.test(syntax.masked))
+        return undefined;
+    const segments = shellSegments(command, "posix").map(segment => segment.trim());
+    if (segments.length < 2 || segments.some(segment => !segment) ||
+        normalizeCommand(command) !== segments.map(normalizeCommand).join(" && "))
+        return undefined;
+    const identities = [...new Set(declared)];
+    for (let start = 1; start < segments.length; start++) {
+        const prefix = segments[start - 1];
+        // Never discard an ordered declared occurrence to find a later matching tail.
+        if (declaredCommandMatch(prefix, identities) !== undefined)
+            return undefined;
+        if (prefix.includes("`"))
+            return undefined;
+        const extracted = shellPaths(prefix, false);
+        const cleanup = /^rmdir(?:\s|$)/u.test(prefix);
+        if (extracted.ambiguous || extracted.remoteMutation || extracted.gitMutation || extracted.applies && !cleanup)
+            return undefined;
+        const members = canonicalDeclaredValidationMembers(segments.slice(start).join(" && "), declared, occurrence);
+        if (members)
+            return members;
+    }
+    return undefined;
+}
 /** Unbound sessions may invoke only tools whose complete input is known to be read-only. */
 export function isKnownReadOnlyTool(tool, args, additionalReadOnlyTools = new Set()) {
     const name = tool.toLowerCase();

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.d.ts

@@ -73,6 +73,7 @@ export declare function missionReviewValidation(run: OperatorState, statePath: s
 export declare function observedMissionValidation(validation: readonly string[], childSessionID: string | null, history: readonly Record<string, unknown>[], notBefore?: number, directory?: string, directories?: Readonly<Record<string, string>>): {
     attempts: readonly {
         command: string;
+        native_command?: string;
         directory?: string;
         observed_members?: readonly string[];
         exit_code: number | null;