sortie-dogs 0.12.15 → 0.12.17

package/README.md

@@ -87,19 +87,29 @@ goal; preserving quality while reducing unnecessary expensive work is.
 
 ### SWE-bench evaluation
 
-A frozen Sortie-dogs v0.10.14 build was evaluated on 23 fixed tasks.
-
-- Official verifier PASS: 6 / 23
-- Scored FAIL: 17 / 23
-- Infrastructure blocked: 0 / 23
-- Total estimated model cost: $15.75
-- Median agent runtime: 15.2 min
-
-The same Sortie-dogs candidate, model routes, budgets, tools, and verification
-procedure were held fixed for all tasks. This is one frozen evaluation, not a
-general success-rate claim.
-
-Full methodology and per-task results: [benchmark details](docs/benchmark-v0.10.14-dev23.md)
+Official SWE-bench Lite `dev` results on the same 23 public instances:
+
+| Candidate / benchmark adapter | Official resolved | Empty patches | Run conditions | Details |
+| --- | ---: | ---: | --- | --- |
+| v0.10.6 candidate (`859c396`) | 4 / 23 (17.4%) | 5 | Four inference slots | [Handoff](docs/swebench-handoff-2026-09-21.md) |
+| Frozen v0.10.14 build | 6 / 23 (26.1%) | — | Four slots; $1.50/task | [Per-task results](docs/benchmark-v0.10.14-dev23.md) |
+| v0.12.8 (`e0f8cef` adapter) | 5 / 23 (21.7%) | 9 | Four slots; budget amended across two batches; 30-minute timeout | [Campaign](docs/swebench-v0128-dev23-2026-09-26.md) |
+| v0.12.8 (`84ccdf1` main adapter) | 6 / 23 (26.1%) | 2 | Fresh 23-task run; four slots; 30-minute timeout | [Main-integrated run](docs/swebench-main-84ccdf1-dev23-2026-09-26.md) |
+| v0.12.15 (`0c9690d`) | 5 / 23 (21.7%) | 3 | Fresh 23-task ext4 retry; four slots; 40-minute timeout | [Campaign](docs/swebench-v01215-dev23-2026-09-27.md) |
+| v0.12.16 (`9b05a34` release; `b1a6c0e` runner) | 4 / 23 (17.4%) | 5 | Fresh 23-task run; eight slots; 40-minute timeout | [Campaign](docs/swebench-v01216-dev23-2026-09-27.md) |
+
+Every row has 23 submitted official predictions; an empty patch counts against
+the score, not as a missing evaluation. The v0.10.14 report does not separately
+summarize empty patches. The v0.12.15 row is the separately approved fresh
+run after an initial `/tmp` quota failure, not an additional score for that
+failed attempt. Inference completion is **not** official resolution.
+Budgets, runtime/adapter versions, and execution conditions changed between
+campaigns, so this table is a history of observed results, not a controlled
+head-to-head comparison or a general success-rate claim. The v0.10.14 run
+estimated $15.75 in model cost and a 15.2-minute median agent runtime.
+The v0.12.16 run is the first eight-slot inference score in this table;
+five runners timed out, and this does not establish a model-quality regression
+against runs with different concurrency and conditions.
 
 Historical qualification references remain in [benchmark reference](docs/benchmark-reference.md).
 

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.15-review-lineage-model-gauges-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.17-review-cost-paths-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.15-review-lineage-model-gauges-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.17-review-cost-paths-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;
@@ -24,6 +53,8 @@ export interface OperatorMission {
     callID: string | null;
     dispatchOpen: boolean;
     runID: string | null;
+    /** Git HEAD before this mission's first implementation unit, retained across replans and commits. */
+    reviewBaseline?: string;
     /** A cancelled run replaced by a later real user turn; never reuse its acceptance or evidence. */
     supersededRunID?: string;
     plans: number;
@@ -42,6 +73,7 @@ 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;
@@ -61,6 +93,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;
@@ -78,7 +119,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,
@@ -228,8 +283,10 @@ export class OperatorMissionRuntime {
         return this.update(root, state => {
             const expected = this.task(state);
             const resume = state.coordinator !== null && args.task_id === state.coordinator && typeof args.prompt === "string" && args.prompt.trim();
+            // The description is a presentation label. The opaque prompt binds the original request and
+            // requirements; changing only the label must not force a second Coordinator dispatch.
             if (["cancelled", "completed"].includes(state.phase) || state.dispatchOpen || args.subagent_type !== expected.subagent_type ||
-                (!resume && (args.prompt !== expected.prompt || args.description !== expected.description || args.task_id))) {
+                (!resume && (args.prompt !== expected.prompt || args.task_id))) {
                 const reason = ["cancelled", "completed"].includes(state.phase) ? `mission is ${state.phase}`
                     : state.dispatchOpen ? "Coordinator Task is still admitted; read operator_status to reconcile its native completion"
                         : args.task_id && args.task_id !== state.coordinator ? `this location owns Coordinator ${state.coordinator ?? "not yet claimed"}, not ${String(args.task_id)}`
@@ -267,6 +324,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 +349,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 +398,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 +419,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 +432,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.d.ts

@@ -343,6 +343,7 @@ export declare class OperatorRuntime {
     /** 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 controlReference;
     private verifyControls;
     /** Follow only the host's authorized parent-link repair; keep the durable control pin in sync. */
     acknowledgeHostHandoffRepair(root: string, taskID: string, path: string, original: string, repaired: string): Promise<void>;

package/dist/core/operator-runtime.js

@@ -910,14 +910,16 @@ export class OperatorRuntime {
             const contents = [JSON.stringify(handoff), JSON.stringify(manifest)];
             controls.push({ path: handoffPath, content: contents[0] }, { path: manifestPath, content: contents[1] });
             const prompt = ["role: implementation", `task_id: ${taskID}`, `project_root: ${this.projectRoot}`,
-                `source_manifest: ${(unit.write.length ? unit.write : unit.read).join(", ") || "none"}`, `operation_manifest: ${manifestRelative}`, `handoff_path: ${handoffPath}`,
+                `source_manifest: ${(unit.write.length ? unit.write : unit.read).join(", ") || "none"}`, `operation_manifest: ${manifestRelative}`,
+                `handoff_path: ${handoffPath}`,
                 `goal_declaration_path: ${declarationPath}`, "acceptance:", ...plan.acceptance.map(value => `  - ${value}`),
                 "validation:", ...unit.validation.map(value => `  - ${value}`),
+                ...(mission ? ["Read handoff_path and other repository files using their project-relative paths as supplied. The native working directory is project_root; do not prepend or reconstruct its absolute path for read/search/shell. Copy project_root only when binding the write gate. Preserve explicitly declared external paths."] : []),
                 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)}`,
@@ -1930,12 +1932,12 @@ export class OperatorRuntime {
         // 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,
+            project_root: this.projectRoot, handoff_path: this.controlReference(unit.handoffPath), operation_manifest: this.controlReference(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. " +
+            "A missing path in a summary does not mean the handoff is missing. Read the retained handoff/manifest using these project-relative paths without prepending project_root, 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.";
     }
@@ -1961,6 +1963,11 @@ export class OperatorRuntime {
                                 ? `call ${this.profile.toolPrefix}operator_status and execute its prepare_operator next_action in this turn; do not stop after reporting status`
                                 : `call ${this.profile.toolPrefix}operator_status and execute its exact next_action in this turn; do not stop after reporting status` });
     }
+    controlReference(path) {
+        const local = relative(this.projectRoot, path);
+        return local === ".." || local.startsWith(`..${sep}`) || isAbsolute(local)
+            ? path : local.replaceAll("\\", "/");
+    }
     async verifyControls(unit) {
         if (!isAbsolute(unit.handoffPath) || !isAbsolute(unit.manifestPath))
             throw new Error("operator-control-path-invalid");

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,6 +1,7 @@
 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";
+export declare function missionReviewBaseline(directory: string): Promise<string | undefined>;
 /** 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. */
@@ -9,7 +10,7 @@ export declare function completedMissionReviewPrompts(mission: OperatorMission |
     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[], baseline?: string): Promise<{
     fingerprint: string;
     excerpt: string;
 }>;