sortie-dogs 0.13.0 → 0.13.2

package/README.md

@@ -1,5 +1,9 @@
 # Sortie-dogs
 
+<p align="center">
+  <img src="docs/assets/sortie-dogs-logo.png" alt="Sortie-dogs logo" width="640">
+</p>
+
 **A goal-preserving, adaptive execution harness for OpenCode that optimizes cost,
 time, and proof without taking your setup over.**
 
@@ -28,6 +32,14 @@ implementation, validation, review, and model routing.
 Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md) ·
 [Testing](docs/testing.md) · [CLI testing](docs/cli-testing.md)
 
+## SWE-bench Lite: 170/300 (56.67%)
+
+The fixed **Sortie-dogs v0.12.24** harness resolved **170 of 300 SWE-bench Lite test issues** in one pass@1 campaign, with 9 empty patches and no official evaluation errors. Every instance has a frozen prediction and an inference-time trajectory. The task Workers ran `openai/gpt-6-luna-fast#max`; operator, coordinator and review roles ran `openai/gpt-6-sol#xhigh`. This is a system result, **not** a Luna-only model comparison or a Verified/full SWE-bench score.
+
+[Technical report and per-repository results](docs/benchmarks/swebench-lite-v01224-test300-2026-09-29.md) · [Public predictions, logs and trajectories](https://github.com/zufall-upon/sortie-dogs-swebench-lite-20260929)
+
+The single official 300-instance report and frozen predictions are hash-bound in the report. Confirmed inference expense was **$162.99**; a separate **$34.60** of usage has unknown pricing and is held against the campaign cap, **not** counted as known expense. Leaderboard registration and maintainer acceptance are separate from this official local evaluation.
+
 > **Beta:** v0.12.2 builds on the v0.10.23 execution engine. Runtime behavior,
 > configuration, and generated assets may still change before 1.0.
 
@@ -99,6 +111,8 @@ Official SWE-bench Lite `dev` results on the same 23 public instances:
 | 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) |
 | v0.12.19 (`24f5386` release; matched rerun) | 8 / 23 (34.8%) | 0 | Eight slots; effective $2/instance; 40-minute timeout; one inference timeout | [Official result and provenance](docs/benchmarks/swebench-v01220-operation-observability-2026-09-28.md) |
 | v0.12.20 (`628eb81` release) | 7 / 23 (30.4%) | 0 | Eight slots; effective $2/instance; 40-minute timeout | [Official result and caveat](docs/benchmarks/swebench-v01220-operation-observability-2026-09-28.md) |
+| v0.12.25 (`49eb1e4` release) | 7 / 23 (30.4%) | 0 | Eight slots; $2/instance; $30 total cap; 20-minute progress check / 40-minute hard maximum | [Comparison baseline](#v0131-dev23-2026-09-30) |
+| v0.13.1 (`d19e8be` release; 2026-09-30) | **8 / 23 (34.8%)** | 0 | Eight slots; $2/instance; $46 total cap; 20-minute progress check / 40-minute hard maximum; GPT-6.1 Sol + Luna Fast | [Run summary](#v0131-dev23-2026-09-30) |
 
 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
@@ -120,6 +134,39 @@ single run-to-run difference does not establish causation.
 
 Historical qualification references remain in [benchmark reference](docs/benchmark-reference.md).
 
+#### v0.13.1 dev23 (2026-09-30)
+
+One fresh pass@1 run and one official SWE-bench harness evaluation resolved
+**8/23**, versus **7/23** for v0.12.25. The new resolution was
+`pylint-dev__astroid-1333`; all seven previously resolved IDs were retained.
+Resolved by repository: marshmallow **2/2**, pvlib **0/5**, pydicom **2/5**,
+astroid **3/5**, pyvista **0/1**, sqlfluff **1/5**.
+
+- The scored row is the user-requested fresh run after a host restart. The
+  interrupted initial run is excluded from this score; the fresh run made one
+  attempt per instance with no inference retry.
+- The dataset revision (`6ec7bb89b9342f664a54a6e0a6ea6501d3437cc2`), public rows,
+  and all 23 official evaluation image IDs match the v0.12.25 run. Both used
+  `official-image-testbed` and sequential official scoring.
+- Operator/Coordinator/Reviewer/Advisor defaults changed to
+  `openai/gpt-6.1-sol#xhigh`. Actual task Workers remained
+  `openai/gpt-6-luna-fast#max`, observed across all 23 instances. The harness and
+  total budget also changed, so the extra resolution cannot be attributed to
+  the model change alone.
+- Inference ended with 20 normal completions, two timeouts
+  (`pvlib__pvlib-python-1154`, `sqlfluff__sqlfluff-1763`) and one agent failure
+  (`pvlib__pvlib-python-1854`). All patches, including stopped attempts, were
+  officially scored: 23 completed evaluations, zero empty patches and zero
+  official evaluation errors or infrastructure failures.
+- Known estimated inference cost: **$17.73**; separate unknown-usage hold:
+  **$1.98**, not counted as known expense. Inference wall time was about
+  **81 minutes**, followed by **7.2 minutes** of official scoring.
+- Fixed release commit: `d19e8be0d21180cc23ad2ae4b853d846a18e77bc`;
+  package SHA-256: `99300ceec0c3eee4fa1f984fed50d15d58b2ff4455df0041850ecd63514b0a51`.
+  OpenCode **2.0.20**, official harness **5.0.2**. Local evidence is retained in
+  `_testenv/swebench-v0131-dev23-20260930-r2/result-summary.json`; generated
+  predictions, databases and raw logs are not committed.
+
 ## Mission tools
 
 1. `start_mission`: Operator supplies concise requirements; the host saves original messages and returns a Coordinator task.
@@ -202,7 +249,7 @@ not invent, probe, or translate variant names.
 - `freeTierFallbackModels`: ordered global last-resort model IDs. Default:
   `opencode/deepseek-v4-flash-free`; `[]` disables this fallback.
 - `dedicatedWorkerModel`: canonical stable serial target, default
-  `openai/gpt-6-sol` / `medium`. The v0.10 profile also supplies its explicit
+  `openai/gpt-6.1-sol` / `medium`. The v0.10 profile also supplies its explicit
   role routes below; do not infer the v0.10 worker route from this stable setting.
 - `consultation.strategy`: fixed advisor identity, optional `required`, and
   positive `maxCallsPerCandidate`; default one call and not required.
@@ -239,14 +286,14 @@ or explicit risk. Workers own static, targeted, and related checks; the root own
 canonical and full-suite checks. An unchanged candidate, command, and environment
 reuse the same evidence instead of spending the validation budget again.
 
-### Default v0.12 routes
+### Default routes
 
-- `dog-operator`: `openai/gpt-6-sol` / `xhigh`
-- `dogs-coordinator`: `openai/gpt-6-sol` / `xhigh`
+- `dog-operator`: `openai/gpt-6.1-sol` / `xhigh`
+- `dogs-coordinator`: `openai/gpt-6.1-sol` / `xhigh`
 - `dog-worker-v010`: `openai/gpt-6-luna-fast` / `max`
 - `dog-scout-v010`: `openai/gpt-6-luna-fast` / `max`
-- `dog-reviewer-v010`: `openai/gpt-6-sol` / `xhigh`
-- `dog-advisor-v010`: `openai/gpt-6-sol` / `xhigh`
+- `dog-reviewer-v010`: `openai/gpt-6.1-sol` / `xhigh`
+- `dog-advisor-v010`: `openai/gpt-6.1-sol` / `xhigh`
 
 An explicit model and variant selected in OpenCode remains authoritative for that
 session. Child role defaults fill absent native settings and may be overridden by

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.13.0-fast-first-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.13.2-anko-recovery-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.13.0-fast-first-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.13.2-anko-recovery-v1";

package/dist/core/contract-limits.d.ts

@@ -1,7 +1,7 @@
 /** Common text bounds shared by handoff, manifest and goal evidence validation. */
 export declare const CONTRACT_TEXT_LIMITS: Readonly<{
     title: 160;
-    objective: 2000;
+    objective: 32768;
     statement: 1000;
     command: 8192;
     path: 512;

package/dist/core/contract-limits.js

@@ -1,2 +1,2 @@
 /** Common text bounds shared by handoff, manifest and goal evidence validation. */
-export const CONTRACT_TEXT_LIMITS = Object.freeze({ title: 160, objective: 2000, statement: 1000, command: 8192, path: 512 });
+export const CONTRACT_TEXT_LIMITS = Object.freeze({ title: 160, objective: 32768, statement: 1000, command: 8192, path: 512 });

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

@@ -39,6 +39,13 @@ export interface GoalEvidence {
         readonly candidate_paths: readonly string[];
         /** Missing on legacy evidence: retain its original all-paths snapshot recipe. */
         readonly source_policy?: "project-files-v1" | "declared-paths-v1";
+        /** Fixed when validation starts. Full manifest_hash still identifies the historical execution contract. */
+        readonly freshness?: {
+            readonly contract_hash: string;
+            readonly scratch_paths: readonly string[];
+            readonly protected_paths: readonly string[];
+            readonly environment: Readonly<Record<string, string | null>>;
+        };
     };
     readonly execution: {
         readonly command: readonly string[];

package/dist/core/goal-bound.js

@@ -64,7 +64,13 @@ export function validGoalEvidence(value, state) {
         protectedBinding.source_paths.every(text) && Array.isArray(protectedBinding.candidate_paths) &&
         protectedBinding.candidate_paths.every(text) &&
         (protectedBinding.source_policy === undefined || protectedBinding.source_policy === "project-files-v1" ||
-            protectedBinding.source_policy === "declared-paths-v1");
+            protectedBinding.source_policy === "declared-paths-v1") &&
+        (protectedBinding.freshness === undefined || (protectedBinding.freshness !== null && typeof protectedBinding.freshness === "object" &&
+            HASH.test(protectedBinding.freshness.contract_hash) &&
+            Array.isArray(protectedBinding.freshness.scratch_paths) && protectedBinding.freshness.scratch_paths.every(text) &&
+            Array.isArray(protectedBinding.freshness.protected_paths) && protectedBinding.freshness.protected_paths.every(text) &&
+            protectedBinding.freshness.environment !== null && typeof protectedBinding.freshness.environment === "object" &&
+            !Array.isArray(protectedBinding.freshness.environment) && Object.values(protectedBinding.freshness.environment).every(value => value === null || typeof value === "string")));
     const matches = criteria.length > 0 && criteria.length === value.measurement.criterion_ids.length &&
         criteria.every((criterion) => criterion.target === value.measurement.target &&
             criterion.entrypoint === value.measurement.entrypoint && criterion.workload === value.measurement.workload &&

package/dist/core/initialize.d.ts

@@ -11,7 +11,7 @@ export declare class ProjectInitializationError extends Error {
     readonly code: ProjectInitializationErrorCode;
     constructor(code: ProjectInitializationErrorCode, message: string, options?: ErrorOptions);
 }
-export declare const V010_COORDINATOR_MODEL = "openai/gpt-6-sol#xhigh";
+export declare const V010_COORDINATOR_MODEL = "openai/gpt-6.1-sol#xhigh";
 /**
  * Report a user config that routes the v0.10 Coordinator away from its packaged model. Measured Luna
  * Coordinators repeated plans and review dispatches until timeout, so init surfaces it without editing it.

package/dist/core/initialize.js

@@ -542,7 +542,7 @@ async function initializeRoot(requestedRoot, layout, installAssets = runtimeAsse
         preservedLegacyPaths,
     };
 }
-export const V010_COORDINATOR_MODEL = "openai/gpt-6-sol#xhigh";
+export const V010_COORDINATOR_MODEL = "openai/gpt-6.1-sol#xhigh";
 /**
  * Report a user config that routes the v0.10 Coordinator away from its packaged model. Measured Luna
  * Coordinators repeated plans and review dispatches until timeout, so init surfaces it without editing it.

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

@@ -19,6 +19,7 @@ export interface MissionEvidenceExcerpt {
 export interface MissionReviewScope {
     read: string[];
     write: string[];
+    validationBindings?: NonNullable<import("./goal-bound.js").GoalEvidence["protected_binding"]>[];
 }
 export interface MissionConsultation {
     id: string;
@@ -47,7 +48,9 @@ export interface MissionAttempt {
     status: "pending" | "dispatched" | "succeeded" | "failed" | "cancelled" | "unconfirmed";
     callID?: string;
     childSessionID?: string;
+    dispatchFingerprint?: string;
     nativeOutcome?: "completed" | "failed" | "unknown";
+    terminal?: import("../plugin/runtime-bridge.js").MissionWorkerTerminalRecord;
     observedModel?: string;
     observedVariant?: string;
     failure?: {
@@ -80,11 +83,23 @@ export interface MissionExecution {
         startedAt: string;
         completedAt?: string;
         exit?: number;
-        status?: "completed" | "error";
+        status?: "running" | "completed" | "error";
+        shellID?: string;
         outcome?: "not-started" | "execution-failed" | "executed";
         result?: Record<string, unknown>;
     }[];
 }
+export interface MissionLaunchConditions {
+    entrypoint?: string;
+    inputs?: string[];
+    timeout_seconds?: number;
+    cost_limit_usd?: number;
+    benchmark_attempts?: number;
+    grading?: "none" | "official";
+    source: string;
+    applies_to: string;
+    recordedAt?: string;
+}
 export interface OperatorMission {
     version: "0.12";
     id: string;
@@ -95,10 +110,14 @@ export interface OperatorMission {
     kind?: "implementation" | "operation";
     /** Native shell observations of the requested operation, separate from auxiliary checks. */
     execution?: MissionExecution;
+    /** Fixed benchmark conditions and their provenance, separate from internal Worker counters. */
+    launchConditions?: MissionLaunchConditions[];
     requirements: {
         id: string;
         text: string;
     }[];
+    /** Explicit user path prohibitions, unlike the Coordinator's estimated write list. */
+    prohibitedWrite?: string[];
     /** The current user intentionally replaced the predecessor's requirements. */
     requirementsReplaced?: boolean;
     phase: "open" | "running" | "submitted" | "completed" | "cancelled";
@@ -141,15 +160,10 @@ export interface OperatorMission {
         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. */
+        /** Observed evidence-only reviews; reporting only, never an acceptance threshold. */
         evidenceGapReviews?: number;
     };
 }
-/**
- * Evidence-only findings do not establish a defect. Each extra round costs a full Reviewer pass and often a
- * Worker unit, so after this many evidence-only reviews the candidate may be submitted with the gaps listed.
- */
-export declare const MISSION_EVIDENCE_GAP_REVIEW_LIMIT = 2;
 export declare const MISSION_CONSULTATION_LIMIT = 32;
 /** Review coverage survives a narrower replan; it is not a Worker write grant. */
 export declare function missionReviewScope(previous: MissionReviewScope | undefined, ...runs: OperatorState[]): MissionReviewScope;
@@ -183,6 +197,7 @@ export declare class OperatorMissionRuntime {
     read(root: string): Promise<OperatorMission | undefined>;
     required(root: string): Promise<OperatorMission>;
     capture(root: string, request: MissionRequest): Promise<void>;
+    recordLaunchConditions(root: string, raw: unknown): Promise<OperatorMission>;
     start(root: string, requirements: unknown, replaceRequirements?: boolean, options?: {
         kind?: OperatorMission["kind"];
         context?: MissionContext[];
@@ -217,5 +232,5 @@ export declare function missionPlan(mission: OperatorMission, raw: unknown): Ope
 export declare function missionPacket(mission: OperatorMission, run?: OperatorState): Record<string, unknown>;
 /** Models forward a short capability, never recopy the host's evidence hashes and source packet. */
 export declare function missionReviewTask(mission: OperatorMission): OperatorTask;
-/** Project grouped R-ID traces, including consecutive ranges, into the existing per-criterion mapping. */
-export declare function missionReviewTraces(mission: OperatorMission, raw: unknown): string[];
+/** Optional implementation notes supplement host-observed source/checks; prose is not a coverage gate. */
+export declare function missionReviewTraces(_mission: OperatorMission, raw: unknown): string[];

package/dist/core/operator-mission.js

@@ -18,17 +18,14 @@ export function missionValidationCommand(command) {
     const expression = `exec(${JSON.stringify(heredoc[4])})`;
     return `${heredoc[1]} -c '${expression.replaceAll("'", "'\\''")}'`;
 }
-/**
- * Evidence-only findings do not establish a defect. Each extra round costs a full Reviewer pass and often a
- * Worker unit, so after this many evidence-only reviews the candidate may be submitted with the gaps listed.
- */
-export const MISSION_EVIDENCE_GAP_REVIEW_LIMIT = 2;
 export const MISSION_CONSULTATION_LIMIT = 32;
 /** Review coverage survives a narrower replan; it is not a Worker write grant. */
 export function missionReviewScope(previous, ...runs) {
+    const bindings = [...(previous?.validationBindings ?? []), ...runs.flatMap(run => run.units.flatMap(unit => (unit.evidence ?? []).flatMap(proof => proof.protected_binding?.freshness ? [proof.protected_binding] : [])))];
     return {
         read: [...new Set([...(previous?.read ?? []), ...runs.flatMap(run => run.units.flatMap(({ unit }) => unit.read ?? []))])].sort(),
         write: [...new Set([...(previous?.write ?? []), ...runs.flatMap(run => run.units.flatMap(({ unit }) => unit.write))])].sort(),
+        ...(bindings.length ? { validationBindings: [...new Map(bindings.map(binding => [JSON.stringify(binding), binding])).values()] } : {}),
     };
 }
 /** Classify an independent Reviewer's first line. Anything else is a finding. */
@@ -38,7 +35,7 @@ export function missionReviewVerdict(text) {
 /** Whether the recorded review permits submission and acceptance of the current candidate. */
 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);
+        review.verdict === "evidence-gaps";
 }
 export function missionExecutionStatus(mission) {
     if (mission.kind !== "operation")
@@ -219,6 +216,24 @@ export class OperatorMissionRuntime {
             }
         });
     }
+    recordLaunchConditions(root, raw) {
+        if (!record(raw) || typeof raw.source !== "string" || !raw.source.trim() || typeof raw.applies_to !== "string" || !raw.applies_to.trim() ||
+            (raw.entrypoint !== undefined && (typeof raw.entrypoint !== "string" || !raw.entrypoint.trim())) ||
+            (raw.inputs !== undefined && (!Array.isArray(raw.inputs) || !raw.inputs.every(path => typeof path === "string" && path.trim()))) ||
+            ["timeout_seconds", "cost_limit_usd", "benchmark_attempts"].some(key => raw[key] !== undefined &&
+                (typeof raw[key] !== "number" || !Number.isFinite(raw[key]) || raw[key] <= 0)) ||
+            (raw.benchmark_attempts !== undefined && !Number.isSafeInteger(raw.benchmark_attempts)) ||
+            (raw.grading !== undefined && !["none", "official"].includes(String(raw.grading))) ||
+            Object.keys(raw).some(key => !["entrypoint", "inputs", "timeout_seconds", "cost_limit_usd", "benchmark_attempts", "grading", "source", "applies_to"].includes(key))) {
+            throw new Error("mission-launch-conditions-invalid");
+        }
+        return this.update(root, state => {
+            state.launchConditions ??= [];
+            if (state.launchConditions.some(item => { const { recordedAt: _at, ...value } = item; return JSON.stringify(value) === JSON.stringify(raw); }))
+                return;
+            state.launchConditions.push({ ...raw, recordedAt: new Date().toISOString() });
+        });
+    }
     start(root, requirements, replaceRequirements = false, options = {}) {
         return this.serial(root, async () => {
             if (!Array.isArray(requirements) || requirements.length === 0 || requirements.length > 64 ||
@@ -371,6 +386,8 @@ 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}`),
+            `Confirmed launch conditions (fixed limits, not consumption or remaining budget): ${JSON.stringify(state.launchConditions ?? [])}`,
+            `Explicit user write prohibitions: ${JSON.stringify(state.prohibitedWrite ?? [])}`,
             `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}`)] : []),
@@ -388,7 +405,7 @@ export function missionPlan(mission, raw) {
         const line = (field) => {
             if (typeof value[field] !== "string" || !value[field].trim())
                 throw new Error(`mission-unit-${index + 1}: ${field} required`);
-            return value[field].replace(/[\r\n]+/gu, " ");
+            return field === "objective" ? value[field] : value[field].replace(/[\r\n]+/gu, " ");
         };
         const paths = (field) => {
             const entries = value[field] ?? [];
@@ -455,6 +472,8 @@ export function missionPacket(mission, run) {
                 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}`),
+        launch_conditions: mission.launchConditions ?? [], prohibited_write: mission.prohibitedWrite ?? [],
+        accounting_scope: "Worker units are not benchmark attempts. Host budget is Worker-only; orchestration, Review and external campaign costs are excluded. Launch caps are fixed conditions, not a known campaign remainder.",
         submission: mission.submission, progress: mission.progress, consultations: mission.consultations ?? [],
         attempts: mission.attempts ?? [], ...(mission.rescue ? { rescue: mission.rescue } : {}),
         operation: { kind: mission.kind ?? "implementation", status: missionExecutionStatus(mission),
@@ -469,7 +488,7 @@ export function missionPacket(mission, run) {
             run_id: mission.review.runID, current_run: currentReview,
             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,
+            evidence_gaps_advisory: true, accepted: reviewAccepted,
             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,
@@ -482,21 +501,21 @@ export function missionPacket(mission, run) {
         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"
                 ? "Operator: compare the submitted candidate with the original requirements and actual evidence, then complete_mission if satisfied. Report remaining evidence gaps; they are not a review PASS."
-                : run?.phase === "awaiting-decision" ? (run.units.some(unit => unit.dispatchDenial)
-                    ? "Coordinator: inspect units[].dispatch_denial before changing the plan. Correct only its diagnosed cause; do not repeat an unchanged refused Task or replan for a host-state mismatch. Report an unresolved runtime mismatch with the loaded runtime identity; preserve requirements and cumulative spend."
-                    : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && !unit.normalRemediationUsed)
-                        ? "Coordinator: one exact declared validation failed. Reconcile the returned Worker and cumulative budget, then call retry_mission_unit once for that unit before replanning. This preserves the same scope and acceptance."
-                        : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && unit.normalRemediationUsed && !unit.terminalRescue)
-                            ? "Coordinator: the one ordinary remediation failed the declared validation again. If its native terminal, writer release, exact candidate and cumulative budget permit, call rescue_mission_unit once; inspect and report a non_rescue reason, then continue ordinary correction within budget. Rescue does not bypass validation, review or root acceptance."
-                            : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
-                    : 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."
+                : mission.kind === "operation" && operationStatus === "running"
+                    ? "The declared operation is already running. Inspect its native shell/progress; do not start another Worker or run. Wait for a terminal result, or report the existing run as blocked if its completion cannot be observed."
+                    : run?.phase === "awaiting-decision" ? (run.units.some(unit => unit.dispatchDenial)
+                        ? "Coordinator: inspect units[].dispatch_denial before changing the plan. Correct only its diagnosed cause; do not repeat an unchanged refused Task or replan for a host-state mismatch. Report an unresolved runtime mismatch with the loaded runtime identity; preserve requirements and cumulative spend."
+                        : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && !unit.normalRemediationUsed)
+                            ? "Coordinator: one exact declared validation failed. Reconcile the returned Worker and cumulative budget, then call retry_mission_unit once for that unit before replanning. This preserves the same scope and acceptance."
+                            : run.units.some(unit => unit.status === "failed" && unit.resultClass === "acceptance" && unit.failure?.outcome === "fail" && unit.normalRemediationUsed && !unit.terminalRescue)
+                                ? "Coordinator: the one ordinary remediation failed the declared validation again. If its native terminal, writer release, exact candidate and cumulative budget permit, call rescue_mission_unit once; inspect and report a non_rescue reason, then continue ordinary correction within budget. Rescue does not bypass validation, review or root acceptance."
+                                : "Coordinator: correct the cause and call plan_units with the remaining work and all requirements; budget is cumulative.")
+                        : 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" ? (reviewAccepted
+                                ? "Coordinator: review permits submission. Retain advisory review notes; do not repeat passed validation or review for evidence formatting. Operator performs final acceptance against the original requirements."
                                 : "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." };
+                                : "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) {
@@ -506,35 +525,12 @@ export function missionReviewTask(mission) {
     return { ...review.task, prompt: `${MISSION_REVIEW_REFERENCE}${JSON.stringify({ r: mission.root,
             m: mission.id, n: review.runID, h: digest(review.task.prompt) })}` };
 }
-/** Project grouped R-ID traces, including consecutive ranges, into the existing per-criterion mapping. */
-export function missionReviewTraces(mission, raw) {
-    if (!Array.isArray(raw) || raw.length === 0 || !raw.every(item => typeof item === "string" && item.trim())) {
-        throw new Error("mission-review-traces: supply concise implementation/test traces");
+/** Optional implementation notes supplement host-observed source/checks; prose is not a coverage gate. */
+export function missionReviewTraces(_mission, raw) {
+    if (raw === undefined)
+        return [];
+    if (!Array.isArray(raw) || !raw.every(item => typeof item === "string")) {
+        throw new Error("mission-review-traces: optional notes must be strings");
     }
-    const grouped = raw.map(text => ({ text,
-        ids: [...text.matchAll(/(?:^|[.;]\s+|[\r\n])\s*((?:R\d+\s*[-/,]?\s*)+):/gu)]
-            .flatMap(match => [...match[1].matchAll(/R(\d+)(?:\s*-\s*R(\d+))?/gu)]
-            .flatMap(([, first, last]) => {
-            const firstID = `R${first}`;
-            if (last === undefined)
-                return [firstID];
-            const lastID = `R${last}`;
-            const start = mission.requirements.findIndex(item => item.id === firstID);
-            const end = mission.requirements.findIndex(item => item.id === lastID);
-            if (start < 0 || end < 0)
-                return [firstID, lastID];
-            if (start > end)
-                throw new Error(`mission-review-traces: descending range ${firstID}-${lastID}`);
-            return mission.requirements.slice(start, end + 1).map(item => item.id);
-        })) }));
-    if (grouped.every(item => item.ids.length === 0) && raw.length === mission.requirements.length)
-        return raw;
-    const unknown = grouped.flatMap(item => item.ids).filter(id => !mission.requirements.some(requirement => requirement.id === id));
-    const missing = mission.requirements.filter(requirement => !grouped.some(item => item.ids.includes(requirement.id)));
-    if (unknown.length || missing.length)
-        throw new Error(`mission-review-traces: name the existing R IDs; ${[
-            ...(missing.length ? [`missing ${missing.map(item => item.id).join(", ")}`] : []),
-            ...(unknown.length ? [`unknown ${unknown.join(", ")}`] : []),
-        ].join("; ")}`);
-    return mission.requirements.map(requirement => grouped.filter(item => item.ids.includes(requirement.id)).map(item => item.text).join("\n"));
+    return raw.map(text => text.trim()).filter(Boolean);
 }

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

@@ -227,6 +227,22 @@ export interface OperatorState {
     decision: string | null;
     receipt: GoalTerminalReceipt | null;
 }
+export interface OperatorProgress {
+    readonly profile: string;
+    readonly view: "progress";
+    readonly run_id: string;
+    readonly stage: OperatorPhase;
+    readonly decision: string | null;
+    readonly current_unit: {
+        readonly id: string;
+        readonly title: string;
+        readonly status: UnitState["status"];
+    } | null;
+    readonly completed_units: number;
+    readonly total_units: number;
+    readonly budget_remaining_units: number | null;
+    readonly next_action: string | null;
+}
 /** A later mission may replace an unexecuted cancellation, but must retain settled work's acceptance. */
 export declare function cancelledMissionRetainsAcceptance(state: OperatorState): boolean;
 export declare function operatorGitPathAuthorized(path: string, scopes: readonly string[], platform?: NodeJS.Platform): boolean;
@@ -267,12 +283,12 @@ export declare class OperatorRuntime {
     prepareMission(root: string, raw: unknown, dispatcher?: {
         sessionID: string;
         callID: string;
-    }, supersededRunID?: string, terminalChildren?: readonly string[], replaceRequirements?: boolean): Promise<OperatorState>;
+    }, supersededRunID?: string, terminalChildren?: readonly string[], replaceRequirements?: boolean, context?: Record<string, unknown>): 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;
         callID: string;
-    }): Promise<OperatorState>;
+    }, context?: Record<string, unknown>): Promise<OperatorState>;
     private prepareOnce;
     operatorTask(state: OperatorState): OperatorTask;
     /** Root-visible handle for the bounded operations delegate; its contract stays host-internal. */
@@ -335,6 +351,8 @@ export declare class OperatorRuntime {
     operatorRejected(root: string): Promise<OperatorState>;
     private operatorRejectedOnce;
     settled(result: SerialDispatchSettlement): Promise<void>;
+    /** Correct an estimated Mission scope without dispatching, restarting, or reserving another unit. */
+    expandMissionWriteScope(root: string, child: string, taskID: string, paths: readonly string[], activate: (manifest: import("./types.js").OperationManifest) => Promise<() => Promise<void>>): Promise<void>;
     private settledOnce;
     /** One ordinary same-scope Mission retry before any optional model Rescue is considered. */
     prepareMissionNormalRemediation(root: string, runID: string, unitID: string): Promise<OperatorState>;
@@ -371,10 +389,13 @@ export declare class OperatorRuntime {
     draftStatus(root: string): Promise<unknown | undefined>;
     completionGoalFingerprint(state: OperatorState): Promise<string>;
     verifyContinuityControls(state: OperatorState): Promise<void>;
+    /** Compact, read-only projection of the same durable run and decision as the complete packet. */
+    progress(state: OperatorState, budgetRemainingUnits: number | null, nextAction?: string | null): OperatorProgress;
     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 continuationNextAction;
     private controlReference;
     private verifyControls;
     /** Follow only the host's authorized parent-link repair; keep the durable control pin in sync. */