sortie-dogs 0.13.12 → 0.13.14

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.12](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.12)**
-· [Release notes](docs/release-v0.13.12.md)
+**Current release: [v0.13.14](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.13.14)**
+· [Release notes](docs/release-v0.13.14.md)
 
 [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.12
+npm install --save-dev sortie-dogs@0.13.14
 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.12
+npm install --save-dev sortie-dogs@0.13.14
 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.12**. SWE-bench remains an optional
+All scores belong to their fixed candidates, **not v0.13.14**. 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.12-validation-paths-v1`; the unchanged Codex skill marker is
+The current Mission asset marker is `0.13.14-mission-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;
@@ -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.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.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.12-validation-paths-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.14-mission-recovery-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.12-validation-paths-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.14-mission-recovery-v1";
 export const CODEX_SKILL_ASSET_VERSION = "0.13.11-codex-skill-v2";

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

@@ -0,0 +1,73 @@
+export interface PublicMissionContext {
+    id: string;
+    role: "user" | "assistant";
+    text: string;
+    tools: {
+        call_id?: string;
+        tool: string;
+        status?: string;
+        input?: unknown;
+        output?: string;
+        error?: string;
+        exit?: number;
+        time?: unknown;
+    }[];
+}
+export interface MissionContextSource {
+    session_id: string;
+    path: string;
+    sha256: string;
+    entries: number;
+    observed_at: string;
+    history_available: boolean;
+}
+export interface MissionContinuity {
+    sources: MissionContextSource[];
+    notes?: {
+        text: string;
+        session_id: string;
+        recorded_at: string;
+    }[];
+}
+/** Public task data only. Keep exact text/results in a lazy snapshot, not private reasoning. */
+export declare function publicMissionContext(messages: readonly Record<string, unknown>[]): PublicMissionContext[];
+/** Preserve earlier available entries when the host later returns a compacted/partial history. */
+export declare function retainMissionContext(directory: string, sessionID: string, messages: readonly Record<string, unknown>[], previous?: MissionContextSource): Promise<{
+    source: MissionContextSource;
+    entries: PublicMissionContext[];
+}>;
+/** Small inline view, with explicit pointers to every omitted byte in the exact snapshot. */
+export declare function missionContextView(source: MissionContextSource, entries: readonly PublicMissionContext[], suppliedRequestIDs?: readonly string[]): {
+    omitted_text_entries: number;
+    conversation: {
+        truncated?: boolean | undefined;
+        original_characters?: number | undefined;
+        id: string;
+        role: "user" | "assistant";
+        text: string;
+    }[];
+    omitted_tool_entries: number;
+    recent_tools: {
+        input: string | undefined;
+        output: string | undefined;
+        error: string | undefined;
+        truncated: boolean;
+        detail_ref: {
+            path: string;
+            message_id: string;
+            call_id: string | undefined;
+        };
+        call_id?: string;
+        tool: string;
+        status?: string;
+        exit?: number;
+        time?: unknown;
+        message_id: string;
+    }[];
+    session_id: string;
+    path: string;
+    sha256: string;
+    entries: number;
+    observed_at: string;
+    history_available: boolean;
+};

package/dist/core/mission-context.js

@@ -0,0 +1,66 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** Public task data only. Keep exact text/results in a lazy snapshot, not private reasoning. */
+export function publicMissionContext(messages) {
+    return messages.flatMap(message => {
+        const info = record(message.info) ? message.info : message;
+        if ((info.role !== "user" && info.role !== "assistant") || typeof info.id !== "string" || !Array.isArray(message.parts))
+            return [];
+        const parts = message.parts.filter(record);
+        const text = parts.filter(part => part.type === "text" && part.synthetic !== true && typeof part.text === "string")
+            .map(part => part.text).join("\n");
+        const tools = parts.flatMap(part => {
+            if (part.type !== "tool" || typeof part.tool !== "string" || !record(part.state))
+                return [];
+            const state = part.state, metadata = record(state.metadata) ? state.metadata : {};
+            return [{ tool: part.tool, ...(typeof part.callID === "string" ? { call_id: part.callID } : {}),
+                    ...(typeof state.status === "string" ? { status: state.status } : {}),
+                    ...(state.input !== undefined ? { input: state.input } : {}),
+                    ...(typeof state.output === "string" ? { output: state.output } : {}),
+                    ...(typeof state.error === "string" ? { error: state.error } : {}),
+                    ...(typeof metadata.exit === "number" ? { exit: metadata.exit } : {}),
+                    ...(part.time !== undefined ? { time: part.time } : {}) }];
+        });
+        return text.trim() || tools.length ? [{ id: info.id, role: info.role, text, tools }] : [];
+    });
+}
+/** Preserve earlier available entries when the host later returns a compacted/partial history. */
+export async function retainMissionContext(directory, sessionID, messages, previous) {
+    const current = publicMissionContext(messages);
+    const retained = previous ? await readFile(previous.path, "utf8")
+        .then(content => JSON.parse(content).entries).catch(() => undefined) : undefined;
+    const merged = new Map((retained ?? []).map(entry => [entry.id, entry]));
+    for (const entry of current)
+        merged.set(entry.id, entry);
+    const entries = [...merged.values()];
+    const content = JSON.stringify({ session_id: sessionID, entries }, null, 2) + "\n";
+    const sha256 = createHash("sha256").update(content).digest("hex");
+    const path = join(directory, `context-${sha256}.json`);
+    if (!retained || previous?.sha256 !== sha256) {
+        await mkdir(directory, { recursive: true });
+        await writeFile(path, content);
+    }
+    return { source: { session_id: sessionID, path, sha256, entries: entries.length,
+            observed_at: new Date().toISOString(), history_available: current.length > 0 }, entries };
+}
+/** Small inline view, with explicit pointers to every omitted byte in the exact snapshot. */
+export function missionContextView(source, entries, suppliedRequestIDs = []) {
+    const textEntries = entries.filter(entry => entry.text.trim() && !suppliedRequestIDs.includes(entry.id));
+    const selected = textEntries.slice(-8);
+    const tools = entries.flatMap(entry => entry.tools.map(tool => ({ message_id: entry.id, ...tool })));
+    const recentTools = tools.filter(tool => !tool.tool.startsWith("sortie_") && ["completed", "error"].includes(tool.status ?? "")).slice(-8);
+    return { ...source, omitted_text_entries: textEntries.length - selected.length,
+        conversation: selected.map(entry => ({ id: entry.id, role: entry.role, text: entry.text.slice(0, 4000),
+            ...(entry.text.length > 4000 ? { truncated: true, original_characters: entry.text.length } : {}) })),
+        omitted_tool_entries: tools.length - recentTools.length,
+        recent_tools: recentTools
+            .map(tool => {
+            const input = tool.input === undefined ? undefined : JSON.stringify(tool.input);
+            return { ...tool, input: input?.slice(0, 1000), output: tool.output?.slice(0, 1000), error: tool.error?.slice(0, 1000),
+                truncated: [input, tool.output, tool.error].some(value => value !== undefined && value.length > 1000),
+                detail_ref: { path: source.path, message_id: tool.message_id, call_id: tool.call_id } };
+        }),
+    };
+}

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

@@ -1,5 +1,6 @@
 import { type OperatorPlan, type OperatorState, type OperatorTask, type OperatorRuntime } from "./operator-runtime.js";
 import { type RuntimeProfile } from "./runtime-profile.js";
+import { type MissionContinuity } from "./mission-context.js";
 export { missionValidationCommand } from "./mission-validation-command.js";
 export declare const MISSION_REFERENCE = "SORTIE_MISSION_REF ";
 export declare const MISSION_REVIEW_REFERENCE = "SORTIE_MISSION_REVIEW_REF ";
@@ -192,6 +193,8 @@ export interface OperatorMission {
     requests: MissionRequest[];
     /** Prior public conversation context, not additional immutable requirements. */
     context?: MissionContext[];
+    /** Shared public context/working notes; observations, never extra requirements or acceptance. */
+    continuity?: MissionContinuity;
     /** Explicit continue deliveries, keyed by the original real turn. */
     steering?: {
         requestID: string;
@@ -321,6 +324,10 @@ export declare class OperatorMissionRuntime {
     constructor(projectRoot: string, profile: RuntimeProfile);
     private file;
     correctionReference(root: string, reviewIdentity: string): string;
+    /** Stage context for a proposed handoff; publish Mission metadata only after plan preparation succeeds. */
+    contextSnapshot(state: OperatorMission, sessionID: string, messages: readonly Record<string, unknown>[], notes?: string): Promise<OperatorMission>;
+    retainContext(root: string, sessionID: string, messages: readonly Record<string, unknown>[], notes?: string): Promise<OperatorMission>;
+    handoffContext(state: OperatorMission): Promise<Record<string, unknown>>;
     private load;
     /** Recover non-replacement continuations only; an explicit replacement must link the current cancelled run. */
     private loadMission;

package/dist/core/operator-mission.js

@@ -6,6 +6,7 @@ import { parseOperatorPlan } from "./operator-runtime.js";
 import { profileAgent } from "./runtime-profile.js";
 import { normalizeCommand } from "../plugin/gate.js";
 import { missionValidationCommand } from "./mission-validation-command.js";
+import { retainMissionContext, missionContextView } from "./mission-context.js";
 export { missionValidationCommand } from "./mission-validation-command.js";
 const digest = (value) => createHash("sha256").update(value).digest("hex");
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
@@ -184,6 +185,47 @@ export class OperatorMissionRuntime {
     correctionReference(root, reviewIdentity) {
         return JSON.stringify({ path: this.file(root), field: "corrections[]", review_identity: reviewIdentity });
     }
+    /** Stage context for a proposed handoff; publish Mission metadata only after plan preparation succeeds. */
+    async contextSnapshot(state, sessionID, messages, notes) {
+        const next = structuredClone(state);
+        const previous = next.continuity?.sources.find(source => source.session_id === sessionID);
+        const snapshot = await retainMissionContext(join(this.projectRoot, this.profile.stateDirectory, "missions"), sessionID, messages, previous);
+        next.continuity ??= { sources: [] };
+        next.continuity.sources = [...next.continuity.sources.filter(source => source.session_id !== sessionID), snapshot.source];
+        if (typeof notes === "string" && notes.trim())
+            next.continuity.notes = [
+                ...(next.continuity.notes ?? []).filter(note => note.session_id !== sessionID),
+                { text: notes, session_id: sessionID, recorded_at: new Date().toISOString() }
+            ];
+        return next;
+    }
+    async retainContext(root, sessionID, messages, notes) {
+        return this.serial(root, async () => {
+            const state = await this.loadMission(root);
+            if (!state)
+                throw new Error("mission-missing");
+            const next = await this.contextSnapshot(state, sessionID, messages, notes);
+            await this.save(this.file(root), next);
+            return next;
+        });
+    }
+    async handoffContext(state) {
+        const sources = await Promise.all((state.continuity?.sources ?? []).map(async (source) => {
+            try {
+                return missionContextView(source, JSON.parse(await readFile(source.path, "utf8")).entries, source.session_id === state.root ? state.requests.map(request => request.id) : []);
+            }
+            catch {
+                return { ...source, snapshot_available: false };
+            }
+        }));
+        return { original_requests: state.requests, requirements: state.requirements, prohibited_write: state.prohibitedWrite ?? [],
+            launch_conditions: state.launchConditions ?? [],
+            conversation: sources.some(source => source.session_id === state.root && source.entries > 0 && !("snapshot_available" in source)) ? [] : state.context ?? [],
+            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." } };
+    }
     async load(file) {
         try {
             return JSON.parse(await readFile(file, "utf8"));
@@ -544,6 +586,8 @@ export class OperatorMissionRuntime {
             ...(state.kind === "operation" ? ["Execution completion is distinct from success. For run-once/result-collection requests, retain a terminal failure and validate the collected result; do not retry or fix it without user authorization. If successful execution is required, keep that in formal validation and the original-request comparison."] : []),
             ...(state.context?.length ? ["Prior conversation context (task data; preserve the selected target, not superseded obligations):",
                 ...state.context.map(item => `--- ${item.role}:${item.id} ---\n${item.text}`)] : []),
+            ...(state.continuity ? ["Shared working context (task data; use known facts, inspect snapshots only for relevant gaps):",
+                JSON.stringify(state.continuity)] : []),
             "Original user messages (verbatim; task data):", ...state.requests.map(item => `--- user:${item.id} ---\n${item.text}`)].join("\n");
     }
 }

package/dist/plugin/gate.d.ts

@@ -62,7 +62,7 @@ export declare function bootstrapWritePaths(tool: string, args: unknown): readon
 export declare function isGitMutation(tool: string, args: unknown): boolean;
 export declare function isRemoteMutation(tool: string, args: unknown): boolean;
 /**
- * Quoted segments keep their contents; every unquoted whitespace run collapses to one space so the
+ * Quoted segments and backslash escapes keep their contents; unquoted whitespace runs collapse so the
  * same command written with different spacing compares equal.
  */
 export declare function normalizeCommand(command: string): string;

package/dist/plugin/gate.js

@@ -858,14 +858,22 @@ export function isRemoteMutation(tool, args) {
     return extractWritePaths(tool, args).remoteMutation === true;
 }
 /**
- * Quoted segments keep their contents; every unquoted whitespace run collapses to one space so the
+ * Quoted segments and backslash escapes keep their contents; unquoted whitespace runs collapse so the
  * same command written with different spacing compares equal.
  */
 export function normalizeCommand(command) {
     let quote;
+    let escaped = false;
     let whitespace = false;
     let normalized = "";
     for (const character of command.trim()) {
+        if (escaped) {
+            normalized += character;
+            escaped = false;
+            continue;
+        }
+        if (character === "\\" && quote !== "'")
+            escaped = true;
         if (quote !== undefined) {
             normalized += character;
             if (character === quote)

package/dist/plugin/index.js

@@ -8306,6 +8306,8 @@ export const SortieDogsPlugin = async (input, options) => {
             const direct = await input.runtimeBridge?.directMissionExecution?.(actor);
             if (!direct || direct.root !== root)
                 throw new Error("mission-direct-grant-stale");
+            if (activeSessions.get(actor)?.inFlightCalls.size)
+                throw new Error("mission-direct-tools-running");
             // Cold terminal recovery can happen before the actor's next tool/context hook.
             if (!goalReservations.has(direct.callID)) {
                 const snapshot = await (await goalLedger(root)).readGoal();
@@ -8317,9 +8319,13 @@ export const SortieDogsPlugin = async (input, options) => {
                 else
                     throw new Error("mission-direct-reservation-unavailable");
             }
-            await settleGoalDispatch(direct.callID, { status: "error",
-                output: "Actual native Reviewer ended before its direct correction was validated.",
-                metadata: { sessionId: actor } }, undefined, []);
+            // Empty successful evidence forces a failed disposition. Reuse the saved
+            // validation observation (including a cold recovered exit) without claiming
+            // a failed native child terminal for this still-active controller.
+            await settleGoalDispatch(direct.callID, {
+                output: "Direct unit stopped incomplete; no successful validation or Mission acceptance.",
+                metadata: { sessionId: actor }
+            }, undefined, []);
             await releaseWriteGate(actor);
             releaseSessionEnforcement(actor);
         },

package/dist/plugin/mission-review.js

@@ -73,7 +73,8 @@ export function observedMissionValidation(validation, childSessionID, history, n
                 !record(part.state) || !["completed", "error"].includes(String(part.state.status)) || !record(part.state.input) ||
                 typeof part.state.input.command !== "string")
                 return [];
-            const command = normalizeCommand(part.state.input.command);
+            // Match raw input first: whitespace normalization destroys Python heredoc boundaries.
+            const command = part.state.input.command;
             const exit = record(part.state.metadata) ? part.state.metadata.exit : undefined;
             const started = record(part.time) ? time(part.time.ran) : record(part.state.time) ? time(part.state.time.start) : null;
             const completed = record(part.time) ? time(part.time.completed) : record(part.state.time) ? time(part.state.time.end) : null;
@@ -99,7 +100,7 @@ export function observedMissionValidation(validation, childSessionID, history, n
                     occurrence = (occurrence + 1) % declared.length;
             }
         const { directory: actual, ...visible } = attempt;
-        return [{ ...visible, ...(directory && resolve(directory, actual ?? ".") !== resolve(directory)
+        return [{ ...visible, command: members.join(" && "), ...(directory && resolve(directory, actual ?? ".") !== resolve(directory)
                     ? { directory: resolve(directory, actual ?? ".") } : {}), ...(members.length > 1 ? { observed_members: members } : {}) }];
     });
     // Retain early attempts and the latest checks if a Worker retried many times.

package/dist/plugin/profiled.js

@@ -219,6 +219,18 @@ export function createProfiledPlugin(profile, assetVersion) {
             const result = payload(await session("messages", { path: { id }, query: { directory: input.directory } }));
             return Array.isArray(result) ? result.filter(record) : [];
         }
+        async function missionHistory(id) {
+            // Reuse the host's public paginated reader when present; bounded context is a usable fallback.
+            if (typeof nativeSession?.reviewMessages === "function") {
+                try {
+                    const value = payload(await session("reviewMessages", { path: { id }, query: { directory: input.directory } }));
+                    if (Array.isArray(value))
+                        return value.filter(record);
+                }
+                catch { /* Context continuity must not add a history-service admission gate. */ }
+            }
+            return messages(id).catch(() => []);
+        }
         async function acceptanceValidationObservation(validation, child, notBefore) {
             if (!child)
                 throw new Error("native-worker-history-session-unavailable");
@@ -989,6 +1001,14 @@ export function createProfiledPlugin(profile, assetVersion) {
             const detail = "Operation result: execution-failed (result accepted; process did not succeed).";
             return text.includes(detail) ? text : text.replace(/^((?:[ \t]*\r?\n)*[^\r\n]+)/u, `$1 ${detail}`);
         }
+        function compactMissionEvidence(packet, run, root) {
+            if (run && run.runID === packet.run_id && Array.isArray(packet.units)) {
+                const validation = missionReviewValidation(run, operators.statePath(root));
+                packet.units = packet.units.map((unit, index) => ({ ...unit, evidence: validation[index].evidence,
+                    evidence_details_ref: validation[index].details_ref }));
+            }
+            return packet;
+        }
         function missionDispatchPacket(mission, run) {
             const packet = { ...missionPacket(mission, run), project_root: input.directory,
                 coordinator_dispatch: mission.dispatchOpen ? "active" : ["completed", "cancelled"].includes(mission.phase) ? "terminal" : "resumable" };
@@ -1500,12 +1520,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     }
                     if (view === "progress")
                         return JSON.stringify(missionProgress(mission, run, budget, packet));
-                    if (view !== "full" && run?.runID === mission.runID && Array.isArray(packet.units)) {
-                        const validation = missionReviewValidation(run, operators.statePath(root));
-                        packet.units = packet.units.map((unit, index) => ({ ...unit, evidence: validation[index].evidence,
-                            evidence_details_ref: validation[index].details_ref }));
-                    }
-                    return JSON.stringify(packet);
+                    return JSON.stringify(view === "full" ? packet : compactMissionEvidence(packet, run, root));
                 }
                 if (root && context.sessionID !== root) {
                     const owned = await operators.read(root);
@@ -2014,14 +2029,18 @@ export function createProfiledPlugin(profile, assetVersion) {
                         return JSON.stringify({ status: "correction-validated",
                             execution: "same-native-task", validation: direct.unit.unit.validation,
                             next_action: 'Compare the original requirements, retained findings and affected public behavior in this same context, then finish THIS native Task with SELF_RECHECKED and self_recheck: {"candidate":"current-validated","unresolved_findings":[],"residual_major":null}. No handoff reread, second Task or Operator round trip. This is author self-recheck; only the actual successful native terminal can bind it, never this tool result.' });
-                    return JSON.stringify({ ...missionPacket(await missions.required(root), await operators.required(root)),
-                        next_action: `Continue remaining units, or call ${reviewMission} with actual risk tags. Independent Review and Operator final acceptance remain required.` });
+                    const run = await operators.required(root);
+                    // Full protected path arrays can make V2 truncate this one-line JSON to zero lines,
+                    // hiding both the successful transition and the next action. Keep measured evidence
+                    // and durable detail references, as default status already does; never rewrite proof.
+                    return JSON.stringify({ ...compactMissionEvidence(missionPacket(await missions.required(root), run), run, root),
+                        next_action: `This direct unit is validated; do not repeat passed checks or finish this settled unit again. Continue remaining units with ${startDirectUnit}, or call ${reviewMission} with actual risk tags. Independent Review and Operator final acceptance remain required.` });
                 });
             } };
         const stringList = { type: "array", items: { type: "string" } };
         const missionUnitSchema = { type: "object", additionalProperties: false,
-            properties: { title: { type: "string" }, objective: { type: "string", description: "Target or corrective delta, about 2000 characters. Do not copy the original request. Longer authored instructions are preserved separately without a retry gate." },
-                read: { ...stringList, description: "Inputs that affect validation, not an allowlist for observation. Do not include whole live session/database/log trees just to inspect them." }, write: stringList,
+            properties: { title: { type: "string" }, objective: { type: "string", description: "Target or corrective delta, about 2000 characters. Do not copy the original request. Carry the remaining action, not a routine reconfirmation of supplied facts, setup or instructions. References are available for relevant gaps, not mandatory rereads. Longer authored instructions are preserved separately without a retry gate." },
+                read: { ...stringList, description: "Known inputs that affect validation, not an allowlist or a checklist to reread. Avoid guessed AGENTS.md paths and whole live session/database/log trees just to inspect them; reuse already supplied instructions and known context." }, write: stringList,
                 validation: { ...stringList, description: "Meaningful commands using observed repository test paths and runner conventions, not guessed filenames. Reuse already discovered recipes; when unknown, locate the relevant test or repository script with ordinary read/search before declaring it. This is planning guidance, not new approval or proof of execution; native checks still establish acceptance." },
                 validation_cwd: { type: "object", additionalProperties: { type: "string" }, description: "Exact cwd per declared command; omitted commands use project_root. Registration-only correction of your active direct unit keeps the same admission and budget and requires new native checks, not historical proof." },
                 requirement_ids: { ...stringList, description: "Related requirement IDs. A single unit inherits all requirements when omitted; specify coverage when splitting work across units." } },
@@ -2043,10 +2062,13 @@ export function createProfiledPlugin(profile, assetVersion) {
         const missionExecutionSchema = { type: "object", properties: { commands: stringList, directory: { type: "string" } },
             required: ["commands", "directory"], additionalProperties: false,
             description: "For an operation: the actual run/grade commands, not a preflight or NO_START check. Host observes their native shell completion separately from successful exits; no handwritten proof file is needed. For run-once/result collection, validate the collected result without rerunning the operation.", "x-sortie-optional": true };
+        const handoffContextSchema = { type: "string", "x-sortie-optional": true,
+            description: "Optional current working notes: intent/rationale, known environment and paths, completed setup/checks with results, failed approaches and remaining work. Reuse known facts with source references; no required form or new approval. Public history and Mission observations are also supplied automatically. Omit when already sufficient; do not recopy the original request." };
         tools[startMission] = { description: `Operator: save current requirements; the host retains the original request verbatim. With a meaningful formal check known from user, project or task context and one useful unit, include unit NOW (and execution for an operation) and dispatch its Worker directly; plan_units remains available after start. A literal command in the original request is not required. Worker owns investigation/edit/check/requested commit before independent Review; no routine preparation or commit-only handoff. ${MISSION_GIT_SCOPE} Unknown checks or real unit decomposition use Coordinator. intent=replace follows an actual user requirement change, retaining unchanged constraints and cumulative spend; for mission-source-reconciliation-required use the saved requirements when they reflect that change. intent=new is separate work in another location.`,
             args: { requirements: { ...stringList, minItems: 1, maxItems: 64 },
                 unit: { ...missionUnitSchema, description: "When the meaningful check and single-unit scope are already known, include this unit now. Returns its configured Worker directly, combining start_mission and plan_units without another model round trip.", "x-sortie-optional": true },
                 execution: missionExecutionSchema,
+                handoff_context: handoffContextSchema,
                 confirmed_conditions: conditionsSchema,
                 prohibited_write: { ...stringList, description: "Only explicit path prohibitions from the user or applicable instructions. Never infer a parent glob from project/repository names, semantic 'do not modify the product', or the complement of estimated unit.write. Preserve the authorized clone and exact prohibited paths; semantic constraints stay in requirements.", "x-sortie-optional": true },
                 kind: { type: "string", enum: ["implementation", "operation"], description: "Use operation for running an existing benchmark, command or procedure. The host records its actual execution separately from setup and checks.", "x-sortie-optional": true },
@@ -2092,11 +2114,13 @@ export function createProfiledPlugin(profile, assetVersion) {
                             return JSON.stringify({ ...relocated, budget: await control.currentBudget(context.sessionID) });
                     }
                     const cancelled = await operators.read(context.sessionID);
+                    const history = await missionHistory(context.sessionID);
                     let mission = await missions.start(context.sessionID, requirements, args.intent === "replace" || args.intent === "new", {
                         kind: args.kind === "operation" ? "operation" : "implementation", executionHost: input.executionHost,
-                        context: missionConversationContext(await messages(context.sessionID)),
+                        context: missionConversationContext(history),
                         ...(args.intent === "replace" && cancelled?.phase === "cancelled" ? { cancelledRunID: cancelled.runID } : {}),
                     });
+                    mission = await missions.retainContext(context.sessionID, context.sessionID, history, args.handoff_context);
                     const prohibited = args.prohibited_write;
                     if (prohibited !== undefined) {
                         if (!Array.isArray(prohibited) || !prohibited.every(path => typeof path === "string"))
@@ -2298,7 +2322,7 @@ 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 declareMissionUnits(root, actor, mission, raw, reason, execution, planningCallID) {
+        async function declareMissionUnits(root, actor, mission, raw, reason, execution, planningCallID, handoffNotes) {
             await control.currentBudget(root);
             mission = await missions.required(root);
             let previous = await operators.read(root);
@@ -2452,13 +2476,16 @@ export function createProfiledPlugin(profile, assetVersion) {
                     },
                 }) : [];
             const dispatcher = actor === root ? undefined : { sessionID: actor, callID: mission.callID };
-            const context = { original_requests: mission.requests, requirements: mission.requirements, prohibited_write: mission.prohibitedWrite ?? [],
-                launch_conditions: mission.launchConditions ?? [] };
+            const histories = await Promise.all([...new Set([root, actor])].map(async (id) => ({ id, messages: await missionHistory(id) })));
+            for (const history of histories)
+                mission = await missions.contextSnapshot(mission, history.id, history.messages, history.id === actor ? handoffNotes : undefined);
+            const context = await missions.handoffContext(mission);
             const state = replanning && previous ? await operators.replanMission(root, previous.runID, plan, dispatcher, context)
                 : await operators.prepareMission(root, plan, dispatcher, mission.supersededRunID, terminalChildren, mission.requirementsReplaced, context);
             await control.registerGoalDeclaration(root, state.units[0].task.prompt, true);
             control.enableUnits(root, state.units.filter(unit => unit.status === "pending").length);
             await missions.update(root, item => {
+                item.continuity = mission.continuity;
                 item.reviewScope = missionReviewScope(item.reviewScope, ...(previous && item.runID === previous.runID ? [previous] : []), state);
                 if (item.runID !== state.runID)
                     item.plans++;
@@ -2484,6 +2511,7 @@ export function createProfiledPlugin(profile, assetVersion) {
         tools[planUnits] = { description: `Coordinator or single-unit Fast-lane Operator: declare useful work with estimated read/write scope and meaningful formal checks. executor=self starts implementation/correction and formal validation HERE without a Worker or handoff read; otherwise dispatch the returned configured Worker promptly. Keep investigation/edit/check/requested commit with the same author before independent Review, not a commit-only handoff. ${MISSION_GIT_SCOPE} Native scope reconciliation/expand_unit retain host permissions and explicit path prohibitions. Objective is the target or corrective delta: aim for 2000 characters; the full original request/public reproduction is supplied separately, not copied here. Oversized unit instructions are retained verbatim in handoff Mission context, not rejected for another planning round. Keep every requirement covered. Final validation proves the unit; empty or dummy checks do not qualify. Diagnostics need no registration. write: [] is read-only; dir/** and native absolute paths support actual outputs. reason replans settled work, or ends your own quiescent direct unit without acceptance to correct its declaration, in the same requirements/budget; same-scope failed validation uses retry_mission_unit. Reviewer FINDINGS stay with the same Reviewer for correction, formal validation and self-recheck.`,
             args: { units: { type: "array", minItems: 1, maxItems: 32, items: missionUnitSchema },
                 execution: missionExecutionSchema,
+                handoff_context: handoffContextSchema,
                 reason: { type: "string", "x-sortie-optional": true },
                 executor: { type: "string", enum: ["worker", "self"], description: "Use self to implement/correct and formally validate here without a Worker handoff. Default worker retains configured Worker routing.", "x-sortie-optional": true } }, execute: async (args, context) => {
                 const { root, mission } = await missionAuthority(context.sessionID);
@@ -2491,7 +2519,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     throw new Error("mission-executor-invalid");
                 try {
                     return await serializeDispatchTransition(root, async () => {
-                        const planned = await declareMissionUnits(root, context.sessionID, mission, args.units, args.reason, args.execution, context.callID);
+                        const planned = await declareMissionUnits(root, context.sessionID, mission, args.units, args.reason, args.execution, context.callID, args.handoff_context);
                         return args.executor === "self" && record(JSON.parse(planned).task) ? startDirect(root, context.sessionID) : planned;
                     });
                 }
@@ -2643,13 +2671,26 @@ export function createProfiledPlugin(profile, assetVersion) {
                     }
                     const newFindings = review?.runID === run.runID && review.verdict === "findings" &&
                         existing?.reviewIdentity !== missionReviewIdentity(mission);
-                    const recovery = existing?.status === "failed" && run.phase === "awaiting-decision";
+                    let validationRecovery = false;
+                    if (existing?.status === "ready" && run.phase === "awaiting-acceptance") {
+                        try {
+                            await assertCorrectionValidation(run);
+                        }
+                        catch (error) {
+                            if (!(error instanceof Error) || !error.message.startsWith("mission-review-correction-validation-stale:"))
+                                throw error;
+                            // Read-only self-recheck cannot repair stale checks. Reuse the existing
+                            // same-author correction admission, without blessing historical evidence.
+                            validationRecovery = true;
+                        }
+                    }
+                    const recovery = existing !== undefined && ((existing.status === "failed" && run.phase === "awaiting-decision") || validationRecovery);
                     if (existing && ((!newFindings && !recovery) || ["prepared", "running"].includes(existing.status)))
                         return JSON.stringify({ status: `correction-${existing.status}`,
                             ...(run.phase === "prepared" ? { task: operators.nextWorkerTask(run) } : {}),
                             next_action: "Continue only the existing correction Task. Ready requires explicit SAME-author native self-recheck; only residual concrete Major risk requires a different Reviewer. Failure retains the candidate and cumulative spend." });
                     if (!run.units.some(unit => unit.unit.write.length) ||
-                        (!recovery && (run.phase !== "awaiting-acceptance" || review?.runID !== run.runID)) || review?.verdict !== "findings" ||
+                        (!recovery && (run.phase !== "awaiting-acceptance" || review?.runID !== run.runID)) || !review || (!validationRecovery && review.verdict !== "findings") ||
                         !review.child || !review.initialPrompt || !review.result)
                         throw new Error("mission-review-correction-unavailable");
                     const original = mission.corrections?.at(-1);
@@ -2675,7 +2716,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                         throw new Error("mission-review-correction-budget-unavailable");
                     const reviewIdentity = missionReviewIdentity(mission);
                     const plan = missionPlan(mission, [{ title: `Correct ${run.units[0].unit.title}`,
-                            objective: `Correct all retained concrete Major/Medium findings in this SAME native conversation; preserve every original requirement. Exact findings are at correction_context.findings in the handoff; retained_findings_ref is optional lineage, not an instruction to reread/print the entire Mission or previous review prompt. Relevant search and focused diagnostics may widen normally; do not rediscover unchanged work. ${REVIEWER_VALIDATION_WORKFLOW} Retain the requested commit/clean boundary. THEN explicitly self-recheck the original requirements, ALL retained findings, correction and relevant impact in this Task. Correct known defects and revalidate affected checks before finishing. First line SELF_RECHECKED. Next line self_recheck: {"candidate":"current-validated","unresolved_findings":[],"residual_major":null}. The HOST binds current-validated to actual current source and fresh successful native checks after this exact prompt; never copy a pre-edit hash. Explain the actual comparison below. List unresolved concrete Major/Medium defects in unresolved_findings (no acceptance). Only concrete reachable residual Major risk uses residual_major:{"reachable_path":"...","consequence":"serious consequence"} and requires a different Reviewer. Tags/hashes/Medium/prose gaps alone never trigger it. This is author self-recheck, NOT independent PASS. Legacy CORRECTION_READY without self-recheck only permits a same-author read-only fallback Task, never acceptance.`,
+                            objective: `${validationRecovery ? "The prior correction completed, but its inherited validation is now stale. Preserve completed implementation, reproduction, original findings and historical checks; refresh only affected checks in this SAME author context. If the check recipe needs repair, use repair_review here as its existing author. Do not redo unchanged implementation/discovery or request another independent Review. " : ""}Correct all retained concrete Major/Medium findings in this SAME native conversation; preserve every original requirement. Exact findings are at correction_context.findings in the handoff; retained_findings_ref is optional lineage, not an instruction to reread/print the entire Mission or previous review prompt. Relevant search and focused diagnostics may widen normally; do not rediscover unchanged work. ${REVIEWER_VALIDATION_WORKFLOW} Retain the requested commit/clean boundary. THEN explicitly self-recheck the original requirements, ALL retained findings, correction and relevant impact in this Task. Correct known defects and revalidate affected checks before finishing. First line SELF_RECHECKED. Next line self_recheck: {"candidate":"current-validated","unresolved_findings":[],"residual_major":null}. The HOST binds current-validated to actual current source and fresh successful native checks after this exact prompt; never copy a pre-edit hash. Explain the actual comparison below. List unresolved concrete Major/Medium defects in unresolved_findings (no acceptance). Only concrete reachable residual Major risk uses residual_major:{"reachable_path":"...","consequence":"serious consequence"} and requires a different Reviewer. Tags/hashes/Medium/prose gaps alone never trigger it. This is author self-recheck, NOT independent PASS. Legacy CORRECTION_READY without self-recheck only permits a same-author read-only fallback Task, never acceptance.`,
                             read: [...new Set([...(mission.reviewScope?.read ?? []), ...run.units.flatMap(unit => unit.unit.read)])],
                             write: [...new Set([...(mission.reviewScope?.write ?? []), ...run.units.flatMap(unit => unit.unit.write)])],
                             validation: run.units.flatMap(unit => unit.unit.validation),
@@ -2695,7 +2736,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                     const baseline = await missionReviewBaseline(input.directory);
                     const dispatcher = mission.coordinator ? { sessionID: mission.coordinator, callID: mission.callID } : undefined;
                     const prepared = await operators.prepareReviewerCorrection(root, run.runID, correctedPlan, authorID, reviewIdentity, retainedPlan.units[0].write, dispatcher, {
-                        original_requests: mission.requests, requirements: mission.requirements, prohibited_write: mission.prohibitedWrite ?? [],
+                        ...await missions.handoffContext(mission),
                         correction_context: { findings: recovery ? existing.findings : review.result,
                             retained_findings_ref: JSON.parse(missions.correctionReference(root, reviewIdentity)),
                             mission_id: mission.id, prior_run_id: run.runID, review_identity: reviewIdentity,
@@ -2860,15 +2901,20 @@ export function createProfiledPlugin(profile, assetVersion) {
                         : { status: "skipped-low-risk" });
                 });
             } };
-        async function assertCorrectionValidation(run) {
+        async function correctionValidationFailure(run) {
             for (const unit of run.units) {
                 if (!unit.reviewerCorrection || !unit.childSessionID)
                     continue;
                 const checked = await reviewerCorrectionValidationFresh(unit.unit.validation, unit.childSessionID, await messages(unit.childSessionID), Date.parse(unit.reviewerCorrection.admittedAt ?? run.createdAt), unit.reviewerCorrection.checks ?? [], input.directory, unit.directExecution?.validationCwd ?? unit.unit.validation_cwd, unit.reviewerCorrection.validationRegisteredAt);
                 if (!checked.ready)
-                    throw new Error(checked.reason);
+                    return checked.reason;
             }
         }
+        async function assertCorrectionValidation(run) {
+            const reason = await correctionValidationFailure(run);
+            if (reason)
+                throw new Error(reason);
+        }
         /** Shared inline/fallback proof: the exact admitted native prompt's actual successful terminal. */
         async function observeNativeSelfRecheck(root, mission, run, author, callID, promptID, admittedAt, expectedSource, suppliedHistory) {
             if (!promptID || !Number.isFinite(admittedAt) || mission.runID !== run.runID || run.phase !== "awaiting-acceptance")
@@ -2894,7 +2940,11 @@ export function createProfiledPlugin(profile, assetVersion) {
             const checked = missionSelfRecheckReport(text, expectedSource ?? source.fingerprint, true);
             if (!checked)
                 return undefined;
-            await assertCorrectionValidation(run);
+            // A stale/missing check is an incomplete self-recheck, not a native lifecycle
+            // accounting error. Settle the real terminal so later prompts can repair it.
+            // Explicit acceptance still requires assertCorrectionValidation.
+            if (await correctionValidationFailure(run))
+                return undefined;
             if (expectedSource !== undefined && source.fingerprint !== expectedSource)
                 return undefined;
             return { runID: run.runID, source: source.fingerprint, candidateSource: source.candidateFingerprint,
@@ -2912,27 +2962,39 @@ export function createProfiledPlugin(profile, assetVersion) {
         }
         tools[submitMission] = { description: "Coordinator: return only a completion candidate, a user-only decision, or a proven external/scope/budget blocker. Continue ordinary investigation, scope extensions and corrections yourself. Unit progress is published automatically without waking Operator.",
             args: { status: { type: "string", enum: ["ready", "needs-decision", "blocked"] }, summary: stringSchema }, execute: async (args, context) => {
-                const { root, mission } = await missionAuthority(context.sessionID);
-                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"
-                                ? "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." });
+                const { root } = await missionAuthority(context.sessionID);
+                return serializeDispatchTransition(root, async () => {
+                    const mission = await missions.required(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"
+                                    ? "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." });
+                        }
+                        const run = await operators.required(root);
+                        if (run.phase !== "awaiting-acceptance")
+                            throw new Error("mission-units-incomplete");
+                        await assertMissionReview(root, mission);
                     }
-                    const run = await operators.required(root);
-                    if (run.phase !== "awaiting-acceptance")
-                        throw new Error("mission-units-incomplete");
-                    await assertMissionReview(root, mission);
-                }
-                const updated = await missions.update(root, state => {
-                    state.phase = "submitted";
-                    state.submission = { status: args.status, summary: args.summary };
+                    else if (args.status === "blocked" || args.status === "needs-decision") {
+                        // This owner is stopping its direct work, not validating it. Keep the
+                        // failed checks/candidate and settle its existing reservation once.
+                        const direct = await activateDirect(context.sessionID);
+                        if (direct)
+                            await control.failDirectUnit(root, context.sessionID);
+                    }
+                    const updated = await missions.update(root, state => {
+                        state.phase = "submitted";
+                        state.submission = { status: args.status, summary: args.summary };
+                    });
+                    const submittedRun = await operators.read(root);
+                    return JSON.stringify({ acceptance_summary: await missionAcceptanceSummary(updated, submittedRun, operators, acceptanceValidationObservation),
+                        ...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." });
                 });
-                const submittedRun = await operators.read(root);
-                return JSON.stringify({ acceptance_summary: await missionAcceptanceSummary(updated, submittedRun, operators, acceptanceValidationObservation),
-                    ...missionPacket(updated, submittedRun),
-                    next_action: "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." });
             } };
         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.",
             args: {}, execute: async (_args, context) => {
@@ -3699,14 +3761,19 @@ export function createProfiledPlugin(profile, assetVersion) {
                                         admittedAt: inline.inlineReview.admittedAt, result: report.result, selfRecheck: report };
                                 });
                             const latest = await missions.required(ownership.root);
+                            const validationFailure = !report && inline.status === "ready" && settled.phase === "awaiting-acceptance"
+                                ? await correctionValidationFailure(settled) : undefined;
                             output.output = JSON.stringify({ status: report ? "review-correction-recorded" : "review-correction-incomplete",
                                 reviewer_report: raw, independent: false,
+                                ...(validationFailure ? { reason: validationFailure } : {}),
                                 acceptance_summary: await missionAcceptanceSummary(latest, settled, operators, acceptanceValidationObservation),
                                 next_action: report && !report.unresolvedFindings.length && !report.residualMajor
                                     ? `Host already recorded source, formal checks, delivery and actual native author self-recheck. Compare the original request with this candidate, then ${current.coordinator ? submitMission : completeMission}; no routine operator_status, new review or validation Worker.`
-                                    : !report && inline.status === "ready" && settled.phase === "awaiting-acceptance"
-                                        ? `Formal correction validation remains current, but the actual native author self-recheck is missing/failed. No acceptance. Call ${reviewMission} only for the missing read-only self-recheck in the SAME author/context, without rerunning successful checks or requesting another Reviewer.`
-                                        : `No acceptance. Continue the SAME author through ${repairReview} for actual defects; only a concrete residual Major risk after self-recheck calls for a different Reviewer.` });
+                                    : validationFailure
+                                        ? `No acceptance: ${validationFailure}. Call ${repairReview} to refresh affected checks in the SAME author/context. Preserve completed work and historical evidence; do not redo unchanged implementation/discovery or request another independent Reviewer.`
+                                        : !report && inline.status === "ready" && settled.phase === "awaiting-acceptance"
+                                            ? `Formal correction validation remains current, but the actual native author self-recheck is missing/failed. No acceptance. Call ${reviewMission} only for the missing read-only self-recheck in the SAME author/context, without rerunning successful checks or requesting another Reviewer.`
+                                            : `No acceptance. Continue the SAME author through ${repairReview} for actual defects; only a concrete residual Major risk after self-recheck calls for a different Reviewer.` });
                             taskOwners.delete(request.callID);
                             return;
                         }

package/dist/plugin/v2.js

@@ -511,7 +511,10 @@ async function registerV2Hooks(context, hooks, background, liveState) {
             };
         });
         for (const [name, definition] of Object.entries(hooks.tool ?? {})) {
-            editor.add({ name, description: definition.description, input: toolSchema(definition.args), options: { codemode: false },
+            // The approved increase is discovered through execute/search. Direct-only registrations
+            // are absent from that catalog; retain the other controls' existing direct entrypoints.
+            editor.add({ name, description: definition.description, input: toolSchema(definition.args),
+                options: { codemode: name === "sortie_v010_extend_mission_budget" },
                 execute: async (input, execution) => {
                     await background.reconcile(String(execution.sessionID ?? ""));
                     let content;
@@ -693,7 +696,7 @@ async function registerV2Hooks(context, hooks, background, liveState) {
             await reconcileCorrectionPermissions(String(event.sessionID));
             if (record(event.tools)) {
                 const visible = {
-                    "dog-operator": ["start_mission", "plan_units", "start_direct_unit", "finish_direct_unit", "retry_mission_unit", "operator_next", "operator_status", "expand_unit", "review_mission", "repair_review", "complete_mission", "cancel_operator", "reflection"],
+                    "dog-operator": ["start_mission", "plan_units", "start_direct_unit", "finish_direct_unit", "retry_mission_unit", "operator_next", "operator_status", "extend_mission_budget", "expand_unit", "review_mission", "repair_review", "complete_mission", "cancel_operator", "reflection"],
                     "dogs-coordinator": ["plan_units", "start_direct_unit", "finish_direct_unit", "operator_next", "operator_status", "expand_unit", "review_mission", "repair_review", "submit_mission", "skip_mission_consultation", "retry_mission_unit", "rescue_mission_unit"],
                     "dog-worker-v010": ["bind_write_gate", "release_write_gate", "operator_status", "expand_unit"],
                     "dog-luna-worker-v010": ["bind_write_gate", "release_write_gate", "operator_status", "expand_unit"],

package/dist/runtime-mission-assets.d.ts

@@ -1,9 +1,11 @@
 import { type RuntimeProfile } from "./core/runtime-profile.ts";
 /** Repository-local dependency environment shared by all units; excluded from reviewed and captured source. */
 export declare const TOOL_ENVIRONMENT = ".sortie-env";
+/** Task-specific environment limits qualify general dependency setup guidance. */
+export declare const MISSION_DEPENDENCY_WORKFLOW = "Honor original dependency limits in setup and unit objectives. If the user permits installs only for\nproven-missing packages, an installed but incompatible package is not missing: do not replace it or\ndescribe it as missing compatible tooling. General registry/compatible-version guidance does not widen\nthat task-specific limit. Reuse a supplied environment; create one only when the original request permits.\nOtherwise carry out authorized dependency repair normally. If required behavior remains unverified under\nthose limits, retain in-scope work and report the limitation, not successful verification.";
 /** Ordinary requested Git delivery uses source scope, not repository control-storage scope. */
 export declare const MISSION_GIT_SCOPE = "Requested git add <paths> (with optional --) and git commit -m ... are normal source-scope Git operations;\nthey do not require .git/** scope. Preserve explicit user ordering and host Git lifecycle; attempt supported\noperations and report actual denials, not inferred gaps. Stage actual changed deliverables only: permission\nfor an unchanged file or deleted untracked scratch does not require staging it. Repair a missing in-request\noutput via expand_unit, then continue the SAME Task; covered paths need no new grant or dispatch.";
-export declare const VALIDATION_WORKFLOW = "## Time-aware validation workflow\n\nOperator/Coordinator: put the known meaningful formal check from the user, project or task context in validation,\nnot another objective copy. A literal command in the original request is not required; empty or dummy checks do not qualify.\nKeep any user/project-required broad validation for the final integrated candidate,\nnot every implementation unit. Do not add a full suite merely as a precaution or create a testing agent.\nWorker: reproduce, batch the related edits, inspect the complete diff, then run the focused checks.\nFix failures with the smallest exercising check before starting a costly suite. Do not execute the entire\nformal validation list after each patch; run it in declared order when the unit candidate is stable.\nIf broad validation is already declared, defer it until focused checks pass and known edits are finished;\ndo not remove it, substitute a tiny check for it, or claim an unrun requirement passed.\nAfter a late fix, select checks for the affected inputs; repeat broad validation when the requested\ncontract or host evidence freshness requires it, not solely because any file or Worker changed.\nDocumentation-only changes do not automatically invalidate unrelated runtime/test results; retain the\nchecked candidate and show why reuse is valid under project and host rules. Never promote stale proof.\nBefore a costly check, state its purpose and known duration (unknown if unmeasured). In the concise return,\nreport command, scope, actual exit/elapsed time and any rerun reason; never invent savings or timings.\nReview evidence gaps need original excerpts, not another patch or full test. Keep autonomous correction,\nrequired review, accepted criteria and cumulative budget intact; this workflow adds no approval or denial.\n";
+export declare const VALIDATION_WORKFLOW = "## Time-aware validation workflow\n\nOperator/Coordinator: put the known meaningful formal check from the user, project or task context in validation,\nnot another objective copy. A literal command in the original request is not required; empty or dummy checks do not qualify.\nFor a concrete public reproduction, carry its entrypoint and relevant input into the unit objective and formal reproduction check.\nPreserve its fixture layout and working directory. A standalone example project belongs in its own fixture root within allowed paths;\ninvoke from there with the active environment, not the source checkout root where import paths or configuration may mask the failure.\nDerive the shell recipe without substituting lower-level library calls; those checks may supplement, never replace, the public entrypoint.\nReuse existing checks that already exercise it. If authorized setup cannot run it, retain useful work and report the verification gap, not a passing reproduction.\nFor direct work with an unknown reproduction recipe, resolve its flags, configuration and cwd with ordinary native diagnostics before formal registration.\nReuse an already observed failing baseline; do not rerun it merely to plan. A command that never exercises the reported path is not a passing reproduction.\nUse existing project configuration within the original path constraints. Known recipes and Worker-owned investigation need no extra preparation or unit.\nKeep any user/project-required broad validation for the final integrated candidate,\nnot every implementation unit. Do not add a full suite merely as a precaution or create a testing agent.\nWorker: reproduce, batch the related edits, inspect the complete diff, then run the focused checks.\nFix failures with the smallest exercising check before starting a costly suite. Do not execute the entire\nformal validation list after each patch; run it in declared order when the unit candidate is stable.\nIf broad validation is already declared, defer it until focused checks pass and known edits are finished;\ndo not remove it, substitute a tiny check for it, or claim an unrun requirement passed.\nAfter a late fix, select checks for the affected inputs; repeat broad validation when the requested\ncontract or host evidence freshness requires it, not solely because any file or Worker changed.\nDocumentation-only changes do not automatically invalidate unrelated runtime/test results; retain the\nchecked candidate and show why reuse is valid under project and host rules. Never promote stale proof.\nBefore a costly check, state its purpose and known duration (unknown if unmeasured). In the concise return,\nreport command, scope, actual exit/elapsed time and any rerun reason; never invent savings or timings.\nReview evidence gaps need original excerpts, not another patch or full test. Keep autonomous correction,\nrequired review, accepted criteria and cumulative budget intact; this workflow adds no approval or denial.\n";
 /** Worker-only projection; planning/review authorities retain the complete shared workflow. */
 export declare const WORKER_VALIDATION_WORKFLOW = "Batch edits, reconcile requirements/diff, run focused tests, then every registered formal check exactly in order:\nseparate foreground native shell calls, no extra tee, redirect or wrapper. Diagnostics are not formal evidence.\nRerun affected checks and required broad checks when contract/freshness requires; never drop required validation or claim stale/unrun proof.\n";
 /** Correction uses the inherited command identities; diagnostics do not acquire formal evidence. */
@@ -11,6 +13,8 @@ export declare const REVIEWER_VALIDATION_WORKFLOW = "Run inherited formal comman
 export declare function missionOperatorContent(profile: RuntimeProfile, version: string): string;
 /** Keep representation oracles consistent in direct execution, Worker and Review. */
 export declare const MISSION_REPRESENTATION_ORACLE = "Same-type representation, not name/visitor analogy; resolve conflicts.";
+/** Coordinator authors and plans regressions without adding another validation/review lane. */
+export declare const MISSION_REGRESSION_PLACEMENT = "Prefer an existing relevant test suite/subtest or fixture when it can express the regression assertion.\nIf a new test module is needed, prefer a distinctive behavior-specific name over automatically mirroring the implementation module.\nPreserve established assertions and project test discovery. This is placement guidance, not another test, unit or review requirement.";
 /** Shared by the installed Reviewer and its host-generated mission prompt. */
 export declare const MISSION_BEHAVIOR_REVIEW = "Establish the test oracle independently of the patch: tests added with the implementation are claims to\nreview, not established API behavior. For a changed failure path, compare a pre-existing analogous public\ntest and its shared assertion helper, including default expected outputs, with the new case. A new test\nthat asserts the implementation's current result can encode the defect rather than catch it. Preserve\nthe pre-change contract unless the request changes it; do not invent a universal failure-result convention.\nSame-type representation, not name/visitor analogy; resolve conflicts.\nTrace a concrete rejected input through the changed code back to the public caller, checking result,\nerror and observable state together, including earlier results that can survive failure. Missing assertions\nalone are not defects; a concrete contradiction with the established contract is a finding even if tests pass.\nDuring correction, reuse the established public test harness where applicable and exercise the smallest\nregression exposing the defect before the fix and passing afterward. Do not change expected values or\nhelper defaults merely to agree with the implementation; derive them from the original contract.\nPrefer existing suites/subtests for regressions. New test entry/helper names should be distinctive\nand compose with other same-package test files, not create generic package-level collisions.\n\nFor a requested per-call mode/option, trace where the setting is chosen and where changed code uses\nretained objects or closures. Distinguish the current caller's setting from a captured creation-time\nsetting; use the requested contract to decide which governs. If actual source crosses that boundary\nand existing tests do not cover it, exercise its smallest public case, including the disabled behavior.\nDo not invent a lifecycle matrix or infer that an opt-in feature is correct from only its enabled path.\n\nFor a changed failure handler, inspect the operation it calls and the public inputs reaching it,\nincluding failures not listed in the new handler. Use the supplied source/tests and established API behavior\nto identify a concrete input that could still violate the requested contract. A passing normal input does\nnot settle a different failure outcome of that same operation. A demonstrable material defect is FINDINGS; ask for\nan excerpt or result only when a specific material outcome cannot be settled. Do not invent new behavior,\nrequire an exhaustive exception inventory, or recommend catching every exception.\n\nReport FINDINGS only for concrete major or medium defects with a material impact on the original requirements,\npublic behavior, correctness or required validation. Name the consequence and smallest necessary fix.\nDo not turn minor style, wording, optional improvements or speculative edge cases into FINDINGS or EVIDENCE_GAPS.\nUse read/search to settle missing context in the current review. If a consequential uncertainty remains,\nrecord EVIDENCE_GAPS as an advisory limitation, not a demand for another evidence packet. Missing narration,\nrequirement mappings, hashes or clipped excerpts alone never justify a blocking finding.\n\nAssess behavioral requirements against actual source, tests and observed results. A required check known to\nhave failed or not run is a concrete finding; missing documentation of a check is not proof it did not run.\nFor incidental workflow constraints such as cache settings or command-path spelling, use existing host observations;\nabsence of a separate settings dump or historical log is not itself an evidence gap. Flag observed material\ncontradictions. The Operator owns final comparison with the original request. If a missing check genuinely\naffects correctness or a requested deliverable, name that consequence and the smallest useful next check.\nOn verification, compare the correction and its affected public outcomes with the original contract, not\nonly the wording of previous findings. Reuse unchanged evidence; do not expand into optional improvements\nor an exhaustive input matrix. PASS means no material finding, not exhaustive proof of every path.";
 /** Mission Reviewer uses ordinary host read/search permissions, not a supplied-packet-only protocol. */

package/dist/runtime-mission-assets.js

@@ -3,6 +3,13 @@ import { STRATEGY_TRIGGERS, SOURCE_REVIEW_RISK_TAGS } from "./core/consultation.
 import { SCOUT_EVIDENCE_CODES } from "./core/scout-contract.js";
 /** Repository-local dependency environment shared by all units; excluded from reviewed and captured source. */
 export const TOOL_ENVIRONMENT = ".sortie-env";
+/** Task-specific environment limits qualify general dependency setup guidance. */
+export const MISSION_DEPENDENCY_WORKFLOW = `Honor original dependency limits in setup and unit objectives. If the user permits installs only for
+proven-missing packages, an installed but incompatible package is not missing: do not replace it or
+describe it as missing compatible tooling. General registry/compatible-version guidance does not widen
+that task-specific limit. Reuse a supplied environment; create one only when the original request permits.
+Otherwise carry out authorized dependency repair normally. If required behavior remains unverified under
+those limits, retain in-scope work and report the limitation, not successful verification.`;
 /** Ordinary requested Git delivery uses source scope, not repository control-storage scope. */
 export const MISSION_GIT_SCOPE = `Requested git add <paths> (with optional --) and git commit -m ... are normal source-scope Git operations;
 they do not require .git/** scope. Preserve explicit user ordering and host Git lifecycle; attempt supported
@@ -13,6 +20,14 @@ export const VALIDATION_WORKFLOW = `## Time-aware validation workflow
 
 Operator/Coordinator: put the known meaningful formal check from the user, project or task context in validation,
 not another objective copy. A literal command in the original request is not required; empty or dummy checks do not qualify.
+For a concrete public reproduction, carry its entrypoint and relevant input into the unit objective and formal reproduction check.
+Preserve its fixture layout and working directory. A standalone example project belongs in its own fixture root within allowed paths;
+invoke from there with the active environment, not the source checkout root where import paths or configuration may mask the failure.
+Derive the shell recipe without substituting lower-level library calls; those checks may supplement, never replace, the public entrypoint.
+Reuse existing checks that already exercise it. If authorized setup cannot run it, retain useful work and report the verification gap, not a passing reproduction.
+For direct work with an unknown reproduction recipe, resolve its flags, configuration and cwd with ordinary native diagnostics before formal registration.
+Reuse an already observed failing baseline; do not rerun it merely to plan. A command that never exercises the reported path is not a passing reproduction.
+Use existing project configuration within the original path constraints. Known recipes and Worker-owned investigation need no extra preparation or unit.
 Keep any user/project-required broad validation for the final integrated candidate,
 not every implementation unit. Do not add a full suite merely as a precaution or create a testing agent.
 Worker: reproduce, batch the related edits, inspect the complete diff, then run the focused checks.
@@ -89,6 +104,8 @@ ${controls(profile, ["start_mission", "plan_units", "start_direct_unit", "finish
 You are Operator, the user-facing strategic authority. Preserve every current requirement, prohibition,
 quality threshold and explicit model/budget choice. Follow AGENTS.md and use the user's language.
 
+${MISSION_DEPENDENCY_WORKFLOW}
+
 1. For an implementation or operation request, give at most three short lines, then call ${profile.toolPrefix}start_mission
    with a few concise one-line requirements including negative constraints. The host saves the original
     user message verbatim and recent public context and generates IDs; do not copy it or author contracts, hashes or a proposal.
@@ -233,6 +250,10 @@ existing user authorization and project gates; npm publication remains manual.
 }
 /** Keep representation oracles consistent in direct execution, Worker and Review. */
 export const MISSION_REPRESENTATION_ORACLE = `Same-type representation, not name/visitor analogy; resolve conflicts.`;
+/** Coordinator authors and plans regressions without adding another validation/review lane. */
+export const MISSION_REGRESSION_PLACEMENT = `Prefer an existing relevant test suite/subtest or fixture when it can express the regression assertion.
+If a new test module is needed, prefer a distinctive behavior-specific name over automatically mirroring the implementation module.
+Preserve established assertions and project test discovery. This is placement guidance, not another test, unit or review requirement.`;
 /** Shared by the installed Reviewer and its host-generated mission prompt. */
 export const MISSION_BEHAVIOR_REVIEW = `Establish the test oracle independently of the patch: tests added with the implementation are claims to
 review, not established API behavior. For a changed failure path, compare a pre-existing analogous public
@@ -429,6 +450,12 @@ run/grade commands and working directory. Setup, launch and result collection no
 do not forbid execution while assigning that Worker the requirement to execute.
 Write objective as a target or corrective delta: aim for 2000 characters.
 The Worker reads the original requests verbatim from the handoff once; do not copy them into objective.
+Public conversation, recent tool results and Mission progress are supplied automatically in continuity.
+When useful, include handoff_context in start_mission/plan_units: current intent and rationale, known environment,
+completed setup/checks, failed approaches and remaining work with existing references. It is optional working
+context, not a form or approval. Preserve useful knowledge instead of assigning unchanged discovery again.
+Assign the remaining action. Reference paths support relevant gaps, not a mandatory reread checklist; avoid
+routine environment/instruction reconfirmation and guessed AGENTS.md paths when that context is already supplied.
 Keep investigation, edits, formal checks and any requested commit in the same Worker before independent Review;
 do not invent a review-before-commit gate or a commit-only handoff. Preserve explicit user ordering.
 ${MISSION_GIT_SCOPE}
@@ -439,7 +466,14 @@ existing analogous source/tests for the expected contract when available. Avoid
 units just to restate the issue. A test of a neighboring name is not an adjacent check unless it runs
 the changed branch on a relevant different input; keep validation focused and do not require an extra
 test when the existing checks already exercise that boundary.
+When changing an error fallback, distinguish already handled errors from errors the called operation
+can still raise. Already handled failures and successful neighbors do not establish that new boundary.
+Repeating the reported error with another input does not cover still-unhandled related errors.
+If peer source/tests expose a plausible related still-unhandled error, probe its expected fallback
+before choosing the fix; reuse adequate checks. Include this in the current author's objective/check
+plan, not another unit or review round. Do not invent an exhaustive error matrix.
 ${MISSION_REPRESENTATION_ORACLE}
+${MISSION_REGRESSION_PLACEMENT}
 For read-only verification, use write: []; do not invent an output file or request write access to inputs.
 If declared build or tests create known generated paths, include those outputs in the initial write scope;
 do not add a separate setup unit just to prepare them.
@@ -452,8 +486,9 @@ Use absolute native paths for requested global installations or other external o
 a directory including a not-yet-created tree. These are execution/evidence scopes, not an additional
 permission grant: the host's native permissions still apply. Include the actual external input/output
 paths in read/write so validation and review observe them; do not substitute a repository symlink.
+${MISSION_DEPENDENCY_WORKFLOW}
 Keep all original requirements covered. Last validation command checks
-that unit. If your quick check shows repository-declared dependencies or the test runner are missing, keep
+that unit. If your quick check shows repository-declared dependencies or the test runner are missing and setup is allowed, keep
 setup inside the first unit: declare its checks through the repository-local tool environment ${TOOL_ENVIRONMENT}/
 (for Python, ${TOOL_ENVIRONMENT}/bin/python -m pytest ...) and let that Worker create it. Never plan a separate setup
 unit or put ${TOOL_ENVIRONMENT}/ in a write scope. Host generates IDs, proof mapping, handoff, manifest and Task references. Dispatch the returned
@@ -549,20 +584,21 @@ mode: subagent
 
 Implement, test and requested commit in this Task.
 Reuse supplied AGENTS.md; for gaps prefer exact ancestor files/affected subtrees over parent globs.
-Read handoff_path in full first: task.objective, verbatim original_requests/unit_instruction, Mission constraints,
-coverage indices. Preserve user scope and ordering; prove assigned criteria, not Mission completion.
+Read handoff_path in full first: task.objective, verbatim original_requests/unit_instruction, constraints/continuity,
+coverage. Preserve user scope and ordering; prove assigned criteria, not Mission completion.
 Denied: reason/remedy. No routine manifest/goal/status/bind.
-Recovery: ${profile.toolPrefix}bind_write_gate with exact project_root and manifest_path=operation_manifest.
-Treat cwd/project_root and paths as opaque; never shorten or normalize segments.
-After compaction recover handoff; inspect diff/results before repeats.
+${profile.toolPrefix}bind_write_gate with exact project_root and manifest_path=operation_manifest.
+cwd/project_root/paths: opaque; never shorten or normalize segments.
+After compaction recover handoff; inspect diff/results.
 Read/search: existing permissions. Fix unit.write/outputs/checks
-here via ${profile.toolPrefix}expand_unit/contract updates and host repair diagnostics;
+here via ${profile.toolPrefix}expand_unit/contract updates; host repair diagnostics;
 no extra approval, restart or delegation. Keep prohibitions, host Git lifecycle, cumulative budget.
 Requested add/commit needs source paths, not .git/** scope.
-Use pre-change test helpers as oracles, not new implementation/tests. Check
-result/error/state together, without a hypothetical exhaustive matrix. Keep reproduction entrypoint/input/layout; rerun or report why unverified.
+Pre-change oracles, not new tests; check result/error/state. Fallback: probe other unhandled errors from peer source/tests.
+No exhaustive matrix. Keep reproduction entrypoint/input/layout; rerun or report why unverified.
 ${MISSION_REPRESENTATION_ORACLE}
-Missing tooling: one documented bounded setup in ${TOOL_ENVIRONMENT}/; reuse, never delete.
+Use bounded documented setup in ${TOOL_ENVIRONMENT}/; reuse, never delete.
+User missing-only: installed/incompatible is not missing.
 Per-call modes: check retained creation/use for captured vs current settings.
 Tests: existing suites/subtests or distinctive regression entry names.
 ${WORKER_VALIDATION_WORKFLOW}

package/package.json

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