sortie-dogs 0.12.19 → 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.19-focused-behavior-review-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.19-focused-behavior-review-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.20-mission-recovery-rescue-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

@@ -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,

package/dist/plugin/profiled.js

@@ -18,7 +18,10 @@ import { publishMissionProgress } from "./mission-progress.js";
 import { completedMissionReviewPrompts, initialMissionReviewPrompt, missionReviewBaseline, missionReviewSource } from "./mission-review.js";
 import { missionLocations, missionLocationPacket } from "./mission-location.js";
 import { SOURCE_REVIEW_RISK_TAGS } from "../core/consultation.js";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
+import { proposeTerminalRescue } from "../core/terminal-rescue-policy.js";
+import { DEFAULT_TERMINAL_RESCUE_MODEL } from "./terminal-rescue-host.js";
+import { readHostModels } from "./model-routing-hook.js";
 const SERIAL_CAPABILITIES = new Set([
     "sortie_bind_write_gate", "sortie_release_write_gate", "sortie_check_contract",
     "sortie_compact_and_continue", "sortie_enable_backlog_drain", "sortie_reflection",
@@ -84,6 +87,17 @@ export function previewModelCatalog(routes = PREVIEW_ROUTES, base = BUILT_IN_MOD
 }
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 const payload = (value) => record(value) && "data" in value ? value.data : value;
+function missionConsultationDetails(role, prompt) {
+    const marker = role === "advisor" ? /^strategy_trigger:\s*(\S+)\s*$/mu : /^missing_evidence_code:\s*(\S+)\s*$/mu;
+    const match = marker.exec(prompt);
+    const lines = prompt.split(/\r?\n/u);
+    const start = match === null ? 0 : lines.findIndex(line => marker.test(line)) + 1;
+    const question = lines.slice(Math.max(0, start)).map(line => line.trim()).find(line => line.length > 0 &&
+        !/^(?:project_root|known_paths|missing_evidence_code|strategy_trigger|role|task_id|acceptance|validation)\s*:/u.test(line));
+    const summary = (question ?? prompt.trim().split(/\r?\n/u).find(line => line.trim()) ?? "consultation requested").slice(0, 1000);
+    return { reason: summary, ...(question === undefined ? {} : { question: question.slice(0, 1000) }),
+        ...(match === null ? {} : { trigger: match[1].slice(0, 128) }) };
+}
 /** Prove native V2 termination of the old dispatch, including earlier units and consultations. */
 export async function terminalCancelledMissionChildren(profile, root, previous, budget, host) {
     if (!budget || budget.reserved_units !== 0)
@@ -153,6 +167,7 @@ export function createProfiledPlugin(profile, assetVersion) {
         const selected = new Map();
         const operatorParents = new Map();
         const taskOwners = new Map();
+        const missionRescueSelections = new Map();
         const operatorTurnLifecycle = new Map();
         const historicalTurnMessages = new Map();
         const dispatchTransitions = new Map();
@@ -189,6 +204,19 @@ export function createProfiledPlugin(profile, assetVersion) {
             const result = payload(await session(typeof nativeSession?.reviewMessages === "function" ? "reviewMessages" : "messages", { path: { id }, query: { directory: input.directory } }));
             return Array.isArray(result) ? result.filter(record) : [];
         }
+        async function observedSessionModel(id) {
+            const info = payload(await session("get", { path: { id }, query: { directory: input.directory } }).catch(() => undefined));
+            if (!record(info))
+                return { outcome: "unknown" };
+            const model = record(info.model) ? info.model : info;
+            const provider = typeof model.providerID === "string" ? model.providerID : info.providerID;
+            const modelID = typeof model.modelID === "string" ? model.modelID : typeof model.id === "string" ? model.id : info.modelID;
+            const variant = typeof model.variant === "string" ? model.variant : typeof info.variant === "string" ? info.variant : undefined;
+            const outcome = ["succeeded", "completed"].includes(String(info.outcome)) ? "completed"
+                : ["failed", "interrupted", "cancelled"].includes(String(info.outcome)) ? "failed" : "unknown";
+            return { ...(typeof provider === "string" && typeof modelID === "string" ? { model: `${provider}/${modelID}` } : {}),
+                ...(variant === undefined ? {} : { variant }), outcome };
+        }
         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;
@@ -466,8 +494,52 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const unit = run.units.find(unit => unit.callID === result.callID);
                 if (!unit)
                     return;
+                const recordedAttempt = [...(mission.attempts ?? [])].reverse().find(attempt => attempt.callID === result.callID);
+                const observed = result.childSessionID ? await observedSessionModel(result.childSessionID) : { outcome: "unknown" };
+                const currentCandidate = result.resultClass === "acceptance" && result.failure?.outcome === "fail"
+                    ? await missionReviewSource(input.directory, run, [], mission.reviewBaseline, mission.reviewScope).then(value => value.fingerprint)
+                    : undefined;
+                const attemptFailure = result.disposition === "cancelled"
+                    ? { category: "cancellation", code: "native-task-cancelled" }
+                    : result.resultClass === "acceptance" && result.failure?.outcome === "fail" && observed.outcome === "completed"
+                        ? { category: "implementation",
+                            code: `validation-failed:${result.failure.exitCode ?? "unknown"}` }
+                        : result.resultClass === "process-defect"
+                            ? { category: "contract", code: result.resultClass }
+                            : { category: "unknown", code: result.resultClass };
                 const progress = { unit: `${run.runID}/${unit.unit.id}`, title: unit.unit.title, status: unit.status, at: new Date().toISOString() };
-                await missions.update(result.rootSessionID, state => { state.progress.push(progress); });
+                await missions.update(result.rootSessionID, state => {
+                    state.progress.push(progress);
+                    const attempt = recordedAttempt && state.attempts?.find(item => item.attemptID === recordedAttempt.attemptID);
+                    if (attempt) {
+                        attempt.status = result.disposition;
+                        attempt.resultClass = result.resultClass;
+                        attempt.nativeOutcome = observed.outcome;
+                        if (result.childSessionID)
+                            attempt.childSessionID = result.childSessionID;
+                        if (observed.model)
+                            attempt.observedModel = observed.model;
+                        if (observed.variant)
+                            attempt.observedVariant = observed.variant;
+                        if (result.disposition !== "succeeded")
+                            attempt.failure = attemptFailure;
+                        else
+                            delete attempt.failure;
+                        if (currentCandidate)
+                            attempt.candidateID = currentCandidate;
+                    }
+                    if (state.rescue && state.rescue.attemptID === unit.terminalRescue?.attempt_id) {
+                        state.rescue.status = result.disposition === "succeeded" ? "succeeded"
+                            : result.disposition === "cancelled" ? "cancelled" : "failed";
+                        state.rescue.outcome = result.disposition;
+                        if (observed.model)
+                            state.rescue.observedModel = observed.model;
+                        if (observed.variant)
+                            state.rescue.observedVariant = observed.variant;
+                    }
+                });
+                if (result.childSessionID)
+                    missionRescueSelections.delete(result.childSessionID);
                 await publishMissionProgress(result.rootSessionID, { description: `🐾 ${unit.status === "succeeded" ? "✅" : "🔧"} ${unit.unit.title}`,
                     sortie_progress: progress });
             },
@@ -507,6 +579,12 @@ export function createProfiledPlugin(profile, assetVersion) {
                         next_action: "Use a known Coordinator's native location to resume. Absence here does not prove absence in other locations." },
                 } : {}) };
         }
+        function sourceReconciliationRequired(mission, previous) {
+            return previous?.phase === "cancelled" && !["completed", "cancelled"].includes(mission.phase) &&
+                mission.runID === null && mission.supersededRunID === undefined &&
+                (previous.sourceRefs[0] !== `user:${mission.requests[0]?.id}` ||
+                    !previous.sourceRefs.every(ref => mission.requests.some(request => ref === `user:${request.id}`)));
+        }
         async function missionAuthority(id) {
             const root = await rootFor(id);
             if (!root)
@@ -516,11 +594,54 @@ export function createProfiledPlugin(profile, assetVersion) {
                 throw new Error("mission-controller-required");
             return { root, mission };
         }
+        async function missionWorkerTerminalProof(root, mission, run, attempt) {
+            if (!attempt.callID || !attempt.childSessionID || !mission.coordinator ||
+                !control) {
+                return { status: "non_rescue", reason: "terminal_not_reconciled" };
+            }
+            if (attempt.runID !== run.runID || attempt.unitID !== run.units.find(unit => unit.unit.id === attempt.unitID)?.unit.id) {
+                return { status: "non_rescue", reason: "terminal_identity_conflict" };
+            }
+            try {
+                await control.assertActiveGoal(root, await operators.completionGoalFingerprint(run));
+            }
+            catch {
+                return { status: "non_rescue", reason: "goal_not_active" };
+            }
+            const budget = await control.currentBudget(root);
+            if (!budget || budget.reserved_units !== 0)
+                return { status: "non_rescue", reason: "goal_reservation_unsettled" };
+            const child = attempt.childSessionID;
+            const who = await identity(child);
+            if (who.role !== "dog-worker" || who.parent !== mission.coordinator) {
+                return { status: "non_rescue", reason: "terminal_identity_conflict" };
+            }
+            const info = payload(await session("get", { path: { id: child }, query: { directory: input.directory } }).catch(() => undefined));
+            const outcome = record(info) ? String(info.outcome) : "unknown";
+            if (!record(info) || info.id !== child || info.parentID !== mission.coordinator ||
+                !["succeeded", "completed"].includes(outcome)) {
+                return { status: "non_rescue", reason: "terminal_not_reconciled" };
+            }
+            const descendants = payload(await session("children", { path: { id: child }, query: { directory: input.directory } }).catch(() => undefined));
+            if (!Array.isArray(descendants) || descendants.length !== 0) {
+                return { status: "non_rescue", reason: "terminal_not_reconciled" };
+            }
+            const terminalObserver = control?.missionWorkerTerminal;
+            if (!terminalObserver) {
+                return { status: "non_rescue", reason: "terminal_not_reconciled" };
+            }
+            if (!await terminalObserver(child, run.units.find(unit => unit.unit.id === attempt.unitID).unit.write)) {
+                return { status: "non_rescue", reason: "writer_not_released" };
+            }
+            return { status: "ready", child };
+        }
         async function reconcileMissionDispatch(root) {
             const mission = await missions.read(root);
-            if (!mission?.dispatchOpen || !mission.callID || ["cancelled", "completed"].includes(mission.phase) ||
-                taskOwners.has(mission.callID))
+            if (!mission?.dispatchOpen || !mission.callID || ["cancelled", "completed"].includes(mission.phase))
                 return mission;
+            // A native Task can be interrupted without an execute.after/event callback. Its in-memory
+            // owner then survives even though the host has already persisted a terminal tool part.
+            // The native record, not that cache, decides whether this exact dispatch can be resumed.
             const history = await messages(root);
             const finished = history.flatMap(message => Array.isArray(message.parts) ? message.parts : []).filter(part => record(part) && part.type === "tool" && part.tool === "task" && part.callID === mission.callID &&
                 record(part.state) && ["completed", "error"].includes(String(part.state.status)) &&
@@ -535,11 +656,20 @@ export function createProfiledPlugin(profile, assetVersion) {
                 if (who.parent !== root || who.role !== "dog-operator")
                     return mission;
             }
-            return missions.reconcileFinishedDispatch(root, mission.id, mission.callID);
+            const reconciled = await missions.reconcileFinishedDispatch(root, mission.id, mission.callID);
+            taskOwners.delete(mission.callID);
+            return reconciled;
         }
         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" };
+            if (sourceReconciliationRequired(mission, run))
+                return { ...packet, status: "mission-source-reconciliation-required",
+                    next_action: mission.dispatchOpen ? "The Coordinator Task is still active. Do not redispatch; wait for its native completion and reconcile via operator_status."
+                        : `The cancelled run's source_refs cannot prove this mission is the same goal. Do not dispatch or repeat plan_units. ` +
+                            `If these saved requirements reflect the user's changed or narrowed scope, Operator: call ${profile.toolPrefix}start_mission ` +
+                            `with intent=replace and the exact requirements array shown here. The host repairs this mission in place, retains spend, ` +
+                            `and verifies old children before preparing a Worker. Otherwise obtain the user's scope decision.` };
             if (!mission.dispatchOpen && (["open", "running"].includes(mission.phase) ||
                 (mission.phase === "submitted" && mission.submission?.status !== "ready"))) {
                 return { ...packet, task: missions.task(mission),
@@ -560,8 +690,7 @@ export function createProfiledPlugin(profile, assetVersion) {
             }
             // A different original user request needs the explicit, host-proven supersession path.
             // Only the same source can retain a cancelled run's acceptance as a prefix.
-            if (previous.sourceRefs[0] !== `user:${mission.requests[0]?.id}` ||
-                !previous.sourceRefs.every(ref => mission.requests.some(request => ref === `user:${request.id}`))) {
+            if (sourceReconciliationRequired(mission, previous)) {
                 throw new Error("mission-cancelled-source-unproven: the cancelled run's source_refs do not prove this is the same request. " +
                     "If the user changed or narrowed the goal, start_mission with intent=replace and the complete current requirements; " +
                     "otherwise preserve the earlier accepted criteria and establish the original source before continuing.");
@@ -838,6 +967,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const activeMission = await reconcileMissionDispatch(root);
                 if (activeMission && !["cancelled", "completed"].includes(activeMission.phase) && activeMission.runID === null && context.sessionID !== root) {
                     const budget = await control.currentBudget(root);
+                    const prior = await operators.read(root);
+                    if (sourceReconciliationRequired(activeMission, prior))
+                        return JSON.stringify({ ...missionDispatchPacket(activeMission, prior), budget });
                     return JSON.stringify({ ...missionDispatchPacket(activeMission, await operators.read(root)), budget,
                         next_action: "This mission has no unit plan yet. Call plan_units with the next useful work under the current requirements; prior run results are historical." });
                 }
@@ -1339,9 +1471,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                     return JSON.stringify({ ...proposalIdentity(committed), execution: JSON.parse(preparedTask(prepared.state)) });
                 });
             } };
-        const startMission = `${profile.toolPrefix}start_mission`, planUnits = `${profile.toolPrefix}plan_units`, reviewMission = `${profile.toolPrefix}review_mission`, submitMission = `${profile.toolPrefix}submit_mission`, completeMission = `${profile.toolPrefix}complete_mission`, expandUnit = `${profile.toolPrefix}expand_unit`;
+        const startMission = `${profile.toolPrefix}start_mission`, planUnits = `${profile.toolPrefix}plan_units`, reviewMission = `${profile.toolPrefix}review_mission`, submitMission = `${profile.toolPrefix}submit_mission`, completeMission = `${profile.toolPrefix}complete_mission`, expandUnit = `${profile.toolPrefix}expand_unit`, skipMissionConsultation = `${profile.toolPrefix}skip_mission_consultation`;
         const stringList = { type: "array", items: { type: "string" } };
-        tools[startMission] = { description: "Operator: save the current user requirements. Use intent=replace when the user changes an existing request (version, parallelism, target): host cancels the previous run and archives its requirements/results while retaining spend. Supply the complete current requirements, retaining constraints the user has not changed. For separate work in a different location use intent=new. Dispatch the Coordinator immediately, or plan_units for a known single-unit procedure; item count and runtime alone do not require a Coordinator.",
+        tools[startMission] = { description: "Operator: save the current user requirements. Use intent=replace when the user changes an existing request (version, parallelism, target): host cancels the previous run and archives its requirements/results while retaining spend. If status reports mission-source-reconciliation-required and the saved requirements reflect that changed scope, call intent=replace with those exact requirements: the host repairs this mission in place and keeps its Coordinator. Supply the complete current requirements, retaining constraints the user has not changed. For separate work in a different location use intent=new. Dispatch the Coordinator immediately, or plan_units for a known single-unit procedure; item count and runtime alone do not require a Coordinator.",
             args: { requirements: { ...stringList, minItems: 1, maxItems: 64 },
                 kind: { type: "string", enum: ["implementation", "operation"], description: "Use operation for running an existing benchmark, command or procedure. The host records its actual execution separately from setup and checks.", "x-sortie-optional": true },
                 intent: { type: "string", enum: ["", "continue", "new", "replace"], "x-sortie-optional": true } }, execute: async (args, context) => {
@@ -1350,6 +1482,27 @@ export function createProfiledPlugin(profile, assetVersion) {
                     throw new Error("mission-intent-invalid");
                 return serializeDispatchTransition(context.sessionID, async () => {
                     const existing = await reconcileMissionDispatch(context.sessionID);
+                    const prior = await operators.read(context.sessionID);
+                    const requirements = args.requirements;
+                    if (args.intent === "replace" && existing && !existing.dispatchOpen && existing.runID === null &&
+                        existing.phase !== "cancelled" && existing.phase !== "completed" &&
+                        (existing.phase !== "submitted" || existing.submission?.status === "blocked") &&
+                        sourceReconciliationRequired(existing, prior) && Array.isArray(requirements) &&
+                        requirements.length === existing.requirements.length &&
+                        existing.requirements.every((item, index) => item.text === requirements[index])) {
+                        const repaired = await missions.update(context.sessionID, state => {
+                            if (state.id !== existing.id || state.runID !== null || state.dispatchOpen)
+                                throw new Error("mission-source-reconciliation-stale");
+                            state.supersededRunID = prior.runID;
+                            state.requirementsReplaced = true;
+                            if (state.phase === "submitted") {
+                                state.phase = "running";
+                                state.submission = null;
+                            }
+                        });
+                        return JSON.stringify({ ...locationObservation(context.sessionID), ...missionDispatchPacket(repaired, prior),
+                            budget: await control.currentBudget(context.sessionID) });
+                    }
                     if (args.intent === "replace" && existing && !["completed", "cancelled"].includes(existing.phase)) {
                         await stop(context.sessionID, "explicit-cancellation", false);
                     }
@@ -1358,12 +1511,16 @@ export function createProfiledPlugin(profile, assetVersion) {
                         if (relocated)
                             return JSON.stringify({ ...relocated, budget: await control.currentBudget(context.sessionID) });
                     }
-                    const prior = await operators.read(context.sessionID);
-                    let mission = await retainCancelledMissionAcceptance(context.sessionID, await missions.start(context.sessionID, args.requirements, args.intent === "replace" || args.intent === "new", {
+                    const cancelled = await operators.read(context.sessionID);
+                    let mission = await missions.start(context.sessionID, requirements, args.intent === "replace" || args.intent === "new", {
                         kind: args.kind === "operation" ? "operation" : "implementation",
                         context: missionConversationContext(await messages(context.sessionID)),
-                        ...(args.intent === "replace" && prior?.phase === "cancelled" ? { cancelledRunID: prior.runID } : {}),
-                    }));
+                        ...(args.intent === "replace" && cancelled?.phase === "cancelled" ? { cancelledRunID: cancelled.runID } : {}),
+                    });
+                    if (sourceReconciliationRequired(mission, cancelled))
+                        return JSON.stringify({ ...locationObservation(context.sessionID),
+                            ...missionDispatchPacket(mission, cancelled), budget: await control.currentBudget(context.sessionID) });
+                    mission = await retainCancelledMissionAcceptance(context.sessionID, mission, cancelled);
                     if (!mission.reviewBaseline) {
                         const baseline = await missionReviewBaseline(input.directory);
                         if (baseline)
@@ -1375,8 +1532,146 @@ export function createProfiledPlugin(profile, assetVersion) {
                                 next_action: "Nontrivial: dispatch task now. Simple single-unit work with known scope/check: call plan_units directly. Do not create a proposal or ask for plan approval." }) });
                 });
             } };
+        tools[skipMissionConsultation] = { description: "Coordinator: durably record why a concrete optional Advisor/Scout consultation is unnecessary. This is observation only: it adds no approval, consultation requirement, or dispatch gate.",
+            args: { role: { type: "string", enum: ["advisor", "scout"] }, reason: stringSchema }, execute: async (args, context) => {
+                const { root, mission } = await missionAuthority(context.sessionID);
+                if (context.sessionID !== mission.coordinator || (await identity(context.sessionID)).role !== "dog-operator") {
+                    throw new Error("mission-consultation-coordinator-required");
+                }
+                const consultation = await missions.recordConsultationSkip(root, args.role, args.reason);
+                return JSON.stringify({ status: "recorded", consultation: consultation.consultations?.at(-1) });
+            } };
+        const retryMissionUnit = `${profile.toolPrefix}retry_mission_unit`, rescueMissionUnit = `${profile.toolPrefix}rescue_mission_unit`;
+        tools[retryMissionUnit] = { description: "Coordinator: after one host-classified implementation validation failure, dispatch exactly one same-scope ordinary Mission Worker remediation. Native child termination, released reservation/writer, and remaining cumulative unit budget are required; this does not change acceptance or scope.",
+            args: { unit_id: stringSchema }, execute: async (args, context) => {
+                const { root, mission } = await missionAuthority(context.sessionID);
+                if (context.sessionID !== mission.coordinator || (await identity(context.sessionID)).role !== "dog-operator") {
+                    throw new Error("mission-remediation-coordinator-required");
+                }
+                const run = await operators.required(root), unitID = String(args.unit_id);
+                const unit = run.units.find(item => item.unit.id === unitID);
+                const attempt = [...(mission.attempts ?? [])].reverse().find(item => item.runID === run.runID && item.unitID === unitID);
+                if (!unit || unit.status !== "failed" || unit.resultClass !== "acceptance" || unit.failure?.outcome !== "fail" ||
+                    unit.normalRemediationUsed || !attempt || attempt.kind !== "implementation" || attempt.status !== "failed" ||
+                    attempt.failure?.category !== "implementation")
+                    throw new Error("operator-mission-normal-remediation-unavailable");
+                const terminal = await missionWorkerTerminalProof(root, mission, run, attempt);
+                if (terminal.status !== "ready") {
+                    const packet = missionPacket(mission, run);
+                    return JSON.stringify({ ...packet, run_status: packet.status, status: "non_rescue", reason: terminal.reason });
+                }
+                const budget = await control.currentBudget(root);
+                if (!budget || budget.remaining_units < 1) {
+                    const packet = missionPacket(mission, run);
+                    return JSON.stringify({ ...packet, run_status: packet.status, status: "non_rescue", reason: "budget_exhausted", budget });
+                }
+                const prepared = await operators.prepareMissionNormalRemediation(root, run.runID, unitID);
+                control.enableUnits(root, 1);
+                const next = await operators.next(root, context.sessionID);
+                return JSON.stringify({ status: "normal_remediation_prepared", run_id: prepared.runID,
+                    unit_id: unitID, task: record(next) ? next.task : undefined, budget: await control.currentBudget(root) });
+            } };
+        tools[rescueMissionUnit] = { description: "Coordinator: only after the same unit's one ordinary remediation failed the same declared validation, evaluate one optional Astra Rescue. The host requires the current Mission failure class, reconciled native terminal, exact current candidate/acceptance/scope/validation, discovered model availability, one-use and cumulative budget; the returned Worker must still pass ordinary validation, independent review, and root acceptance. This is not the legacy sortie_execute_terminal_rescue tool.",
+            args: { unit_id: stringSchema }, execute: async (args, context) => {
+                const { root, mission } = await missionAuthority(context.sessionID);
+                if (context.sessionID !== mission.coordinator || (await identity(context.sessionID)).role !== "dog-operator") {
+                    throw new Error("mission-rescue-coordinator-required");
+                }
+                const run = await operators.required(root), unitID = String(args.unit_id);
+                const unit = run.units.find(item => item.unit.id === unitID);
+                const attempt = [...(mission.attempts ?? [])].reverse().find(item => item.runID === run.runID && item.unitID === unitID);
+                const nonRescue = async (reason) => {
+                    await missions.update(root, state => {
+                        state.rescue = { attemptID: attempt?.attemptID ?? randomUUID(),
+                            runID: run.runID, unitID, status: "non_rescue", reason };
+                    });
+                    const packet = missionPacket(await missions.required(root), await operators.read(root));
+                    return JSON.stringify({ ...packet, run_status: packet.status, status: "non_rescue", reason });
+                };
+                if (!unit || unit.status !== "failed" || unit.resultClass !== "acceptance" || unit.failure?.outcome !== "fail" ||
+                    unit.normalRemediationUsed !== true || unit.terminalRescue || !attempt || attempt.kind !== "normal_remediation" ||
+                    attempt.status !== "failed" || attempt.resultClass !== "acceptance" || attempt.failure?.category !== "implementation") {
+                    return nonRescue("normal_remediation_not_exhausted");
+                }
+                const terminal = await missionWorkerTerminalProof(root, mission, run, attempt);
+                if (terminal.status !== "ready")
+                    return nonRescue(terminal.reason);
+                const candidate = await missionReviewSource(input.directory, run, [], mission.reviewBaseline, mission.reviewScope);
+                if (!attempt.candidateID || attempt.candidateID !== candidate.fingerprint)
+                    return nonRescue("accepted_candidate_changed");
+                const budget = await control.currentBudget(root);
+                if (!budget || budget.reserved_units !== 0)
+                    return nonRescue("budget_exhausted");
+                const budgetDetails = budget;
+                const hasTimeLimit = typeof budgetDetails.time_limit_ms === "number";
+                const timeLimit = hasTimeLimit ? budgetDetails.time_limit_ms : Number.MAX_SAFE_INTEGER;
+                const consumedTime = hasTimeLimit ? budgetDetails.settled_time_ms : 0;
+                const hasCostLimit = typeof budgetDetails.cost_limit_usd === "number";
+                const costLimit = hasCostLimit ? budgetDetails.cost_limit_usd : Number.MAX_VALUE;
+                const consumedCost = hasCostLimit ? budgetDetails.settled_cost_usd : (budgetDetails.settled_cost_usd ?? 0);
+                if (!Number.isSafeInteger(timeLimit) || timeLimit < 0 || !Number.isSafeInteger(consumedTime) || consumedTime < 0 ||
+                    !Number.isFinite(costLimit) || costLimit < 0 || typeof consumedCost !== "number" || !Number.isFinite(consumedCost) || consumedCost < 0) {
+                    return nonRescue("budget_exhausted");
+                }
+                if ((hasTimeLimit && consumedTime >= timeLimit) || (hasCostLimit && consumedCost >= costLimit)) {
+                    return nonRescue("budget_exhausted");
+                }
+                const nativeModels = await readHostModels(input.client);
+                const target = nativeModels?.has(DEFAULT_TERMINAL_RESCUE_MODEL)
+                    ? { model: DEFAULT_TERMINAL_RESCUE_MODEL, variant: null } : null;
+                const terminalIdentity = { run_id: run.runID, unit_id: unitID, attempt_id: attempt.attemptID,
+                    predecessor_attempt_id: attempt.predecessorAttemptID ?? null, candidate_id: candidate.fingerprint,
+                    route_id: `${profile.id}:mission:${unitID}`, child_id: terminal.child, call_id: attempt.callID };
+                const priorFailure = attempt.failure;
+                const policy = proposeTerminalRescue({ prior_attempt: { identity: terminalIdentity, role: "implementation", recovery_kind: "normal_remediation",
+                        disposition: "failed", failure: priorFailure ? { category: priorFailure.category, code: priorFailure.code } : null },
+                    terminal_reconciliation: { current: terminalIdentity, observation: { identity: terminalIdentity, disposition: "failed" }, evidence: {
+                            terminal: "satisfied", tools_quiescent: "satisfied", artifact_window_closed: "satisfied", writer_released: "satisfied",
+                            gate_released: "satisfied", lease_released: "satisfied", worktree_released: "satisfied"
+                        } },
+                    accepted_base: { candidate_id: candidate.fingerprint, contract_id: run.acceptanceFingerprint, scope: [...unit.unit.write],
+                        acceptance: [...run.acceptance], validation: [...unit.unit.validation] }, available_target: target,
+                    explicit_override: (attempt.selectedModel !== undefined && attempt.selectedModel !== PREVIEW_WORKER_ROUTE.model) ||
+                        (attempt.observedModel !== undefined && attempt.observedModel !== PREVIEW_WORKER_ROUTE.model) ||
+                        (attempt.observedVariant !== undefined && attempt.observedVariant !== PREVIEW_WORKER_ROUTE.variant),
+                    unit_rescue_count: (mission.attempts ?? []).filter(item => item.runID === run.runID && item.unitID === unitID && item.kind === "astra_rescue").length,
+                    active_run_rescue_count: (mission.attempts ?? []).filter(item => item.runID === run.runID && item.kind === "astra_rescue").length,
+                    budget_limits: { counters: { recovery_actions: budget.max_units, probe_iterations: 0, model_attempts: budget.max_units },
+                        resources: { time_ms: timeLimit, cost_usd: costLimit } },
+                    budget_consumed: { counters: { recovery_actions: budget.consumed_units + budget.reserved_units, probe_iterations: 0,
+                            model_attempts: budget.consumed_units + budget.reserved_units },
+                        resources: { time_ms: consumedTime, cost_usd: consumedCost } },
+                    budget_request: { counters: { recovery_actions: 1, probe_iterations: 0, model_attempts: 1 },
+                        // Current Mission charges native time/cost through its cumulative goal ledger at normal dispatch settlement;
+                        // this policy reservation consumes one existing unit, not an invented parallel resource allowance.
+                        resources: { time_ms: 0, cost_usd: 0 } } });
+                if (policy.status !== "proposed")
+                    return nonRescue(policy.reason);
+                const rescueAttemptID = randomUUID();
+                const prepared = await operators.prepareMissionTerminalRescue(root, run.runID, unitID, {
+                    attempt_id: rescueAttemptID, selected_model: policy.proposal.target.model,
+                    selected_variant: policy.proposal.target.variant,
+                    accepted_base: { candidate_id: policy.proposal.accepted_base_candidate_id, contract_id: policy.proposal.contract_id,
+                        scope: policy.proposal.scope, acceptance: policy.proposal.acceptance, validation: policy.proposal.validation },
+                });
+                control.enableUnits(root, 1);
+                await missions.update(root, state => {
+                    state.rescue = { attemptID: rescueAttemptID, runID: run.runID, unitID,
+                        selectedModel: policy.proposal.target.model, selectedVariant: policy.proposal.target.variant, status: "prepared" };
+                });
+                const next = await operators.next(root, context.sessionID);
+                return JSON.stringify({ status: "prepared", rescue: { attempt_id: rescueAttemptID, selected_model: policy.proposal.target.model,
+                        selected_variant: policy.proposal.target.variant, accepted_base_candidate_id: policy.proposal.accepted_base_candidate_id,
+                        obligations: policy.proposal.obligations }, run_id: prepared.runID, unit_id: unitID,
+                    task: record(next) ? next.task : undefined, budget: await control.currentBudget(root) });
+            } };
         async function declareMissionUnits(root, actor, mission, raw, reason, execution) {
             const previous = await operators.read(root);
+            if (sourceReconciliationRequired(mission, previous))
+                return JSON.stringify({ ...missionDispatchPacket(mission, previous),
+                    next_action: `Coordinator: do not repeat plan_units. Call ${submitMission} with status=blocked and report the saved ` +
+                        `requirements to Operator. Operator can relink this mission in place via ${startMission} intent=replace ` +
+                        `when they match the user's changed scope; no Worker can start before that decision.` });
             mission = await retainCancelledMissionAcceptance(root, mission, previous);
             let operation = mission.execution;
             // Models can serialize an optional operation field as an empty object for a normal edit.
@@ -1583,7 +1878,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                     await missions.update(context.sessionID, state => { state.phase = "completed"; });
                 return result;
             } };
-        const ownTools = new Set([startMission, planUnits, expandUnit, reviewMission, submitMission, completeMission,
+        const ownTools = new Set([startMission, planUnits, expandUnit, reviewMission, submitMission, completeMission, skipMissionConsultation,
+            retryMissionUnit, rescueMissionUnit,
             prepare, repair, next, status, cancel, complete, resume, resolveContractRepair,
             beginProposal, submitProposal, approveProposal, reviseProposal, extendProposalBudget, reopenProposalScope,
             reconcileOrphan, reviseApprovedIntent]);
@@ -1798,17 +2094,36 @@ export function createProfiledPlugin(profile, assetVersion) {
                             });
                         }
                         textParts[0].text = admitted.prompt;
+                        const current = await operators.required(root);
+                        const activeUnit = current.units.find(unit => unit.status === "running" && unit.childSessionID === chat.sessionID);
+                        if (activeUnit?.terminalRescue)
+                            missionRescueSelections.set(chat.sessionID, {
+                                attemptID: activeUnit.terminalRescue.attempt_id,
+                                model: activeUnit.terminalRescue.selected_model, variant: activeUnit.terminalRescue.selected_variant,
+                            });
                     }
                 }
                 const mapped = translate(output, false);
-                await core["chat.message"]?.(translate(chat, false), mapped);
+                const mappedChat = translate(chat, false);
+                const rescueSelection = role === "dog-worker" ? missionRescueSelections.get(chat.sessionID) : undefined;
+                if (rescueSelection)
+                    mappedChat.missionRescueSelection = { attempt_id: rescueSelection.attemptID,
+                        model: rescueSelection.model, variant: rescueSelection.variant };
+                await core["chat.message"]?.(mappedChat, mapped);
                 Object.assign(output, translate(mapped, true));
                 if (role === "dog-worker")
                     for (const part of output.parts) {
                         if (record(part) && part.type === "text" && typeof part.text === "string")
                             part.text = workerControlPrompt(part.text, true);
                     }
-                if (role === "dog-worker" && explicitWorkerSelection) {
+                if (rescueSelection) {
+                    const split = rescueSelection.model.indexOf("/");
+                    if (split <= 0)
+                        throw new Error("invalid-mission-terminal-rescue-model");
+                    output.message.model = { providerID: rescueSelection.model.slice(0, split), modelID: rescueSelection.model.slice(split + 1),
+                        ...(rescueSelection.variant === null ? {} : { variant: rescueSelection.variant }) };
+                }
+                else if (role === "dog-worker" && explicitWorkerSelection) {
                     if (explicitWorkerSelection.model) {
                         const split = explicitWorkerSelection.model.indexOf("/");
                         if (split <= 0)
@@ -1907,6 +2222,11 @@ export function createProfiledPlugin(profile, assetVersion) {
                     const mapped = translate(output, false);
                     await core["tool.execute.before"]?.({ ...request, sessionID: root, agent: "dog-coordinator" }, mapped);
                     Object.assign(output, translate(mapped, true));
+                    if ((consultRole === "dog-advisor" || consultRole === "dog-scout") && typeof args.prompt === "string") {
+                        const role = consultRole === "dog-advisor" ? "advisor" : "scout";
+                        await missions.recordConsultationDispatch(root, { role, callID: request.callID,
+                            ...missionConsultationDetails(role, args.prompt) });
+                    }
                     taskOwners.set(request.callID, { root, actor: request.sessionID, operator: false, consultation: consultRole });
                     return;
                 }
@@ -1995,6 +2315,13 @@ export function createProfiledPlugin(profile, assetVersion) {
                     throw new Error("operator-worker-task-required");
                 let expandedWorker;
                 if (delegated) {
+                    const pendingUnit = state.units.find(unit => unit.status !== "succeeded");
+                    if (pendingUnit?.terminalRescue) {
+                        const requiredModel = pendingUnit.terminalRescue.selected_model;
+                        if (args.model !== undefined && args.model !== requiredModel)
+                            throw new Error("operator-mission-terminal-rescue-model-mismatch");
+                        args.model = requiredModel;
+                    }
                     if (!mission || mission.runID !== state.runID)
                         await proposals.assertExecutionApproved(root, state.planHash);
                     if (!mission || mission.runID !== state.runID)
@@ -2080,6 +2407,27 @@ export function createProfiledPlugin(profile, assetVersion) {
                     }
                     throw error;
                 }
+                if (delegated && mission?.runID === state.runID) {
+                    const admitted = await operators.required(root);
+                    const unit = admitted.units.find(candidate => candidate.callID === request.callID);
+                    const taskID = unit && /^task_id: (.+)$/m.exec(unit.task.prompt)?.[1];
+                    if (unit && taskID) {
+                        const previousAttempt = [...(mission.attempts ?? [])].reverse().find(attempt => attempt.runID === admitted.runID && attempt.unitID === unit.unit.id);
+                        const kind = unit.terminalRescue ? "astra_rescue"
+                            : unit.normalRemediationUsed ? "normal_remediation" : "implementation";
+                        await missions.update(root, current => {
+                            current.attempts ??= [];
+                            if (current.attempts.some(attempt => attempt.callID === request.callID))
+                                return;
+                            current.attempts.push({ attemptID: unit.terminalRescue?.attempt_id ?? randomUUID(), runID: admitted.runID,
+                                unitID: unit.unit.id, taskID, ...(previousAttempt ? { predecessorAttemptID: previousAttempt.attemptID } : { predecessorAttemptID: null }),
+                                kind, status: "dispatched", callID: request.callID,
+                                ...(unit.terminalRescue ? { selectedModel: unit.terminalRescue.selected_model } :
+                                    typeof args.model === "string" ? { selectedModel: args.model } : {}) });
+                            current.attempts = current.attempts.slice(-64);
+                        });
+                    }
+                }
             },
             "tool.execute.after": async (request, output) => {
                 const id = request.sessionID;
@@ -2124,6 +2472,16 @@ export function createProfiledPlugin(profile, assetVersion) {
                                 : `\n\nHOST: evidence-gap review ${count}/${MISSION_EVIDENCE_GAP_REVIEW_LIMIT}. Supply focused original-file excerpts through review_mission evidence and traces. Do not create an evidence-copying Worker or re-implement.`;
                         }
                     }
+                    else if (ownership.consultation === "dog-advisor" || ownership.consultation === "dog-scout") {
+                        const child = taskChildSessionID(output);
+                        const observed = child ? await observedSessionModel(child) : { outcome: "unknown" };
+                        await missions.settleConsultation(ownership.root, request.callID, observed.outcome, {
+                            ...(child === undefined ? {} : { childSessionID: child }),
+                            ...(observed.model === undefined ? {} : { observedModel: observed.model }),
+                            ...(observed.variant === undefined ? {} : { observedVariant: observed.variant }),
+                            ...(typeof raw === "string" ? { result: raw } : {}),
+                        });
+                    }
                     taskOwners.delete(request.callID);
                     return;
                 }

package/dist/plugin/v2.js

@@ -492,7 +492,7 @@ async function registerV2Hooks(context, hooks) {
             if (record(event.tools)) {
                 const visible = {
                     "dog-operator": ["start_mission", "plan_units", "operator_next", "operator_status", "expand_unit", "review_mission", "complete_mission", "cancel_operator", "reflection"],
-                    "dogs-coordinator": ["plan_units", "operator_next", "operator_status", "expand_unit", "review_mission", "submit_mission"],
+                    "dogs-coordinator": ["plan_units", "operator_next", "operator_status", "expand_unit", "review_mission", "submit_mission", "skip_mission_consultation", "retry_mission_unit", "rescue_mission_unit"],
                     "dog-worker-v010": ["bind_write_gate", "release_write_gate", "operator_status"],
                     "dog-luna-worker-v010": ["bind_write_gate", "release_write_gate", "operator_status"],
                     "dog-reviewer-v010": [], "dog-scout-v010": [], "dog-advisor-v010": [],

package/dist/runtime-mission-assets.js

@@ -56,6 +56,13 @@ quality threshold and explicit model/budget choice. Follow AGENTS.md and use the
     When the user replaces a version, target, parallelism or other requirement, call start_mission with
     intent: "replace" and the complete current requirements. The host cancels/archives the old run and
     retains spend/results; superseded instructions are history, not additional obligations.
+    If status/start_mission reports mission-source-reconciliation-required, do not dispatch its Task
+    or declare the user's work impossible. Compare the saved requirements with the user's current
+    scope. When they reflect an already requested narrowing/change, call start_mission with intent:
+    "replace" and the exact saved requirements. The host links the cancelled predecessor to the
+    SAME mission before any Worker starts, retains its Coordinator and cumulative spend, and checks
+    old children before preparing a Worker. This is not permission to discard unchanged acceptance:
+    if the scope is uncertain, ask the user which requirements remain instead of inferring a replacement.
 2. Dispatch the returned ${profileAgent(profile, "dog-operator")} task immediately. It owns investigation,
    unit boundaries, Worker/Scout/Advisor/independent Reviewer calls, write-scope extensions and corrections
    within the original request and cumulative budget. Do not investigate or approve each unit at the root.
@@ -135,7 +142,7 @@ permission:
     ${profileAgent(profile, "dog-advisor")}: allow
 tools:
   "sortie_*": false
-${controls(profile, ["plan_units", "operator_next", "operator_status", "expand_unit", "review_mission", "submit_mission"])}
+${controls(profile, ["plan_units", "operator_next", "operator_status", "expand_unit", "review_mission", "submit_mission", "skip_mission_consultation", "retry_mission_unit", "rescue_mission_unit"])}
 ---
 # ${profileAgent(profile, "dog-operator")}
 
@@ -190,6 +197,10 @@ ${profileAgent(profile, "dog-worker")} task verbatim, in foreground. V2 maps sub
 task_id to sessionID. Do not insert model overrides unless the user explicitly selected them.
 
 After each Worker returns, use its actual report and host evidence. Continue pending units with operator_next.
+If plan_units returns mission-source-reconciliation-required, do not retry the same plan. The
+root-only Operator must reconcile the prior cancelled run. Submit status=blocked with the saved
+requirements and exact host diagnostic, then return; do not declare a user-only decision when
+the current request already narrowed the old scope.
 For a needed write-scope addition within the original request, call expand_unit with unit_id, paths and
 reason; the host returns a replacement contract without Operator approval. For a changed approach, formal
 check or reviewer finding, call plan_units with the corrected units and a short observed reason. Replanning
@@ -213,6 +224,22 @@ the header, correct and redispatch this same consultation once before proceeding
 do not investigate runtime policy or bounce the question to Operator. Use your existing evidence
 and ask a bounded question in the user's language; do not send generic exploratory delegations.
 If the user explicitly requested Advisor input before a decision, do not treat it as optional.
+Actual Advisor/Scout dispatches are recorded in operator_status with their trigger/code, bounded question,
+observed model and native outcome. When you considered a concrete decision or missing fact but existing
+evidence makes consultation unnecessary, record the role and concise skip reason with
+${profile.toolPrefix}skip_mission_consultation. Record only meaningful considered skips, not a generic
+"not needed" for each unit. This is observation only: it neither requires consultation nor adds approval.
+
+After a Mission Worker returns a host-classified failed declared validation (not a Task launch error, contract
+defect, cancellation, or unknown outcome), you may call ${profile.toolPrefix}retry_mission_unit once for that unit.
+It reuses the exact scope, acceptance and validation under the ordinary cumulative budget. If that same normal
+remediation then fails the same declared validation and native termination/writer release are confirmed, you may
+call ${profile.toolPrefix}rescue_mission_unit once. The host records the Astra model actually selected, or a
+specific non_rescue reason; do not expose or substitute the legacy sortie_execute_terminal_rescue capability.
+Rescue is still a normal current-Mission Worker dispatch: its declared validation must pass, then the existing
+independent review, final evidence check and root complete_mission acceptance remain mandatory. A Worker return
+or rescue dispatch alone is never success. On non_rescue, continue the ordinary correction/replan within the same
+requirements and remaining budget; never bypass a failure class or create another run to reset spend.
 
 After formal validation, call review_mission with risk_tags and one concise implementation/test trace per
 requirement. For changed failure behavior, connect the operation and concrete input to the contract-derived

package/package.json

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