sortie-dogs 0.12.19 → 0.12.21

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.
@@ -1402,7 +1697,18 @@ export function createProfiledPlugin(profile, assetVersion) {
                 if (!reason?.trim())
                     throw new Error("mission-replan-reason-required: name the observed correction or write-scope extension");
             }
-            const budget = await control.currentBudget(root);
+            // A cancelled V2 delegate may leave its Worker Task running after the parent Task aborts.
+            // Reconcile that exact native orphan before checking the cumulative budget or replacing
+            // the run; an unproven orphan remains reserved and the normal terminal check still blocks.
+            const cancelledPredecessor = previous?.phase === "cancelled" &&
+                (mission.supersededRunID === previous.runID ||
+                    (mission.supersededRunID === undefined && ["explicit-cancellation", "agent-changed"].includes(previous.decision ?? "") &&
+                        previous.units.some(unit => (previous.decision === "agent-changed" || unit.status === "cancelled") && unit.childSessionID !== null)));
+            let budget = await control.currentBudget(root);
+            if (cancelledPredecessor && budget?.reserved_units) {
+                await control.reconcileAbortedOperatorOrphan(root);
+                budget = await control.currentBudget(root);
+            }
             if (budget && budget.remaining_units < plan.units.length && !same)
                 throw new Error(`mission-budget-exhausted: plan needs ${plan.units.length} units; ${budget.remaining_units} remain. ` +
                     "The current run is retained. Correct the plan within the remaining budget, or report a necessary cumulative extension to Operator.");
@@ -1413,10 +1719,6 @@ export function createProfiledPlugin(profile, assetVersion) {
             }
             // Cancellation marks the durable units before interrupting their native sessions. A cancelled
             // status alone therefore cannot prove the old Worker stopped or its reservation settled.
-            const cancelledPredecessor = previous?.phase === "cancelled" &&
-                (mission.supersededRunID === previous.runID ||
-                    (mission.supersededRunID === undefined && ["explicit-cancellation", "agent-changed"].includes(previous.decision ?? "") &&
-                        previous.units.some(unit => (previous.decision === "agent-changed" || unit.status === "cancelled") && unit.childSessionID !== null)));
             const terminalChildren = cancelledPredecessor
                 ? await terminalCancelledMissionChildren(profile, root, previous, budget, {
                     get: async (id) => {
@@ -1583,7 +1885,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 +2101,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 +2229,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 +2322,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)
@@ -2023,6 +2357,20 @@ export function createProfiledPlugin(profile, assetVersion) {
                             }
                         }
                     }
+                    const operationArgs = record(mapped.args) ? mapped.args : {};
+                    // A decorated launch would spend on the real operation but leave the native mission observation empty.
+                    // Ask the same Worker to correct its shell input before that expensive side effect.
+                    if (who.role === "dog-worker" && ["bash", "shell"].includes(request.tool.toLowerCase()) && mission?.execution &&
+                        typeof operationArgs.command === "string" &&
+                        resolve(input.directory, typeof operationArgs.workdir === "string" ? operationArgs.workdir : ".") === mission.execution.directory) {
+                        const actual = normalizeCommand(operationArgs.command);
+                        const decorated = mission.execution.commands.some(declared => actual.startsWith(declared) &&
+                            /^\s*(?:\||\d?>|&&?|;)/u.test(actual.slice(declared.length)));
+                        if (decorated)
+                            throw new Error("mission-operation-command-not-observed: run the declared operation command exactly; " +
+                                "do not append a pipe, tee, redirection or chained command. Capture its tool output or write a separate result file afterward. " +
+                                "No new plan or approval is needed; if the run already started, inspect its existing state instead of starting another one.");
+                    }
                     await core["tool.execute.before"]?.({ ...translate(request, false),
                         ...(delegated ? { sessionID: root, agent: "dog-coordinator" } : {}) }, mapped);
                     if (who.role === "dog-worker") {
@@ -2080,6 +2428,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 +2493,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/protected-snapshot.d.ts

@@ -5,6 +5,9 @@ export declare function isRuntimeControlPath(path: string): boolean;
 /** An existing operation may create its declared outputs. Compare its other inputs during execution;
  * ordinary evidence still pins the full post-operation source and outputs for later acceptance. */
 export declare function operationInputSnapshot(projectRoot: string, binding: Binding): Promise<string | undefined>;
+/** A validation may populate write-only caches. Keep its declared read inputs stable
+ * while binding the resulting candidate (including those outputs) after the command. */
+export declare function validationInputSnapshot(projectRoot: string, binding: Binding): Promise<string | undefined>;
 export declare function protectedSnapshot(authorization: {
     manifestPath: string;
     manifestHash: string;