sortie-dogs 0.13.13 → 0.13.15

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

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

@@ -266,17 +266,21 @@ export function createProfiledPlugin(profile, assetVersion) {
         async function identity(id) {
             const info = payload(await session("get", { path: { id }, query: { directory: input.directory } }));
             const parent = record(info) && typeof info.parentID === "string" ? info.parentID : undefined;
-            let agent = selected.get(id);
+            // Native session identity survives reload; a completion's metadata.agent is its
+            // child author, not a selection of the receiving session's agent.
+            let agent = selected.get(id) ?? (record(info) && typeof info.agent === "string" ? info.agent : undefined);
             if (agent === undefined) {
                 const history = await messages(id);
                 for (const message of [...history].reverse()) {
+                    if (Array.isArray(message.parts) && message.parts.length > 0 &&
+                        message.parts.every(part => record(part) && part.synthetic === true))
+                        continue;
                     const metadata = record(message.info) ? message.info : message;
                     if (metadata.role === "user" && typeof metadata.agent === "string") {
                         agent = metadata.agent;
                         break;
                     }
                 }
-                agent ??= record(info) && typeof info.agent === "string" ? info.agent : undefined;
             }
             return { role: canonicalAgent(profile, agent), ...(parent === undefined ? {} : { parent }) };
         }
@@ -1001,6 +1005,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" };
@@ -1512,12 +1524,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);
@@ -2026,8 +2033,12 @@ 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" } };
@@ -2664,13 +2675,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);
@@ -2696,7 +2720,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),
@@ -2881,15 +2905,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")
@@ -2915,7 +2944,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,
@@ -2933,27 +2966,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) => {
@@ -3720,14 +3765,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

@@ -147,7 +147,9 @@ function legacyClient(context) {
         active: async () => ({ data: await (context.session.active ? context.session.active() : active()) }),
         get: async (request) => {
             const id = sessionID(request);
-            return { data: id === undefined ? undefined : await context.session.get({ sessionID: id }) };
+            const info = id === undefined ? undefined : await context.session.get({ sessionID: id });
+            // The native correction alias is still this same Reviewer's logical role.
+            return { data: record(info) && correctionAgent(info.agent) ? { ...info, agent: "dog-reviewer-v010" } : info };
         },
         messages: async (request) => {
             const id = sessionID(request);
@@ -511,7 +513,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 +698,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
@@ -445,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.
@@ -458,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
@@ -558,17 +587,18 @@ Reuse supplied AGENTS.md; for gaps prefer exact ancestor files/affected subtrees
 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.13",
+  "version": "0.13.15",
   "description": "Bounded agent harness and validated orchestration loop plugin for OpenCode",
   "keywords": [
     "opencode",