sortie-dogs 0.13.1 → 0.13.2

package/README.md

@@ -111,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
@@ -132,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.

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.1-quality-first-review-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.1-quality-first-review-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/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?: {
@@ -86,6 +89,17 @@ export interface MissionExecution {
         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;
@@ -96,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";
@@ -179,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[];

package/dist/core/operator-mission.js

@@ -21,9 +21,11 @@ export function missionValidationCommand(command) {
 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. */
@@ -214,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 ||
@@ -366,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}`)] : []),
@@ -383,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] ?? [];
@@ -450,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),

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

@@ -283,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. */
@@ -351,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>;

package/dist/core/operator-runtime.js

@@ -177,7 +177,7 @@ export function parseOperatorPlan(value, scopeFormat = "repository") {
     const mappingDiagnostics = [];
     for (const [unitIndex, unit] of value.units.entries()) {
         if (!record(unit) || !exactKeys(unit, ["id", "title", "objective", "read", "write", "validation", "acceptance_indices"]) ||
-            !identifier(unit.id) || ids.has(unit.id) || !text(unit.title) || !text(unit.objective) ||
+            !identifier(unit.id) || ids.has(unit.id) || !text(unit.title) || typeof unit.objective !== "string" || !unit.objective.trim() ||
             !strings(unit.read) || !strings(unit.write) || !strings(unit.validation, true))
             return planError(`/units/${unitIndex}`, "operator-unit-invalid", "operator-unit-shape");
         unit.validation.forEach((command, index) => rejectValidationAnnotation(command, `/units/${unitIndex}/validation/${index}`));
@@ -686,12 +686,12 @@ export class OperatorRuntime {
         }
     }
     /** Mission authority is supplied only by the owning profile, never by a model-authored plan. */
-    prepareMission(root, raw, dispatcher, supersededRunID, terminalChildren = [], replaceRequirements = false) {
-        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID, terminalChildren, replaceRequirements }));
+    prepareMission(root, raw, dispatcher, supersededRunID, terminalChildren = [], replaceRequirements = false, context) {
+        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, supersededRunID, terminalChildren, replaceRequirements, context }));
     }
     /** Stage a settled mission's replacement; rejected preparation never cancels the usable run. */
-    replanMission(root, runID, raw, dispatcher) {
-        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, replaceRunID: runID }));
+    replanMission(root, runID, raw, dispatcher, context) {
+        return this.serial(root, () => this.prepareOnce(root, raw, undefined, { dispatcher, replaceRunID: runID, context }));
     }
     async prepareOnce(root, raw, scopeApprovalTurnID, mission) {
         const previous = await this.read(root);
@@ -859,6 +859,7 @@ export class OperatorRuntime {
                 task: { title: unit.title, objective: unit.objective }, state: { done: [], next: [unit.title], blocked: [] }, risks: [],
                 verification: unit.validation.map(check => ({ check, status: "not_run", exit_code: null, summary: "Execute in the admitted worker." })),
                 ext: {
+                    ...(mission ? { "sortie-dogs/mission-context": { write_scope_origin: "coordinator-estimate", ...mission.context } } : {}),
                     "sortie-dogs/write-gate": { operation_manifest: manifestRelative, project_root: this.projectRoot },
                     [ACCEPTANCE_CONTINUITY_EXTENSION]: { schema_version: "0.1", authority: "dispatch", task_id: taskID,
                         criteria: plan.acceptance, fingerprint: acceptanceFingerprint,
@@ -914,23 +915,27 @@ export class OperatorRuntime {
                 throw new OperatorContractError(diagnostics);
             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}`,
+            const promptHeader = ["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}`,
-                `goal_declaration_path: ${declarationPath}`, "acceptance:", ...plan.acceptance.map(value => `  - ${value}`),
+                `handoff_path: ${handoffPath}`, `goal_declaration_path: ${declarationPath}`];
+            const commitBoundary = plan.git_lifecycle !== undefined && index === plan.units.length - 1 ? [
+                `git_post_commit_validation: ${JSON.stringify(plan.git_lifecycle.post_commit_validation)}`,
+                "Complete every source write before invoking any git_post_commit_validation command. Its first exact invocation is the host commit boundary; after it, source mutation and undeclared shell commands are denied. Run every listed command and return its real evidence.",
+            ] : [];
+            // Mission Workers already must read this host-generated handoff before binding. Preserve its
+            // verbatim objective, original requests, criteria and checks there, not in another prompt copy.
+            // Saved Tasks and non-Mission dispatch keep their existing text/identity.
+            const prompt = (mission ? [...promptHeader, "contract_reference: handoff",
+                'acceptance: handoff.ext["sortie-dogs/acceptance-continuity"].criteria', "validation: handoff.verification",
+                `unit_acceptance_indices: ${JSON.stringify(unit.acceptance_indices)}`, "",
+                "Read handoff_path once before binding. Implement task.objective; preserve the original requests, global criteria and constraints in ext, and prove this unit's assigned indices. Run verification checks exactly in order within this Task. Use supplied paths; do not reconstruct project_root. Return actual results and limitations, not whole-Mission completion.",
+                ...commitBoundary,
+            ] : [...promptHeader, "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 parent Operator or 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.",
-                ...(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
-                    ? "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 parent Operator or 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)}`,
-                    "Complete every source write before invoking any git_post_commit_validation command. Its first exact invocation is the host commit boundary; after it, source mutation and undeclared shell commands are denied. Run every listed command and return its real evidence.",
-                ] : []),
-                `unit_acceptance_indices: ${JSON.stringify(unit.acceptance_indices)}`, "", unit.objective].join("\n");
+                "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.",
+                "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.",
+                ...commitBoundary, `unit_acceptance_indices: ${JSON.stringify(unit.acceptance_indices)}`, "", unit.objective]).join("\n");
             units.push({ unit, task: { subagent_type: profileAgent(this.profile, "dog-worker"), description: unit.title, prompt },
                 handoffPath, manifestPath, hashes: [...contents.map(hash), hash(declaration)], status: "pending", callID: null,
                 childSessionID: null, evidence: [], resultClass: null, repairValidationAttempts: 0, repairValidation: null });
@@ -1521,6 +1526,50 @@ export class OperatorRuntime {
     settled(result) {
         return this.serial(result.rootSessionID, () => this.settledOnce(result));
     }
+    /** Correct an estimated Mission scope without dispatching, restarting, or reserving another unit. */
+    expandMissionWriteScope(root, child, taskID, paths, activate) {
+        return this.serial(root, async () => {
+            const state = await this.required(root);
+            const unit = state.units.find(item => /^task_id: (.+)$/m.exec(item.task.prompt)?.[1] === taskID && item.childSessionID === child);
+            if (!unit || !["running", "failed", "succeeded"].includes(unit.status) ||
+                !["running", "awaiting-decision", "awaiting-acceptance"].includes(state.phase) || !unit.callID || state.gitLifecycle) {
+                throw new Error("mission-scope-update-current-task-required");
+            }
+            await this.verifyControls(unit);
+            const write = [...new Set([...unit.unit.write, ...paths.map(normalizeExecutionScope)])];
+            for (const path of write) {
+                const scoped = relative(this.projectRoot, resolve(this.projectRoot, normalizeManifestScope(path).path)).replaceAll("\\", "/");
+                if ([".git", ...Object.values(RUNTIME_PROFILES).map(profile => profile.stateDirectory)].some(dir => scoped === dir || scoped.startsWith(`${dir}/`))) {
+                    throw new Error(`operator-control-write-forbidden:${path}`);
+                }
+            }
+            if (JSON.stringify(write) === JSON.stringify(unit.unit.write))
+                return;
+            const oldManifest = await readFile(unit.manifestPath, "utf8"), oldHandoff = await readFile(unit.handoffPath, "utf8");
+            const manifest = { ...JSON.parse(oldManifest), write };
+            const handoff = JSON.parse(oldHandoff);
+            const m = validateOperationManifestSchema(manifest), h = validateHandoffSchema(handoff);
+            if (!m.ok || !h.ok)
+                throw new Error("mission-scope-update-invalid-contract");
+            const nextManifest = JSON.stringify(manifest), nextHandoff = JSON.stringify(handoff);
+            let rollback;
+            try {
+                await writeFile(unit.manifestPath, nextManifest);
+                await writeFile(unit.handoffPath, nextHandoff);
+                rollback = await activate(manifest);
+                unit.unit = { ...unit.unit, write };
+                unit.hashes = [hash(nextHandoff), hash(nextManifest), unit.hashes[2]];
+                unit.task = { ...unit.task, prompt: unit.task.prompt.replace(/^source_manifest: .*$/mu, `source_manifest: ${write.join(", ")}`) };
+                await this.save(state);
+            }
+            catch (error) {
+                await writeFile(unit.manifestPath, oldManifest);
+                await writeFile(unit.handoffPath, oldHandoff);
+                await rollback?.();
+                throw error;
+            }
+        });
+    }
     async settledOnce(result) {
         const state = await this.read(result.rootSessionID);
         const unit = state?.units.find(item => item.callID === result.callID);

package/dist/core/scope-lease-registry.d.ts

@@ -23,6 +23,7 @@ export interface ScopeLease {
     assertHeld(): Promise<void>;
     isReleased(): Promise<boolean>;
     release(): Promise<void>;
+    replaceScope(scope: WorktreeScope): Promise<void>;
     abandon(): Promise<void>;
     close(): void;
 }

package/dist/core/scope-lease-registry.js

@@ -198,7 +198,29 @@ export class ScopeLeaseRegistry {
         return Object.freeze({
             id,
             ownerId,
-            scope: Object.freeze({ read: [...scope.read], write: [...scope.write] }),
+            get scope() { return Object.freeze({ read: [...scope.read], write: [...scope.write] }); },
+            replaceScope: (replacement) => {
+                const normalized = this.validateRequest(replacement);
+                const result = pending.then(async () => {
+                    if (!active || closing)
+                        throw new ScopeLeaseError("not-held", "Lease is not held.");
+                    await this.withLock(async (mutex) => {
+                        const state = await this.load();
+                        const held = state.leases.find(lease => lease.id === id && lease.ownerHash === ownerHash && lease.tokenHash === credentialHash);
+                        if (!held || held.expiresAt <= Date.now())
+                            throw new ScopeLeaseError("not-held", "Lease is not held.");
+                        if (state.leases.some(lease => lease.id !== id && lease.expiresAt > Date.now() && worktreeScopesConflict(normalized, lease))) {
+                            throw new ScopeLeaseError("scope-conflict", "Requested scope is already leased.");
+                        }
+                        held.read = [...normalized.read];
+                        held.write = [...normalized.write];
+                        await this.save({ ...state, revision: state.revision + 1 }, mutex);
+                        scope = normalized;
+                    });
+                });
+                pending = result.catch(() => undefined);
+                return result;
+            },
             heartbeat: () => serialized("heartbeat"),
             assertHeld: () => serialized("assert"),
             isReleased: () => this.withLock(async () => {