sortie-dogs 0.12.18 → 0.12.20

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.18-review-references-retry-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.20-mission-recovery-rescue-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.18-review-references-retry-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.20-mission-recovery-rescue-v1";

package/dist/core/contract-limits.d.ts

@@ -3,6 +3,6 @@ export declare const CONTRACT_TEXT_LIMITS: Readonly<{
     title: 160;
     objective: 2000;
     statement: 1000;
-    command: 1000;
+    command: 8192;
     path: 512;
 }>;

package/dist/core/contract-limits.js

@@ -1,2 +1,2 @@
 /** Common text bounds shared by handoff, manifest and goal evidence validation. */
-export const CONTRACT_TEXT_LIMITS = Object.freeze({ title: 160, objective: 2000, statement: 1000, command: 1000, path: 512 });
+export const CONTRACT_TEXT_LIMITS = Object.freeze({ title: 160, objective: 2000, statement: 1000, command: 8192, path: 512 });

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. */
@@ -130,8 +186,23 @@ export declare class OperatorMissionRuntime {
     start(root: string, requirements: unknown, replaceRequirements?: boolean, options?: {
         kind?: OperatorMission["kind"];
         context?: MissionContext[];
+        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 {
@@ -240,16 +241,19 @@ export class OperatorMissionRuntime {
             }
             if (previous)
                 await this.save(this.file(root, `.${previous.id}`), previous);
+            // A cancelled standalone/legacy run has no mission-owned runID. Only an explicit
+            // replacement may link it; normal continuation must not silently inherit its goal.
+            const predecessor = previous?.runID ?? previous?.supersededRunID ??
+                (replaceRequirements ? options.cancelledRunID : undefined);
             const state = { version: "0.12", id: `mission-${randomUUID()}`, root, requests: [request],
                 kind: options.kind ?? "implementation",
                 context: (options.context ?? []).filter(item => item.id !== request.id),
                 requirements: requirements.map((text, index) => ({ id: `R${index + 1}`, text })), phase: "open",
                 ...(replaceRequirements ? { requirementsReplaced: true } : {}),
                 coordinator: null, callID: null, dispatchOpen: false, runID: null, plans: 0, progress: [], submission: null,
-                ...(previous?.phase === "cancelled" &&
-                    (previous.runID === null || request.id !== previous.requests[0]?.id) &&
-                    (previous.runID ?? previous.supersededRunID)
-                    ? { supersededRunID: (previous.runID ?? previous.supersededRunID) } : {}) };
+                ...((previous === undefined || previous.phase === "cancelled") &&
+                    (previous?.runID === null || previous === undefined || request.id !== previous.requests[0]?.id) && predecessor
+                    ? { supersededRunID: predecessor } : {}) };
             await this.save(this.file(root), state);
             return state;
         });
@@ -264,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 => {
@@ -356,17 +395,20 @@ export function missionPlan(mission, raw) {
                 throw new Error(`mission-unit-${index + 1}: ${field} must be paths`);
             return [...new Set(entries.map(item => normalizeExecutionScope(item)))];
         };
-        // Scheduling coverage is not semantic proof. Only a single requirement is unambiguous.
-        const ids = value.requirement_ids ?? (mission.requirements.length === 1 ? [mission.requirements[0].id] : []);
+        // A sole unit owns the whole request. This schedules work; it does not prove acceptance.
+        const ids = value.requirement_ids ?? (raw.length === 1 || mission.requirements.length === 1 ? mission.requirements.map(item => item.id) : []);
         if (!Array.isArray(ids) || ids.length === 0 || !ids.every(id => mission.requirements.some(item => item.id === id))) {
-            throw new Error(`mission-unit-${index + 1}: requirement_ids must name the related R IDs; multi-requirement work needs explicit coverage`);
+            throw new Error(`mission-unit-${index + 1}: requirement_ids must name the related R IDs; splitting multiple requirements across units needs explicit coverage`);
         }
         if (!Array.isArray(value.validation) || value.validation.length === 0 ||
             !value.validation.every(command => typeof command === "string" && command.trim())) {
             throw new Error(`mission-unit-${index + 1}: validation must contain exact commands; final command proves the unit`);
         }
+        const validation = value.validation.map(missionValidationCommand);
+        // Retain last occurrences so removing a redundant check preserves the final proof command.
         return { id: `unit-${index + 1}`, title: line("title"), objective: line("objective"), read: paths("read"), write: paths("write"),
-            validation: value.validation.map(missionValidationCommand), acceptance_indices: [...new Set(ids.map(id => mission.requirements.findIndex(item => item.id === id)))] };
+            validation: validation.filter((command, i) => validation.lastIndexOf(command) === i),
+            acceptance_indices: [...new Set(ids.map(id => mission.requirements.findIndex(item => item.id === id)))] };
     });
     // The serial engine counts new proof milestones. Units sharing the same final suite are one
     // milestone, so coalesce them instead of making the model repair a bookkeeping rejection.
@@ -412,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,
@@ -432,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
@@ -462,7 +511,8 @@ export function missionReviewTraces(mission, raw) {
         throw new Error("mission-review-traces: supply concise implementation/test traces");
     }
     const grouped = raw.map(text => ({ text,
-        ids: /^\s*((?:R\d+\s*[/,]?\s*)+):/u.exec(text)?.[1]?.match(/R\d+/gu) ?? [] }));
+        ids: [...text.matchAll(/(?:^|[.;]\s+|[\r\n])\s*((?:R\d+\s*[/,]?\s*)+):/gu)]
+            .flatMap(match => match[1].match(/R\d+/gu) ?? []) }));
     if (grouped.every(item => item.ids.length === 0) && raw.length === mission.requirements.length)
         return raw;
     const unknown = grouped.flatMap(item => item.ids).filter(id => !mission.requirements.some(requirement => requirement.id === id));

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

@@ -6259,14 +6259,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 +6596,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 +6614,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) => {
@@ -7850,12 +7861,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,