sortie-dogs 0.12.12 → 0.12.14

package/dist/asset-version.d.ts

@@ -3,5 +3,5 @@
  * installed project marker without importing every asset body.
  */
 export declare const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export declare const V010_RUNTIME_ASSET_VERSION = "0.12.12-mission-lineage-external-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.14-worker-context-progress-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,4 +3,4 @@
  * installed project marker without importing every asset body.
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export const V010_RUNTIME_ASSET_VERSION = "0.12.12-mission-lineage-external-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.14-worker-context-progress-v1";

package/dist/core/goal-bound.d.ts

@@ -167,6 +167,15 @@ export type GoalFlightEvent = (GoalEventBase & {
     readonly evidence: readonly GoalEvidence[];
     readonly elapsed_ms: number | null;
     readonly cost_usd: number | null;
+    readonly native_session_id?: string;
+    readonly native_started_at?: string;
+}) | (GoalEventBase & {
+    readonly kind: "unit.usage-reconciled";
+    readonly goal_id: string;
+    readonly reservation_id: string;
+    readonly native_session_id: string;
+    readonly cost_usd: number;
+    readonly source: "native-usage-price-table";
 }) | (GoalEventBase & {
     readonly kind: "unit.evidence-reconciled";
     readonly goal_id: string;

package/dist/core/goal-bound.js

@@ -115,6 +115,7 @@ export function reduceGoalFlight(records) {
     let legacyResetRevision = false;
     let previous = null;
     const processDefects = new Map();
+    const unitCosts = new Map();
     const validationAdmissions = new Map();
     const validationSettlements = new Map();
     const reopenedValidationEvidence = new Set();
@@ -128,6 +129,7 @@ export function reduceGoalFlight(records) {
             continue;
         requireState(instant(event.at), "invalid", "Goal event timestamp is invalid.");
         if (event.kind === "goal.accepted") {
+            unitCosts.clear();
             requireState(state.goal_id === null || state.phase === "terminal" || state.phase === "stopped", "transition", "An active goal already owns this root.");
             requireState(text(event.goal_id) && HASH.test(event.acceptance_fingerprint) && text(event.origin_user_message_id) &&
                 text(event.origin_session_id) && text(event.selected_agent) && event.budget.max_units > 0 &&
@@ -222,6 +224,7 @@ export function reduceGoalFlight(records) {
                 : state.no_progress_results;
             const elapsed = state.consumed_time_ms === null || event.elapsed_ms === null ? null : state.consumed_time_ms + event.elapsed_ms;
             const cost = state.consumed_cost_usd === null || event.cost_usd === null ? null : state.consumed_cost_usd + event.cost_usd;
+            unitCosts.set(event.reservation_id, { cost: event.cost_usd, session: event.native_session_id });
             state = { ...state, consumed_units: state.consumed_units + 1, consumed_time_ms: elapsed, consumed_cost_usd: cost,
                 no_progress_results: nextNoProgress, replan_required: nextNoProgress >= 2,
                 outstanding_reservations: state.outstanding_reservations.filter((entry) => entry.reservation_id !== event.reservation_id),
@@ -232,6 +235,17 @@ export function reduceGoalFlight(records) {
                 processDefects.set(event.receipt_id, { unitID: event.unit_id, revision: state.revision, epoch: state.scope_epoch });
             }
         }
+        else if (event.kind === "unit.usage-reconciled") {
+            const prior = unitCosts.get(event.reservation_id);
+            requireState(event.goal_id === state.goal_id && prior !== undefined && prior.session === event.native_session_id &&
+                event.source === "native-usage-price-table" &&
+                Number.isFinite(event.cost_usd) && event.cost_usd >= 0 &&
+                (prior.cost === null || prior.cost === event.cost_usd), "transition", "Usage reconciliation must identify one settled native unit.");
+            unitCosts.set(event.reservation_id, { cost: event.cost_usd, session: event.native_session_id });
+            const costs = [...unitCosts.values()];
+            state = { ...state, consumed_cost_usd: costs.some(item => item.cost === null) ? null
+                    : costs.reduce((sum, item) => sum + item.cost, 0) };
+        }
         else if (event.kind === "unit.evidence-reconciled") {
             const old = processDefects.get(event.previous_receipt_id);
             requireState(state.phase === "active" && state.receipt === null && old?.unitID === event.unit_id &&

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

@@ -17,6 +17,8 @@ export interface OperatorMission {
         id: string;
         text: string;
     }[];
+    /** The current user intentionally replaced the predecessor's requirements. */
+    requirementsReplaced?: boolean;
     phase: "open" | "running" | "submitted" | "completed" | "cancelled";
     coordinator: string | null;
     callID: string | null;
@@ -74,7 +76,7 @@ export declare class OperatorMissionRuntime {
     read(root: string): Promise<OperatorMission | undefined>;
     required(root: string): Promise<OperatorMission>;
     capture(root: string, request: MissionRequest): Promise<void>;
-    start(root: string, requirements: unknown): Promise<OperatorMission>;
+    start(root: string, requirements: unknown, replaceRequirements?: boolean): Promise<OperatorMission>;
     update(root: string, change: (state: OperatorMission) => void): Promise<OperatorMission>;
     /** Keep host-accepted criteria ahead of new text, including an exactly linked settled predecessor. */
     carryForward(root: string, missionID: string, acceptance: readonly string[], supersededRunID?: string): Promise<OperatorMission>;

package/dist/core/operator-mission.js

@@ -160,7 +160,7 @@ export class OperatorMissionRuntime {
             }
         });
     }
-    start(root, requirements) {
+    start(root, requirements, replaceRequirements = false) {
         return this.serial(root, async () => {
             if (!Array.isArray(requirements) || requirements.length === 0 || requirements.length > 64 ||
                 !requirements.every(item => typeof item === "string" && item.trim() && !/[\r\n]/u.test(item))) {
@@ -182,6 +182,7 @@ export class OperatorMissionRuntime {
                 await this.save(this.file(root, `.${previous.id}`), previous);
             const state = { version: "0.12", id: `mission-${randomUUID()}`, root, requests: [request],
                 requirements: requirements.map((text, index) => ({ id: `R${index + 1}`, text })), phase: "open",
+                ...(replaceRequirements ? { requirementsReplaced: true } : {}),
                 coordinator: null, callID: null, dispatchOpen: false, runID: null, plans: 0, progress: [], submission: null,
                 ...(previous?.phase === "cancelled" &&
                     (previous.runID === null || request.id !== previous.requests[0]?.id) &&
@@ -331,9 +332,15 @@ export function missionPlan(mission, raw) {
         units }, "execution");
 }
 export function missionPacket(mission, run) {
+    const predecessor = run && mission.runID !== run.runID && (mission.supersededRunID === run.runID || run.phase === "cancelled") ? run : undefined;
+    if (predecessor)
+        run = undefined;
     const currentReview = mission.review !== undefined && mission.review.runID === (run?.runID ?? mission.runID);
     const reviewAccepted = currentReview && missionReviewAccepted(mission.review);
     return { mission_id: mission.id, phase: mission.phase, coordinator_session_id: mission.coordinator,
+        ...(predecessor ? { predecessor: { run_id: predecessor.runID, status: predecessor.phase,
+                completed_units: predecessor.units.filter(unit => unit.status === "succeeded").length,
+                note: "Historical results and spend are retained; they do not complete the current requirements." } } : {}),
         requirements: mission.requirements, original_request_refs: mission.requests.map(item => `user:${item.id}`),
         submission: mission.submission, progress: mission.progress,
         execution_summary: { completed_units: run?.units.filter(unit => unit.status === "succeeded").length ?? 0,
@@ -351,6 +358,8 @@ export function missionPacket(mission, run) {
         ...(run ? { run_id: run.runID, status: run.phase, decision: run.decision,
             units: run.units.map(unit => ({ id: unit.unit.id, title: unit.unit.title, status: unit.status,
                 child_session_id: unit.childSessionID, result_class: unit.resultClass, evidence: unit.evidence,
+                handoff_path: unit.handoffPath, operation_manifest_path: unit.manifestPath,
+                scope_read: unit.unit.read, scope_write: unit.unit.write, validation: unit.unit.validation,
                 ...(unit.dispatchDenial ? { dispatch_denial: unit.dispatchDenial } : {}) })) } : {}),
         next_action: mission.phase === "completed" ? "Mission completed. Report the accepted result and retained review gaps; no further dispatch or completion call is needed."
             : mission.phase === "submitted" && mission.submission?.status === "ready"

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

@@ -204,6 +204,8 @@ export interface OperatorState {
     operatorCallID: string | null;
     operatorSessionID: string | null;
     dispatched: number;
+    /** Native interrupt acknowledgements for this cancelled run, persisted before settlement. */
+    stoppedChildren?: string[];
     units: UnitState[];
     decision: string | null;
     receipt: GoalTerminalReceipt | null;
@@ -248,7 +250,7 @@ export declare class OperatorRuntime {
     prepareMission(root: string, raw: unknown, dispatcher?: {
         sessionID: string;
         callID: string;
-    }, supersededRunID?: string, terminalChildren?: readonly string[]): Promise<OperatorState>;
+    }, supersededRunID?: string, terminalChildren?: readonly string[], replaceRequirements?: boolean): Promise<OperatorState>;
     /** Stage a settled mission's replacement; rejected preparation never cancels the usable run. */
     replanMission(root: string, runID: string, raw: unknown, dispatcher?: {
         sessionID: string;
@@ -323,6 +325,7 @@ export declare class OperatorRuntime {
     processReplacementRequired(root: string, runID: string): Promise<OperatorState>;
     private operatorReturnedOnce;
     interrupted(root: string, reason: string): Promise<readonly string[]>;
+    recordStoppedChild(root: string, runID: string, child: string): Promise<void>;
     private interruptedOnce;
     terminal(root: string, receipt: GoalTerminalReceipt): Promise<void>;
     private terminalOnce;
@@ -337,6 +340,8 @@ export declare class OperatorRuntime {
     completionGoalFingerprint(state: OperatorState): Promise<string>;
     verifyContinuityControls(state: OperatorState): Promise<void>;
     packet(state: OperatorState): unknown;
+    /** Reconstruct the admitted child's instructions without trusting a lossy conversation summary. */
+    workerContext(root: string, child: string): Promise<string | undefined>;
     continuationCheckpoint(root: string): Promise<string | undefined>;
     private verifyControls;
     /** Follow only the host's authorized parent-link repair; keep the durable control pin in sync. */

package/dist/core/operator-runtime.js

@@ -686,8 +686,8 @@ export class OperatorRuntime {
         }
     }
     /** Mission authority is supplied only by the owning profile, never by a model-authored plan. */
-    prepareMission(root, raw, dispatcher, supersededRunID, terminalChildren = []) {
-        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID, terminalChildren }));
+    prepareMission(root, raw, dispatcher, supersededRunID, terminalChildren = [], replaceRequirements = false) {
+        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID, terminalChildren, replaceRequirements }));
     }
     /** Stage a settled mission's replacement; rejected preparation never cancels the usable run. */
     replanMission(root, runID, raw, dispatcher) {
@@ -758,12 +758,12 @@ export class OperatorRuntime {
                 return previous;
             throw new Error("operator-active-contract-immutable");
         }
-        // Cancellation stops execution, not the accepted user order. A replacement
-        // plan must carry the original ordered criteria; only a completed root clears them.
+        // Same-request continuation retains acceptance. Explicit user replacement keeps the
+        // predecessor's history/spend but uses the current requirements instead of an old prefix.
         // Treat the predecessor as retired only in this staged replacement. Its durable state remains
         // intact through schema checks, control writes and archive creation, until save atomically switches it.
         const parent = replanning ? { ...previous, phase: "cancelled", decision: "mission-replan" }
-            : (!superseding || retainAcceptance) && previous?.phase === "cancelled" ? previous : undefined;
+            : (!superseding || (retainAcceptance && !mission?.replaceRequirements)) && previous?.phase === "cancelled" ? previous : undefined;
         if (parent && ["explicit-cancellation", "agent-changed"].includes(parent.decision ?? "")) {
             const cancelled = parent.units.flatMap(unit => (parent.decision === "agent-changed" || unit.status === "cancelled") && unit.childSessionID !== null
                 ? [unit.childSessionID] : []);
@@ -1579,6 +1579,15 @@ export class OperatorRuntime {
     interrupted(root, reason) {
         return this.serial(root, () => this.interruptedOnce(root, reason));
     }
+    recordStoppedChild(root, runID, child) {
+        return this.serial(root, async () => {
+            const state = await this.required(root);
+            if (state.runID !== runID || state.phase !== "cancelled")
+                return;
+            state.stoppedChildren = [...new Set([...(state.stoppedChildren ?? []), child])];
+            await this.save(state);
+        });
+    }
     async interruptedOnce(root, reason) {
         const state = await this.read(root);
         if (!state || state.phase === "completed")
@@ -1910,6 +1919,26 @@ export class OperatorRuntime {
             throw new Error("operator-packet-too-large-no-evidence-truncated");
         return packet;
     }
+    /** Reconstruct the admitted child's instructions without trusting a lossy conversation summary. */
+    async workerContext(root, child) {
+        const state = await this.read(root);
+        if (!state || state.phase !== "running")
+            return undefined;
+        const unit = state.units.find(item => item.childSessionID === child && item.status === "running");
+        if (!unit)
+            return undefined;
+        // Keep this prefix stable across reads/edits: changing counters belong in status/tool results.
+        return `SORTIE_WORKER_CONTEXT\n${JSON.stringify({ root_session_id: root, run_id: state.runID,
+            unit_id: unit.unit.id, task_id: /^task_id: (.+)$/m.exec(unit.task.prompt)?.[1],
+            project_root: this.projectRoot, handoff_path: unit.handoffPath, operation_manifest: unit.manifestPath,
+            objective: unit.unit.objective, read: unit.unit.read, write: unit.unit.write,
+            validation: unit.unit.validation, acceptance: state.acceptance,
+            ...(unit.repairValidation === null ? {} : { validation_only: true }),
+        })}\nThis is the durable assignment for this same Worker, including after compaction or reload. ` +
+            "A missing path in a summary does not mean the handoff is missing. Read the retained handoff/manifest and inspect the actual diff and outputs before claiming no edits or replaying work. " +
+            `Use ${this.profile.toolPrefix}operator_status for observed validation and remaining work; do not repeat successful checks for an unchanged candidate. ` +
+            "This context is an assignment, not proof of execution or acceptance.";
+    }
     async continuationCheckpoint(root) {
         const state = await this.read(root);
         const cancelledRemediation = state?.phase === "cancelled" &&

package/dist/core/run-flight-ledger.js

@@ -918,6 +918,10 @@ export class RunFlightLedger {
             const records = await this.#readGoalRecords();
             if (guard !== undefined)
                 guard(reduceGoalFlight(records));
+            if (event.kind === "unit.usage-reconciled" && records.some(({ event: stored }) => stored.kind === "unit.usage-reconciled" && stored.goal_id === event.goal_id &&
+                stored.reservation_id === event.reservation_id && stored.native_session_id === event.native_session_id &&
+                stored.cost_usd === event.cost_usd))
+                return reduceGoalFlight(records);
             if (event.kind === "goal.accepted") {
                 const prior = records.find(({ event: stored }) => stored.kind === "goal.accepted" &&
                     stored.origin_user_message_id === event.origin_user_message_id);

package/dist/plugin/gate.js

@@ -1240,21 +1240,16 @@ export async function createWriteGate(project, value, toolDirectory = project.ro
                 : undefined;
             if (command !== undefined && declaredValidation.has(command))
                 return;
+            // Shell syntax is not an execution permission boundary. Mission workers already use
+            // native host permissions; only declared checks produce formal validation evidence.
+            if (options?.investigativeShell && ["bash", "shell"].includes(_input.tool))
+                return;
             const extracted = extractWritePaths(_input.tool, output.args);
             if (!extracted.applies)
                 return;
-            // Mission workers may investigate with repository-specific executables without registering
-            // every diagnostic as a formal check. Known write destinations/Git mutations still use the
-            // same scope gate; this option never makes diagnostic output acceptance evidence.
-            if (options?.investigativeShell && ["bash", "shell"].includes(_input.tool) &&
-                extracted.issue?.cause === "executable-not-allowlisted" && extracted.paths.length === 0 &&
-                !extracted.gitMutation && !extracted.remoteMutation)
-                return;
             if (extracted.ambiguous || (extracted.paths.length === 0 && !extracted.gitCommit)) {
                 if (extracted.issue !== undefined) {
-                    const formatCorrection = options?.investigativeShell === true &&
-                        ["unsupported-curl-form", "unsupported-git-archive-form", "unsupported-webrequest-form"].includes(extracted.issue.cause);
-                    throw new WriteDeniedError("unclassified-command", issuePath(extracted.issue, formatCorrection));
+                    throw new WriteDeniedError("unclassified-command", issuePath(extracted.issue));
                 }
                 throw new WriteDeniedError("path-required", "<missing-path>");
             }

package/dist/plugin/index.js

@@ -52,6 +52,7 @@ import { STABLE_RUNTIME_PROFILE } from "../core/runtime-profile.js";
 import { evidenceFromObservedExecution } from "../core/observed-goal-evidence.js";
 import { receiptBoundTerminalText } from "./receipt-presentation.js";
 import { protectedSnapshot, refreshProtectedSnapshot } from "./protected-snapshot.js";
+import { settledUnitUsage } from "./unit-usage.js";
 import { goalCompletionReadiness } from "./goal-completion.js";
 const INPUT_LIMITS = { config: 64 * 1024, manifest: 512 * 1024, handoff: 2 * 1024 * 1024, parallel: 512 * 1024 };
 const INSPECTION_CACHE = { maximum: 256, ttlMilliseconds: 30 * 60 * 1000 };
@@ -1520,6 +1521,32 @@ export const SortieDogsPlugin = async (input, options) => {
             startedAt: observedStartedAt, endedAt, exitCode: exitCode ?? null,
             ...(outcome === undefined ? {} : { outcome }), ...(immutableRef === undefined ? {} : { immutableRef }), fresh });
     }
+    async function nativeUnitCost(child, startedAt) {
+        if (!child || !input.client?.session?.messages)
+            return null;
+        try {
+            const response = await input.client.session.messages({ path: { id: child }, query: { directory: input.directory } });
+            return isRecord(response) && Array.isArray(response.data) ? settledUnitUsage(response.data, startedAt) : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async function reconcileUnitUsage(root) {
+        const ledger = await goalLedger(root), snapshot = await ledger.readGoal();
+        const reconciled = new Set(snapshot.records.flatMap(({ event }) => event.kind === "unit.usage-reconciled" ? [event.reservation_id] : []));
+        for (const { event } of snapshot.records) {
+            if (event.kind !== "unit.settled" || event.goal_id !== snapshot.state.goal_id || event.cost_usd !== null ||
+                !event.native_session_id || reconciled.has(event.reservation_id))
+                continue;
+            const cost = await nativeUnitCost(event.native_session_id, event.native_started_at);
+            if (cost === null)
+                continue;
+            await ledger.appendGoal({ kind: "unit.usage-reconciled", at: new Date().toISOString(), goal_id: event.goal_id,
+                reservation_id: event.reservation_id, native_session_id: event.native_session_id,
+                cost_usd: cost, source: "native-usage-price-table" });
+        }
+    }
     async function recoverCompletedGoalReservations(sessionID) {
         const root = goalRoot(sessionID);
         const active = goalReservationRecoveries.get(root);
@@ -1531,7 +1558,31 @@ export const SortieDogsPlugin = async (input, options) => {
             // A terminal host Task is authoritative even when a missed after hook left process-local
             // dispatch accounting behind. Treating that memory as live made the reservation permanent.
             const pending = state.outstanding_reservations;
-            if (pending.length === 0 || state.goal_id === null || input.client?.session?.messages === undefined)
+            for (const reservation of pending) {
+                const dispatch = await input.runtimeBridge?.recoverMissionDispatch?.(root, reservation.unit_id);
+                if (!dispatch || !state.goal_id || goalFingerprint({ goal_id: state.goal_id, unit_id: reservation.unit_id,
+                    call_id: dispatch.callID }) !== reservation.reservation_id)
+                    continue;
+                const startedAt = (await ledger.readGoal()).records.find(({ event }) => event.kind === "dispatch.reserved" &&
+                    event.reservation_id === reservation.reservation_id)?.event.at;
+                await ledger.appendGoal({ kind: "unit.settled", at: new Date().toISOString(),
+                    reservation_id: reservation.reservation_id,
+                    receipt_id: goalFingerprint({ recovered_host_task: dispatch.callID, reservation: reservation.reservation_id }),
+                    goal_id: state.goal_id, unit_id: reservation.unit_id,
+                    disposition: dispatch.cancelled ? "cancelled" : "failed", result_class: dispatch.cancelled ? "interrupted" : "process-defect",
+                    progress_fingerprint: null, evidence: [], elapsed_ms: null,
+                    cost_usd: await nativeUnitCost(dispatch.childSessionID, startedAt),
+                    ...(dispatch.childSessionID ? { native_session_id: dispatch.childSessionID, native_started_at: startedAt } : {}) });
+                // A missed after hook closes execution, but cannot turn unobserved validation into acceptance.
+                await input.runtimeBridge?.onSerialSettlement?.({ rootSessionID: root, callID: dispatch.callID,
+                    unitID: reservation.unit_id, ...(dispatch.childSessionID ? { childSessionID: dispatch.childSessionID } : {}),
+                    disposition: dispatch.cancelled ? "cancelled" : "failed", resultClass: dispatch.cancelled ? "interrupted" : "process-defect", evidence: [] });
+                goalReservations.delete(dispatch.callID);
+                if (finishCoordinatorTask(root, dispatch.callID))
+                    fastLane.workerCompleted(root);
+            }
+            const remaining = (await ledger.readGoal()).state.outstanding_reservations;
+            if (remaining.length === 0 || state.goal_id === null || input.client?.session?.messages === undefined)
                 return;
             const messages = input.client.session.messages;
             const response = await messages.call(input.client.session, { path: { id: root },
@@ -1615,7 +1666,7 @@ export const SortieDogsPlugin = async (input, options) => {
                     return undefined;
                 return candidates[0].callID;
             }
-            for (const reservation of pending) {
+            for (const reservation of remaining) {
                 const matches = [];
                 for (const message of data) {
                     if (!isRecord(message) || !isRecord(message.info) || message.info.role !== "assistant" ||
@@ -2240,11 +2291,12 @@ export const SortieDogsPlugin = async (input, options) => {
         const reservation = goalReservations.get(callID);
         if (reservation === undefined)
             return;
-        goalReservations.delete(callID);
         const ledger = await goalLedger(reservation.root);
         const state = (await ledger.readGoal()).state;
-        if (state.goal_id === null)
+        if (state.goal_id === null || !state.outstanding_reservations.some(item => item.reservation_id === reservation.reservationID)) {
+            goalReservations.delete(callID);
             return;
+        }
         const outputText = typeof output.output === "string" ? output.output : "";
         // Task text and Task result metadata are model/child-controlled. Only an exact declared command
         // observed in the child tool hooks with a native host exit may produce goal evidence.
@@ -2288,7 +2340,10 @@ export const SortieDogsPlugin = async (input, options) => {
             goal_id: state.goal_id, unit_id: reservation.unitID,
             disposition: validated ? "succeeded" : interrupted ? "cancelled" : "failed", result_class: resultClass,
             progress_fingerprint: progress ? goalFingerprint(acceptedEvidence) : null,
-            evidence: acceptedEvidence, elapsed_ms: Math.max(0, Date.now() - reservation.started), cost_usd: null });
+            evidence: acceptedEvidence, elapsed_ms: Math.max(0, Date.now() - reservation.started),
+            cost_usd: await nativeUnitCost(childSessionID, new Date(reservation.started).toISOString()),
+            ...(childSessionID ? { native_session_id: childSessionID, native_started_at: new Date(reservation.started).toISOString() } : {}) });
+        goalReservations.delete(callID);
         await input.runtimeBridge?.onSerialSettlement?.({
             rootSessionID: reservation.root, callID, unitID: reservation.unitID,
             ...(childSessionID === undefined ? {} : { childSessionID }),
@@ -7761,6 +7816,7 @@ export const SortieDogsPlugin = async (input, options) => {
             // Planning must account for terminal native Tasks before reserving new units.
             // Otherwise a cancelled predecessor keeps a stale unit reservation across missions.
             await recoverCompletedGoalReservations(root);
+            await reconcileUnitUsage(root);
             const state = await currentGoal(root);
             if (state.goal_id === null || state.budget === null)
                 return null;
@@ -7769,7 +7825,8 @@ export const SortieDogsPlugin = async (input, options) => {
                 reserved_units: reserved, remaining_units: Math.max(0, state.budget.max_units - state.consumed_units - reserved),
                 settled_cost_usd: state.consumed_cost_usd, cost_limit_usd: state.budget.cost_usd,
                 cost_status: state.consumed_cost_usd === null ? "unknown-usage" : reserved > 0 ? "in-flight-not-final" : "settled",
-                cost_note: "Goal Worker ledger only; excludes unfinalized native requests, orchestration/review and external campaign spend. Zero settled cost does not mean free execution." };
+                cost_source: "native-usage-price-table",
+                cost_note: "Worker token-price estimates from complete native usage; missing requests remain unknown and are reconciled on later status. Excludes orchestration/review and external campaign spend. Zero settled cost does not mean free execution." };
         },
         registerGoalDeclaration: async (root, prompt, missionRevision) => {
             if (!isCoordinatorSession(root) && !await recoverCoordinatorRoot(root))
@@ -7949,6 +8006,7 @@ export const SortieDogsPlugin = async (input, options) => {
             fastLane.grantSerialUnits(sessionID, maximum);
         },
         cancelChildren: async (sessionID) => {
+            await recoverCompletedGoalReservations(sessionID);
             for (const [callID, reservation] of [...goalReservations]) {
                 if (reservation.root !== sessionID)
                     continue;

package/dist/plugin/mission-progress.d.ts

@@ -1,5 +1,6 @@
-/** Display-only native Task progress. Never prompts a model or changes execution ownership. */
 type Sink = (value: Record<string, unknown>) => Promise<void>;
 export declare function bindMissionProgress(root: string, sink: Sink): () => void;
 export declare function publishMissionProgress(root: string, value: Record<string, unknown>): Promise<void>;
+/** Read durable transitions even when settlement ran in a different/reloaded plugin instance. */
+export declare function missionProgressReader(directory: string, root: string, callID: string): () => Promise<Record<string, unknown> | undefined>;
 export {};

package/dist/plugin/mission-progress.js

@@ -1,3 +1,7 @@
+/** Display-only native Task progress. Never prompts a model or changes execution ownership. */
+import { OperatorMissionRuntime } from "../core/operator-mission.js";
+import { OperatorRuntime } from "../core/operator-runtime.js";
+import { V010_RUNTIME_PROFILE } from "../core/runtime-profile.js";
 const sinks = new Map();
 export function bindMissionProgress(root, sink) {
     sinks.set(root, sink);
@@ -7,3 +11,27 @@ export function bindMissionProgress(root, sink) {
 export async function publishMissionProgress(root, value) {
     await sinks.get(root)?.(value).catch(() => undefined);
 }
+/** Read durable transitions even when settlement ran in a different/reloaded plugin instance. */
+export function missionProgressReader(directory, root, callID) {
+    const missions = new OperatorMissionRuntime(directory, V010_RUNTIME_PROFILE);
+    return async () => {
+        const mission = await missions.read(root);
+        if (!mission || mission.callID !== callID)
+            return undefined;
+        // OperatorRuntime caches its own writes; a display observer must read a fresh disk snapshot.
+        const run = await new OperatorRuntime(directory, V010_RUNTIME_PROFILE).read(root);
+        const units = run?.runID === mission.runID ? run.units : [];
+        const running = units.find(unit => unit.status === "running");
+        const last = mission.progress.at(-1);
+        const status = running ? "running" : last?.status ?? mission.phase;
+        const title = running?.unit.title ?? last?.title ?? mission.requirements[0]?.text ?? "Coordinator";
+        return { description: `🐾 ${status}: ${title}`, sortie_progress: {
+                mission_id: mission.id, phase: mission.phase, unit: running ? `${run.runID}/${running.unit.id}` : last?.unit ?? null,
+                title, status, child_session_id: running?.childSessionID ?? null,
+                completed_units: units.filter(unit => unit.status === "succeeded").length,
+                failed_units: units.filter(unit => unit.status === "failed").length,
+                historical_failed_attempts: mission.progress.filter(unit => unit.status === "failed").length,
+                accepted: mission.phase === "completed",
+            } };
+    };
+}

package/dist/plugin/profiled.js

@@ -10,7 +10,7 @@ import { BUILT_IN_MODEL_CATALOG } from "./model-routing.js";
 import { goalFingerprint } from "../core/goal-bound.js";
 import { decoratePreviewHeadings, returnReportPanel } from "./receipt-presentation.js";
 import { sanitizeTerminalReport, terminalRunOutcome } from "./run-metrics.js";
-import { extractWritePaths, normalizeCommand } from "./gate.js";
+import { normalizeCommand } from "./gate.js";
 import { normalizeRelativePath } from "../core/path.js";
 import { MISSION_EVIDENCE_GAP_REVIEW_LIMIT, OperatorMissionRuntime, missionPacket, missionPlan, missionReviewAccepted, missionReviewTask, missionReviewTraces, missionReviewVerdict } from "../core/operator-mission.js";
 import { publishMissionProgress } from "./mission-progress.js";
@@ -362,6 +362,36 @@ export function createProfiledPlugin(profile, assetVersion) {
                     state.units.some(unit => unit.status === "running" && unit.callID === callID &&
                         /^task_id: (.+)$/m.exec(unit.task.prompt)?.[1] === taskID);
             },
+            recoverMissionDispatch: async (root, taskID) => {
+                let run = await operators.read(root);
+                const unit = run?.units.find(item => /^task_id: (.+)$/m.exec(item.task.prompt)?.[1] === taskID);
+                if (!run || !unit?.callID)
+                    return undefined;
+                if (run.phase !== "cancelled") {
+                    const history = await messages(run.operatorSessionID ?? root);
+                    const terminal = history.some(message => Array.isArray(message.parts) && message.parts.some(part => record(part) && part.type === "tool" && part.callID === unit.callID && record(part.state) &&
+                        ["completed", "error"].includes(String(part.state.status))));
+                    if (!terminal)
+                        return undefined;
+                    if (unit.childSessionID) {
+                        const child = payload(await session("get", { path: { id: unit.childSessionID }, query: { directory: input.directory } }));
+                        if (!record(child) || child.parentID !== (run.operatorSessionID ?? root) ||
+                            !["succeeded", "failed", "interrupted"].includes(String(child.outcome)))
+                            return undefined;
+                    }
+                    return { callID: unit.callID, ...(unit.childSessionID ? { childSessionID: unit.childSessionID } : {}), cancelled: false };
+                }
+                await stopCancelledChildren(root, run);
+                run = await operators.required(root);
+                // A Task rejected before creating a child still has a native terminal record.
+                if (!unit.childSessionID) {
+                    const history = await messages(run.operatorSessionID ?? root);
+                    if (!history.some(message => Array.isArray(message.parts) && message.parts.some(part => record(part) && part.type === "tool" && part.callID === unit.callID && record(part.state) &&
+                        ["completed", "error"].includes(String(part.state.status)))))
+                        return undefined;
+                }
+                return { callID: unit.callID, ...(unit.childSessionID ? { childSessionID: unit.childSessionID } : {}), cancelled: true };
+            },
             allowsInvestigativeShell: async (child) => {
                 const root = await rootFor(child);
                 if (!root)
@@ -487,7 +517,8 @@ export function createProfiledPlugin(profile, assetVersion) {
             if (previous?.phase !== "cancelled" || mission.runID !== null)
                 return mission;
             if (mission.supersededRunID !== undefined) {
-                if (mission.supersededRunID !== previous.runID || !cancelledMissionRetainsAcceptance(previous))
+                // The predecessor remains archived for costs/results, not as obligations for a new request.
+                if (mission.requirementsReplaced || mission.supersededRunID !== previous.runID || !cancelledMissionRetainsAcceptance(previous))
                     return mission;
                 return missions.carryForward(root, mission.id, previous.acceptance, previous.runID);
             }
@@ -638,6 +669,37 @@ export function createProfiledPlugin(profile, assetVersion) {
         const reopenProposalScope = profileTool(profile, "sortie_reopen_operator_proposal_scope");
         const reconcileOrphan = profileTool(profile, "sortie_reconcile_orphaned_operator_dispatch");
         const reviseApprovedIntent = profileTool(profile, "sortie_revise_approved_operator_intent");
+        async function stopCancelledChildren(root, run) {
+            if (run.phase !== "cancelled")
+                return;
+            const children = new Set(run.units.flatMap(unit => unit.childSessionID ? [unit.childSessionID] : []));
+            if (run.operatorSessionID) {
+                // Older V2 private servers expose get/interrupt but no session.list. The durable
+                // dispatch IDs suffice to cancel our work; a missing listing must not veto that operation.
+                const nested = payload(await session("children", { path: { id: run.operatorSessionID }, query: { directory: input.directory } }).catch(() => undefined));
+                if (Array.isArray(nested))
+                    for (const child of nested)
+                        if (record(child) && typeof child.id === "string" &&
+                            child.parentID === run.operatorSessionID)
+                            children.add(child.id);
+                children.add(run.operatorSessionID);
+            }
+            for (const child of children) {
+                if (run.stoppedChildren?.includes(child))
+                    continue;
+                const who = payload(await session("get", { path: { id: child }, query: { directory: input.directory } }));
+                if (!record(who) || who.parentID !== (child === run.operatorSessionID ? root : run.operatorSessionID ?? root)) {
+                    throw new Error(`mission-cancellation-lineage-unavailable: ${child}`);
+                }
+                if (!["succeeded", "failed", "interrupted"].includes(String(who.outcome))) {
+                    const result = await session("abort", { path: { id: child }, query: { directory: input.directory } });
+                    if (result === undefined || result === false || (record(result) && result.data === false)) {
+                        throw new Error(`mission-cancellation-stop-unconfirmed: ${child}`);
+                    }
+                }
+                await operators.recordStoppedChild(root, run.runID, child);
+            }
+        }
         async function stop(root, reason, retireRoot = true) {
             if (retireRoot)
                 retired.add(root);
@@ -664,6 +726,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const result = await session("abort", { path: { id: child }, query: { directory: input.directory } });
                 if (result === undefined || result === false || (record(result) && result.data === false))
                     throw new Error("operator-child-stop-unconfirmed");
+                const run = await operators.read(root);
+                if (run)
+                    await operators.recordStoppedChild(root, run.runID, child);
             }
             await control?.cancelChildren(root);
             if (retireRoot)
@@ -733,6 +798,11 @@ export function createProfiledPlugin(profile, assetVersion) {
                 if (!root)
                     throw new Error("operator-grant-invalid");
                 const activeMission = await reconcileMissionDispatch(root);
+                if (activeMission && !["cancelled", "completed"].includes(activeMission.phase) && activeMission.runID === null && context.sessionID !== root) {
+                    const budget = await control.currentBudget(root);
+                    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." });
+                }
                 if (activeMission && context.sessionID === root && !activeMission.dispatchOpen &&
                     ["open", "running"].includes(activeMission.phase)) {
                     return JSON.stringify({ ...missionDispatchPacket(activeMission, await operators.read(root)), budget: await control.currentBudget(root) });
@@ -786,9 +856,10 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const mission = root && context.sessionID === root ? await reconcileMissionDispatch(root) : root ? await missions.read(root) : undefined;
                 // Observation is available to every owned role. Only the root reconciles dispatch above.
                 if (mission) {
+                    const budget = await control.currentBudget(root);
                     const run = await operators.read(root);
                     const completion = run?.phase === "awaiting-acceptance" ? await control.completionReadiness(root) : undefined;
-                    return JSON.stringify({ ...missionDispatchPacket(mission, run), budget: await control.currentBudget(root),
+                    return JSON.stringify({ ...missionDispatchPacket(mission, run), budget,
                         ...(completion ? { completion, ...(!completion.ready ? { next_action: completion.blockers.map(item => item.next_action).join("\n") } : {}) } : {}) });
                 }
                 if (root && context.sessionID !== root) {
@@ -1226,20 +1297,23 @@ export function createProfiledPlugin(profile, assetVersion) {
             } };
         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 stringList = { type: "array", items: { type: "string" } };
-        tools[startMission] = { description: "Operator: save a few one-line requirements/negative constraints. Original user messages, IDs and ownership are captured automatically. An unfinished mission in another location returns its continuation location. For intentionally separate work in this location, intent=new creates a separate mission without cancelling other missions or resetting cumulative spend. Dispatch the returned Coordinator task immediately, or use plan_units for simple single-unit work.",
+        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.",
             args: { requirements: { ...stringList, minItems: 1, maxItems: 64 },
-                intent: { type: "string", enum: ["", "continue", "new"], "x-sortie-optional": true } }, execute: async (args, context) => {
+                intent: { type: "string", enum: ["", "continue", "new", "replace"], "x-sortie-optional": true } }, execute: async (args, context) => {
                 await requireRoot(context.sessionID);
-                if (args.intent !== undefined && !["", "continue", "new"].includes(args.intent))
+                if (args.intent !== undefined && !["", "continue", "new", "replace"].includes(args.intent))
                     throw new Error("mission-intent-invalid");
                 return serializeDispatchTransition(context.sessionID, async () => {
                     const existing = await reconcileMissionDispatch(context.sessionID);
+                    if (args.intent === "replace" && existing && !["completed", "cancelled"].includes(existing.phase)) {
+                        await stop(context.sessionID, "explicit-cancellation", false);
+                    }
                     if (args.intent !== "new" && (!existing || ["completed", "cancelled"].includes(existing.phase))) {
                         const relocated = await relocatedMission(context.sessionID);
                         if (relocated)
                             return JSON.stringify({ ...relocated, budget: await control.currentBudget(context.sessionID) });
                     }
-                    const mission = await retainCancelledMissionAcceptance(context.sessionID, await missions.start(context.sessionID, args.requirements));
+                    const mission = await retainCancelledMissionAcceptance(context.sessionID, await missions.start(context.sessionID, args.requirements, args.intent === "replace" || args.intent === "new"));
                     return JSON.stringify({ ...locationObservation(context.sessionID), ...(mission.dispatchOpen
                             ? missionDispatchPacket(mission, await operators.read(context.sessionID))
                             : { mission_id: mission.id, requirements: mission.requirements, task: missions.task(mission),
@@ -1270,12 +1344,25 @@ export function createProfiledPlugin(profile, assetVersion) {
                         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) => payload(await session("get", { path: { id }, query: { directory: input.directory } })),
-                    children: async (id) => payload(await session("children", { path: { id }, query: { directory: input.directory } })),
+                    get: async (id) => {
+                        const value = payload(await session("get", { path: { id }, query: { directory: input.directory } }));
+                        const stopped = (await operators.required(root)).stoppedChildren?.includes(id);
+                        return record(value) && stopped ? { ...value, outcome: "interrupted" } : value;
+                    },
+                    children: async (id) => {
+                        try {
+                            return payload(await session("children", { path: { id }, query: { directory: input.directory } }));
+                        }
+                        catch {
+                            const run = await operators.required(root);
+                            // The cancellation acknowledgements are scoped to this exact durable run.
+                            return id === run.operatorSessionID ? run.units.flatMap(unit => unit.childSessionID ? [{ id: unit.childSessionID }] : []) : [];
+                        }
+                    },
                 }) : [];
             const dispatcher = actor === root ? undefined : { sessionID: actor, callID: mission.callID };
             const state = replanning ? await operators.replanMission(root, previous.runID, plan, dispatcher)
-                : await operators.prepareMission(root, plan, dispatcher, mission.supersededRunID, terminalChildren);
+                : await operators.prepareMission(root, plan, dispatcher, mission.supersededRunID, terminalChildren, mission.requirementsReplaced);
             await control.registerGoalDeclaration(root, state.units[0].task.prompt, true);
             control.enableUnits(root, state.units.filter(unit => unit.status === "pending").length);
             await missions.update(root, item => {
@@ -1290,7 +1377,8 @@ export function createProfiledPlugin(profile, assetVersion) {
         }
         tools[planUnits] = { description: "Coordinator (or single-unit Fast-lane Operator): declare useful units, then dispatch the returned Worker immediately. Host generates IDs, handoff, manifest and proof mapping. Keep every original requirement covered. Use write: [] for read-only verification; use dir/** for directory outputs including not-yet-created trees. Native absolute paths support global installs and external outputs under host permissions; include their actual paths in read/write for evidence. Final validation command in each unit proves that unit; read-only diagnostic commands need no registration. Recalling with reason replaces settled work within unchanged requirements and cumulative budget; include required scope extensions here. Rejected budget, contract or control-storage preparation preserves the existing run so you can correct the plan directly.",
             args: { units: { type: "array", minItems: 1, maxItems: 32, items: { type: "object", additionalProperties: false,
-                        properties: { title: { type: "string" }, objective: { type: "string" }, read: stringList, write: stringList,
+                        properties: { title: { type: "string" }, objective: { type: "string" },
+                            read: { ...stringList, description: "Inputs that affect validation, not an allowlist for observation. Do not include whole live session/database/log trees just to inspect them." }, write: stringList,
                             validation: stringList, requirement_ids: stringList }, required: ["title", "objective", "write", "validation"] } },
                 reason: { type: "string", "x-sortie-optional": true } }, execute: async (args, context) => {
                 const { root, mission } = await missionAuthority(context.sessionID);
@@ -1669,9 +1757,8 @@ export function createProfiledPlugin(profile, assetVersion) {
                     if (["read", "glob", "grep", "list", "execute", "todowrite", "todoread", "webfetch", "websearch", "skill"].includes(request.tool))
                         return;
                     if (["bash", "shell"].includes(request.tool)) {
-                        const writes = extractWritePaths(request.tool, args);
-                        if (writes.paths.length || writes.gitMutation || writes.remoteMutation)
-                            throw new Error("mission-coordinator-shell-readonly: delegate source changes to Worker");
+                        // Native shell permissions own execution. Parsing shell syntax cannot enforce read-only
+                        // behavior (interpreter bodies were already opaque); the role still delegates source edits.
                         return;
                     }
                     throw new Error("mission-coordinator-no-edit-tool");
@@ -2025,6 +2112,11 @@ export function createProfiledPlugin(profile, assetVersion) {
                 (output.system ??= []).push(`SORTIE_RUNTIME_PROFILE ${profile.id}; marker ${assetVersion}. ` +
                     `Shared MkII protocol role names are logical: ${protocolMap}. Use only ${profile.toolPrefix} tools for this profile. ` +
                     "Never rewrite user acceptance or evidence to rename protocol roles. Final acceptance belongs only to the root coordinator.");
+                if ((await identity(request.sessionID)).role === "dog-worker") {
+                    const context = await operators.workerContext(root, request.sessionID);
+                    if (context)
+                        (output.system ??= []).push(context);
+                }
                 const proposal = await proposals.read(root);
                 if (proposal?.phase !== "approved" && proposal?.proposal_session_id === request.sessionID) {
                     // Only immutable identity and the frozen budget caps belong here. Consumed counters move with
@@ -2079,6 +2171,12 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const root = await rootFor(request.sessionID);
                 if (!root)
                     return;
+                if ((await identity(request.sessionID)).role === "dog-worker") {
+                    const context = await operators.workerContext(root, request.sessionID);
+                    if (context)
+                        (output.context ??= []).push(context +
+                            " Preserve the actual edits, tool outcomes and next action in the summary; do not replace them with an empty-work claim.");
+                }
                 if ((await identity(request.sessionID)).role === "dog-operator") {
                     const mission = await missions.read(root);
                     if (mission?.coordinator === request.sessionID) {

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

@@ -31,6 +31,12 @@ export interface RuntimeBridge {
     ownsCanonicalValidation?(rootSessionID: string, unitID: string, childSessionID: string, command: string): Promise<boolean>;
     /** A mission's hash-pinned Task has already passed durable run/acceptance admission. */
     ownsMissionDispatch?(rootSessionID: string, callID: string, taskID: string): Promise<boolean>;
+    /** Durable operator dispatch identity survives adapter reload and missed after hooks. */
+    recoverMissionDispatch?(rootSessionID: string, taskID: string): Promise<{
+        callID: string;
+        childSessionID?: string;
+        cancelled: boolean;
+    } | undefined>;
     onHostHandoffRepaired?(rootSessionID: string, taskID: string, handoffPath: string, original: string, repaired: string): Promise<void>;
     allowsInvestigativeShell?(sessionID: string): Promise<boolean>;
     onSerialSettlement?(settlement: SerialDispatchSettlement): Promise<void>;

package/dist/plugin/unit-usage.d.ts

@@ -0,0 +1,2 @@
+/** Price complete native requests; absent/interrupted usage is unknown, never a fabricated zero. */
+export declare function settledUnitUsage(messages: readonly unknown[], startedAt?: string): number | null;

package/dist/plugin/unit-usage.js

@@ -0,0 +1,44 @@
+import { estimateModelUsageCost } from "./model-cost.js";
+const record = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+/** Price complete native requests; absent/interrupted usage is unknown, never a fabricated zero. */
+export function settledUnitUsage(messages, startedAt) {
+    let cost = 0, requests = 0;
+    const seen = new Set();
+    for (const message of messages) {
+        if (!record(message) || !record(message.info) || message.info.role !== "assistant")
+            continue;
+        const info = message.info;
+        if (typeof info.id !== "string" || seen.has(info.id))
+            continue;
+        seen.add(info.id);
+        const time = record(info.time) ? info.time : undefined;
+        if (startedAt) {
+            if (typeof time?.created !== "number")
+                return null;
+            if (time.created < Date.parse(startedAt))
+                continue;
+        }
+        if (typeof time?.completed !== "number")
+            return null;
+        const tokens = record(info.tokens) ? info.tokens : undefined;
+        const cache = record(tokens?.cache) ? tokens.cache : undefined;
+        if (info.error && [tokens?.input, tokens?.output, tokens?.reasoning, cache?.read, cache?.write]
+            .every(value => value === 0 || value === undefined))
+            return null;
+        const estimate = estimateModelUsageCost({
+            providerID: typeof info.providerID === "string" ? info.providerID : undefined,
+            modelID: typeof info.modelID === "string" ? info.modelID : undefined,
+            uncachedInputTokens: typeof tokens?.input === "number" ? tokens.input : undefined,
+            outputTokens: typeof tokens?.output === "number" ? tokens.output : undefined,
+            reasoningTokens: typeof tokens?.reasoning === "number" ? tokens.reasoning : undefined,
+            cacheReadTokens: typeof cache?.read === "number" ? cache.read : undefined,
+            cacheWriteTokens: typeof cache?.write === "number" ? cache.write : undefined,
+            serviceTier: typeof info.serviceTier === "string" ? info.serviceTier : undefined,
+        });
+        if (estimate.status !== "priced")
+            return null;
+        requests++;
+        cost += estimate.usd;
+    }
+    return requests ? cost : null;
+}

package/dist/plugin/v2.js

@@ -1,5 +1,5 @@
 import { SortieDogsV010Plugin } from "./profiled.js";
-import { bindMissionProgress } from "./mission-progress.js";
+import { bindMissionProgress, missionProgressReader } from "./mission-progress.js";
 import { owningServiceSessionList } from "./v2-session-history.js";
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
@@ -332,18 +332,50 @@ async function registerV2Hooks(context, hooks) {
                     return execute(value, execution);
                 const report = execution.progress;
                 let metadata = {};
-                const unbind = bindMissionProgress(String(execution.sessionID), async (progress) => {
-                    metadata = { ...metadata, ...progress };
-                    await report(metadata);
-                });
+                let pending = Promise.resolve();
+                const update = (update) => {
+                    metadata = { ...metadata, ...update };
+                    const snapshot = { ...metadata };
+                    pending = pending.catch(() => undefined).then(() => report(snapshot));
+                    return pending;
+                };
+                const unbind = bindMissionProgress(String(execution.sessionID), update);
+                const readProgress = missionProgressReader(context.location.directory, String(execution.sessionID), String(execution.id));
+                let previous = "", reading;
+                const refresh = () => {
+                    if (reading)
+                        return reading;
+                    reading = (async () => {
+                        try {
+                            const progress = await readProgress(), key = JSON.stringify(progress);
+                            if (progress && key !== previous) {
+                                await update(progress);
+                                previous = key;
+                            }
+                        }
+                        catch (error) {
+                            console.warn("[sortie-dogs-v010] mission progress unavailable", error instanceof Error ? error.message : "unknown");
+                        }
+                    })().finally(() => { reading = undefined; });
+                    return reading;
+                };
+                // The native executor is a stable snapshot. Poll only local durable state, not models or
+                // session status APIs; this also recovers progress after another plugin instance settles work.
+                const timer = setInterval(() => { void refresh(); }, 1000);
+                timer.unref();
                 try {
-                    return await execute(value, { ...execution, progress: async (update) => {
-                            metadata = { ...metadata, ...update };
-                            await report(metadata);
-                        } });
+                    await refresh();
+                    const result = await execute(value, { ...execution, progress: update });
+                    await refresh();
+                    await pending.catch(() => undefined);
+                    // Native completion replaces metadata, so retain our display fields alongside its own.
+                    return { ...result, metadata: { ...metadata, ...(record(result.metadata) ? result.metadata : {}) } };
                 }
                 finally {
+                    clearInterval(timer);
                     unbind();
+                    await reading;
+                    await pending.catch(() => undefined);
                 }
             };
         });

package/dist/runtime-mission-assets.js

@@ -39,7 +39,7 @@ ${controls(profile, ["start_mission", "plan_units", "operator_next", "operator_s
 ---
 # ${profileAgent(profile, "dog-coordinator")}
 
-You are Operator, the user-facing strategic authority. Preserve every original requirement, prohibition,
+You are Operator, the user-facing strategic authority. Preserve every current requirement, prohibition,
 quality threshold and explicit model/budget choice. Follow AGENTS.md and use the user's language.
 
 1. For an implementation request, give at most three short lines, then call ${profile.toolPrefix}start_mission
@@ -49,7 +49,10 @@ quality threshold and explicit model/budget choice. Follow AGENTS.md and use the
    the host session_move operation to its resume_location.directory and read status there; do not create
    a substitute mission in the current worktree. Multiple candidates are selected by the user's request.
    For intentionally separate work in a new location, start_mission(intent: "new") keeps other missions
-   intact and retains cumulative spend. Choose from the user's intent; no routine approval round trip.
+    intact and retains cumulative spend. Choose from the user's intent; no routine approval round trip.
+    When the user replaces a version, target, parallelism or other requirement, call start_mission with
+    intent: "replace" and the complete current requirements. The host cancels/archives the old run and
+    retains spend/results; superseded instructions are history, not additional obligations.
 2. Dispatch the returned ${profileAgent(profile, "dog-operator")} task immediately. It owns investigation,
    unit boundaries, Worker/Scout/Advisor/independent Reviewer calls, write-scope extensions and corrections
    within the original request and cumulative budget. Do not investigate or approve each unit at the root.
@@ -58,12 +61,16 @@ quality threshold and explicit model/budget choice. Follow AGENTS.md and use the
    (or the host accepted it at the evidence-gap limit, with the gaps reported), call
    ${profile.toolPrefix}complete_mission. Only its succeeded receipt authorizes DONE.
 
-Fast-lane exception: simple, low-risk, single-unit work with known files and validation may use
+Fast-lane: Simple known procedures that one Worker can complete, with known scope and meaningful validation, may use
 ${profile.toolPrefix}plan_units directly after start_mission, then dispatch its exact Worker task.
 Use title, objective, read/write file or directory scopes, and validation commands. The final command
 proves the unit; investigation commands need no registration. After success, record the low-risk review
 skip with review_mission (risk_tags: [], one concise trace per requirement), then complete_mission.
 Everything else goes through Coordinator. Unit start or a passing tiny task is never whole-task completion.
+Item count, parallelism inside an existing runner, or long duration alone do not require Coordinator.
+For example, a configured 23-case benchmark run can be one unit. A subsequent result-dependent
+reproduce/fix/PR loop needs Coordinator, which should start the known runner promptly and use actual
+results to guide the following units. Do not invent preparation units or plan-approval rounds.
 
 Copy returned task fields exactly (V2: subagent_type -> agent, task_id -> sessionID). Do not append to a
 reference prompt or name another model unless the user explicitly selected it. Preserve explicit selections.
@@ -110,10 +117,20 @@ You are Coordinator. Own most of the practical work and dispatch within the save
 Read/search and confirmation shell commands are available; source edits belong to Worker. Do not edit
 through shell. There is no proposal/approval/contract-repair round trip in this route.
 
+For release/benchmark work, resolve the package from its release receipt and hash, not a matching version
+or filename. Record the runner's own revision separately. Before repairing infrastructure on an old branch,
+check current main for an existing fix; preserve local edits and use a current-main worktree when needed.
+Report setup/route failures as such, with observed inference count, instead of calling runner exits a score.
+
 Investigate only enough to start the first useful Worker. Prefer a targeted read/reproduction over a broad
 inventory or speculative full design. Call ${profile.toolPrefix}plan_units with concise units:
 title, objective, read/write file or directory scopes, validation commands, optionally requirement_ids.
 For read-only verification, use write: []; do not invent an output file or request write access to inputs.
+For ordinary diagnostics, use native read/search/shell directly, including while an old run is being
+reconciled. Do not create a dummy validation/console.log unit just to inspect status. The read list is
+the input set whose bytes affect the unit's validation, not every directory you may inspect. Keep live
+session databases, logs and transient progress outside that proof input set unless they are the artifact
+actually being validated. Native host permissions continue to govern observation.
 Use absolute native paths for requested global installations or other external outputs; dir/** declares
 a directory including a not-yet-created tree. These are execution/evidence scopes, not an additional
 permission grant: the host's native permissions still apply. Include the actual external input/output

package/package.json

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