sortie-dogs 0.13.20 → 0.13.22

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.20](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.20)**
-· [Release notes](docs/release-v0.13.20.md)
+**Current release: [v0.13.21](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.21)**
+· [Release notes](docs/release-v0.13.21.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.20
+npm install --save-dev sortie-dogs@0.13.21
 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.20
+npm install --save-dev sortie-dogs@0.13.21
 npx --no-install sortie-dogs init .
 ```
 
@@ -193,7 +193,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.20**. SWE-bench remains an optional
+All scores belong to their fixed candidates, **not v0.13.21**. SWE-bench remains an optional
 measurement, not a release gate. Different budgets, models and conditions are not controlled comparisons.
 
 ## Configuration
@@ -216,7 +216,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.20-review-followup-v1`; the unchanged Codex skill marker is
+The current Mission asset marker is `0.13.21-operation-recovery-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;
@@ -232,7 +232,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.20](docs/release-v0.13.20.md) · [v0.13.19](docs/release-v0.13.19.md) · [v0.13.18](docs/release-v0.13.18.md) · [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) ·
+- **Releases:** [v0.13.21](docs/release-v0.13.21.md) · [v0.13.20](docs/release-v0.13.20.md) · [v0.13.19](docs/release-v0.13.19.md) · [v0.13.18](docs/release-v0.13.18.md) · [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.20-review-followup-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.22-owned-task-lifecycle-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.20-review-followup-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.22-owned-task-lifecycle-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";

package/dist/cli/codex-mission.js

@@ -47,7 +47,7 @@ export async function runCodexMissionCommand(argv) {
         const result = await adapter.run(prompt);
         process.stdout.write(`${JSON.stringify({ status: result.accepted ? "succeeded" : "incomplete", root_session_id: result.rootSessionID,
             thread_id: result.turn.threadID, turn_id: result.turn.turnID, native_status: result.turn.status,
-            response: result.turn.finalResponse, sessions: result.sessions, cost: null })}\n`);
+            response: result.turn.finalResponse, lifecycle: result.lifecycle, sessions: result.sessions, cost: null })}\n`);
         return signalExit ?? (result.accepted ? 0 : 1);
     }
     catch (error) {
@@ -66,6 +66,11 @@ export async function runCodexMissionCommand(argv) {
 }
 /** Bounded user-facing progress; do not dump control packets or hidden reasoning. */
 export function codexMissionProgress(event) {
+    if (event.method === "turn/completed")
+        return { thread_id: event.threadId, phase: "native-turn-terminal", turn_id: event.params.turn?.id,
+            native_status: event.params.turn?.status };
+    if (event.method === "sortie/continuation")
+        return { thread_id: event.threadId, turn_id: event.params.turnId, phase: event.params.phase, calls: event.params.calls };
     if (event.method === "sortie/modelRoute")
         return { thread_id: event.threadId, phase: "model-route", agent: event.params.agent, model: event.params.model,
             effort: event.params.effort, service_tier: event.params.serviceTier };

package/dist/codex/app-server.d.ts

@@ -46,6 +46,14 @@ export interface CodexTurnResult {
     readonly finalResponse?: string;
     readonly items: readonly JsonObject[];
     readonly usage?: JsonObject;
+    /** Host tools still running at native turn completion, drained without resending them. */
+    readonly deferredToolResults?: readonly CodexDeferredToolResult[];
+}
+export interface CodexDeferredToolResult {
+    readonly callID: string;
+    readonly tool: string;
+    readonly success: boolean;
+    readonly output: string;
 }
 export interface CodexAuthenticationState {
     readonly type: string | null;

package/dist/codex/app-server.js

@@ -188,7 +188,7 @@ export class CodexAppServerHost {
         if (!turnID)
             throw new CodexHostError("protocol-invalid-response", "turn/start returned no turn id.");
         return new Promise((resolve, reject) => {
-            this.active = { threadID, turnID, items: [], observer: Promise.resolve(), onEvent: options.onEvent, resolve, reject };
+            this.active = { threadID, turnID, items: [], observer: Promise.resolve(), tools: new Set(), onEvent: options.onEvent, resolve, reject };
             const backlog = this.notificationBacklog.splice(0);
             void backlog.reduce((prior, event) => prior.then(() => this.notification(event.method, event.params)), Promise.resolve())
                 .catch(error => { this.active?.reject(error); this.active = undefined; });
@@ -289,20 +289,34 @@ export class CodexAppServerHost {
         const params = object(message.params) ? message.params : {};
         if (method === "item/tool/call") {
             const active = this.active;
-            let result;
+            if (!active || active.completing || params.threadId !== active.threadID || params.turnId !== active.turnID ||
+                (params.namespace != null) || typeof params.callId !== "string" || typeof params.tool !== "string" || !this.options.dynamicTool) {
+                this.transport.send({ id: message.id, result: { contentItems: [{ type: "inputText",
+                                text: "Dynamic tool call does not belong to an active Sortie turn." }], success: false } });
+                return;
+            }
+            const call = { threadId: active.threadID, turnId: active.turnID, callId: params.callId, tool: params.tool, arguments: params.arguments };
+            const pending = Promise.resolve().then(async () => {
+                let output, success;
+                try {
+                    output = await this.options.dynamicTool(call);
+                    success = true;
+                }
+                catch (error) {
+                    output = error instanceof Error ? error.message : "Dynamic tool failed.";
+                    success = false;
+                }
+                if (!this.closed && !this.fault)
+                    this.transport.send({ id: message.id, result: { contentItems: [{ type: "inputText", text: output }], success } });
+                return { callID: call.callId, tool: call.tool, success, output };
+            });
+            active.tools.add(pending);
             try {
-                if (!active || active.completing || params.threadId !== active.threadID || params.turnId !== active.turnID ||
-                    (params.namespace != null) || typeof params.callId !== "string" || typeof params.tool !== "string" || !this.options.dynamicTool)
-                    throw new Error("Dynamic tool call does not belong to an active Sortie turn.");
-                const output = await this.options.dynamicTool({ threadId: active.threadID, turnId: active.turnID,
-                    callId: params.callId, tool: params.tool, arguments: params.arguments });
-                result = { contentItems: [{ type: "inputText", text: output }], success: true };
+                await pending;
             }
-            catch (error) {
-                result = { contentItems: [{ type: "inputText", text: error instanceof Error ? error.message : "Dynamic tool failed." }], success: false };
+            finally {
+                active.tools.delete(pending);
             }
-            if (!this.closed)
-                this.transport.send({ id: message.id, result });
             return;
         }
         if (method === "item/commandExecution/requestApproval" || method === "item/fileChange/requestApproval") {
@@ -374,14 +388,23 @@ export class CodexAppServerHost {
         // requests such as interrupt(), whose response must be read by this pump.
         // Keep the completing turn active until observers settle so close() can
         // reject it and a later turn cannot receive an interrupt meant for it.
-        void active.observer.then(() => {
+        const deferred = status === "completed" ? [...active.tools] : [];
+        // Native response completion is not host execution completion. Keep pumping
+        // command responses and child Tasks; explicit close/transport loss can still
+        // reject this turn. Failed/interrupted native turns never auto-continue.
+        void Promise.all([active.observer, Promise.all(deferred)]).then(([, tools]) => {
             if (this.active !== active)
                 return;
             this.active = undefined;
             if (active.observerError)
                 active.reject(new CodexHostError("request-failed", "Codex turn event observer failed.", active.observerError));
             else
-                active.resolve(result);
+                active.resolve({ ...result, ...(tools.length ? { deferredToolResults: tools } : {}) });
+        }).catch(error => {
+            if (this.active !== active)
+                return;
+            this.active = undefined;
+            active.reject(error);
         });
     }
 }

package/dist/codex/mission-session.d.ts

@@ -67,6 +67,12 @@ export declare class CodexMissionSession {
         rootSessionID: string;
         turn: CodexTurnResult;
         accepted: boolean;
+        lifecycle: {
+            root_turn_terminal: boolean;
+            owned_tasks_settled: boolean;
+            mission_phase: string | null;
+            mission_accepted: boolean;
+        };
         sessions: readonly JsonObject[];
     }>;
     private stopHosts;
@@ -85,6 +91,7 @@ export declare class CodexMissionSession {
     private restoreSession;
     private tools;
     private prompt;
+    private promptTurn;
     private execute;
 }
 export {};

package/dist/codex/mission-session.js

@@ -72,8 +72,11 @@ export class CodexMissionSession {
         const previous = await new OperatorMissionRuntime(this.directory, profile).read(session.id);
         const turn = await this.prompt(session, prompt);
         const mission = await new OperatorMissionRuntime(this.directory, profile).read(session.id);
-        return { rootSessionID: session.id, turn, accepted: turn.status === "completed" && mission?.phase === "completed" &&
-                (previous?.phase !== "completed" || previous.id !== mission.id), sessions: [...this.sessions.values()].map(item => ({ thread_id: item.id, agent: item.agent, model: item.model, usage: item.usage ?? null, usage_scope: "native-thread-cumulative", cost: null })) };
+        const ownedTasksSettled = [...this.sessions.values()].every(item => !["running", "unknown"].includes(item.outcome));
+        const accepted = turn.status === "completed" && ownedTasksSettled && mission?.phase === "completed" &&
+            (previous?.phase !== "completed" || previous.id !== mission.id);
+        return { rootSessionID: session.id, turn, accepted, lifecycle: { root_turn_terminal: ["completed", "failed", "interrupted", "cancelled"].includes(turn.status),
+                owned_tasks_settled: ownedTasksSettled, mission_phase: mission?.phase ?? null, mission_accepted: accepted }, sessions: [...this.sessions.values()].map(item => ({ thread_id: item.id, agent: item.agent, model: item.model, usage: item.usage ?? null, usage_scope: "native-thread-cumulative", cost: null })) };
     }
     async stopHosts() {
         this.closed = true;
@@ -459,11 +462,33 @@ export class CodexMissionSession {
         return tools;
     }
     async prompt(session, prompt, onDispatch) {
+        let result = await this.promptTurn(session, prompt, onDispatch);
+        while (result.status === "completed" && result.deferredToolResults?.length) {
+            if (this.closed)
+                throw new Error("Codex Mission adapter is closed.");
+            const mission = await new OperatorMissionRuntime(this.directory, profile).read(this.rootOf(session));
+            if (!mission || ["completed", "cancelled"].includes(mission.phase))
+                break;
+            await this.claimOwner(this.rootOf(session));
+            await this.options.onEvent?.({ method: "sortie/continuation", threadId: session.id,
+                params: { turnId: result.turnID, phase: "owned-tools-settled", calls: result.deferredToolResults.map(item => ({ callId: item.callID, tool: item.tool, success: item.success })) } });
+            result = await this.promptTurn(session, "The previous native response ended while existing host tools were still running. Those exact calls have now returned:\n" +
+                JSON.stringify(result.deferredToolResults) +
+                "\nContinue this same Mission from these results through the remaining validation, delivery, review and root acceptance. " +
+                "Do not resend the original request or redispatch the completed Tasks. Preserve failures, ownership and cumulative budget; use existing Mission status for the next action.", undefined, true);
+        }
+        return result;
+    }
+    async promptTurn(session, prompt, onDispatch, continuation = false) {
         const startedAt = Date.now();
         const messageID = randomUUID();
         const message = { id: messageID, agent: session.agent, model: { ...session.model } };
-        const parts = [{ type: "text", text: prompt }];
-        await this.hooks["chat.message"]?.({ sessionID: session.id, messageID, agent: session.agent }, { message, parts });
+        const parts = [{ type: "text", text: prompt, ...(continuation ? { synthetic: true } : {}) }];
+        // Only this host's drained results can continue an already-admitted execution.
+        // Reclaiming that Task with the result prompt rejects Workers' exact handoff;
+        // treating it as a real root request also grants spurious user-turn authority.
+        if (!continuation)
+            await this.hooks["chat.message"]?.({ sessionID: session.id, messageID, agent: session.agent }, { message, parts });
         // Shared Task routing may select a model; explicit adapter overrides still govern every native turn.
         if (message.model.providerID !== "openai")
             throw new Error("Codex Mission cannot use a non-OpenAI model route.");

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

@@ -101,16 +101,30 @@ export interface MissionTerminalRescue {
 export interface MissionExecution {
     commands: string[];
     directory: string;
+    /** History-service availability is not a process outcome or an execution permission. */
+    recovery?: {
+        status: "unavailable";
+        errors: {
+            sessionID: string;
+            reason: string;
+        }[];
+    };
     observations: {
         command: string;
         directory: string;
         callID: string;
         sessionID: string;
         startedAt: string;
+        /** Actual native execution start, distinct from a live hook's admission clock. */
+        nativeStartedAt?: string;
         completedAt?: string;
         exit?: number;
         status?: "running" | "completed" | "error";
         shellID?: string;
+        /** Contradictory native records retained for this same call, not a process outcome. */
+        conflicting?: boolean;
+        /** Latest actual start reported for a conflicting call; original startedAt is retained. */
+        latestConflictingStartedAt?: string;
         outcome?: "not-started" | "execution-failed" | "executed";
         result?: Record<string, unknown>;
     }[];
@@ -314,10 +328,19 @@ export declare function missionReviewVerdict(text: string): "PASS" | "evidence-g
 export declare function missionReviewAccepted(review: NonNullable<OperatorMission["review"]>): boolean;
 /** A short native report, not a tag/hash-based second-review policy or an approval checklist. */
 export declare function missionSelfRecheckReport(text: string, source: string, hostBound?: boolean): Pick<MissionSelfRecheck, "unresolvedFindings" | "residualMajor"> | undefined;
-export declare function missionExecutionStatus(mission: OperatorMission): "not-required" | "not-started" | "running" | "execution-failed" | "executed";
+export declare function missionExecutionStatus(mission: OperatorMission): "not-required" | "not-started" | "recovery-unavailable" | "recovery-blocked" | "running" | "execution-failed" | "executed";
+/** Native Windows cwd case/separator spelling is not a different operation directory. */
+export declare function missionOperationDirectoryMatch(actual: string, declared: string): boolean;
+/** Match only the same declared operation, allowing its native PowerShell envelope and
+ * an absolute Node/script/path spelling resolved from the unchanged operation cwd. */
+export declare function missionOperationCommandMatch(command: string, declared: readonly string[], directory: string): string | undefined;
+/** Apply the existing no-decoration operation check to the same accepted native spelling. */
+export declare function missionOperationCommandDecorated(command: string, declared: readonly string[], directory: string): boolean;
 /** A terminal failure is a collected result, not a successful operation. Required success
  * remains in the declared formal checks and Operator's original-request comparison. */
 export declare function missionExecutionComplete(mission: OperatorMission): boolean;
+/** Missing history cannot justify replay; adequate collected results remain usable. */
+export declare function missionExecutionRecoveryAction(mission: OperatorMission): string | undefined;
 /** Projection of existing observations only; never another check or inferred success. */
 export declare function missionOperationSummary(mission: OperatorMission): Record<string, unknown>;
 /** Observe the command's own terminal summary, never Worker/Reviewer prose. Scores are result data,

package/dist/core/operator-mission.js

@@ -1,10 +1,10 @@
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, open, readFile, readdir, rename, rm, rmdir, unlink, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { join, resolve, win32 } from "node:path";
 import { normalizeExecutionScope } from "./path.js";
 import { parseOperatorPlan } from "./operator-runtime.js";
 import { profileAgent } from "./runtime-profile.js";
-import { normalizeCommand } from "../plugin/gate.js";
+import { normalizeCommand, shellCommandBase, shellCommandWords } from "../plugin/gate.js";
 import { missionValidationCommand } from "./mission-validation-command.js";
 import { retainMissionContext, missionContextView } from "./mission-context.js";
 import { planWorkQuantity, projectWorkQuantity, syncWorkQuantity } from "./work-quantity.js";
@@ -111,22 +111,129 @@ export function missionExecutionStatus(mission) {
     if (mission.kind !== "operation")
         return "not-required";
     const execution = mission.execution;
-    if (!execution || execution.commands.length === 0 || execution.observations.length === 0)
+    if (!execution || execution.commands.length === 0)
         return "not-started";
-    const latest = execution.commands.map(command => [...execution.observations].reverse().find(item => item.command === command && item.directory === execution.directory));
+    if (execution.observations.length === 0)
+        return execution.recovery ? "recovery-unavailable" : "not-started";
+    // Recovery may discover an older call after a newer live/failed observation was saved.
+    const orderingTime = (item) => Math.max(Date.parse(item.nativeStartedAt ?? item.startedAt), Date.parse(item.latestConflictingStartedAt ?? item.nativeStartedAt ?? item.startedAt));
+    const ordered = [...execution.observations].sort((left, right) => orderingTime(left) - orderingTime(right)).reverse();
+    const latest = execution.commands.map(command => ordered.find(item => item.command === command && item.directory === execution.directory));
+    if (latest.some(item => item?.conflicting || item && ["completed", "error"].includes(item.status ?? "") &&
+        !["executed", "execution-failed", "not-started"].includes(item.outcome ?? "")))
+        return "recovery-blocked";
     if (latest.some(item => item && !item.completedAt))
         return "running";
+    if (latest.some(item => !item) && execution.recovery)
+        return "recovery-unavailable";
     if (latest.some(item => !item || !["executed", "execution-failed"].includes(item.outcome ?? "")))
         return "not-started";
     if (latest.some(item => item?.outcome === "execution-failed" || (item && (item.status === "error" || item.exit !== 0))))
         return "execution-failed";
     return "executed";
 }
+function stripMissionPowerShellPrefix(command) {
+    return command.trim().replace(/^\$ErrorActionPreference\s*=\s*(['"])Stop\1\s*;\s*/iu, "");
+}
+function missionCommandTokens(command) {
+    const tokens = shellCommandWords(stripMissionPowerShellPrefix(command));
+    if (tokens[0] === "&")
+        tokens.shift();
+    return tokens.length ? tokens : undefined;
+}
+function missionWindowsPath(value) {
+    return /^[A-Za-z]:[\\/]/u.test(value) || value.startsWith("\\\\");
+}
+function missionPathIdentity(value, directory, windows) {
+    if (!windows)
+        return resolve(directory, value);
+    return win32.normalize(win32.resolve(directory, value)).toLowerCase();
+}
+/** Native Windows cwd case/separator spelling is not a different operation directory. */
+export function missionOperationDirectoryMatch(actual, declared) {
+    const windows = missionWindowsPath(actual) || missionWindowsPath(declared);
+    return missionPathIdentity(actual, declared, windows) === missionPathIdentity(declared, declared, windows);
+}
+function sameNodeOperation(declared, actual, directory) {
+    const expected = missionCommandTokens(declared), observed = missionCommandTokens(actual);
+    if (!expected || !observed || expected.length !== observed.length || expected.length < 2)
+        return false;
+    const windows = missionWindowsPath(directory);
+    const name = (value) => {
+        const basename = value.split(windows ? /[\\/]/u : /\//u).at(-1) ?? "";
+        return windows ? basename.toLowerCase() : basename;
+    };
+    const nodeNames = windows ? ["node", "node.exe"] : ["node"];
+    if (!nodeNames.includes(name(expected[0])) || !nodeNames.includes(name(observed[0])))
+        return false;
+    const executablePath = (value) => windows ? /[\\/]/u.test(value) : value.includes("/");
+    if (executablePath(expected[0]) && (!executablePath(observed[0]) ||
+        missionPathIdentity(expected[0], directory, windows) !== missionPathIdentity(observed[0], directory, windows)))
+        return false;
+    const script = expected[1];
+    if (!/\.(?:cjs|mjs|js)$/iu.test(script) || !/\.(?:cjs|mjs|js)$/iu.test(observed[1]))
+        return false;
+    if (missionPathIdentity(script, directory, windows) !== missionPathIdentity(observed[1], directory, windows))
+        return false;
+    for (let index = 2; index < expected.length; index += 1) {
+        const left = expected[index], right = observed[index];
+        if (left === right)
+            continue;
+        // Options and URI values are script inputs, not filesystem paths with Windows case rules.
+        const literal = (value) => value.startsWith("-") || !missionWindowsPath(value) && /^[A-Za-z][A-Za-z\d+.-]*:/u.test(value);
+        if (literal(left) || literal(right))
+            return false;
+        // Only the supported absolute-path substitution can change a positional argument.
+        // Two different relative opaque values must not collapse via path normalization.
+        const absolute = (value) => missionWindowsPath(value) || value.startsWith("/");
+        const pathArgument = absolute(left) !== absolute(right) || windows && missionWindowsPath(left) && missionWindowsPath(right);
+        if (pathArgument
+            ? missionPathIdentity(left, directory, windows) !== missionPathIdentity(right, directory, windows)
+            : left !== right)
+            return false;
+    }
+    return true;
+}
+/** Match only the same declared operation, allowing its native PowerShell envelope and
+ * an absolute Node/script/path spelling resolved from the unchanged operation cwd. */
+export function missionOperationCommandMatch(command, declared, directory) {
+    const normalized = normalizeCommand(stripMissionPowerShellPrefix(command));
+    const exact = declared.filter(item => normalizeCommand(stripMissionPowerShellPrefix(item)) === normalized);
+    if (exact.length === 1)
+        return normalizeCommand(exact[0]);
+    if (exact.length > 1)
+        return undefined;
+    const equivalent = declared.filter(item => sameNodeOperation(item, command, directory));
+    return equivalent.length === 1 ? normalizeCommand(equivalent[0]) : undefined;
+}
+/** Apply the existing no-decoration operation check to the same accepted native spelling. */
+export function missionOperationCommandDecorated(command, declared, directory) {
+    if (missionOperationCommandMatch(command, declared, directory) !== undefined)
+        return false;
+    const stripped = stripMissionPowerShellPrefix(command), actual = normalizeCommand(stripped);
+    if (declared.some(item => {
+        const expected = normalizeCommand(stripMissionPowerShellPrefix(item));
+        return actual.startsWith(expected) && /^\s*(?:\||\d?>|&&?|;)/u.test(actual.slice(expected.length));
+    }))
+        return true;
+    const base = shellCommandBase(stripped, stripped !== command.trim() || stripped.startsWith("&") ? "powershell" : "posix");
+    return base !== undefined && missionOperationCommandMatch(base, declared, directory) !== undefined;
+}
 /** A terminal failure is a collected result, not a successful operation. Required success
  * remains in the declared formal checks and Operator's original-request comparison. */
 export function missionExecutionComplete(mission) {
     return ["not-required", "executed", "execution-failed"].includes(missionExecutionStatus(mission));
 }
+/** Missing history cannot justify replay; adequate collected results remain usable. */
+export function missionExecutionRecoveryAction(mission) {
+    if (missionExecutionStatus(mission) === "recovery-blocked")
+        return "An admitted operation has missing or contradictory terminal evidence. Preserve existing observations; inspect the same native call's shell/progress and recover its actual result. " +
+            "Do not replay or rerun the operation. Report the actual recovery blocker if its result remains unknown.";
+    if (!mission.execution?.recovery || missionExecutionComplete(mission))
+        return undefined;
+    return "Native operation history could not be read. Preserve existing observations; inspect the admitted session's existing shell/progress or restore the history reader. " +
+        "Do not replay or rerun the operation. Report the actual recovery blocker if history remains unavailable.";
+}
 /** Projection of existing observations only; never another check or inferred success. */
 export function missionOperationSummary(mission) {
     const status = missionExecutionStatus(mission);
@@ -836,21 +943,22 @@ export function missionPacket(mission, run, includeWorkQuantity = true) {
                             : "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. 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)
-                                    ? "Coordinator: one exact declared validation failed. Reconcile the returned Worker and cumulative budget, then call retry_mission_unit once for that unit before replanning. This preserves the same scope and acceptance."
-                                    : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && unit.normalRemediationUsed && !unit.terminalRescue)
-                                        ? "Coordinator: the one ordinary remediation failed the declared validation again. If its native terminal, writer release, exact candidate and cumulative budget permit, call rescue_mission_unit once; inspect and report a non_rescue reason, then continue ordinary correction within budget. Rescue does not bypass validation, review or root acceptance."
-                                        : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
-                                : 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, 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." };
+                        : missionExecutionRecoveryAction(mission) !== undefined ? missionExecutionRecoveryAction(mission)
+                            : run?.phase === "awaiting-decision" && mission.corrections?.some(item => item.runID === run.runID && item.status === "failed")
+                                ? "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)
+                                        ? "Coordinator: one exact declared validation failed. Reconcile the returned Worker and cumulative budget, then call retry_mission_unit once for that unit before replanning. This preserves the same scope and acceptance."
+                                        : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && unit.normalRemediationUsed && !unit.terminalRescue)
+                                            ? "Coordinator: the one ordinary remediation failed the declared validation again. If its native terminal, writer release, exact candidate and cumulative budget permit, call rescue_mission_unit once; inspect and report a non_rescue reason, then continue ordinary correction within budget. Rescue does not bypass validation, review or root acceptance."
+                                            : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
+                                    : 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, 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. */
 export function missionReviewTask(mission) {

package/dist/plugin/gate.d.ts

@@ -51,7 +51,14 @@ export declare function resolveProjectRoot(input: {
     directory: string;
     worktree?: string;
 }): string;
+/** Reuse the write-gate's quoted shell tokenization for non-authorizing command identity checks. */
+export declare function shellCommandWords(command: string): string[];
+type ShellDialect = "posix" | "powershell";
+/** The command before an unquoted shell suffix, reusing the gate's existing syntax scanner. */
+export declare function shellCommandBase(command: string, dialect: ShellDialect): string | undefined;
 export declare function describeUnclassifiedCommand(tool: string, args: unknown): string | undefined;
+/** Shell tool names already supported by the write gate, including native suffixes. */
+export declare function isShellTool(tool: string): boolean;
 /** Extract known write destinations; unknown shell executables fail closed as ambiguous. */
 export declare function extractWritePaths(tool: string, args: unknown, toolDirectory?: string): Extraction;
 /**

package/dist/plugin/gate.js

@@ -101,6 +101,10 @@ function unquote(value) {
 function words(command) {
     return command.match(/"(?:\\.|[^"])*"|'[^']*'|[^\s]+/gu)?.map(unquote) ?? [];
 }
+/** Reuse the write-gate's quoted shell tokenization for non-authorizing command identity checks. */
+export function shellCommandWords(command) {
+    return words(command);
+}
 function operands(tokens) {
     const result = [];
     for (let index = 1; index < tokens.length; index += 1) {
@@ -411,6 +415,18 @@ function shellSegments(command, dialect) {
     segments.push(command.slice(start));
     return segments;
 }
+/** The command before an unquoted shell suffix, reusing the gate's existing syntax scanner. */
+export function shellCommandBase(command, dialect) {
+    const masked = scanShellSyntax(command, dialect).masked;
+    for (let index = 0; index < masked.length; index += 1) {
+        const character = masked[index];
+        if (!";|><\r\n".includes(character) && !(character === "&" && masked.slice(0, index).trim()))
+            continue;
+        const base = command.slice(0, index);
+        return (character === ">" || character === "<" ? base.replace(/(?:^|\s)\d+$/u, "") : base).trim();
+    }
+    return undefined;
+}
 function depthOnePowerShellLiteral(source) {
     const match = /^\s*(?:"[^"]*(?:pwsh|powershell)(?:\.exe)?"|[^\s"']*(?:pwsh|powershell)(?:\.exe)?)\s+-noprofile\s+-command\s+'((?:''|[^'])*)'\s*$/iu.exec(source);
     return match?.[1].replaceAll("''", "'");
@@ -761,6 +777,10 @@ export function describeUnclassifiedCommand(tool, args) {
     const extracted = extractWritePaths(tool, args);
     return extracted.ambiguous && extracted.issue !== undefined ? issuePath(extracted.issue) : undefined;
 }
+/** Shell tool names already supported by the write gate, including native suffixes. */
+export function isShellTool(tool) {
+    return /^(?:bash|shell|powershell|pwsh)(?:$|[_-])/u.test(tool.toLowerCase());
+}
 /** Extract known write destinations; unknown shell executables fail closed as ambiguous. */
 export function extractWritePaths(tool, args, toolDirectory) {
     const name = tool.toLowerCase();
@@ -774,7 +794,7 @@ export function extractWritePaths(tool, args, toolDirectory) {
         const extracted = patch === undefined ? [] : patchPaths(patch);
         return { applies: true, ambiguous: extracted.length === 0, paths: [...paths, ...extracted] };
     }
-    if (/^(?:bash|shell|powershell|pwsh)(?:$|[_-])/u.test(name)) {
+    if (isShellTool(tool)) {
         const command = isRecord(args) && typeof args.command === "string" ? args.command : undefined;
         if (command === undefined) {
             const ambiguous = paths.length === 0;
@@ -1036,7 +1056,7 @@ export function isKnownReadOnlyTool(tool, args, additionalReadOnlyTools = new Se
     const name = tool.toLowerCase();
     if (READ_ONLY_TOOLS.has(name) || additionalReadOnlyTools.has(name))
         return true;
-    if (!/^(?:bash|shell|powershell|pwsh)(?:$|[_-])/u.test(name))
+    if (!isShellTool(tool))
         return false;
     const extraction = extractWritePaths(tool, args);
     return !extraction.applies && !extraction.ambiguous && extraction.remoteMutation !== true;

package/dist/plugin/profiled.js

@@ -11,9 +11,9 @@ import { BUILT_IN_MODEL_CATALOG } from "./model-routing.js";
 import { goalFingerprint } from "../core/goal-bound.js";
 import { decoratePreviewHeadings, returnReportPanel } from "./receipt-presentation.js";
 import { sanitizeTerminalReport, terminalRunOutcome } from "./run-metrics.js";
-import { normalizeCommand, canonicalObservedValidationMembers, extractWritePaths } from "./gate.js";
+import { normalizeCommand, canonicalObservedValidationMembers, extractWritePaths, isShellTool } from "./gate.js";
 import { normalizeExecutionScope, normalizeManifestScope, normalizeRelativePath } from "../core/path.js";
-import { OperatorMissionRuntime, missionAcceptanceSummary, missionPacket, missionPlan, missionReviewAccepted, missionReviewIndependent, missionReviewScope, missionReviewTask, missionCommandOutcome, missionConversationContext, missionExecutionComplete, missionExecutionStatus, missionOperationSummary, missionValidationCommand, missionReviewTraces, missionReviewVerdict, missionSelfRecheckReport } from "../core/operator-mission.js";
+import { OperatorMissionRuntime, missionAcceptanceSummary, missionPacket, missionPlan, missionReviewAccepted, missionReviewIndependent, missionReviewScope, missionReviewTask, missionCommandOutcome, missionConversationContext, missionExecutionComplete, missionExecutionRecoveryAction, missionExecutionStatus, missionOperationCommandMatch, missionOperationCommandDecorated, missionOperationDirectoryMatch, missionOperationSummary, missionValidationCommand, missionReviewTraces, missionReviewVerdict, missionSelfRecheckReport } from "../core/operator-mission.js";
 import { publishMissionProgress } from "./mission-progress.js";
 import { formatWorkQuantity, planWorkQuantity } from "../core/work-quantity.js";
 import { cachedWorkProgress, forgetWorkSession, observeActorWork, workRootForActor } from "../core/work-quantity-observations.js";
@@ -242,8 +242,14 @@ export function createProfiledPlugin(profile, assetVersion) {
             return observedMissionValidationSummary(validation, child, typeof nativeSession?.messages === "function"
                 ? () => session("messages", { path: { id: child }, query: { directory: input.directory } }) : undefined, notBefore, notBefore === undefined ? undefined : input.directory, direct?.unit.directExecution?.validationCwd ?? direct?.unit.unit.validation_cwd);
         }
-        async function reviewMessages(id, notBefore) {
-            const result = payload(await session(typeof nativeSession?.reviewMessages === "function" ? "reviewMessages" : "messages", { path: { id }, query: { directory: input.directory, ...(notBefore ? { notBefore } : {}) } }));
+        async function reviewMessages(id, notBefore, requireAvailable = false) {
+            const method = typeof nativeSession?.reviewMessages === "function" ? "reviewMessages" : "messages";
+            if (requireAvailable && typeof nativeSession?.[method] !== "function")
+                throw new Error("native-operation-history-api-unavailable");
+            const response = await session(method, { path: { id }, query: { directory: input.directory, ...(notBefore ? { notBefore } : {}) } });
+            const result = payload(response);
+            if (requireAvailable && (record(response) && response.error || !Array.isArray(result)))
+                throw new Error("native-operation-history-response-unavailable");
             return Array.isArray(result) ? result.filter(record) : [];
         }
         async function observedSessionModel(id) {
@@ -1617,6 +1623,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 if (mission) {
                     const budget = await control.currentBudget(root);
                     const run = await operators.read(root);
+                    mission = await reconcileMissionExecution(root, mission, run);
                     const completion = run?.phase === "awaiting-acceptance" ? await control.completionReadiness(root) : undefined;
                     const acceptanceSummary = await missionAcceptanceSummary(mission, run, operators, acceptanceValidationObservation);
                     const packet = { acceptance_summary: acceptanceSummary, ...missionDispatchPacket(mission, run), budget,
@@ -1635,6 +1642,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                         delete packet.task;
                         delete packet.coordinator_dispatch;
                     }
+                    const recoveryAction = missionExecutionRecoveryAction(mission);
+                    if (recoveryAction)
+                        packet.next_action = recoveryAction;
                     if (view === "progress")
                         return serializeOperatorStatus(missionProgress(mission, run, budget, packet));
                     return serializeOperatorStatus(view === "full" ? packet : compactMissionEvidence(packet, run, root));
@@ -1766,10 +1776,12 @@ export function createProfiledPlugin(profile, assetVersion) {
                 await requireRoot(context.sessionID);
                 const state = await operators.required(context.sessionID);
                 let mission = await missions.read(context.sessionID);
+                if (mission)
+                    mission = await reconcileMissionExecution(context.sessionID, mission, state);
                 if (mission?.kind === "operation" && !missionExecutionComplete(mission))
                     return JSON.stringify({
                         status: "not-ready", operation_status: missionExecutionStatus(mission),
-                        next_action: "The requested operation has not completed. Preserve its real outcome; auxiliary checks and a bounded review do not complete it. Continue the declared operation or report its blocker.",
+                        next_action: missionExecutionRecoveryAction(mission) ?? "The requested operation has not completed. Preserve its real outcome; auxiliary checks and a bounded review do not complete it. Continue the declared operation or report its blocker.",
                         packet: missionPacket(mission, state)
                     });
                 if (mission && !["completed", "cancelled"].includes(mission.phase))
@@ -2518,6 +2530,225 @@ export function createProfiledPlugin(profile, assetVersion) {
             const commands = [...new Set(execution.commands.map(missionValidationCommand).map(normalizeCommand))];
             return { commands, directory: resolve(input.directory, execution.directory), observations: operation?.observations ?? [] };
         }
+        async function reconcileMissionExecution(root, mission, run) {
+            const execution = mission.execution;
+            if (mission.kind !== "operation" || !execution || !run || run.runID !== mission.runID ||
+                ["completed", "cancelled"].includes(mission.phase))
+                return mission;
+            const owners = new Map();
+            const recoveryErrors = [];
+            const addOwner = (actor, window) => owners.set(actor, [...(owners.get(actor) ?? []), window]);
+            for (const unit of run.units) {
+                if (unit.directExecution?.actor) {
+                    addOwner(unit.directExecution.actor, { notBefore: unit.directExecution.startedAt,
+                        ...(unit.directExecution.finishedAt ? { notAfter: unit.directExecution.finishedAt } : {}) });
+                    continue;
+                }
+                const child = unit.childSessionID;
+                if (!child || !unit.callID)
+                    continue;
+                const attempt = mission.attempts?.find(item => item.runID === run.runID && item.unitID === unit.unit.id &&
+                    item.callID === unit.callID && item.childSessionID === child);
+                if (!attempt || attempt.status === "pending")
+                    continue;
+                let info;
+                try {
+                    const response = await session("get", { path: { id: child }, query: { directory: input.directory } });
+                    const value = payload(response);
+                    if (!record(value) || record(response) && response.error)
+                        throw new Error("native-operation-session-unavailable");
+                    info = value;
+                }
+                catch (error) {
+                    recoveryErrors.push({ sessionID: child, reason: error instanceof Error ? error.message : String(error) });
+                    continue;
+                }
+                if (info.id !== undefined && info.id !== child || info.parentID !== (run.operatorSessionID ?? root))
+                    continue;
+                const created = record(info.time) ? info.time.created : undefined;
+                const createdAt = typeof created === "number" && Number.isFinite(created) ? created
+                    : typeof created === "string" ? Date.parse(created) : NaN;
+                // A reusable correction author belongs to this admission, not every earlier turn
+                // since the conversation was created. Ordinary Workers have a new native session.
+                const admittedAt = Date.parse(unit.reviewerCorrection?.admittedAt ?? run.createdAt);
+                const settled = unit.reviewerCorrection && ["succeeded", "failed", "cancelled"].includes(unit.status)
+                    ? [...mission.progress].reverse().find(item => item.unit === `${run.runID}/${unit.unit.id}` &&
+                        ["succeeded", "failed", "cancelled"].includes(item.status) && Number.isFinite(Date.parse(item.at)))?.at
+                    : undefined;
+                // The correction session is reusable after settlement; its later turns are
+                // not this unit's operation. Reuse the existing recorded settlement boundary.
+                if (unit.reviewerCorrection && unit.status !== "running" && !settled)
+                    continue;
+                if (Number.isFinite(createdAt) && Number.isFinite(admittedAt)) {
+                    addOwner(child, { notBefore: new Date(Math.max(createdAt, admittedAt)).toISOString(),
+                        ...(settled ? { notAfter: settled } : {}) });
+                }
+            }
+            if (owners.size === 0 && recoveryErrors.length === 0)
+                return mission;
+            const recovered = [];
+            const observedInputs = [];
+            const conflictingCalls = [];
+            const laterStart = (saved, observed) => !saved || Date.parse(observed) > Date.parse(saved) ? observed : saved;
+            for (const [sessionID, windows] of owners) {
+                // A direct session has its own native admission time; a delegated session is bounded
+                // by its native creation time when exposed by the existing session API.
+                const notBefore = windows.map(window => window.notBefore).sort()[0];
+                if (!notBefore)
+                    continue;
+                let history;
+                try {
+                    history = await reviewMessages(sessionID, notBefore, true);
+                }
+                catch (error) {
+                    recoveryErrors.push({ sessionID, reason: error instanceof Error ? error.message : String(error) });
+                    continue;
+                }
+                const calls = new Map();
+                const conflicts = new Set();
+                const nativeStarts = new Map();
+                const nativeInputs = new Map();
+                for (const message of history) {
+                    const info = record(message.info) ? message.info : message;
+                    if (info.role !== "assistant" || info.sessionID !== sessionID || !Array.isArray(message.parts))
+                        continue;
+                    for (const part of message.parts) {
+                        if (!record(part) || part.type !== "tool" || !isShellTool(String(part.tool)) ||
+                            (part.sessionID !== undefined && part.sessionID !== sessionID) || typeof part.callID !== "string" ||
+                            !record(part.state) || !record(part.state.input))
+                            continue;
+                        const state = part.state;
+                        const nativeInput = state.input;
+                        if (typeof nativeInput.command !== "string")
+                            continue;
+                        const time = record(state.time) ? state.time : record(part.time) ? part.time : {};
+                        const date = (value) => typeof value === "number" && Number.isFinite(value) ? new Date(value).toISOString()
+                            : typeof value === "string" && Number.isFinite(Date.parse(value)) ? new Date(value).toISOString() : undefined;
+                        const startedAt = date(time.start ?? time.ran);
+                        if (!startedAt)
+                            continue;
+                        // A boundary page may include tools from a later reusable-session turn.
+                        // Ignore them before comparing call input or terminal state as well.
+                        if (!windows.some(window => Date.parse(startedAt) >= Date.parse(window.notBefore) &&
+                            (!window.notAfter || Date.parse(startedAt) <= Date.parse(window.notAfter))))
+                            continue;
+                        const nativeDirectory = resolve(input.directory, typeof nativeInput.workdir === "string" ? nativeInput.workdir : ".");
+                        const directory = missionOperationDirectoryMatch(nativeDirectory, execution.directory) ? execution.directory : nativeDirectory;
+                        const key = part.callID;
+                        nativeStarts.set(key, laterStart(nativeStarts.get(key), startedAt));
+                        const nativeInputIdentity = { command: nativeInput.command, directory };
+                        const priorInput = nativeInputs.get(key);
+                        if (priorInput && (priorInput.command !== nativeInput.command || priorInput.directory !== directory)) {
+                            conflicts.add(key);
+                        }
+                        nativeInputs.set(key, nativeInputIdentity);
+                        const command = missionOperationCommandMatch(nativeInput.command, execution.commands, execution.directory);
+                        // Compare admitted inputs with persisted same-call observations even when this
+                        // record is no longer a matching command/cwd and will not yield a new result.
+                        observedInputs.push({ sessionID, callID: key, command, directory, startedAt });
+                        if (directory !== execution.directory)
+                            continue;
+                        if (!command)
+                            continue;
+                        const metadata = record(state.metadata) ? state.metadata : {};
+                        const nativeStatus = String(state.status ?? "").toLowerCase();
+                        const resultStatus = String(metadata.status ?? "").toLowerCase();
+                        if ((nativeStatus === "error" && resultStatus === "running") || (nativeStatus === "running" && resultStatus === "error")) {
+                            conflicts.add(key);
+                        }
+                        const running = nativeStatus === "running" || resultStatus === "running";
+                        const failed = nativeStatus === "error" || resultStatus === "error";
+                        if (!["completed", "error", "running"].includes(nativeStatus))
+                            continue;
+                        if (!running && !failed && nativeStatus !== "completed")
+                            continue;
+                        const completedAt = running ? undefined : date(time.end ?? time.completed);
+                        const exit = Number.isSafeInteger(metadata.exit) ? metadata.exit : undefined;
+                        const output = typeof state.output === "string" ? state.output : typeof part.output === "string" ? part.output : "";
+                        const status = failed ? "error" : running ? "running" : "completed";
+                        const outcome = conflicts.has(key) || running || !completedAt || exit === undefined ? undefined : missionCommandOutcome(output, exit, status);
+                        // A completed tool envelope without an exit/result does not prove a successful
+                        // process. Keep it unclassified instead of turning missing metadata into success.
+                        if (nativeInput.background === true && !running)
+                            continue;
+                        const observation = { command, directory: execution.directory, callID: key, sessionID, startedAt, nativeStartedAt: startedAt,
+                            ...(completedAt ? { completedAt } : {}), ...(exit === undefined ? {} : { exit }), status,
+                            ...(typeof metadata.shellID === "string" ? { shellID: metadata.shellID } : {}), ...(outcome ?? {}) };
+                        const prior = calls.get(key);
+                        if (prior && (prior.command !== command || prior.directory !== directory || prior.observation.startedAt !== startedAt ||
+                            prior.observation.completedAt && observation.completedAt && (prior.observation.status !== status ||
+                                prior.observation.completedAt !== observation.completedAt ||
+                                prior.observation.exit !== undefined && exit !== undefined && prior.observation.exit !== exit ||
+                                prior.observation.outcome !== undefined && observation.outcome !== undefined && JSON.stringify(prior.observation) !== JSON.stringify(observation)))) {
+                            conflicts.add(key);
+                        }
+                        else if (!prior || !conflicts.has(key) && (prior.observation.outcome === undefined || observation.outcome !== undefined)) {
+                            calls.set(key, { command, directory, observation });
+                        }
+                    }
+                }
+                for (const [callID, item] of calls)
+                    recovered.push({ ...item.observation, ...(conflicts.has(callID)
+                            ? { conflicting: true, latestConflictingStartedAt: nativeStarts.get(callID) } : {}) });
+                for (const callID of conflicts)
+                    conflictingCalls.push({ sessionID, callID, latestConflictingStartedAt: nativeStarts.get(callID) });
+            }
+            if (recovered.length === 0 && conflictingCalls.length === 0 && observedInputs.length === 0 && recoveryErrors.length === 0 && !execution.recovery)
+                return mission;
+            return missions.update(root, current => {
+                if (current.runID !== mission.runID || current.kind !== "operation" || !current.execution ||
+                    ["completed", "cancelled"].includes(current.phase) ||
+                    current.execution.directory !== execution.directory || JSON.stringify(current.execution.commands) !== JSON.stringify(execution.commands))
+                    return;
+                if (recoveryErrors.length)
+                    current.execution.recovery = { status: "unavailable", errors: recoveryErrors };
+                else
+                    delete current.execution.recovery;
+                for (const nativeInput of observedInputs) {
+                    const prior = current.execution.observations.find(item => item.callID === nativeInput.callID && item.sessionID === nativeInput.sessionID);
+                    if (prior && (prior.command !== nativeInput.command || prior.directory !== nativeInput.directory)) {
+                        prior.conflicting = true;
+                        prior.latestConflictingStartedAt = laterStart(prior.latestConflictingStartedAt ?? prior.nativeStartedAt, nativeInput.startedAt);
+                    }
+                }
+                for (const observation of recovered) {
+                    const prior = current.execution.observations.find(item => item.callID === observation.callID && item.sessionID === observation.sessionID);
+                    if (!prior) {
+                        current.execution.observations.push(observation);
+                        continue;
+                    }
+                    if (prior.command !== observation.command || prior.directory !== observation.directory)
+                        continue;
+                    if (observation.conflicting || prior.nativeStartedAt !== undefined && prior.nativeStartedAt !== observation.nativeStartedAt ||
+                        prior.completedAt && observation.completedAt && (prior.status !== observation.status ||
+                            prior.exit !== undefined && observation.exit !== undefined && prior.exit !== observation.exit ||
+                            prior.outcome !== undefined && observation.outcome !== undefined && prior.outcome !== observation.outcome)) {
+                        prior.conflicting = true;
+                    }
+                    if (prior.conflicting)
+                        prior.latestConflictingStartedAt = laterStart(prior.latestConflictingStartedAt ?? prior.nativeStartedAt, observation.latestConflictingStartedAt ?? observation.nativeStartedAt);
+                    prior.nativeStartedAt ??= observation.nativeStartedAt;
+                    if (prior.outcome !== undefined)
+                        continue;
+                    const latestConflictingStartedAt = prior.latestConflictingStartedAt;
+                    const nativeStartedAt = prior.nativeStartedAt;
+                    delete prior.completedAt;
+                    delete prior.exit;
+                    delete prior.outcome;
+                    delete prior.result;
+                    Object.assign(prior, observation, { startedAt: prior.startedAt,
+                        ...(nativeStartedAt ? { nativeStartedAt } : {}),
+                        ...(latestConflictingStartedAt ? { latestConflictingStartedAt } : {}) });
+                }
+                for (const conflict of conflictingCalls) {
+                    const prior = current.execution.observations.find(item => item.callID === conflict.callID && item.sessionID === conflict.sessionID);
+                    if (prior) {
+                        prior.conflicting = true;
+                        prior.latestConflictingStartedAt = laterStart(prior.latestConflictingStartedAt ?? prior.nativeStartedAt, conflict.latestConflictingStartedAt);
+                    }
+                }
+            });
+        }
         async function declareMissionUnits(root, actor, mission, raw, reason, execution, planningCallID, handoffNotes, workQuantities) {
             await control.currentBudget(root);
             mission = await missions.required(root);
@@ -3186,13 +3417,14 @@ export function createProfiledPlugin(profile, assetVersion) {
             args: { status: { type: "string", enum: ["ready", "needs-decision", "blocked"] }, summary: stringSchema }, execute: async (args, context) => {
                 const { root } = await missionAuthority(context.sessionID);
                 return serializeDispatchTransition(root, async () => {
-                    const mission = await missions.required(root);
+                    let mission = await missions.required(root);
+                    mission = await reconcileMissionExecution(root, mission, await operators.read(root));
                     if (args.status === "ready") {
                         if (mission.kind === "operation" && !missionExecutionComplete(mission)) {
                             return JSON.stringify({ ...missionPacket(mission, await operators.read(root)), status: "operation-incomplete",
-                                next_action: missionExecutionStatus(mission) === "running"
+                                next_action: missionExecutionRecoveryAction(mission) ?? (missionExecutionStatus(mission) === "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."
-                                    : "Continue the requested operation or submit its actual blocker. A successful setup/NO_START check does not authorize ready." });
+                                    : "Continue the requested operation or submit its actual blocker. A successful setup/NO_START check does not authorize ready.") });
                         }
                         const run = await operators.required(root);
                         if (run.phase !== "awaiting-acceptance")
@@ -3215,7 +3447,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                         ...compactMissionEvidence(missionPacket(updated, submittedRun), submittedRun, root),
                         next_action: args.status === "ready"
                             ? "Return this result and acceptance_summary to Operator now. Compare the original requests with the candidate and actual evidence; inspect concrete gaps only, then complete_mission if satisfied. No routine archive search or full source reread. Completion still requires its final comparison and complete_mission receipt."
-                            : "Return the saved blocker or user-only decision to Operator now. This is incomplete delivery, not acceptance; retain the candidate, failed checks and cumulative spend. Do not repeat unchanged work or dispatch a replacement merely to finalize this result." });
+                            : ["Return the saved blocker or user-only decision to Operator now. This is incomplete delivery, not acceptance; retain the candidate, failed checks and cumulative spend. Do not repeat unchanged work or dispatch a replacement merely to finalize this result.",
+                                missionExecutionRecoveryAction(updated)].filter(Boolean).join(" ") });
                 });
             } };
         tools[completeMission] = { description: "Operator only: after comparing the original request, source, actual checks and current review disposition (explicit native author self-recheck is not independent PASS), explicitly accept the whole mission. A collected terminal failure can satisfy a run-once/report request, not a request for successful execution. Returns operation outcome separately from the measured 🐾 Mission receipt; never treat Worker start, CORRECTION_READY or one passing check as completion.",
@@ -3872,17 +4105,16 @@ export function createProfiledPlugin(profile, assetVersion) {
                     const operationArgs = record(mapped.args) ? mapped.args : {};
                     // A decorated launch would spend on the real operation but leave the native mission observation empty.
                     // Ask the same Worker to correct its shell input before that expensive side effect.
-                    if (writer && ["bash", "shell"].includes(request.tool.toLowerCase()) && mission?.execution &&
+                    if (writer && isShellTool(request.tool) && mission?.execution &&
                         typeof operationArgs.command === "string" &&
-                        resolve(input.directory, typeof operationArgs.workdir === "string" ? operationArgs.workdir : ".") === mission.execution.directory) {
-                        const actual = normalizeCommand(operationArgs.command);
-                        if (operationArgs.background === true && mission.execution.commands.includes(actual)) {
+                        missionOperationDirectoryMatch(resolve(input.directory, typeof operationArgs.workdir === "string" ? operationArgs.workdir : "."), mission.execution.directory)) {
+                        const declaredOperation = missionOperationCommandMatch(operationArgs.command, mission.execution.commands, mission.execution.directory);
+                        if (operationArgs.background === true && declaredOperation !== undefined) {
                             throw new Error("mission-operation-background: run the declared command in foreground with a suitable timeout. " +
                                 "A background shell reports only launch, not process exit; no run was started by this refused call. " +
                                 "Correct this same Worker command without a new plan or approval.");
                         }
-                        const decorated = mission.execution.commands.some(declared => actual.startsWith(declared) &&
-                            /^\s*(?:\||\d?>|&&?|;)/u.test(actual.slice(declared.length)));
+                        const decorated = missionOperationCommandDecorated(operationArgs.command, mission.execution.commands, mission.execution.directory);
                         if (decorated)
                             throw new Error("mission-operation-command-not-observed: run the declared operation command exactly; " +
                                 "do not append a pipe, tee, redirection or chained command. Capture its tool output or write a separate result file afterward. " +
@@ -3926,16 +4158,16 @@ export function createProfiledPlugin(profile, assetVersion) {
                     }
                     else
                         Object.assign(output, outward);
-                    if (writer && ["bash", "shell"].includes(request.tool) && mission?.execution &&
-                        typeof args.command === "string" && mission.execution.commands.includes(normalizeCommand(args.command)) &&
-                        resolve(input.directory, typeof args.workdir === "string" ? args.workdir : ".") === mission.execution.directory) {
-                        const command = normalizeCommand(args.command);
-                        await missions.update(root, item => {
-                            if (!item.execution.observations.some(observation => observation.callID === request.callID)) {
-                                item.execution.observations.push({ command, directory: item.execution.directory,
-                                    callID: request.callID, sessionID: request.sessionID, startedAt: new Date().toISOString() });
-                            }
-                        });
+                    if (writer && isShellTool(request.tool) && mission?.execution &&
+                        typeof args.command === "string" && missionOperationDirectoryMatch(resolve(input.directory, typeof args.workdir === "string" ? args.workdir : "."), mission.execution.directory)) {
+                        const command = missionOperationCommandMatch(args.command, mission.execution.commands, mission.execution.directory);
+                        if (command !== undefined)
+                            await missions.update(root, item => {
+                                if (!item.execution.observations.some(observation => observation.callID === request.callID)) {
+                                    item.execution.observations.push({ command, directory: item.execution.directory,
+                                        callID: request.callID, sessionID: request.sessionID, startedAt: new Date().toISOString() });
+                                }
+                            });
                     }
                 }
                 catch (error) {
@@ -4192,7 +4424,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 await core["tool.execute.after"]?.({ ...translate(request, false),
                     ...(ownership ? { sessionID: ownership.root } : {}) }, mapped);
                 Object.assign(output, translate(mapped, true));
-                if (!ownership && ["bash", "shell"].includes(request.tool.toLowerCase())) {
+                if (!ownership && isShellTool(request.tool)) {
                     const root = await rootFor(id);
                     const mission = root ? await missions.read(root) : undefined;
                     if (root && mission?.execution?.observations.some(item => item.callID === request.callID && item.sessionID === id)) {
@@ -4211,7 +4443,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                             observation.status = output.status === "error" || metadata.status === "error" ? "error" : "completed";
                             if (Number.isSafeInteger(metadata.exit))
                                 observation.exit = metadata.exit;
-                            Object.assign(observation, missionCommandOutcome(returnedOutput, metadata.exit, observation.status));
+                            if (Number.isSafeInteger(metadata.exit)) {
+                                Object.assign(observation, missionCommandOutcome(returnedOutput, metadata.exit, observation.status));
+                            }
                         });
                     }
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.13.20",
+  "version": "0.13.22",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",