sortie-dogs 0.12.19 → 0.12.21

package/README.md

@@ -97,6 +97,8 @@ Official SWE-bench Lite `dev` results on the same 23 public instances:
 | v0.12.8 (`84ccdf1` main adapter) | 6 / 23 (26.1%) | 2 | Fresh 23-task run; four slots; 30-minute timeout | [Main-integrated run](docs/swebench-main-84ccdf1-dev23-2026-09-26.md) |
 | v0.12.15 (`0c9690d`) | 5 / 23 (21.7%) | 3 | Fresh 23-task ext4 retry; four slots; 40-minute timeout | [Campaign](docs/swebench-v01215-dev23-2026-09-27.md) |
 | v0.12.16 (`9b05a34` release; `b1a6c0e` runner) | 4 / 23 (17.4%) | 5 | Fresh 23-task run; eight slots; 40-minute timeout | [Campaign](docs/swebench-v01216-dev23-2026-09-27.md) |
+| v0.12.19 (`24f5386` release; matched rerun) | 8 / 23 (34.8%) | 0 | Eight slots; effective $2/instance; 40-minute timeout; one inference timeout | [Official result and provenance](docs/benchmarks/swebench-v01220-operation-observability-2026-09-28.md) |
+| v0.12.20 (`628eb81` release) | 7 / 23 (30.4%) | 0 | Eight slots; effective $2/instance; 40-minute timeout | [Official result and caveat](docs/benchmarks/swebench-v01220-operation-observability-2026-09-28.md) |
 
 Every row has 23 submitted official predictions; an empty patch counts against
 the score, not as a missing evaluation. The v0.10.14 report does not separately
@@ -110,6 +112,11 @@ estimated $15.75 in model cost and a 15.2-minute median agent runtime.
 The v0.12.16 run is the first eight-slot inference score in this table;
 five runners timed out, and this does not establish a model-quality regression
 against runs with different concurrency and conditions.
+The v0.12.19 row is the corrected run with an effective $2 per-instance cap;
+an earlier v0.12.19 run scored 7/23 but had no effective per-instance cap and
+is not a same-condition comparison. The v0.12.20 run lost the
+`sqlfluff__sqlfluff-2419` resolution relative to the corrected run; this
+single run-to-run difference does not establish causation.
 
 Historical qualification references remain in [benchmark reference](docs/benchmark-reference.md).
 

package/dist/asset-version.d.ts

@@ -3,5 +3,5 @@
  * 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.12.19-focused-behavior-review-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.21-validation-recovery-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,4 +3,4 @@
  * 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.12.19-focused-behavior-review-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.21-validation-recovery-v1";

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

@@ -20,6 +20,55 @@ export interface MissionReviewScope {
     read: string[];
     write: string[];
 }
+export interface MissionConsultation {
+    id: string;
+    role: "advisor" | "scout";
+    disposition: "skipped" | "dispatched";
+    reason: string;
+    at: string;
+    trigger?: string;
+    question?: string;
+    callID?: string;
+    childSessionID?: string;
+    observedModel?: string;
+    observedVariant?: string;
+    outcome?: "completed" | "failed" | "unknown";
+    result?: string;
+}
+export interface MissionAttempt {
+    attemptID: string;
+    runID: string;
+    unitID: string;
+    taskID: string;
+    predecessorAttemptID?: string | null;
+    /** Fingerprint of the settled scoped candidate against which a later Rescue is proposed. */
+    candidateID?: string;
+    kind: "implementation" | "normal_remediation" | "astra_rescue";
+    status: "pending" | "dispatched" | "succeeded" | "failed" | "cancelled" | "unconfirmed";
+    callID?: string;
+    childSessionID?: string;
+    nativeOutcome?: "completed" | "failed" | "unknown";
+    observedModel?: string;
+    observedVariant?: string;
+    failure?: {
+        category: "infrastructure" | "authorization" | "contract" | "cancellation" | "implementation" | "unknown";
+        code: string;
+    };
+    resultClass?: string;
+    selectedModel?: string;
+}
+export interface MissionTerminalRescue {
+    attemptID: string;
+    runID: string;
+    unitID: string;
+    selectedModel?: string;
+    selectedVariant?: string | null;
+    status: "prepared" | "dispatched" | "succeeded" | "failed" | "cancelled" | "unconfirmed" | "non_rescue";
+    reason?: string;
+    observedModel?: string;
+    observedVariant?: string;
+    outcome?: "succeeded" | "failed" | "cancelled" | "unknown";
+}
 export interface MissionExecution {
     commands: string[];
     directory: string;
@@ -61,6 +110,12 @@ export interface OperatorMission {
     reviewBaseline?: string;
     /** Cumulative declared review inputs/outputs, including units that failed after writing source. */
     reviewScope?: MissionReviewScope;
+    /** Optional Advisor/Scout decisions and native consultation outcomes; never an admission gate. */
+    consultations?: MissionConsultation[];
+    /** Host-observed current-Mission Worker attempts; only an implementation failure followed by a failed remediation can qualify for Rescue. */
+    attempts?: MissionAttempt[];
+    /** One bounded Astra Rescue per eligible unit; validation, independent review and root acceptance remain separate. */
+    rescue?: MissionTerminalRescue;
     /** A cancelled run replaced by a later real user turn; never reuse its acceptance or evidence. */
     supersededRunID?: string;
     plans: number;
@@ -95,6 +150,7 @@ export interface OperatorMission {
  * Worker unit, so after this many evidence-only reviews the candidate may be submitted with the gaps listed.
  */
 export declare const MISSION_EVIDENCE_GAP_REVIEW_LIMIT = 2;
+export declare const MISSION_CONSULTATION_LIMIT = 32;
 /** Review coverage survives a narrower replan; it is not a Worker write grant. */
 export declare function missionReviewScope(previous: MissionReviewScope | undefined, ...runs: OperatorState[]): MissionReviewScope;
 /** Classify an independent Reviewer's first line. Anything else is a finding. */
@@ -133,6 +189,20 @@ export declare class OperatorMissionRuntime {
         cancelledRunID?: string;
     }): Promise<OperatorMission>;
     update(root: string, change: (state: OperatorMission) => void): Promise<OperatorMission>;
+    recordConsultationSkip(root: string, role: MissionConsultation["role"], reason: string): Promise<OperatorMission>;
+    recordConsultationDispatch(root: string, input: {
+        role: MissionConsultation["role"];
+        callID: string;
+        reason: string;
+        trigger?: string;
+        question?: string;
+    }): Promise<OperatorMission>;
+    settleConsultation(root: string, callID: string, outcome: MissionConsultation["outcome"], details?: {
+        childSessionID?: string;
+        observedModel?: string;
+        observedVariant?: string;
+        result?: string;
+    }): Promise<OperatorMission>;
     /** Keep host-accepted criteria ahead of new text, including an exactly linked settled predecessor. */
     carryForward(root: string, missionID: string, acceptance: readonly string[], supersededRunID?: string): Promise<OperatorMission>;
     task(state: OperatorMission): OperatorTask;

package/dist/core/operator-mission.js

@@ -23,6 +23,7 @@ export function missionValidationCommand(command) {
  * Worker unit, so after this many evidence-only reviews the candidate may be submitted with the gaps listed.
  */
 export const MISSION_EVIDENCE_GAP_REVIEW_LIMIT = 2;
+export const MISSION_CONSULTATION_LIMIT = 32;
 /** Review coverage survives a narrower replan; it is not a Worker write grant. */
 export function missionReviewScope(previous, ...runs) {
     return {
@@ -267,6 +268,41 @@ export class OperatorMissionRuntime {
             return state;
         });
     }
+    recordConsultationSkip(root, role, reason) {
+        if ((role !== "advisor" && role !== "scout") || typeof reason !== "string" || !reason.trim() ||
+            reason.length > 1000 || /[\r\n]/u.test(reason))
+            throw new Error("mission-consultation-input-invalid");
+        return this.update(root, state => {
+            state.consultations = [...(state.consultations ?? []), { id: randomUUID(), role, disposition: "skipped",
+                    reason: reason.trim(), at: new Date().toISOString() }].slice(-MISSION_CONSULTATION_LIMIT);
+        });
+    }
+    recordConsultationDispatch(root, input) {
+        if ((input.role !== "advisor" && input.role !== "scout") || !input.callID || !input.reason.trim() ||
+            input.reason.length > 1000 || /[\r\n]/u.test(input.reason) ||
+            (input.trigger !== undefined && (input.trigger.length > 128 || /[\r\n]/u.test(input.trigger))) ||
+            (input.question !== undefined && (input.question.length > 1000 || /[\r\n]/u.test(input.question)))) {
+            throw new Error("mission-consultation-input-invalid");
+        }
+        return this.update(root, state => {
+            state.consultations = [...(state.consultations ?? []), { id: randomUUID(), role: input.role,
+                    disposition: "dispatched", reason: input.reason.trim(), at: new Date().toISOString(), callID: input.callID,
+                    ...(input.trigger === undefined ? {} : { trigger: input.trigger }),
+                    ...(input.question === undefined ? {} : { question: input.question }) }].slice(-MISSION_CONSULTATION_LIMIT);
+        });
+    }
+    settleConsultation(root, callID, outcome, details = {}) {
+        if (!callID || !["completed", "failed", "unknown"].includes(String(outcome)))
+            throw new Error("mission-consultation-input-invalid");
+        return this.update(root, state => {
+            const item = [...(state.consultations ?? [])].reverse().find(entry => entry.callID === callID);
+            if (!item)
+                return;
+            if (details.result !== undefined && details.result.length > 4000)
+                details.result = details.result.slice(0, 4000);
+            Object.assign(item, { outcome, ...details });
+        });
+    }
     /** Keep host-accepted criteria ahead of new text, including an exactly linked settled predecessor. */
     carryForward(root, missionID, acceptance, supersededRunID) {
         return this.update(root, state => {
@@ -418,7 +454,8 @@ export function missionPacket(mission, run) {
                 completed_units: predecessor.units.filter(unit => unit.status === "succeeded").length,
                 note: "Historical results and spend are retained; they do not complete the current requirements." } } : {}),
         requirements: mission.requirements, original_request_refs: mission.requests.map(item => `user:${item.id}`),
-        submission: mission.submission, progress: mission.progress,
+        submission: mission.submission, progress: mission.progress, consultations: mission.consultations ?? [],
+        attempts: mission.attempts ?? [], ...(mission.rescue ? { rescue: mission.rescue } : {}),
         operation: { kind: mission.kind ?? "implementation", status: missionExecutionStatus(mission),
             ...(mission.execution ? { ...mission.execution } : {}) },
         execution_summary: { completed_units: run?.units.filter(unit => unit.status === "succeeded").length ?? 0,
@@ -438,13 +475,19 @@ export function missionPacket(mission, run) {
                 child_session_id: unit.childSessionID, result_class: unit.resultClass, evidence: unit.evidence,
                 handoff_path: unit.handoffPath, operation_manifest_path: unit.manifestPath,
                 scope_read: unit.unit.read, scope_write: unit.unit.write, validation: unit.unit.validation,
+                normal_remediation_used: unit.normalRemediationUsed ?? false,
+                ...(unit.failure ? { failure: { outcome: unit.failure.outcome, exit_code: unit.failure.exitCode } } : {}),
                 ...(unit.dispatchDenial ? { dispatch_denial: unit.dispatchDenial } : {}) })) } : {}),
         next_action: mission.phase === "completed" ? "Mission completed. Report the accepted result and retained review gaps; no further dispatch or completion call is needed."
             : mission.phase === "submitted" && mission.submission?.status === "ready"
                 ? "Operator: compare the submitted candidate with the original requirements and actual evidence, then complete_mission if satisfied. Report remaining evidence gaps; they are not a review PASS."
                 : run?.phase === "awaiting-decision" ? (run.units.some(unit => unit.dispatchDenial)
                     ? "Coordinator: inspect units[].dispatch_denial before changing the plan. Correct only its diagnosed cause; do not repeat an unchanged refused Task or replan for a host-state mismatch. Report an unresolved runtime mismatch with the loaded runtime identity; preserve requirements and cumulative spend."
-                    : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
+                    : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && !unit.normalRemediationUsed)
+                        ? "Coordinator: one exact declared validation failed. Reconcile the returned Worker and cumulative budget, then call retry_mission_unit once for that unit before replanning. This preserves the same scope and acceptance."
+                        : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && unit.normalRemediationUsed && !unit.terminalRescue)
+                            ? "Coordinator: the one ordinary remediation failed the declared validation again. If its native terminal, writer release, exact candidate and cumulative budget permit, call rescue_mission_unit once; inspect and report a non_rescue reason, then continue ordinary correction within budget. Rescue does not bypass validation, review or root acceptance."
+                            : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
                     : run?.phase === "awaiting-acceptance" && !operationComplete
                         ? `Requested operation is ${operationStatus}. Continue the actual operation or report its blocker; auxiliary checks and review disposition cannot complete it.`
                         : run?.phase === "awaiting-acceptance" ? (currentReview && mission.review?.verdict === "evidence-gaps" && !reviewAccepted

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

@@ -106,15 +106,32 @@ export type OperatorProposal = {
 type OperatorPhase = "prepared" | "running" | "awaiting-decision" | "awaiting-acceptance" | "completed" | "cancelled";
 interface UnitState {
     readonly unit: OperatorUnit;
-    readonly task: OperatorTask;
+    task: OperatorTask;
     readonly handoffPath: string;
     readonly manifestPath: string;
-    hashes: readonly string[];
+    hashes: string[];
     status: "pending" | "running" | "succeeded" | "failed" | "cancelled";
     callID: string | null;
     childSessionID: string | null;
     evidence: readonly GoalEvidence[];
     resultClass: string | null;
+    failure?: SerialDispatchSettlement["failure"];
+    normalRemediationUsed?: boolean;
+    terminalRescue?: {
+        readonly attempt_id: string;
+        readonly selected_model: string;
+        readonly selected_variant: string | null;
+        readonly accepted_base: {
+            readonly candidate_id: string;
+            readonly contract_id: string;
+            readonly scope: readonly string[];
+            readonly acceptance: readonly string[];
+            readonly validation: readonly string[];
+        };
+        readonly prior_failure: SerialDispatchSettlement["failure"];
+        status: "prepared" | "dispatched" | "settled";
+        disposition?: "succeeded" | "failed" | "cancelled";
+    };
     dispatchDenial?: string;
     repairValidationAttempts: number;
     repairValidation: {
@@ -319,6 +336,21 @@ export declare class OperatorRuntime {
     private operatorRejectedOnce;
     settled(result: SerialDispatchSettlement): Promise<void>;
     private settledOnce;
+    /** One ordinary same-scope Mission retry before any optional model Rescue is considered. */
+    prepareMissionNormalRemediation(root: string, runID: string, unitID: string): Promise<OperatorState>;
+    /** Requeue a host-classified normal-remediation failure through the ordinary Mission Worker gates. */
+    prepareMissionTerminalRescue(root: string, runID: string, unitID: string, input: {
+        attempt_id: string;
+        selected_model: string;
+        selected_variant: string | null;
+        accepted_base: {
+            candidate_id: string;
+            contract_id: string;
+            scope: readonly string[];
+            acceptance: readonly string[];
+            validation: readonly string[];
+        };
+    }): Promise<OperatorState>;
     observeChild(root: string, callID: string, childID: string): Promise<void>;
     private observeChildOnce;
     operatorReturned(root: string): Promise<OperatorState>;

package/dist/core/operator-runtime.js

@@ -1237,6 +1237,8 @@ export class OperatorRuntime {
             state.dispatched++;
         unit.status = "running";
         unit.callID = callID;
+        if (unit.terminalRescue)
+            unit.terminalRescue.status = "dispatched";
         state.phase = "running";
         await this.save(state);
         return admitted;
@@ -1528,7 +1530,13 @@ export class OperatorRuntime {
         unit.resultClass = result.resultClass;
         if (result.failure !== undefined)
             unit.failure = result.failure;
+        else
+            delete unit.failure;
         unit.status = result.disposition;
+        if (unit.terminalRescue) {
+            unit.terminalRescue.status = "settled";
+            unit.terminalRescue.disposition = result.disposition;
+        }
         if (result.disposition !== "succeeded") {
             state.phase = "awaiting-decision";
             state.decision = result.resultClass === "acceptance" ? ACCEPTANCE_REMEDIATION_DECISION : result.resultClass;
@@ -1540,6 +1548,76 @@ export class OperatorRuntime {
         }
         await this.save(state);
     }
+    /** One ordinary same-scope Mission retry before any optional model Rescue is considered. */
+    prepareMissionNormalRemediation(root, runID, unitID) {
+        return this.serial(root, async () => {
+            const state = await this.required(root);
+            const unit = state.units.find(candidate => candidate.unit.id === unitID);
+            if (state.runID !== runID || state.phase !== "awaiting-decision" || state.units.some(candidate => candidate.status === "running") ||
+                !unit || unit.status !== "failed" || unit.resultClass !== "acceptance" || !unit.failure ||
+                unit.failure.outcome !== "fail" || unit.normalRemediationUsed || unit.terminalRescue ||
+                state.units.some(candidate => candidate.terminalRescue))
+                throw new Error("operator-mission-normal-remediation-unavailable");
+            await this.verifyControls(unit);
+            unit.normalRemediationUsed = true;
+            unit.status = "pending";
+            unit.callID = null;
+            unit.childSessionID = null;
+            unit.evidence = [];
+            unit.resultClass = null;
+            delete unit.failure;
+            unit.repairValidation = null;
+            state.phase = "prepared";
+            state.decision = null;
+            await this.save(state);
+            return structuredClone(state);
+        });
+    }
+    /** Requeue a host-classified normal-remediation failure through the ordinary Mission Worker gates. */
+    prepareMissionTerminalRescue(root, runID, unitID, input) {
+        return this.serial(root, async () => {
+            const state = await this.required(root);
+            const unit = state.units.find(candidate => candidate.unit.id === unitID);
+            const base = input.accepted_base;
+            if (state.runID !== runID || state.phase !== "awaiting-decision" || state.units.some(candidate => candidate.status === "running") ||
+                !unit || unit.status !== "failed" || unit.resultClass !== "acceptance" || !unit.failure ||
+                unit.failure.outcome !== "fail" || unit.normalRemediationUsed !== true || unit.terminalRescue ||
+                state.units.some(candidate => candidate.terminalRescue) ||
+                !identifier(input.attempt_id) || !text(input.selected_model) ||
+                (input.selected_variant !== null && !text(input.selected_variant))) {
+                throw new Error("operator-mission-terminal-rescue-unavailable");
+            }
+            if (!/^sha256:[0-9a-f]{64}$/u.test(base.candidate_id) ||
+                !text(base.contract_id) || base.contract_id !== state.acceptanceFingerprint ||
+                !strings(base.scope, true) || JSON.stringify(base.scope) !== JSON.stringify(unit.unit.write) ||
+                !strings(base.acceptance, true) || base.acceptance.length !== state.acceptance.length ||
+                base.acceptance.some((criterion, index) => criterion !== state.acceptance[index]) ||
+                !strings(base.validation, true) || JSON.stringify(base.validation) !== JSON.stringify(unit.unit.validation)) {
+                throw new Error("operator-mission-terminal-rescue-contract-mismatch");
+            }
+            const header = /^task_id: [^\r\n]+$/mu;
+            if (!header.test(unit.task.prompt) || /^terminal_rescue_attempt:/mu.test(unit.task.prompt)) {
+                throw new Error("operator-mission-terminal-rescue-task-invalid");
+            }
+            await this.verifyControls(unit);
+            // The Rescue route is sealed in host-owned operator state and the returned Task reference.
+            // Do not alter the registered handoff or expose the stable runtime's rescue capability.
+            unit.task = { ...unit.task, prompt: unit.task.prompt.replace(header, line => `${line}\nterminal_rescue_attempt: ${input.attempt_id}`) };
+            unit.terminalRescue = { attempt_id: input.attempt_id, selected_model: input.selected_model,
+                selected_variant: input.selected_variant, accepted_base: structuredClone(base), prior_failure: structuredClone(unit.failure), status: "prepared" };
+            unit.status = "pending";
+            unit.callID = null;
+            unit.childSessionID = null;
+            unit.evidence = [];
+            unit.resultClass = null;
+            delete unit.failure;
+            unit.repairValidation = null;
+            state.phase = "prepared";
+            state.decision = null;
+            await this.save(state);
+            return structuredClone(state);
+        });
+    }
     observeChild(root, callID, childID) {
         return this.serial(root, () => this.observeChildOnce(root, callID, childID));
     }
@@ -1910,6 +1988,10 @@ export class OperatorRuntime {
                 handoff_path: unit.handoffPath, operation_manifest_path: unit.manifestPath,
                 scope_read: unit.unit.read, scope_write: unit.unit.write, validation: unit.unit.validation,
                 acceptance_indices: unit.unit.acceptance_indices,
+                normal_remediation_used: unit.normalRemediationUsed ?? false,
+                ...(unit.terminalRescue ? { terminal_rescue: { attempt_id: unit.terminalRescue.attempt_id,
+                        selected_model: unit.terminalRescue.selected_model, selected_variant: unit.terminalRescue.selected_variant,
+                        status: unit.terminalRescue.status, ...(unit.terminalRescue.disposition ? { disposition: unit.terminalRescue.disposition } : {}) } } : {}),
                 evidence: unit.evidence.map(item => ({ id: item.evidence_id, criteria: item.measurement.criterion_ids,
                     candidate: item.identity.candidate, command: item.execution.command, outcome: item.execution.outcome, exit_code: item.execution.exit_code })),
                 repair_validation: unit.repairValidation === null ? null : { repair_fingerprint: unit.repairValidation.repair_fingerprint,

package/dist/plugin/index.js

@@ -51,7 +51,7 @@ import { collectRunMetrics, createSortieResult, createGoalReport, insertRunMetri
 import { STABLE_RUNTIME_PROFILE } from "../core/runtime-profile.js";
 import { evidenceFromObservedExecution } from "../core/observed-goal-evidence.js";
 import { receiptBoundTerminalText } from "./receipt-presentation.js";
-import { operationInputSnapshot, protectedSnapshot, refreshProtectedSnapshot } from "./protected-snapshot.js";
+import { operationInputSnapshot, protectedSnapshot, refreshProtectedSnapshot, validationInputSnapshot } from "./protected-snapshot.js";
 import { settledUnitUsage } from "./unit-usage.js";
 import { goalCompletionReadiness } from "./goal-completion.js";
 const INPUT_LIMITS = { config: 64 * 1024, manifest: 512 * 1024, handoff: 2 * 1024 * 1024, parallel: 512 * 1024 };
@@ -1481,11 +1481,14 @@ export const SortieDogsPlugin = async (input, options) => {
         const operationInputs = mission?.kind === "operation" && mission.execution?.commands.includes(rawCommand) &&
             resolve(input.directory, typeof args?.workdir === "string" ? args.workdir : ".") === mission.execution.directory
             ? await operationInputSnapshot(authorization.projectRoot, snapshot.binding).catch(() => undefined) : undefined;
+        const validationInputs = validation !== undefined && operationInputs === undefined
+            ? await validationInputSnapshot(authorization.projectRoot, snapshot.binding).catch(() => undefined) : undefined;
         hostGoalExecutions.set(toolInput.callID, { root, projectRoot: authorization.projectRoot,
             sessionID: toolInput.sessionID,
             callID: toolInput.callID, tool: toolInput.tool, command: [rawCommand], startedAt: new Date().toISOString(),
             binding: snapshot.binding, source: snapshot.source, candidate: snapshot.candidate,
             ...(operationInputs === undefined ? {} : { operationInputs }),
+            ...(validationInputs === undefined ? {} : { validationInputs }),
             owner: validation?.request.owner ?? "worker", validation,
             ...(reusedEvidence === undefined ? {} : { reusedEvidence }) });
     }
@@ -1513,11 +1516,13 @@ export const SortieDogsPlugin = async (input, options) => {
             ? new Date(timing.start).toISOString() : execution.startedAt;
         const endedAt = typeof timing?.end === "number" && Number.isFinite(timing.end)
             ? new Date(timing.end).toISOString() : new Date().toISOString();
-        // Existing operations produce declared outputs. Preserve their read-only inputs during execution,
-        // then bind ordinary evidence to all post-operation bytes, including those outputs.
-        const fresh = refreshed !== undefined && (execution.operationInputs === undefined
-            ? refreshed.source === execution.source
-            : await operationInputSnapshot(execution.projectRoot, execution.binding).catch(() => undefined) === execution.operationInputs);
+        // Declared outputs can change during a successful validation. Read inputs must not;
+        // the evidence still binds to the complete post-command candidate and source.
+        const fresh = refreshed !== undefined && (execution.operationInputs !== undefined
+            ? await operationInputSnapshot(execution.projectRoot, execution.binding).catch(() => undefined) === execution.operationInputs
+            : execution.validationInputs !== undefined
+                ? await validationInputSnapshot(execution.projectRoot, execution.binding).catch(() => undefined) === execution.validationInputs
+                : refreshed.source === execution.source);
         const immutableRef = outcome === undefined || execution.reusedEvidence !== undefined ? undefined : goalFingerprint({ root: execution.root,
             child_session_id: execution.sessionID, call_id: execution.callID, command: execution.command,
             started_at: observedStartedAt, ended_at: endedAt, exit_code: exitCode ?? null, outcome,
@@ -6259,14 +6264,24 @@ export const SortieDogsPlugin = async (input, options) => {
                 let terminalRescueTarget;
                 if (selectedAgent === SERIAL_WORKER_AGENT) {
                     const text = explicitTaskText(output);
-                    const rescueRequested = text !== undefined && handoffValue(handoffEntries(text), ["terminal_rescue_attempt"]) !== undefined;
+                    const rescueAttemptID = text === undefined ? undefined : handoffValue(handoffEntries(text), ["terminal_rescue_attempt"]);
+                    const rescueRequested = rescueAttemptID !== undefined;
+                    const missionSelection = chatInput.missionRescueSelection;
+                    const missionRescueTarget = runtimeProfile.id === "v010" && rescueRequested && isRecord(missionSelection) &&
+                        missionSelection.attempt_id === rescueAttemptID && typeof missionSelection.model === "string" &&
+                        missionSelection.model.includes("/") &&
+                        (missionSelection.variant === null || typeof missionSelection.variant === "string")
+                        ? { model: missionSelection.model,
+                            ...(missionSelection.variant === null ? {} : { variant: missionSelection.variant }) }
+                        : undefined;
                     if (text !== undefined && !rescueRequested)
                         terminalRescueHandoffs.delete(chatInput.sessionID);
                     const suppliedPath = !rescueRequested ? undefined : handoffValue(handoffEntries(text), ["handoff_path"]);
                     const path = suppliedPath === undefined ? terminalRescueHandoffs.get(chatInput.sessionID) : unquoteValue(suppliedPath);
                     if (path !== undefined) {
-                        const identity = await inspect(path, undefined, { report: true, rescueSessionID: chatInput.sessionID });
-                        terminalRescueTarget = identity?.terminalRescueTarget;
+                        const identity = await inspect(path, undefined, { report: true,
+                            ...(missionRescueTarget === undefined ? { rescueSessionID: chatInput.sessionID } : {}) });
+                        terminalRescueTarget = missionRescueTarget ?? identity?.terminalRescueTarget;
                         if (rescueRequested && terminalRescueTarget === undefined)
                             throw new Error("rescue-binding-unavailable");
                         if (terminalRescueTarget !== undefined) {
@@ -6586,10 +6601,11 @@ export const SortieDogsPlugin = async (input, options) => {
                     diagnosis.accepting = false;
                     diagnosisCalls.delete(toolInput.callID ?? "");
                 }
-                const returnedMissionWorker = completedChildSessionID !== undefined &&
-                    await input.runtimeBridge?.allowsInvestigativeShell?.(completedChildSessionID);
                 parallelCalls.delete(toolInput.callID ?? "");
                 activeSessions.get(toolInput.sessionID ?? "")?.inFlightCalls.delete(toolInput.callID ?? "");
+                // Snapshot Mission ownership before settling a failed validation changes its durable phase to awaiting-decision.
+                const returnedMissionWorker = completedChildSessionID !== undefined &&
+                    await input.runtimeBridge?.allowsInvestigativeShell?.(completedChildSessionID);
                 if (coordinatorTaskFinished && diagnosis === undefined) {
                     if (toolInput.callID !== undefined) {
                         await settleGoalDispatch(toolInput.callID, output).catch((error) => {
@@ -6603,16 +6619,16 @@ export const SortieDogsPlugin = async (input, options) => {
                     if (repair?.callID === toolInput.callID)
                         operatorContractRepairResumes.delete(toolInput.sessionID);
                 }
+                if (completedChildSessionID !== undefined && activeSessions.get(completedChildSessionID)?.parallel !== "valid" &&
+                    returnedMissionWorker) {
+                    // Mission failures also leave the run awaiting-decision before this return hook completes. Release the
+                    // serial writer before settlement/correction can observe terminal ownership, then evict as usual.
+                    await releaseWriteGate(completedChildSessionID);
+                }
                 if (completedChildSessionID !== undefined && !recoverableWorkerChildren.has(completedChildSessionID)) {
                     evictSession(completedChildSessionID);
                     void childLifecycles.get(completedChildSessionID)?.check();
                 }
-                else if (completedChildSessionID !== undefined && activeSessions.get(completedChildSessionID)?.parallel !== "valid" &&
-                    returnedMissionWorker) {
-                    // Keep same-worker recovery identity, but a returned serial Task must not keep a live
-                    // write reservation. Rebinding the retained manifest reacquires it before any later write.
-                    await releaseWriteGate(completedChildSessionID);
-                }
             }
         },
         "tool.execute.before": async (toolInput, output) => {
@@ -7517,8 +7533,17 @@ export const SortieDogsPlugin = async (input, options) => {
                 return { status: "unproven", reservation_id: reservation.reservation_id, reason: "owned-native-lineage-unavailable" };
             }
             const sessionAPI = input.client.session;
+            // V2's session.context is bounded. The aborted parent Task can be days older than
+            // that window; use the owning service's paginated history when the adapter offers it.
+            const historyAPI = sessionAPI;
+            const readHistory = historyAPI.reviewMessages ?? sessionAPI.messages;
             const messages = async (id) => {
-                const response = await sessionAPI.messages({ path: { id }, query: { directory: input.directory } });
+                const request = { path: { id }, query: { directory: input.directory } };
+                const response = await readHistory.call(sessionAPI, request).catch(error => {
+                    if (readHistory === sessionAPI.messages)
+                        throw error;
+                    return sessionAPI.messages(request);
+                });
                 return isRecord(response) && Array.isArray(response.data) ? response.data.filter(isRecord) : [];
             };
             const children = async (id) => {
@@ -7850,12 +7875,32 @@ export const SortieDogsPlugin = async (input, options) => {
             if (state.goal_id === null || state.budget === null)
                 return null;
             const reserved = state.outstanding_reservations.length;
-            return { max_units: state.budget.max_units, consumed_units: state.consumed_units,
+            const snapshot = { max_units: state.budget.max_units, consumed_units: state.consumed_units,
                 reserved_units: reserved, remaining_units: Math.max(0, state.budget.max_units - state.consumed_units - reserved),
+                settled_time_ms: state.consumed_time_ms, time_limit_ms: state.budget.time_ms,
                 settled_cost_usd: state.consumed_cost_usd, cost_limit_usd: state.budget.cost_usd,
                 cost_status: state.consumed_cost_usd === null ? "unknown-usage" : reserved > 0 ? "in-flight-not-final" : "settled",
                 cost_source: "native-usage-price-table",
                 cost_note: "Worker token-price estimates from complete native usage; missing requests remain unknown and are reconciled on later status. Excludes orchestration/review and external campaign spend. Zero settled cost does not mean free execution." };
+            return snapshot;
+        },
+        ...{
+            missionWorkerTerminal: async (childSessionID, writeScopes) => {
+                const active = activeSessions.get(childSessionID), authorization = sessionAuthorizations.get(childSessionID);
+                if ((active?.inFlightCalls.size ?? 0) !== 0 || (active !== undefined && active.released !== true) ||
+                    (authorization !== undefined && (!authorization.suspended || authorization.lease !== undefined)))
+                    return false;
+                const scopeRoot = await durableScopeRoot(project?.root ?? input.directory);
+                if (scopeRoot === undefined)
+                    return false;
+                try {
+                    const scope = normalizeWorktreeScope({ read: [], write: [...writeScopes] });
+                    return !await new ScopeLeaseRegistry(scopeRoot).hasConflictingLease(scope);
+                }
+                catch {
+                    return false;
+                }
+            },
         },
         registerGoalDeclaration: async (root, prompt, missionRevision) => {
             if (!isCoordinatorSession(root) && !await recoverCoordinatorRoot(root))

package/dist/plugin/mission-progress.js

@@ -28,6 +28,10 @@ export function missionProgressReader(directory, root, callID) {
         return { description: `🐾 ${status}: ${title}`, sortie_progress: {
                 mission_id: mission.id, phase: mission.phase, unit: running ? `${run.runID}/${running.unit.id}` : last?.unit ?? null,
                 title, status, child_session_id: running?.childSessionID ?? null,
+                // Stable timestamps, not a fabricated heartbeat. The parent can tell when the
+                // run began and when a unit last settled without generating another model turn.
+                run_created_at: run?.runID === mission.runID ? run.createdAt : null,
+                last_transition_at: last?.at ?? null,
                 completed_units: units.filter(unit => unit.status === "succeeded").length,
                 failed_units: units.filter(unit => unit.status === "failed").length,
                 historical_failed_attempts: mission.progress.filter(unit => unit.status === "failed").length,