sortie-dogs 0.16.4 → 0.16.5

package/dist/asset-version.d.ts

@@ -3,6 +3,6 @@
  * installed project marker without importing every asset body.
  */
 export declare const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export declare const V010_RUNTIME_ASSET_VERSION = "0.16.4-compaction-model-view-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.16.5-mission-direct-retry-v2";
 export declare const CODEX_SKILL_ASSET_VERSION = "0.14.6-codex-skill-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION | typeof CODEX_SKILL_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,5 +3,5 @@
  * installed project marker without importing every asset body.
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export const V010_RUNTIME_ASSET_VERSION = "0.16.4-compaction-model-view-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.16.5-mission-direct-retry-v2";
 export const CODEX_SKILL_ASSET_VERSION = "0.14.6-codex-skill-v1";

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

@@ -64,6 +64,8 @@ export interface MissionAttempt {
     /** Fingerprint of the settled scoped candidate against which a later Rescue is proposed. */
     candidateID?: string;
     kind: "implementation" | "normal_remediation" | "astra_rescue" | "reviewer_correction" | "direct_execution";
+    /** A direct execution may itself be the one ordinary remediation. */
+    normalRemediation?: boolean;
     status: "pending" | "dispatched" | "succeeded" | "failed" | "cancelled" | "unconfirmed" | "handed-off";
     callID?: string;
     childSessionID?: string;

package/dist/core/operator-mission.js

@@ -964,7 +964,7 @@ export function missionPacket(mission, run, includeWorkQuantity = true) {
                                 : 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."
                                     : 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."
+                                        ? `Coordinator: one exact declared validation failed. Reconcile the ${run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && !unit.normalRemediationUsed && unit.directExecution) ? "settled direct execution" : "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.")

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

@@ -155,6 +155,12 @@ interface UnitState {
         handedOffAt: string;
         settledCallID?: string;
     })[];
+    /** Settled direct attempts are historical, not handoffs or validation for a later attempt. */
+    priorDirectExecutions?: (NonNullable<UnitState["directExecution"]> & {
+        callID: string;
+        resultClass: string | null;
+        failure?: SerialDispatchSettlement["failure"];
+    })[];
     resultClass: string | null;
     failure?: SerialDispatchSettlement["failure"];
     normalRemediationUsed?: boolean;

package/dist/core/operator-runtime.js

@@ -393,6 +393,7 @@ export class OperatorRuntime {
                         ...(unit.reviewerCorrection ? { reviewerCorrection: sizedChecks(unit.reviewerCorrection) } : {}),
                         ...(unit.validationRegistration ? { validationRegistration: sizedChecks(unit.validationRegistration) } : {}),
                         ...(Array.isArray(unit.directHandoffs) ? { directHandoffs: unit.directHandoffs.map(sizedChecks) } : {}),
+                        ...(Array.isArray(unit.priorDirectExecutions) ? { priorDirectExecutions: unit.priorDirectExecutions.map(sizedChecks) } : {}),
                     };
                 }) : execution.units };
             if (Buffer.byteLength(JSON.stringify(sized)) > OPERATOR_LIMITS.planBytes * 4)
@@ -2000,11 +2001,19 @@ export class OperatorRuntime {
                 state.units.some(candidate => candidate.terminalRescue))
                 throw new Error("operator-mission-normal-remediation-unavailable");
             await this.verifyControls(unit);
+            if (unit.directExecution) {
+                if (!unit.directExecution.finishedAt || !unit.callID)
+                    throw new Error("operator-mission-normal-remediation-unavailable");
+                (unit.priorDirectExecutions ??= []).push({ ...structuredClone(unit.directExecution), callID: unit.callID,
+                    resultClass: unit.resultClass, failure: structuredClone(unit.failure) });
+                delete unit.directExecution;
+            }
             // The ordinary retry keeps its exact scope and validation, but the next Worker needs the
             // host-observed failed command/exit rather than reconstructing it from an earlier session.
             unit.task = { ...unit.task, prompt: `${unit.task.prompt}\nnormal_remediation_prior_validation: ${JSON.stringify({
                     command: unit.failure.command, exit_code: unit.failure.exitCode
-                })}` };
+                })}${unit.validationRegistration
+                    ? `\nnormal_remediation_validation: ${JSON.stringify({ validation: unitValidation(unit), validation_cwd: unitValidationCwd(unit) })}` : ""}` };
             unit.normalRemediationUsed = true;
             unit.status = "pending";
             unit.callID = null;
@@ -2048,6 +2057,13 @@ export class OperatorRuntime {
             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.
+            if (unit.directExecution) {
+                if (!unit.directExecution.finishedAt || !unit.callID)
+                    throw new Error("operator-mission-terminal-rescue-unavailable");
+                (unit.priorDirectExecutions ??= []).push({ ...structuredClone(unit.directExecution), callID: unit.callID,
+                    resultClass: unit.resultClass, failure: structuredClone(unit.failure) });
+                delete unit.directExecution;
+            }
             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" };

package/dist/plugin/index.js

@@ -7942,6 +7942,56 @@ export const SortieDogsPlugin = async (input, options) => {
             }
         },
     };
+    // Both direct and Worker retries must prove the exact reservation settled and its writer released.
+    // A direct actor is not a native child Task and must not acquire a fabricated terminal record.
+    async function missionDispatchWriterReleased(root, taskID, callID, actor, writeScopes) {
+        const snapshot = await (await goalLedger(root)).readGoal();
+        const origin = await input.runtimeBridge?.missionDispatchOrigin?.(root, taskID, callID);
+        const reservationID = goalFingerprint({ goal_id: snapshot.state.goal_id, unit_id: taskID, call_id: origin?.callID ?? callID });
+        if (snapshot.state.outstanding_reservations.some(item => item.reservation_id === reservationID) ||
+            !snapshot.records.some(({ event }) => event.kind === "unit.settled" && event.goal_id === snapshot.state.goal_id &&
+                event.unit_id === taskID && event.reservation_id === reservationID)) {
+            return { ready: false, reason: "exact_dispatch_settlement_missing" };
+        }
+        const active = activeSessions.get(actor), authorization = sessionAuthorizations.get(actor);
+        if (authorization && (authorization.rootSessionID !== root || authorization.taskID !== taskID ||
+            authorization.dispatchCallID !== callID))
+            return { ready: false, reason: "writer_owned_by_other_dispatch" };
+        if (active?.inFlightCalls.size) {
+            const response = await input.client?.session?.messages?.({ path: { id: actor }, query: { directory: input.directory } }).catch(() => undefined);
+            const history = isRecord(response) && Array.isArray(response.data) ? response.data : undefined;
+            if (!history)
+                return { ready: false, reason: "tool_terminal_records_unavailable" };
+            for (const pendingID of active.inFlightCalls) {
+                const parts = history.flatMap(message => isRecord(message) && isRecord(message.info) &&
+                    message.info.sessionID === actor && Array.isArray(message.parts) ? message.parts : [])
+                    .filter(part => isRecord(part) && part.type === "tool" && part.callID === pendingID);
+                if (parts.length !== 1 || !isRecord(parts[0]) || !isRecord(parts[0].state) ||
+                    !["completed", "error"].includes(String(parts[0].state.status)))
+                    return { ready: false, reason: "tool_dispatch_active_or_unproven" };
+            }
+            active.inFlightCalls.clear();
+        }
+        const released = JSON.parse(await releaseWriteGate(actor));
+        if (released.status === "denied")
+            return { ready: false, reason: released.reason };
+        if (active)
+            active.released = true;
+        const scopeRoot = await durableScopeRoot(project?.root ?? input.directory);
+        if (scopeRoot === undefined)
+            return active?.parallel === "valid"
+                ? { ready: false, reason: "writer_registry_unavailable" } : { ready: true };
+        try {
+            const local = writeScopes.map(path => relative(project?.root ?? input.directory, resolve(project?.root ?? input.directory, normalizeManifestScope(path).path)).replaceAll("\\", "/"))
+                .filter(path => path !== ".." && !path.startsWith("../") && !isAbsolute(path));
+            const scope = normalizeWorktreeScope({ read: [], write: local });
+            return await new ScopeLeaseRegistry(scopeRoot).hasConflictingLease(scope)
+                ? { ready: false, reason: "writer_lease_owned_elsewhere" } : { ready: true };
+        }
+        catch {
+            return { ready: false, reason: "writer_registry_unavailable" };
+        }
+    }
     input.runtimeBridge?.connected?.({
         renderReturnReport: async (root, text, expectedReceipt, missionReview, reviewEvidenceGaps) => {
             let rendered;
@@ -8571,56 +8621,8 @@ export const SortieDogsPlugin = async (input, options) => {
                 throw new Error("mission-activation-grant-stale");
             }
         }),
-        missionWorkerTerminal: async (root, terminal, writeScopes) => {
-            const childSessionID = terminal.childSessionID;
-            const snapshot = await (await goalLedger(root)).readGoal();
-            const origin = await input.runtimeBridge?.missionDispatchOrigin?.(root, terminal.taskID, terminal.callID);
-            const reservationID = goalFingerprint({ goal_id: snapshot.state.goal_id, unit_id: terminal.taskID, call_id: origin?.callID ?? terminal.callID });
-            if (snapshot.state.outstanding_reservations.some(item => item.reservation_id === reservationID) ||
-                !snapshot.records.some(({ event }) => event.kind === "unit.settled" && event.goal_id === snapshot.state.goal_id &&
-                    event.unit_id === terminal.taskID && event.reservation_id === reservationID)) {
-                return { ready: false, reason: "exact_dispatch_settlement_missing" };
-            }
-            const active = activeSessions.get(childSessionID), authorization = sessionAuthorizations.get(childSessionID);
-            if (authorization && (authorization.rootSessionID !== root || authorization.taskID !== terminal.taskID ||
-                authorization.dispatchCallID !== terminal.callID)) {
-                return { ready: false, reason: "writer_owned_by_other_dispatch" };
-            }
-            if (active?.inFlightCalls.size) {
-                const response = await input.client?.session?.messages?.({ path: { id: childSessionID }, query: { directory: input.directory } }).catch(() => undefined);
-                const history = isRecord(response) && Array.isArray(response.data) ? response.data : undefined;
-                if (!history)
-                    return { ready: false, reason: "tool_terminal_records_unavailable" };
-                for (const callID of active.inFlightCalls) {
-                    const parts = history.flatMap(message => isRecord(message) && isRecord(message.info) &&
-                        message.info.sessionID === childSessionID && Array.isArray(message.parts) ? message.parts : [])
-                        .filter(part => isRecord(part) && part.type === "tool" && part.callID === callID);
-                    if (parts.length !== 1 || !isRecord(parts[0]) || !isRecord(parts[0].state) ||
-                        !["completed", "error"].includes(String(parts[0].state.status)))
-                        return { ready: false, reason: "tool_dispatch_active_or_unproven" };
-                }
-                active.inFlightCalls.clear();
-            }
-            const released = JSON.parse(await releaseWriteGate(childSessionID));
-            if (released.status === "denied")
-                return { ready: false, reason: released.reason };
-            if (active)
-                active.released = true;
-            const scopeRoot = await durableScopeRoot(project?.root ?? input.directory);
-            if (scopeRoot === undefined)
-                return active?.parallel === "valid"
-                    ? { ready: false, reason: "writer_registry_unavailable" } : { ready: true };
-            try {
-                const local = writeScopes.map(path => relative(project?.root ?? input.directory, resolve(project?.root ?? input.directory, normalizeManifestScope(path).path)).replaceAll("\\", "/"))
-                    .filter(path => path !== ".." && !path.startsWith("../") && !isAbsolute(path));
-                const scope = normalizeWorktreeScope({ read: [], write: local });
-                return await new ScopeLeaseRegistry(scopeRoot).hasConflictingLease(scope)
-                    ? { ready: false, reason: "writer_lease_owned_elsewhere" } : { ready: true };
-            }
-            catch {
-                return { ready: false, reason: "writer_registry_unavailable" };
-            }
-        },
+        missionWorkerTerminal: (root, terminal, writeScopes) => missionDispatchWriterReleased(root, terminal.taskID, terminal.callID, terminal.childSessionID, writeScopes),
+        missionDirectTerminal: (root, dispatch, writeScopes) => missionDispatchWriterReleased(root, dispatch.taskID, dispatch.callID, dispatch.actor, writeScopes),
         expandMissionWriteGate,
         registerGoalDeclaration: async (root, prompt, missionRevision) => {
             if (!isCoordinatorSession(root) && !await recoverCoordinatorRoot(root))

package/dist/plugin/profiled.js

@@ -940,7 +940,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                     : undefined;
                 const attemptFailure = result.disposition === "cancelled"
                     ? { category: "cancellation", code: "native-task-cancelled" }
-                    : result.resultClass === "acceptance" && result.failure?.outcome === "fail" && observed.outcome === "completed"
+                    : result.resultClass === "acceptance" && result.failure?.outcome === "fail" &&
+                        (observed.outcome === "completed" || !!unit.directExecution?.finishedAt)
                         ? { category: "implementation",
                             code: `validation-failed:${result.failure.exitCode ?? "unknown"}` }
                         : result.resultClass === "process-defect"
@@ -1085,10 +1086,28 @@ export function createProfiledPlugin(profile, assetVersion) {
                 unit.childSessionID !== attempt.childSessionID || /^task_id: (.+)$/m.exec(unit.task.prompt)?.[1] !== attempt.taskID) {
                 return { status: "non_rescue", reason: "terminal_identity_conflict" };
             }
-            if (unit.directExecution)
-                return unit.directExecution.finishedAt && unit.status !== "running"
-                    ? { status: "ready", child: unit.directExecution.actor }
-                    : { status: "non_rescue", reason: "direct_unit_still_running" };
+            if (unit.directExecution) {
+                if (!unit.directExecution.finishedAt || unit.status === "running")
+                    return { status: "non_rescue", reason: "direct_unit_still_running" };
+                if (unit.directExecution.actor !== attempt.childSessionID)
+                    return { status: "non_rescue", reason: "terminal_identity_conflict" };
+                if (checkLiveOutcome) {
+                    try {
+                        await control.assertActiveGoal(root, await operators.completionGoalFingerprint(run));
+                    }
+                    catch {
+                        return { status: "non_rescue", reason: "goal_not_active" };
+                    }
+                    const budget = await control.currentBudget(root, { reconcileUsage: false });
+                    if (!budget || budget.reserved_units !== 0)
+                        return { status: "non_rescue", reason: "goal_reservation_unsettled" };
+                    const released = await control.missionDirectTerminal(root, { taskID: attempt.taskID, callID: attempt.callID,
+                        actor: unit.directExecution.actor }, unit.unit.write);
+                    if (!released.ready)
+                        return { status: "non_rescue", reason: released.reason ?? "writer_not_released" };
+                }
+                return { status: "ready", child: unit.directExecution.actor };
+            }
             const observed = await observeWorkerTerminal(mission, run, attempt, !checkLiveOutcome);
             if (observed.status !== "ready")
                 return observed;
@@ -1306,7 +1325,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 run.units[0]?.status === "failed" && run.units[0]?.resultClass === "acceptance" &&
                 run.units[0]?.failure?.outcome === "fail" && !run.units[0]?.normalRemediationUsed) {
                 return { ...packet, task: missions.task(mission),
-                    next_action: `Fast-lane: declared validation failed. After the Worker returns, for the same scope and command ` +
+                    next_action: `Fast-lane: declared validation failed. After the ${run.units[0]?.directExecution ? "direct execution settles" : "Worker returns"}, for the same scope and command ` +
                         `call ${retryMissionUnit} once, then ${startDirectUnit} to correct and formally validate here when you have the context; ` +
                         `delegate its Worker only when useful. For a changed contract use ${planUnits} with executor=self, reason and one ` +
                         `corrective unit. The Coordinator remains available for actual coordination. Keep cumulative budget and failed history.` };
@@ -2398,8 +2417,10 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const unit = run.units.find(item => item.directExecution?.actor === actor && item.status === "running");
                 const taskID = /^task_id: (.+)$/mu.exec(unit.task.prompt)[1];
                 await missions.update(root, mission => {
+                    const previous = [...(mission.attempts ?? [])].reverse().find(item => item.runID === run.runID && item.unitID === unit.unit.id);
                     (mission.attempts ??= []).push({ attemptID: randomUUID(), runID: run.runID, unitID: unit.unit.id,
-                        taskID, kind: "direct_execution", status: "dispatched", callID: unit.callID, childSessionID: actor });
+                        taskID, kind: "direct_execution", ...(unit.normalRemediationUsed ? { normalRemediation: true } : {}),
+                        ...(previous ? { predecessorAttemptID: previous.attemptID } : {}), status: "dispatched", callID: unit.callID, childSessionID: actor });
                 });
                 direct = await directExecution(actor);
             }
@@ -2416,7 +2437,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 throw new Error("mission-run-registration-incomplete: retry plan_units with the same plan to finish goal registration and Mission binding; no unit admitted");
             await operators.verifyContinuityControls(run);
         }
-        async function assertDirectPlanningQuiescent(actor, planningCallID) {
+        async function assertDirectPlanningQuiescent(actor, planningCallID, planningTool = planUnits) {
             await control.assertDirectUnitQuiescent(actor);
             // Cold hook state is not proof. Only the exact current planner may be pending;
             // a completed background launch or another Task remains an active/unproven writer.
@@ -2433,7 +2454,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                         throw new Error("mission-replan-terminal-unreconciled:tool_terminal_records_unavailable");
                     if (part.type !== "tool")
                         continue;
-                    if (part.callID === planningCallID && planningCallID && part.tool === planUnits)
+                    if (part.callID === planningCallID && planningCallID && part.tool === planningTool)
                         continue;
                     if (typeof part.callID !== "string")
                         throw new Error("mission-replan-terminal-unreconciled:tool_identity_unavailable");
@@ -2703,129 +2724,158 @@ export function createProfiledPlugin(profile, assetVersion) {
                 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: "Owning Coordinator or Fast-lane Operator: after a host-classified Worker validation failure, prepare one same-scope remediation. Use start_direct_unit to correct and formally validate in this session, or dispatch the returned Worker when useful. Native child termination, released reservation/writer, and remaining cumulative unit budget are required; acceptance and scope remain intact.",
+        tools[retryMissionUnit] = { description: "Owning Coordinator or Fast-lane Operator: after a host-classified direct or Worker validation failure, prepare one same-scope remediation. Use start_direct_unit to correct and formally validate in this session, or dispatch the returned Worker when useful. Exact settlement, a quiescent and released writer, and remaining cumulative unit budget are required; acceptance and scope remain intact.",
             args: { unit_id: stringSchema }, execute: async (args, context) => {
-                const { root, mission } = await missionAuthority(context.sessionID);
-                if (context.sessionID !== (mission.coordinator ?? root) ||
-                    (await identity(context.sessionID)).role !== (mission.coordinator ? "dog-operator" : "dog-coordinator")) {
-                    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, true);
-                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) });
+                const { root } = await missionAuthority(context.sessionID);
+                return serializeDispatchTransition(root, async () => {
+                    const { mission } = await missionAuthority(context.sessionID);
+                    if (context.sessionID !== (mission.coordinator ?? root) ||
+                        (await identity(context.sessionID)).role !== (mission.coordinator ? "dog-operator" : "dog-coordinator")) {
+                        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);
+                    const oldDirectUnknown = attempt?.kind === "direct_execution" && attempt.failure?.category === "unknown" &&
+                        attempt.failure.code === "acceptance" && typeof unit?.failure?.exitCode === "number" && unit.failure.exitCode !== 0 &&
+                        unit.directExecution?.checks.some(check => check.exitCode === unit.failure?.exitCode &&
+                            JSON.stringify(check.command) === JSON.stringify(unit.failure?.command));
+                    if (!unit || unit.status !== "failed" || unit.resultClass !== "acceptance" || unit.failure?.outcome !== "fail" ||
+                        unit.normalRemediationUsed || !attempt || !["implementation", "direct_execution"].includes(attempt.kind) || attempt.status !== "failed" ||
+                        (attempt.failure?.category !== "implementation" && !oldDirectUnknown))
+                        throw new Error("operator-mission-normal-remediation-unavailable");
+                    if (attempt.kind === "direct_execution") {
+                        try {
+                            await assertDirectPlanningQuiescent(context.sessionID, context.callID, retryMissionUnit);
+                        }
+                        catch (error) {
+                            const packet = missionPacket(mission, run);
+                            return JSON.stringify({ ...packet, run_status: packet.status, status: "non_rescue",
+                                reason: error instanceof Error ? error.message : "direct_unit_tools_unreconciled" });
+                        }
+                    }
+                    const terminal = await missionWorkerTerminalProof(root, mission, run, attempt, true);
+                    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) => {
+                const { root } = await missionAuthority(context.sessionID);
+                return serializeDispatchTransition(root, async () => {
+                    const { 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.kind === "direct_execution" && attempt.normalRemediation === true) ||
+                        attempt.status !== "failed" || attempt.resultClass !== "acceptance" || attempt.failure?.category !== "implementation") {
+                        return nonRescue("normal_remediation_not_exhausted");
+                    }
+                    if (attempt.kind === "direct_execution") {
+                        try {
+                            await assertDirectPlanningQuiescent(context.sessionID, context.callID, rescueMissionUnit);
+                        }
+                        catch (error) {
+                            return nonRescue(error instanceof Error ? error.message : "direct_unit_tools_unreconciled");
+                        }
+                    }
+                    const terminal = await missionWorkerTerminalProof(root, mission, run, attempt, true);
+                    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: attempt?.attemptID ?? randomUUID(),
-                            runID: run.runID, unitID, status: "non_rescue", reason };
+                        state.rescue = { attemptID: rescueAttemptID, runID: run.runID, unitID,
+                            selectedModel: policy.proposal.target.model, selectedVariant: policy.proposal.target.variant, status: "prepared" };
                     });
-                    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, true);
-                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) });
                 });
-                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) });
             } };
         function declaredMissionExecution(mission, execution) {
             const operation = mission.execution;

package/dist/plugin/runtime-bridge.d.ts

@@ -239,6 +239,14 @@ export interface RuntimeBridge {
             ready: boolean;
             reason?: string;
         }>;
+        missionDirectTerminal(rootSessionID: string, dispatch: {
+            taskID: string;
+            callID: string;
+            actor: string;
+        }, writeScopes: readonly string[]): Promise<{
+            ready: boolean;
+            reason?: string;
+        }>;
         restoreReviewerCorrectionChild(rootSessionID: string, childSessionID: string, callID: string, taskID: string): Promise<void>;
         activateMissionWorker(rootSessionID: string, childSessionID: string, handoffPath: string, admission: MissionImplementationAdmission): Promise<void>;
         activateDirectUnit(rootSessionID: string, actorSessionID: string, prompt: string, handoffPath: string): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sortie-dogs",
-  "version": "0.16.4",
+  "version": "0.16.5",
   "description": "Adaptive execution harness for OpenCode and Codex: goal retention, validation, review, and evidence-backed handoff",
   "keywords": [
     "opencode",