sortie-dogs 0.12.14 → 0.12.16

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.14-worker-context-progress-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.16-operation-efficiency-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.14-worker-context-progress-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.16-operation-efficiency-v1";

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

@@ -8,11 +8,40 @@ export interface MissionRequest {
     id: string;
     text: string;
 }
+export interface MissionContext extends MissionRequest {
+    role: "user" | "assistant";
+}
+export interface MissionEvidenceExcerpt {
+    path: string;
+    offset: number;
+    limit: number;
+}
+export interface MissionExecution {
+    commands: string[];
+    directory: string;
+    observations: {
+        command: string;
+        directory: string;
+        callID: string;
+        sessionID: string;
+        startedAt: string;
+        completedAt?: string;
+        exit?: number;
+        status?: "completed" | "error";
+        outcome?: "not-started" | "execution-failed" | "executed";
+        result?: Record<string, unknown>;
+    }[];
+}
 export interface OperatorMission {
     version: "0.12";
     id: string;
     root: string;
     requests: MissionRequest[];
+    /** Prior public conversation context, not additional immutable requirements. */
+    context?: MissionContext[];
+    kind?: "implementation" | "operation";
+    /** Native shell observations of the requested operation, separate from auxiliary checks. */
+    execution?: MissionExecution;
     requirements: {
         id: string;
         text: string;
@@ -42,10 +71,13 @@ export interface OperatorMission {
         risk: string[];
         source: string;
         task: OperatorTask | null;
+        evidence?: MissionEvidenceExcerpt[];
         requestFingerprint?: string;
         verdict: "pending" | "PASS" | "findings" | "evidence-gaps" | "skipped-low-risk";
         result?: string;
         child?: string;
+        /** Completed, independent initial review for this mission, not merely an inherited child ID. */
+        initialPrompt?: string;
         /** Reviews on this mission that found only missing evidence; bounded by MISSION_EVIDENCE_GAP_REVIEW_LIMIT. */
         evidenceGapReviews?: number;
     };
@@ -59,6 +91,15 @@ export declare const MISSION_EVIDENCE_GAP_REVIEW_LIMIT = 2;
 export declare function missionReviewVerdict(text: string): "PASS" | "evidence-gaps" | "findings";
 /** Whether the recorded review permits submission and acceptance of the current candidate. */
 export declare function missionReviewAccepted(review: NonNullable<OperatorMission["review"]>): boolean;
+export declare function missionExecutionStatus(mission: OperatorMission): "not-required" | "not-started" | "running" | "execution-failed" | "executed";
+/** Observe the command's own terminal summary, never Worker/Reviewer prose. Scores are result data,
+ * not process success. Unstructured commands retain their native exit semantics. */
+export declare function missionCommandOutcome(output: unknown, exit: unknown, status: unknown): {
+    outcome: "not-started" | "execution-failed" | "executed";
+    result?: Record<string, unknown>;
+};
+/** Bounded public text only: tool logs and private reasoning are not delegation context. */
+export declare function missionConversationContext(messages: readonly Record<string, unknown>[]): MissionContext[];
 /** Durable user intent and dispatch ownership. Execution/evidence still belong to the v0.10 engine. */
 export declare class OperatorMissionRuntime {
     readonly projectRoot: string;
@@ -76,7 +117,10 @@ 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, replaceRequirements?: boolean): Promise<OperatorMission>;
+    start(root: string, requirements: unknown, replaceRequirements?: boolean, options?: {
+        kind?: OperatorMission["kind"];
+        context?: MissionContext[];
+    }): 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

@@ -32,6 +32,57 @@ export function missionReviewAccepted(review) {
     return review.verdict === "PASS" || review.verdict === "skipped-low-risk" ||
         (review.verdict === "evidence-gaps" && (review.evidenceGapReviews ?? 0) >= MISSION_EVIDENCE_GAP_REVIEW_LIMIT);
 }
+export function missionExecutionStatus(mission) {
+    if (mission.kind !== "operation")
+        return "not-required";
+    const execution = mission.execution;
+    if (!execution || execution.observations.length === 0)
+        return "not-started";
+    const latest = execution.commands.map(command => [...execution.observations].reverse().find(item => item.command === command && item.directory === execution.directory));
+    if (latest.some(item => item && !item.completedAt))
+        return "running";
+    if (latest.some(item => item?.outcome === "execution-failed" || (item && (item.status === "error" || item.exit !== 0))))
+        return "execution-failed";
+    return latest.every(item => item?.outcome === "executed") ? "executed" : "not-started";
+}
+/** Observe the command's own terminal summary, never Worker/Reviewer prose. Scores are result data,
+ * not process success. Unstructured commands retain their native exit semantics. */
+export function missionCommandOutcome(output, exit, status) {
+    const text = typeof output === "string" ? output.trim() : "";
+    let result;
+    for (const value of [text, ...text.split(/\r?\n/u).reverse().slice(0, 8)]) {
+        try {
+            const parsed = JSON.parse(value);
+            if (record(parsed)) {
+                result = parsed;
+                break;
+            }
+        }
+        catch { /* not a JSON summary */ }
+    }
+    const state = String(result?.status ?? "").toLowerCase().replaceAll("_", "-");
+    const summary = result ? Object.fromEntries(["status", "attempts", "launches", "inference_count", "reward", "score", "session_id", "exit"]
+        .filter(key => Object.hasOwn(result, key)).map(key => [key, result[key]])) : undefined;
+    const outcome = ["no-start", "not-started", "prepared", "preflight"].includes(state) || text === "NO_START" ||
+        [result?.attempts, result?.launches, result?.inference_count].some(value => value === 0) ? "not-started"
+        : status === "error" || exit !== 0 || ["execution-failed", "setup-failed", "route-failed"].includes(state)
+            ? "execution-failed" : "executed";
+    return { outcome, ...(summary ? { result: summary } : {}) };
+}
+/** Bounded public text only: tool logs and private reasoning are not delegation context. */
+export function missionConversationContext(messages) {
+    const entries = messages.flatMap(message => {
+        const info = record(message.info) ? message.info : message;
+        if ((info.role !== "user" && info.role !== "assistant") || typeof info.id !== "string" || !Array.isArray(message.parts))
+            return [];
+        const text = message.parts.filter(record).filter(part => part.type === "text" && part.synthetic !== true && typeof part.text === "string")
+            .map(part => part.text).join("\n");
+        return text.trim() ? [{ id: info.id, role: info.role, text: text.slice(0, 4_000) }] : [];
+    });
+    // Keep the last two user exchanges, including the current request, rather than the last N tools.
+    const users = entries.flatMap((entry, i) => entry.role === "user" ? [i] : []);
+    return entries.slice(users.at(-2) ?? 0).slice(-8);
+}
 /** Durable user intent and dispatch ownership. Execution/evidence still belong to the v0.10 engine. */
 export class OperatorMissionRuntime {
     projectRoot;
@@ -160,7 +211,7 @@ export class OperatorMissionRuntime {
             }
         });
     }
-    start(root, requirements, replaceRequirements = false) {
+    start(root, requirements, replaceRequirements = false, options = {}) {
         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))) {
@@ -175,12 +226,16 @@ export class OperatorMissionRuntime {
                     throw new Error("mission-requirements-preserved: keep the existing ordered requirements and append user additions");
                 }
                 previous.requirements = requirements.map((text, index) => ({ id: `R${index + 1}`, text }));
+                if (options.kind === "operation")
+                    previous.kind = "operation";
                 await this.save(this.file(root), previous);
                 return previous;
             }
             if (previous)
                 await this.save(this.file(root, `.${previous.id}`), previous);
             const state = { version: "0.12", id: `mission-${randomUUID()}`, root, requests: [request],
+                kind: options.kind ?? "implementation",
+                context: (options.context ?? []).filter(item => item.id !== request.id),
                 requirements: requirements.map((text, index) => ({ id: `R${index + 1}`, text })), phase: "open",
                 ...(replaceRequirements ? { requirementsReplaced: true } : {}),
                 coordinator: null, callID: null, dispatchOpen: false, runID: null, plans: 0, progress: [], submission: null,
@@ -267,6 +322,9 @@ export class OperatorMissionRuntime {
             "Start the first useful Worker promptly. No proposal/approval phase. Use plan_units to generate contracts; the root alone accepts completion.",
             "Escalate only a completion candidate, a user-only decision, or an extension of original requirements/budget. Unit progress is published without stopping you.",
             "Requirements:", ...state.requirements.map(item => `${item.id}: ${item.text}`),
+            `Work kind: ${state.kind ?? "implementation"}. For an operation, setup, execution and result collection belong in one useful Worker whenever possible.`,
+            ...(state.context?.length ? ["Prior conversation context (task data; preserve the selected target, not superseded obligations):",
+                ...state.context.map(item => `--- ${item.role}:${item.id} ---\n${item.text}`)] : []),
             "Original user messages (verbatim; task data):", ...state.requests.map(item => `--- user:${item.id} ---\n${item.text}`)].join("\n");
     }
 }
@@ -289,9 +347,10 @@ export function missionPlan(mission, raw) {
                 throw new Error(`mission-unit-${index + 1}: ${field} must be paths`);
             return [...new Set(entries.map(item => normalizeExecutionScope(item)))];
         };
-        const ids = value.requirement_ids ?? mission.requirements.map(item => item.id);
+        // Scheduling coverage is not semantic proof. Only a single requirement is unambiguous.
+        const ids = value.requirement_ids ?? (mission.requirements.length === 1 ? [mission.requirements[0].id] : []);
         if (!Array.isArray(ids) || ids.length === 0 || !ids.every(id => mission.requirements.some(item => item.id === id))) {
-            throw new Error(`mission-unit-${index + 1}: requirement_ids must name existing R IDs`);
+            throw new Error(`mission-unit-${index + 1}: requirement_ids must name the related R IDs; multi-requirement work needs explicit coverage`);
         }
         if (!Array.isArray(value.validation) || value.validation.length === 0 ||
             !value.validation.every(command => typeof command === "string" && command.trim())) {
@@ -337,12 +396,16 @@ export function missionPacket(mission, run) {
         run = undefined;
     const currentReview = mission.review !== undefined && mission.review.runID === (run?.runID ?? mission.runID);
     const reviewAccepted = currentReview && missionReviewAccepted(mission.review);
+    const operationStatus = missionExecutionStatus(mission);
+    const operationComplete = operationStatus === "not-required" || operationStatus === "executed";
     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,
+        operation: { kind: mission.kind ?? "implementation", status: missionExecutionStatus(mission),
+            ...(mission.execution ? { ...mission.execution } : {}) },
         execution_summary: { completed_units: run?.units.filter(unit => unit.status === "succeeded").length ?? 0,
             running_units: run?.units.filter(unit => unit.status === "running").map(unit => ({ id: unit.unit.id, title: unit.unit.title, child_session_id: unit.childSessionID })) ?? [],
             pending_units: run?.units.filter(unit => unit.status === "pending").length ?? 0,
@@ -354,7 +417,7 @@ export function missionPacket(mission, run) {
             source_fingerprint: mission.review.source, reviewer_session_id: mission.review.child ?? null,
             result: mission.review.result ?? null, evidence_gap_reviews: mission.review.evidenceGapReviews ?? 0,
             evidence_gap_review_limit: MISSION_EVIDENCE_GAP_REVIEW_LIMIT, accepted: reviewAccepted,
-            passed: currentReview && mission.review.verdict === "PASS", permits_submission: reviewAccepted } : null,
+            passed: currentReview && mission.review.verdict === "PASS", permits_submission: reviewAccepted && operationComplete } : null,
         ...(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,
@@ -367,12 +430,14 @@ export function missionPacket(mission, run) {
                 : run?.phase === "awaiting-decision" ? (run.units.some(unit => unit.dispatchDenial)
                     ? "Coordinator: inspect units[].dispatch_denial before changing the plan. Correct only its diagnosed cause; do not repeat an unchanged refused Task or replan for a host-state mismatch. Report an unresolved runtime mismatch with the loaded runtime identity; preserve requirements and cumulative spend."
                     : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
-                    : run?.phase === "awaiting-acceptance" ? (currentReview && mission.review?.verdict === "evidence-gaps" && !reviewAccepted
-                        ? "Coordinator: the Reviewer found only missing evidence. Supply it through review_mission traces (or at most one evidence-only unit) and re-review once; do not re-implement. At the evidence-gap limit, submit_mission ready with the gaps listed."
-                        : reviewAccepted
-                            ? "Coordinator: review permits submission. Submit the candidate with any remaining gaps; do not repeat passed validation or review. Operator performs final acceptance."
-                            : "Coordinator: address recorded findings or obtain the required independent review, then submit_mission. Operator compares all requirements with source/evidence before complete_mission.")
-                        : "Coordinator: continue the next useful unit within original requirements. Return only a completion candidate, user-only decision, or scope/budget extension." };
+                    : run?.phase === "awaiting-acceptance" && !operationComplete
+                        ? `Requested operation is ${operationStatus}. Continue the actual operation or report its blocker; auxiliary checks and review disposition cannot complete it.`
+                        : run?.phase === "awaiting-acceptance" ? (currentReview && mission.review?.verdict === "evidence-gaps" && !reviewAccepted
+                            ? "Coordinator: the Reviewer found only missing evidence. Supply focused original-file excerpts through review_mission evidence and traces; do not re-implement. At the evidence-gap limit, review ends with the gaps listed, not with execution proof."
+                            : reviewAccepted
+                                ? "Coordinator: review permits submission. Submit the candidate with any remaining gaps; do not repeat passed validation or review. Operator performs final acceptance."
+                                : "Coordinator: address recorded findings or obtain the required independent review, then submit_mission. Operator compares all requirements with source/evidence before complete_mission.")
+                            : "Coordinator: continue the next useful unit within original requirements. Return only a completion candidate, user-only decision, or scope/budget extension." };
 }
 /** Models forward a short capability, never recopy the host's evidence hashes and source packet. */
 export function missionReviewTask(mission) {

package/dist/core/operator-runtime.js

@@ -915,9 +915,9 @@ export class OperatorRuntime {
                 "validation:", ...unit.validation.map(value => `  - ${value}`),
                 mission ? "Read-only investigation commands are unrestricted. Use shell to reproduce and diagnose without asking for command registration. Keep all writes, including generated/transient outputs and cleanup, inside unit.write. Run formal validation exactly as listed, in order and in separate calls, so the host records its real result. If a write scope or formal check must change, return the precise change to your Coordinator; it can extend/redeclare immediately within the original requirements. Diagnostic success is not formal acceptance evidence."
                     : "Execute validation in its declared order. Earlier entries may be approved generator, build, formatter, or exact cleanup commands required before canonical criterion tests. Every persistent or transient generator output must be declared in unit.write. Cleanup may remove only declared unit.write outputs and must be an explicit ordered command after generation and before post-commit or canonical validation; never add an ignore rule or remove an undeclared path. If any necessary command, input, output, or cleanup is missing, do not run an undeclared command or variant and do not use resume evidence tooling to invent permission; return a contract-repair decision.",
-                "Preserve existing public API success and error return semantics unless acceptance explicitly changes them, and cover those compatibility boundaries in the declared validation.",
+                ...(mission ? [] : ["Preserve existing public API success and error return semantics unless acceptance explicitly changes them, and cover those compatibility boundaries in the declared validation."]),
                 mission
-                    ? "Do not spawn nested subagents for consultation. Required technical or user decisions that must precede implementation belong to the root before dispatch; use the confirmed decisions and evidence declared in the unit objective and inputs. If a required prior decision is missing, return the exact contract gap to the parent instead of implementing dependent changes, inventing consent, or asking the user to repeat an already recorded decision. Independent SourceReview is a separate post-implementation and post-validation review: do not require it before implementation or formal validation, and do not stop this Task solely because it has not yet occurred. Complete the assigned implementation and all listed formal validation commands, then return the real evidence so the Coordinator can dispatch the independent review_mission with applicable risk_tags (for example, public-logic). Do not conduct or delegate that independent review yourself. Reflect supplied prior Reviewer FINDINGS within this unit's scope."
+                    ? "Complete the assigned work and listed validation within this Task. For a known operation, proceed through setup, execution and result collection; preparation alone is not execution. Preserve existing public behavior when changing source. Do not spawn nested subagents. The Coordinator handles any applicable independent review after your return; review is not a prerequisite to execution. Return actual results, including failed or not-started operations, and any exact contract correction needed."
                     : "Do not spawn nested subagents for consultation. Required consultations belong to the root before dispatch; use the confirmed decisions and evidence declared in the unit objective and inputs. If required consultation results or user decisions are missing, return the exact contract gap to the parent instead of attempting a deeper Task, inventing consent, or asking the user to repeat an already recorded decision.",
                 ...(plan.git_lifecycle !== undefined && index === plan.units.length - 1 ? [
                     `git_post_commit_validation: ${JSON.stringify(plan.git_lifecycle.post_commit_validation)}`,

package/dist/plugin/fast-lane.js

@@ -28,6 +28,10 @@ function lineValue(prompt, key) {
     const values = [...prompt.matchAll(new RegExp(`^\\s*${escapedKey}\\s*:\\s*(.+?)\\s*$`, "gmu"))];
     return values.length === 1 ? values[0][1] : undefined;
 }
+/** Keep an unambiguous, known Strategy trigger when Japanese sentence punctuation joins its prose. */
+function normalizeAdvisorPrompt(prompt) {
+    return prompt.replace(/^([ \t]*strategy_trigger[ \t]*:[ \t]*(?:architecture-choice|cross-boundary-tradeoff|material-uncertainty))[。．][ \t]*(?=\S)/mu, "$1\n");
+}
 function hasReviewEvidence(prompt) {
     if (lineValue(prompt, "canonical_validation_exit") !== "0")
         return false;
@@ -416,13 +420,17 @@ export class FastLaneController {
             return;
         }
         if (role === "dog-advisor") {
-            const trigger = lineValue(prompt, "strategy_trigger");
+            const normalized = normalizeAdvisorPrompt(prompt);
+            const trigger = lineValue(normalized, "strategy_trigger");
             if (trigger === undefined || !STRATEGY_TRIGGER_SET.has(trigger)) {
                 const error = new FastLaneDeniedError("ADVISOR_TRIGGER_REQUIRED");
-                error.message += `; required: strategy_trigger: <${STRATEGY_TRIGGERS.join(" | ")}>; repair the request header, not runtime policy`;
+                error.message += `; required: strategy_trigger: <${STRATEGY_TRIGGERS.join(" | ")}> on its own line; ` +
+                    "correct this Task header and redispatch the same consultation before proceeding, not runtime policy";
                 throw error;
             }
-            const basis = fallbackBasis(prompt);
+            if (normalized !== prompt)
+                args.prompt = normalized;
+            const basis = fallbackBasis(normalized);
             const dispatches = state.advisorRequests.get(basis) ?? 0;
             const retry = lineValue(prompt, "fallback_retry");
             if ((dispatches === 0 && retry !== undefined) || (dispatches === 1 && retry !== "true")) {

package/dist/plugin/index.js

@@ -51,7 +51,7 @@ import { collectRunMetrics, createSortieResult, createGoalReport, insertRunMetri
 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 { operationInputSnapshot, 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 };
@@ -1477,10 +1477,15 @@ export const SortieDogsPlugin = async (input, options) => {
                 }
             }
         }
+        const mission = await new OperatorMissionRuntime(input.directory, runtimeProfile).read(root);
+        const operationInputs = mission?.kind === "operation" && mission.execution?.commands.includes(rawCommand) &&
+            resolve(input.directory, typeof args?.workdir === "string" ? args.workdir : ".") === mission.execution.directory
+            ? await operationInputSnapshot(authorization.projectRoot, snapshot.binding).catch(() => undefined) : undefined;
         hostGoalExecutions.set(toolInput.callID, { root, projectRoot: authorization.projectRoot,
             sessionID: toolInput.sessionID,
             callID: toolInput.callID, tool: toolInput.tool, command: [rawCommand], startedAt: new Date().toISOString(),
             binding: snapshot.binding, source: snapshot.source, candidate: snapshot.candidate,
+            ...(operationInputs === undefined ? {} : { operationInputs }),
             owner: validation?.request.owner ?? "worker", validation,
             ...(reusedEvidence === undefined ? {} : { reusedEvidence }) });
     }
@@ -1508,10 +1513,11 @@ export const SortieDogsPlugin = async (input, options) => {
             ? new Date(timing.start).toISOString() : execution.startedAt;
         const endedAt = typeof timing?.end === "number" && Number.isFinite(timing.end)
             ? new Date(timing.end).toISOString() : new Date().toISOString();
-        // The candidate is expected to change during a valid implementation task (the goal fixture
-        // itself is a declared write). Protect the source snapshot across the task, then bind evidence
-        // to the post-task candidate snapshot instead of rejecting the genuine mutation.
-        const fresh = refreshed !== undefined && refreshed.source === execution.source;
+        // Existing operations produce declared outputs. Preserve their read-only inputs during execution,
+        // then bind ordinary evidence to all post-operation bytes, including those outputs.
+        const fresh = refreshed !== undefined && (execution.operationInputs === undefined
+            ? refreshed.source === execution.source
+            : await operationInputSnapshot(execution.projectRoot, execution.binding).catch(() => undefined) === execution.operationInputs);
         const immutableRef = outcome === undefined || execution.reusedEvidence !== undefined ? undefined : goalFingerprint({ root: execution.root,
             child_session_id: execution.sessionID, call_id: execution.callID, command: execution.command,
             started_at: observedStartedAt, ended_at: endedAt, exit_code: exitCode ?? null, outcome,
@@ -4770,6 +4776,7 @@ export const SortieDogsPlugin = async (input, options) => {
                 remedy: "No write-gate state changed after one retry; stop this candidate and record the local blocker.",
             },
         };
+        let conflicts = [];
         const deny = (reason, defects = []) => {
             const detail = remedies[reason] ?? {
                 recoverable: false,
@@ -4798,6 +4805,7 @@ export const SortieDogsPlugin = async (input, options) => {
                 reason,
                 ...detail,
                 ...(reported.length === 0 ? {} : { defects: reported }),
+                ...(reason === "manifest-overlap" && conflicts.length ? { conflicts } : {}),
                 escalation,
             });
         };
@@ -4884,10 +4892,23 @@ export const SortieDogsPlugin = async (input, options) => {
             if (diagnostics.some(({ severity }) => severity === "error") ||
                 inspectionFingerprint(handoffValidation.value, diagnostics, validation.value) !== inspectedEntry.fingerprint)
                 return denyHandoffMismatch(handoffValue, contractDefects(diagnostics));
-            const conflictsWithActiveAuthorization = (writeScopes, readScopes) => [...sessionAuthorizations.entries()].some(([ownerSessionID, authorization]) => ownerSessionID !== sessionID && !authorization.suspended &&
-                (writeScopesOverlap(writeScopes, authorization.writeScopes) ||
-                    writeScopesOverlap(writeScopes, authorization.readScopes) ||
-                    writeScopesOverlap(readScopes, authorization.writeScopes)));
+            const conflictsWithActiveAuthorization = (writeScopes, readScopes) => {
+                conflicts = [];
+                for (const [ownerSessionID, authorization] of sessionAuthorizations) {
+                    if (ownerSessionID === sessionID || authorization.suspended)
+                        continue;
+                    for (const [requested, held, access] of [[writeScopes, authorization.writeScopes, "write/write"],
+                        [writeScopes, authorization.readScopes, "write/read"], [readScopes, authorization.writeScopes, "read/write"]]) {
+                        for (const left of requested)
+                            for (const right of held) {
+                                if (conflicts.length < 8 && writeScopesOverlap([left], [right])) {
+                                    conflicts.push({ session_id: ownerSessionID, requested: left, held: right, access });
+                                }
+                            }
+                    }
+                }
+                return conflicts.length > 0;
+            };
             const acquireDurableLease = async (readScopes, writeScopes) => {
                 if (activeSessions.get(sessionID)?.parallel !== "valid")
                     return undefined;
@@ -5103,7 +5124,7 @@ export const SortieDogsPlugin = async (input, options) => {
         for (const [sessionID, state] of activeSessions) {
             if (state.expiresAt > now)
                 continue;
-            if (state.inFlightCalls.size > 0)
+            if (state.inFlightCalls.size > 0 || childHasInFlightParentTask(sessionID))
                 state.expiresAt = now + ACTIVE_SESSION_CACHE.ttlMilliseconds;
             else
                 expireSession(sessionID);
@@ -5116,7 +5137,7 @@ export const SortieDogsPlugin = async (input, options) => {
         for (const [sessionID, state] of coordinatorRoots) {
             if (state.expiresAt > now)
                 continue;
-            const hasInFlightChild = [...sessionRoots.entries()].some(([childID, rootID]) => rootID === sessionID && (activeSessions.get(childID)?.inFlightCalls.size ?? 0) > 0);
+            const hasInFlightChild = [...sessionRoots.entries()].some(([childID, rootID]) => rootID === sessionID && ((activeSessions.get(childID)?.inFlightCalls.size ?? 0) > 0 || childHasInFlightParentTask(childID)));
             if (hasInFlightChild)
                 state.expiresAt = now + ACTIVE_SESSION_CACHE.ttlMilliseconds;
             else {
@@ -6565,6 +6586,8 @@ export const SortieDogsPlugin = async (input, options) => {
                     diagnosis.accepting = false;
                     diagnosisCalls.delete(toolInput.callID ?? "");
                 }
+                const returnedMissionWorker = completedChildSessionID !== undefined &&
+                    await input.runtimeBridge?.allowsInvestigativeShell?.(completedChildSessionID);
                 parallelCalls.delete(toolInput.callID ?? "");
                 activeSessions.get(toolInput.sessionID ?? "")?.inFlightCalls.delete(toolInput.callID ?? "");
                 if (coordinatorTaskFinished && diagnosis === undefined) {
@@ -6584,6 +6607,12 @@ export const SortieDogsPlugin = async (input, options) => {
                     evictSession(completedChildSessionID);
                     void childLifecycles.get(completedChildSessionID)?.check();
                 }
+                else if (completedChildSessionID !== undefined && activeSessions.get(completedChildSessionID)?.parallel !== "valid" &&
+                    returnedMissionWorker) {
+                    // Keep same-worker recovery identity, but a returned serial Task must not keep a live
+                    // write reservation. Rebinding the retained manifest reacquires it before any later write.
+                    await releaseWriteGate(completedChildSessionID);
+                }
             }
         },
         "tool.execute.before": async (toolInput, output) => {

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

@@ -1,13 +1,15 @@
 import type { OperatorState } from "../core/operator-runtime.js";
-import { type OperatorMission } from "../core/operator-mission.js";
+import { type MissionEvidenceExcerpt, type OperatorMission } from "../core/operator-mission.js";
 import { type RuntimeProfile } from "../core/runtime-profile.js";
+/** A child ID alone cannot establish the initial phase after a restart or failed dispatch. */
+export declare function initialMissionReviewPrompt(mission: OperatorMission, prompts: readonly string[]): string | undefined;
 /** Recover from native completion records, never from the pending review's inherited child ID. */
 export declare function completedMissionReviewPrompts(mission: OperatorMission | undefined, profile: RuntimeProfile, root: string, requestedPrompt: string, host: {
     get(id: string): Promise<unknown>;
     messages(id: string): Promise<readonly Record<string, unknown>[]>;
 }): Promise<string[]>;
 /** Pin all scoped tracked/untracked source bytes, including deletions; display a bounded excerpt only. */
-export declare function missionReviewSource(directory: string, run: OperatorState): Promise<{
+export declare function missionReviewSource(directory: string, run: OperatorState, evidence?: readonly MissionEvidenceExcerpt[]): Promise<{
     fingerprint: string;
     excerpt: string;
 }>;

package/dist/plugin/mission-review.js

@@ -2,8 +2,9 @@ import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
 import { createReadStream } from "node:fs";
 import { lstat, readlink } from "node:fs/promises";
-import { isAbsolute, relative, resolve } from "node:path";
+import { isAbsolute, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
+import { createInterface } from "node:readline";
 import { TOOL_ENVIRONMENT } from "../runtime-mission-assets.js";
 import { MISSION_REVIEW_REFERENCE } from "../core/operator-mission.js";
 import { canonicalAgent } from "../core/runtime-profile.js";
@@ -12,11 +13,21 @@ import { normalizeManifestScope } from "../core/path.js";
 import { declaredArtifacts } from "./declared-artifacts.js";
 const exec = promisify(execFile);
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** A child ID alone cannot establish the initial phase after a restart or failed dispatch. */
+export function initialMissionReviewPrompt(mission, prompts) {
+    return [mission.review?.initialPrompt, ...prompts].find(prompt => typeof prompt === "string" &&
+        prompt.startsWith(`candidate_id: ${mission.id}\n`) && /^review_phase: initial$/mu.test(prompt) &&
+        /^canonical_validation_exit: 0$/mu.test(prompt));
+}
 /** Recover from native completion records, never from the pending review's inherited child ID. */
 export async function completedMissionReviewPrompts(mission, profile, root, requestedPrompt, host) {
     if (!mission || mission.root !== root || !mission.coordinator || ["completed", "cancelled"].includes(mission.phase) ||
         mission.review?.task?.prompt !== requestedPrompt)
         return [];
+    // The completion hook has already bound this prompt to a real independent Reviewer child.
+    // Avoid a second V2 history read when its page/list API is temporarily unavailable.
+    if (initialMissionReviewPrompt(mission, []))
+        return [mission.review.initialPrompt];
     const coordinator = await host.get(mission.coordinator);
     if (!record(coordinator) || coordinator.parentID !== root || canonicalAgent(profile, coordinator.agent) !== "dog-operator")
         return [];
@@ -75,12 +86,38 @@ export async function completedMissionReviewPrompts(mission, profile, root, requ
     return prompts;
 }
 /** Pin all scoped tracked/untracked source bytes, including deletions; display a bounded excerpt only. */
-export async function missionReviewSource(directory, run) {
+export async function missionReviewSource(directory, run, evidence = []) {
     const hash = createHash("sha256").update(JSON.stringify(run.units.map(unit => ({ unit: unit.unit, hashes: unit.hashes }))));
+    let selected = "";
+    for (const entry of evidence) {
+        const absolute = resolve(directory, entry.path);
+        const allowed = run.units.flatMap(unit => [...unit.unit.read, ...unit.unit.write]).some(scope => {
+            const root = resolve(directory, scope === "." ? scope : normalizeManifestScope(scope).path), rest = relative(root, absolute);
+            return rest === "" || (rest !== ".." && !rest.startsWith(`..${sep}`) && !isAbsolute(rest));
+        });
+        if (!allowed || !Number.isSafeInteger(entry.offset) || entry.offset < 1 ||
+            !Number.isSafeInteger(entry.limit) || entry.limit < 1 || entry.limit > 200)
+            throw new Error("mission-review-evidence: select up to 200 lines from a declared input/output");
+        const info = await lstat(absolute);
+        if (!info.isFile())
+            throw new Error("mission-review-evidence: select a regular file");
+        hash.update(JSON.stringify(entry)).update(String(info.size));
+        const stream = createReadStream(absolute);
+        stream.on("data", chunk => hash.update(chunk));
+        const lines = createInterface({ input: stream, crlfDelay: Infinity });
+        selected += `\n--- evidence: ${entry.path}:${entry.offset} ---\n`;
+        let number = 0;
+        for await (const line of lines) {
+            number++;
+            if (number >= entry.offset && number < entry.offset + entry.limit && Buffer.byteLength(selected) < 12_000) {
+                selected += `${number}: ${line.slice(0, 2_000)}\n`;
+            }
+        }
+    }
     const writes = [...new Set(run.units.flatMap(unit => unit.unit.write).map(path => path === "." ? path : normalizeManifestScope(path).path))];
     if (writes.length === 0)
         return { fingerprint: `sha256:${hash.digest("hex")}`,
-            excerpt: "[Read-only units: no declared output files. Review the supplied observations, traces and validation evidence.]" };
+            excerpt: selected + "[Read-only units: no declared output files. Review the supplied observations, traces and validation evidence.]" };
     // The shared dependency environment is local tooling, never reviewed or pinned source.
     const external = [], local = [];
     for (const path of writes) {
@@ -99,8 +136,9 @@ export async function missionReviewSource(directory, run) {
     const ignored = local.length ? await git(["ls-files", "-z", "--others", "--ignored", "--exclude-standard", "--", ...scopes]) : "";
     for (const path of ignored.split("\0").filter(Boolean))
         untracked.add(path);
-    let excerpt = local.length ? await git(["diff", "--no-ext-diff", "--no-textconv", "HEAD", "--", ...scopes]).catch(() => git(["diff", "--no-ext-diff", "--no-textconv", "--", ...scopes])) : "";
-    const unchanged = excerpt.length === 0;
+    const diff = local.length ? await git(["diff", "--no-ext-diff", "--no-textconv", "HEAD", "--", ...scopes]).catch(() => git(["diff", "--no-ext-diff", "--no-textconv", "--", ...scopes])) : "";
+    const unchanged = diff.length === 0;
+    let excerpt = selected + diff;
     const paths = [...new Set([...names.split("\0"), ...ignored.split("\0")].filter(Boolean))].sort();
     const omitted = [];
     for (const path of paths) {