sortie-dogs 0.10.0 → 0.10.1

package/README.md

@@ -70,7 +70,7 @@ bounded implementation, canonical validation, and evidence-backed completion.
 
 Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md) · [テスト実行](docs/testing.md) · [CLI testing](docs/cli-testing.md)
 
-Release: [v0.10.0](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.10.0)
+Release: [v0.10.1](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.10.1)
 
 ## Latest local benchmark case study
 
@@ -88,31 +88,38 @@ Run configuration was fixed per product configuration:
   children on `openai/gpt-5.6-sol` / `medium`, with the pinned Sortie package and runtime assets.
   No Luna, Astra, or Opus messages were observed in these trials.
 
-| Metric · one frozen task | Bare OpenCode | Sortie v0.9.12 | Sortie v0.10.0 clean qualification |
-| --- | ---: | ---: | ---: |
-| Attempts needed | 3 | 5 | 1 |
-| Completed runs compared | 3 | 3 | 1 |
-| Verified PASS | 0/3 | 0/3 | 0/1 |
-| Task checks · F2P | 11.1% · 3/27 | 85.2% · 23/27 | 88.9% · 8/9 |
-| Retained checks · P2P | 282/282 | 282/282 | 94/94 |
-| Median agent wall | 24.5 min | 25.7 min | 29.9 min · n=1 |
-| Median model steps | 43 | 39 | 33 · CLI stream only |
-| Implementation child sessions · total | 0 | 13 | 4 |
-| Estimated API-equivalent cost · median completed run | $3.53 | $2.85 | **$3.94** · n=1 |
-| Estimated cost · completed runs | $10.69 | $9.74 | **$3.94** |
-| Additional interrupted-attempt cost | $0 | $6.20 | $0 |
-| Total cost to acquire completed runs | $10.69 | $15.94 | **$3.94** |
+| Metric · one frozen task | Bare OpenCode | Sortie v0.9.12 | Sortie v0.10.1 RC qualification |
+| --- | ---: | ---: | ---: |
+| Attempts needed | 3 | 5 | 1 |
+| Completed runs compared | 3 | 3 | 1 |
+| Verified PASS | 0/3 | 0/3 | 0/1 |
+| Task checks · F2P | 11.1% · 3/27 | 85.2% · 23/27 | 88.9% · 8/9 |
+| Retained checks · P2P | 282/282 | 282/282 | 94/94 |
+| Median agent wall | 24.5 min | 25.7 min | 23.2 min · n=1 |
+| Median model steps | 43 | 39 | 41 · CLI stream only |
+| Implementation child sessions · total | 0 | 13 | 3 |
+| Estimated API-equivalent cost · median completed run | $3.53 | $2.85 | **$4.48** · n=1 |
+| Estimated cost · completed runs | $10.69 | $9.74 | **$4.48** |
+| Additional interrupted-attempt cost · same fixed snapshot | $0 | $6.20 | $0 |
+| Total cost to acquire completed runs · same fixed snapshot | $10.69 | $15.94 | **$4.48** |
 
 All three Bare runs passed 1/9 task checks. The three completed Sortie runs passed 7/9, 8/9,
 and 8/9. Every compared candidate retained 94/94 prior checks, but every official verifier still
 returned reward 0. The two interrupted Sortie attempts are excluded from completed-run quality,
 time, and cost aggregates; their attempt count and estimated cost remain visible above.
 
-The v0.10 value is a standalone qualification-only reference, not a fourth matched run or a
-FrontierHarness leaderboard result. It used no fresh Bare control and a localized Docker-free
-verifier. Its estimated API-equivalent cost is **$3.94**: $3.26 from Sol and $0.68 from Terra,
-calculated from the root and descendant session tokens with 100% pricing coverage. A preceding
-debug run returned reward 1 (F2P 9/9, P2P 94/94), so that pass is not presented as reproducible.
+The v0.10.1 RC value is a standalone qualification-only reference, not a fourth matched run or a
+FrontierHarness leaderboard result. It used no fresh Bare control and a localized Docker-free
+verifier. The RC label identifies an unreleased working-tree snapshot; its packed metadata remained
+`0.10.0`, fixed by package SHA-256 `67582ee023c3bd57813262e292c067a3f90f30d61c01d8caf6f91f09ae78f61d`.
+
+Its estimated API-equivalent cost is **$4.478613**: $3.23 Sol and $1.25 Terra when rounded to cents.
+The audit prices all root and descendant assistant messages: 84 priced requests, 4,215,698 tokens,
+100% pricing coverage, and no unpriced requests. It uses the product's 2026-09-14 Standard schedule
+per request, including cached input, reasoning as output, and the long-context rate band. The earlier
+delivery-incomplete run used a different packed source snapshot, so it is not folded into this RC's
+same-snapshot acquisition cost. Historical Bare and v0.9.12 costs retain their 2026-07-30 schedule;
+their cost cells are not same-rate comparisons with this RC estimate.
 
 ![Latest local case study: Bare completed 11.1 percent of task checks at a median estimated API-equivalent cost of $3.53; Sortie completed 85.2 percent at $2.85. Sortie needed five attempts and $15.94 to collect three completed runs. Neither configuration achieved a Verified PASS.](docs/assets/quality-cost-reference.svg)
 

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.10.0-v0912-language4-cost-rpt10-compaction-ref1-proposal1-review-remediation1-surface3";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.10.0-v0912-language4-cost-rpt10-compaction-ref1-proposal1-review-remediation1-surface3-proposal-recovery2-quality1";
 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.10.0-v0912-language4-cost-rpt10-compaction-ref1-proposal1-review-remediation1-surface3";
+export const V010_RUNTIME_ASSET_VERSION = "0.10.0-v0912-language4-cost-rpt10-compaction-ref1-proposal1-review-remediation1-surface3-proposal-recovery2-quality1";

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

@@ -95,6 +95,9 @@ export declare class OperatorProposalRuntime {
     readonly projectRoot: string;
     constructor(projectRoot: string, profile: RuntimeProfile);
     private file;
+    private spendFile;
+    private readSpend;
+    private saveSpend;
     read(root: string): Promise<OperatorProposalState | undefined>;
     private readUnlocked;
     private save;
@@ -117,9 +120,16 @@ export declare class OperatorProposalRuntime {
     accountRead(root: string, actor: string, path?: string): Promise<OperatorProposalState>;
     private accountReadUnlocked;
     submit(root: string, actor: string, raw: unknown): Promise<OperatorProposalState>;
+    submitJSON(root: string, actor: string, source: string): Promise<OperatorProposalState>;
     private submitUnlocked;
     approve(root: string, raw: unknown, commit?: boolean): Promise<OperatorProposalState>;
     private approveUnlocked;
+    /**
+     * Release a pre-approval proposal grant on explicit root cancellation. Without this the root holds an
+     * immutable investigating intent whose admitted child can no longer bind, so no retry path exists at all.
+     * An approved proposal is already connected to the execution lane and stays durable.
+     */
+    discardPreApproval(root: string): Promise<OperatorProposalState | undefined>;
     required(root: string): Promise<OperatorProposalState>;
     assertExecutionApproved(root: string, planHash: string): Promise<void>;
     private requiredUnlocked;

package/dist/core/operator-proposal.js

@@ -120,23 +120,63 @@ function parseIntent(value) {
 function parsePacket(value, state) {
     if (Buffer.byteLength(JSON.stringify(value)) > 128 * 1024)
         throw new Error("operator-proposal-too-large");
-    if (!record(value) || !exact(value, ["schema_version", "revision", "coverage", "existing_surface", "uncovered", "negative_handling", "read_scope", "write_scope", "budget_estimate", "plan"])) {
-        return proposalError("/", "operator-proposal-invalid", "proposal-fields");
-    }
-    if (value.schema_version !== "0.1")
-        return proposalError("/schema_version", "operator-proposal-invalid", "schema-version", { repair_paths: ["/schema_version"] });
-    if (!Number.isSafeInteger(value.revision) || value.revision < 1) {
-        return proposalError("/revision", "operator-proposal-revision-invalid", "positive-integer", { repair_paths: ["/revision"], expected: "positive-integer", actual_type: jsonType(value.revision) });
-    }
-    if (!Array.isArray(value.coverage) || !Array.isArray(value.uncovered) || !Array.isArray(value.negative_handling) ||
-        !Array.isArray(value.read_scope) || !value.read_scope.every(normalizedRelativePath) ||
-        !Array.isArray(value.write_scope) || !value.write_scope.every(normalizedRelativePath) || !record(value.budget_estimate) ||
-        !exact(value.budget_estimate, ["proposal_reads", "execution_units"]) || !Number.isSafeInteger(value.budget_estimate.proposal_reads) || !Number.isSafeInteger(value.budget_estimate.execution_units)) {
-        return proposalError("/", "operator-proposal-invalid", "proposal-fields");
+    if (!record(value))
+        return proposalError("/", "operator-proposal-invalid", "object", { expected: "object", actual_type: jsonType(value) });
+    const diagnostics = [];
+    const invalid = (pointer, rule, expected, actual, code = "operator-proposal-invalid") => {
+        diagnostics.push({ document: "proposal", pointer, code, rule, repair_kind: "repair-field",
+            repair_paths: [pointer], expected, actual_type: jsonType(actual) });
+    };
+    const fields = ["schema_version", "revision", "coverage", "existing_surface", "uncovered", "negative_handling", "read_scope", "write_scope", "budget_estimate", "plan"];
+    for (const key of Object.keys(value).filter(key => !fields.includes(key)).sort()) {
+        invalid(`/${pointerToken(key)}`, "unknown-field", "remove-unknown-field", value[key]);
+    }
+    for (const key of fields)
+        if (!Object.hasOwn(value, key))
+            invalid(`/${key}`, "required", "required-field", undefined);
+    if (Object.hasOwn(value, "schema_version") && value.schema_version !== "0.1") {
+        invalid("/schema_version", "schema-version", 'literal-"0.1"', value.schema_version);
+    }
+    if (Object.hasOwn(value, "revision") && (!Number.isSafeInteger(value.revision) || value.revision < 1)) {
+        invalid("/revision", "positive-integer", "positive-integer", value.revision, "operator-proposal-revision-invalid");
+    }
+    for (const key of ["coverage", "existing_surface", "uncovered", "negative_handling", "read_scope", "write_scope"]) {
+        if (!Object.hasOwn(value, key))
+            continue;
+        const items = value[key];
+        if (!Array.isArray(items)) {
+            invalid(`/${key}`, "array", "array", items);
+            continue;
+        }
+        if (key === "read_scope" || key === "write_scope")
+            items.forEach((item, index) => {
+                if (!normalizedRelativePath(item))
+                    invalid(`/${key}/${index}`, "normalized-relative-path", "nonempty repository-relative path; forward slashes; no trailing slash, dot segments, traversal, or absolute path", item);
+            });
+    }
+    if (Object.hasOwn(value, "budget_estimate")) {
+        const budget = value.budget_estimate;
+        if (!record(budget))
+            invalid("/budget_estimate", "object", "object", budget);
+        else {
+            const keys = ["proposal_reads", "execution_units"];
+            for (const key of Object.keys(budget).filter(key => !keys.includes(key)).sort()) {
+                invalid(`/budget_estimate/${pointerToken(key)}`, "unknown-field", "remove-unknown-field", budget[key]);
+            }
+            for (const key of keys)
+                if (!Number.isSafeInteger(budget[key])) {
+                    invalid(`/budget_estimate/${key}`, Object.hasOwn(budget, key) ? "integer" : "required", "integer", budget[key]);
+                }
+        }
     }
+    if (diagnostics.length > 0)
+        throw new OperatorContractError(diagnostics);
+    // The shape checks above are batched for repair; semantic checks below remain strict.
+    const coverage = value.coverage, uncovered = value.uncovered, negatives = value.negative_handling;
+    const budget = value.budget_estimate;
     const requirementIDs = new Set(state.intent.requirements.map(item => item.id));
     const coverageIDs = new Set(), uncoveredIDs = new Set();
-    for (const item of value.coverage) {
+    for (const item of coverage) {
         if (!record(item) || !exact(item, ["requirement_id", "approach", "validation"]) || !identifier(item.requirement_id) ||
             !requirementIDs.has(item.requirement_id) || coverageIDs.has(item.requirement_id) || !text(item.approach) || !text(item.validation))
             throw new Error("operator-proposal-coverage-invalid");
@@ -159,7 +199,7 @@ function parsePacket(value, state) {
     }
     if ([...coverageIDs].some(id => !surfaced.has(id)))
         throw new Error("operator-proposal-existing-surface-incomplete");
-    for (const item of value.uncovered) {
+    for (const item of uncovered) {
         if (!record(item) || !exact(item, ["requirement_id", "reason"]) || !identifier(item.requirement_id) || !requirementIDs.has(item.requirement_id) ||
             coverageIDs.has(item.requirement_id) || uncoveredIDs.has(item.requirement_id) || !text(item.reason))
             throw new Error("operator-proposal-uncovered-invalid");
@@ -169,7 +209,7 @@ function parsePacket(value, state) {
         throw new Error("operator-proposal-requirement-coverage-incomplete");
     const negativeIDs = new Set(state.intent.requirements.filter(item => item.kind === "negative").map(item => item.id));
     const handled = new Set();
-    for (const item of value.negative_handling) {
+    for (const item of negatives) {
         if (!record(item) || !exact(item, ["requirement_id", "handling"]) || !identifier(item.requirement_id) || !negativeIDs.has(item.requirement_id) || handled.has(item.requirement_id) || !text(item.handling))
             throw new Error("operator-proposal-negative-handling-invalid");
         handled.add(item.requirement_id);
@@ -204,9 +244,17 @@ function parsePacket(value, state) {
     if (plan.acceptance.length !== acceptance.length || plan.acceptance.some((item, index) => item !== acceptance[index]))
         throw new Error("operator-proposal-acceptance-rewritten");
     const writes = [...new Set(plan.units.flatMap(unit => unit.write))].sort();
-    if (JSON.stringify([...new Set(value.write_scope)].sort()) !== JSON.stringify(writes))
-        throw new Error("operator-proposal-write-scope-mismatch");
-    if (value.budget_estimate.proposal_reads !== state.read_count || value.budget_estimate.execution_units !== plan.units.length)
+    if (JSON.stringify([...new Set(value.write_scope)].sort()) !== JSON.stringify(writes)) {
+        proposalError("/write_scope", "operator-proposal-write-scope-mismatch", "exact-union-of-unit-write-scopes", { repair_paths: ["/write_scope", "/plan/units"] });
+    }
+    for (const [unitIndex, unit] of plan.units.entries())
+        for (const [pathIndex, path] of unit.read.entries()) {
+            const executionReads = [...value.read_scope, ...plan.units.slice(0, unitIndex + 1).flatMap(item => item.write)];
+            if (!executionReads.some(scope => path === scope || path.startsWith(`${scope}/`))) {
+                proposalError(`/plan/units/${unitIndex}/read/${pathIndex}`, "operator-proposal-unit-read-scope-expanded", "unit-input-within-declared-read-scope-or-generated-write-scope");
+            }
+        }
+    if (budget.proposal_reads !== state.read_count || budget.execution_units !== plan.units.length)
         throw new Error("operator-proposal-budget-estimate-mismatch");
     return { ...structuredClone(materialized), plan };
 }
@@ -233,6 +281,37 @@ export class OperatorProposalRuntime {
         this.projectRoot = resolve(projectRoot);
     }
     file(root) { return join(this.projectRoot, this.profile.stateDirectory, "operator-proposals", `${hash(root)}.json`); }
+    spendFile(root) { return join(this.projectRoot, this.profile.stateDirectory, "operator-proposals", `${hash(root)}.spend.json`); }
+    async readSpend(root) {
+        let source;
+        try {
+            source = await readFile(this.spendFile(root), "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return { schema_version: "0.1", profile: this.profile.id, root_session_id: root, reads: 0, submissions: 0 };
+            }
+            throw error;
+        }
+        const spend = JSON.parse(source);
+        if (spend.schema_version !== "0.1" || spend.profile !== this.profile.id || spend.root_session_id !== root ||
+            !Number.isSafeInteger(spend.reads) || spend.reads < 0 || !Number.isSafeInteger(spend.submissions) || spend.submissions < 0) {
+            throw new Error("operator-proposal-spend-invalid");
+        }
+        return spend;
+    }
+    async saveSpend(spend) {
+        const directory = join(this.projectRoot, this.profile.stateDirectory, "operator-proposals");
+        await mkdir(directory, { recursive: true });
+        const temporary = `${this.spendFile(spend.root_session_id)}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(temporary, JSON.stringify(spend), { flag: "wx", mode: 0o600 });
+            await rename(temporary, this.spendFile(spend.root_session_id));
+        }
+        finally {
+            await rm(temporary, { force: true }).catch(() => undefined);
+        }
+    }
     async read(root) {
         return this.serial(root, () => this.readUnlocked(root));
     }
@@ -304,6 +383,11 @@ export class OperatorProposalRuntime {
                 "Git mutationが明示要件の時だけplan.git_lifecycleを追加する。exact shape: {\"branch_create\":{\"branch\":\"validated destination branch\",\"start_ref\":\"existing commit/ref\"},\"commit\":{\"message\":\"single-line commit message\"},\"post_commit_validation\":[\"exact declared validation command\"]}。post_commit_validationは既存canonical command identityでgoal criterion commandと一致し、final unit.validationの同順・連続suffixでなければならない。全non-post validationを先に実行し、全source write完了後にsuffixを実行する。hostはworker spend前にclean root、existing start_ref、nonexisting destinationを検証し、fixed argvでbranch作成する。suffix先頭command直前に全unit.write union内変更を明示stageしてcommitし、以後のsource writeを拒否する。既存validation executorが各post-commit commandのfresh evidenceを記録し、全evidenceなしのroot acceptanceは禁止。任意Git command、git add -A、commit -a、amend、force、push、既存branch上書きは禁止。git_lifecycle省略時のGit mutationはない。",
                 "acceptance_indicesは0-based。各unitのacceptance_indicesに置く全indexについて、そのacceptance_proof[index]が参照するcriterionのresolved validation_commandを同じunit.validationへ文字列完全一致で最低1個含める。範囲外index禁止。さらに各unitはそれ以前のunitにないgoal criterion validation_commandを少なくとも1個validationへ含める。同じvalidation commandだけを全unitで再利用禁止。順序付き2 unitなら例としてunit 1に中間状態を許すcommand、unit 2に最終commandを割り当てる。",
                 "existing_surfaceは各covered requirementにつき最低1件。対象codebaseで、その要件が制約・変更する既存構文や既存経路を実際にReadして特定し、そのfileのproject相対pathと見つけた形(form)を書く。formは文面の言い換えでなく、observedした構文形・node種別・dispatch分岐を書く。生成・宣言・束縛の経路と変更・代入の経路は別項目として挙げる。単数形しか要件に書かれていなくても、grammarやdispatchに複数値・分配・入れ子・暗黙形があればそれも挙げる。既存形が無いと判断した場合も、探索したfileのpathと「既存形なし」の根拠をformへ書く。pathはこのTaskで実際にReadしたfileでなければhostが拒否する。",
+                "調査順: authoritative_refsと既知entrypointから始める。対象pathが分かっているならdirectory巡回を挟まず直接そこへ進み、path未知の時だけ許可scope内のdirectoryやindexをReadして実在を確認する。名前を推測しただけのReadをしない。各requirementについて、それが変更する既存経路、symbol、validation oracle、build recipeを結び付ける。巨大な概念書やtest群を既定で全文読込せず、既知location・目次・周辺範囲から必要なoffset/limitを選ぶ。部分Readは探索手段であって完了条件ではない。既存分岐、関連呼出先、値の表現、負要件の影響範囲が不明なら範囲を広げ、必要ならfile全体を読む。読込量の少なさ自体を達成度にしない。authoritative Makefile、言語のgenerator directive、package/build scriptは後回しにせず関連実装経路と併せて早期に確認する。同じ内容の再読は、新しい未解決点、参照先、範囲不足、source変化のいずれかを理由とする。Read以外のtoolは要求しない。",
+                "記述は既存fieldで簡潔に行う。raw sourceやlogの全文再掲、同じplanの自然文による二重転記をしない。ただしcoverage、existing_surface、ordered validation、read/write、negative_handling、uncoveredは省略しない。初回提出で全requirementを扱えるproposalを目指し、調査できなかった点はuncoveredへ正直に残す。薄いproposalを出してrootへ追加調査を戻す往復を前提にしない。",
+                "提出前に正本commandと照合する。観測済みのexecutable、引数、test path、build target範囲をそのまま保持し、全体buildを一部targetへ縮めたり未確認の絶対executable pathを補完したりしない。検証script自身の副作用まで確認し、全生成物をunit.writeへ宣言する。unit.readはread_scopeまたは宣言済みwrite_scope内。再提出は診断fieldとactual_readsだけを直し、既に正しいcommand・scopeを再生成しない。",
+                "unit.validationとcriterionのvalidation_commandには実行commandだけを書く。手動GUI確認、root専有review、運用上の予算会計を説明文やラベル付きの疑似commandへ変換しない。fixture・新規Sessionの自動生成は実Backendの既存Session表示の証拠とは限らず、oracleが実際に確認する対象と副作用を照合する。現行契約で表現できない要件はuncoveredへ理由を残し、無関係なtestを全要件の証明として割り当てない。",
+                "status=submittedが返ったら、この調査Taskは完了。追加toolなしで親へ返す。汎用の続行指示が来てもoperator_nextやworker起動へ進まない。提出は承認でも実行許可でもない。",
                 "許可sourceをReadで1回以上調査後、返答前にproposal packetをsortie_v010_submit_operator_proposalへ提出する。invalid-proposal返却時だけ、そのcodeに該当するfieldを修正する。返却されたactual_readsはhostのcanonical accountingであり、再提出時はcodeに関係なくbudget_estimate.proposal_readsをその値へ一致させる。これはread budgetをresetせず、成功/失敗tool表示からcountを推測しない。失敗したReadが一律に未計上とも仮定しない。有限submission budget内で再提出する。proseだけ返して終了禁止。未対応要件はuncoveredへ明示する。承認・実行を主張しない。"].join("\n") };
     }
     /** Root-visible bounded handle; the canonical prompt remains only in durable host state. */
@@ -357,9 +441,10 @@ export class OperatorProposalRuntime {
                 throw new Error("operator-proposal-active-intent-immutable");
             throw new Error("operator-proposal-new-intent-requires-explicit-root-revision");
         }
+        const spend = await this.readSpend(root);
         const state = { schema_version: "0.1", profile: this.profile.id, root_session_id: root,
             intent_id: `intent-${intentHash.slice(0, 24)}`, intent_hash: intentHash, intent, created_at: new Date().toISOString(), phase: "investigating",
-            goal_binding: null, proposal_call_id: null, proposal_session_id: null, read_count: 0, read_paths: [], submission_count: 0, proposal_id: null,
+            goal_binding: null, proposal_call_id: null, proposal_session_id: null, read_count: spend.reads, read_paths: [], submission_count: spend.submissions, proposal_id: null,
             proposal_revision: null, proposal_hash: null, proposal: null, approval_rationale: null };
         await this.save(state);
         return state;
@@ -448,9 +533,19 @@ export class OperatorProposalRuntime {
         return state;
     }
     async submit(root, actor, raw) {
-        return this.serial(root, () => this.submitUnlocked(root, actor, raw));
+        return this.serial(root, () => this.submitUnlocked(root, actor, () => raw));
+    }
+    async submitJSON(root, actor, source) {
+        return this.serial(root, () => this.submitUnlocked(root, actor, () => {
+            try {
+                return JSON.parse(source);
+            }
+            catch {
+                return proposalError("/", "operator-proposal-json-invalid", "json");
+            }
+        }));
     }
-    async submitUnlocked(root, actor, raw) {
+    async submitUnlocked(root, actor, readPacket) {
         const state = await this.requiredUnlocked(root);
         if (state.proposal_session_id !== actor || state.phase !== "investigating")
             throw new Error("operator-proposal-submit-grant-invalid");
@@ -458,7 +553,7 @@ export class OperatorProposalRuntime {
             throw new Error("operator-proposal-submission-budget-exhausted");
         let packet;
         try {
-            packet = parsePacket(raw, state);
+            packet = parsePacket(readPacket(), state);
         }
         catch (error) {
             state.submission_count++;
@@ -493,6 +588,23 @@ export class OperatorProposalRuntime {
         }
         return state;
     }
+    /**
+     * Release a pre-approval proposal grant on explicit root cancellation. Without this the root holds an
+     * immutable investigating intent whose admitted child can no longer bind, so no retry path exists at all.
+     * An approved proposal is already connected to the execution lane and stays durable.
+     */
+    async discardPreApproval(root) {
+        return this.serial(root, async () => {
+            const state = await this.readUnlocked(root);
+            if (!state || state.phase === "approved")
+                return undefined;
+            await this.saveSpend({ schema_version: "0.1", profile: this.profile.id, root_session_id: root,
+                reads: state.read_count, submissions: state.submission_count });
+            await rm(this.file(root), { force: true });
+            this.states.delete(root);
+            return state;
+        });
+    }
     async required(root) { const state = await this.read(root); if (!state)
         throw new Error("operator-proposal-missing"); return state; }
     async assertExecutionApproved(root, planHash) {

package/dist/core/operator-runtime.js

@@ -41,6 +41,15 @@ export function operatorGitPathAuthorized(path, scopes, platform = process.platf
 }
 const contractError = (diagnostic) => { throw new OperatorContractError([diagnostic]); };
 const planError = (pointer, code, rule, repair_kind = "repair-field") => contractError({ document: "plan", pointer, code, rule, repair_kind });
+function rejectValidationAnnotation(command, pointer) {
+    // A bare multi-character label followed by ':' and whitespace is an instruction annotation,
+    // not a supported executable validation. Do not interpret or strip it into a fake passing oracle.
+    // This is deliberately not a shell parser or a claim of semantic proof; quoted commands, drive
+    // paths, URLs in arguments, and shell syntax remain the executor's responsibility.
+    if (/^\s*[A-Za-z][A-Za-z0-9_-]*(?:\s+[A-Za-z][A-Za-z0-9_-]*)*:(?:\s|$)/u.test(command)) {
+        planError(pointer, "operator-validation-annotation-invalid", "executable-command-not-instruction-label");
+    }
+}
 function strings(value, nonempty = false) {
     return Array.isArray(value) && (!nonempty || value.length > 0) && value.every(text);
 }
@@ -104,6 +113,12 @@ export function parseOperatorPlan(value) {
             return contractError({ document: "plan", pointer: `/goal_declaration/criteria/${proofCommands.size}/goal_validation_command`,
                 code: "operator-goal-command-required", rule: "declared-validation-command-for-criterion", repair_kind: "repair-proof-mapping",
                 repair_paths: [`/goal_declaration/criteria/${proofCommands.size}/goal_validation_command`] });
+        const commandOwner = raw.goal_validation_command != null || raw.validation_command != null ? raw
+            : record(declaration.defaults) && (declaration.defaults.goal_validation_command != null || declaration.defaults.validation_command != null)
+                ? declaration.defaults : declaration;
+        const commandPrefix = commandOwner === raw ? `/goal_declaration/criteria/${proofCommands.size}`
+            : commandOwner === declaration ? "/goal_declaration" : "/goal_declaration/defaults";
+        rejectValidationAnnotation(command, `${commandPrefix}/${commandOwner.goal_validation_command != null ? "goal_validation_command" : "validation_command"}`);
         proofCommands.set(id, command);
     }
     if (!Array.isArray(value.acceptance_proof) || value.acceptance_proof.length !== value.acceptance.length ||
@@ -119,6 +134,7 @@ export function parseOperatorPlan(value) {
             !identifier(unit.id) || ids.has(unit.id) || !text(unit.title) || !text(unit.objective) ||
             !strings(unit.read) || !strings(unit.write, true) || !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}`));
         ids.add(unit.id);
         if (!Array.isArray(unit.acceptance_indices) || unit.acceptance_indices.length === 0 ||
             unit.acceptance_indices.some(index => !Number.isSafeInteger(index) || index < 0 || index >= acceptanceCount ||

package/dist/plugin/profiled.js

@@ -286,8 +286,11 @@ export function createProfiledPlugin(profile, assetVersion) {
             : { ...(record(stringSchema) ? stringSchema : { type: "string" }), description: OPERATOR_INTENT_CONTRACT };
         const proposalContract = "proposal_json must encode one JSON object with exactly these required fields and types: " +
             'schema_version string "0.1"; revision positive integer, for example "revision":1, never string "revision":"1"; ' +
-            "coverage array of {requirement_id:string,approach:string,validation:string}; uncovered array of {requirement_id:string,reason:string}; " +
-            "negative_handling array of {requirement_id:string,handling:string}; read_scope string array; write_scope string array; " +
+            "coverage array of {requirement_id:string,approach:string,validation:string}; " +
+            "existing_surface array of {requirement_id:string,path:string,form:string}, with at least one observed form per covered requirement and each path actually Read by this child; " +
+            "uncovered array of {requirement_id:string,reason:string}; " +
+            "negative_handling array of {requirement_id:string,handling:string}, containing only and all IDs whose intent kind is negative; " +
+            "read_scope string array; write_scope string array; all scope and existing_surface paths must be normalized repository-relative paths with forward slashes, no trailing slash, dot segments, traversal, or absolute paths; " +
             "budget_estimate object with proposal_reads:integer and execution_units:integer; plan object with schema_version:string, " +
             "acceptance_proof:string[][], source_refs:string[], goal_declaration:object, units:object[], and optional git_lifecycle with exact shape " +
             "Each unit.validation is the complete ordered execution list, not a tests-only list: commands required by observed authoritative Makefiles, language generator directives, or repository scripts for generation, build, formatting, and exact cleanup precede post-commit or canonical criterion tests. Put every required input in unit.read and every persistent or transient generated output in unit.write. Cleanup may remove only declared unit.write outputs; never approve arbitrary ignore rules or removal of undeclared paths. Do not guess a tool-specific command or output, claim an unobserved capability, or add a preparatory or cleanup command as a goal criterion unless it independently proves acceptance. The host preserves declared order and authority but does not statically discover or inject every build dependency or generator output. " +
@@ -329,7 +332,15 @@ export function createProfiledPlugin(profile, assetVersion) {
                 await control?.stopAutomaticRecovery(root);
             const proposal = await proposals.read(root);
             if (proposal?.phase === "investigating" && proposal.proposal_call_id !== null) {
-                await control?.settleProposalBudget(root, proposal.intent_id, proposal.proposal_call_id, "cancelled");
+                // The admitted proposal Task already settles this reservation when its child returns. A terminal
+                // settlement is final, so an explicit cancellation must release the grant instead of failing on it.
+                try {
+                    await control?.settleProposalBudget(root, proposal.intent_id, proposal.proposal_call_id, "cancelled");
+                }
+                catch (error) {
+                    if (!(error instanceof Error) || error.message !== "operator-proposal-budget-settlement-conflict")
+                        throw error;
+                }
             }
             const children = await operators.interrupted(root, reason);
             for (const child of children) {
@@ -425,7 +436,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const proposal = await proposals.read(context.sessionID);
                 const proposalNextAction = proposal?.phase === "investigating"
                     ? proposal.proposal_call_id !== null
-                        ? "proposal Task is already admitted; do not redispatch it or call operator_next. Continue submission repairs only in the same active claimed child. If that child terminated without submission, report the terminal proposal failure; remaining read or submission capacity does not authorize a new Task, budget reset, or replacement child"
+                        ? "proposal Task is already admitted; do not redispatch it or call operator_next. Continue submission repairs only in the same active claimed child. If that child terminated without submission, report the terminal proposal failure; remaining read or submission capacity does not authorize a new Task, budget reset, or replacement child. Only an explicit root decision to retry may call cancel_operator with no reason to release this grant, which discards the spent proposal accounting and never reuses the terminated child"
                         : proposal.submission_count >= proposal.intent.proposal_budget.max_submissions
                             ? "proposal submission budget exhausted; do not call operator_next; report the bounded proposal failure"
                             : "proposal is not submitted; do not call operator_next; complete or repair the bounded proposal submission"
@@ -441,13 +452,29 @@ export function createProfiledPlugin(profile, assetVersion) {
                             next_action: proposalNextAction }
                             : { status: "absent", profile: profile.id });
             } };
-        tools[cancel] = { description: "Revoke this root's operator grant and stop only its owned children before releasing core state. reason is a closed set: omit it for a plain cancellation, including replanning or contract revision, and never send free text such as a written justification. Use reason=acceptance-remediation only for decision=operator-acceptance-remediation-required. At awaiting-acceptance, reason=review-blocking authorizes a same-goal review-remediation replacement only within the exact acceptance, committed head, approved write union, and retained remaining budget.",
+        tools[cancel] = { description: "Revoke this root's operator grant and stop only its owned children before releasing core state. Before approval it instead releases the bounded proposal grant, including one whose admitted child already terminated, so the root can begin a new investigation; it never reuses that child or restores spent proposal budget. reason is a closed set: omit it for a plain cancellation, including replanning, contract revision, and any pre-approval proposal release, and never send free text such as a written justification. Use reason=acceptance-remediation only for decision=operator-acceptance-remediation-required. At awaiting-acceptance, reason=review-blocking authorizes a same-goal review-remediation replacement only within the exact acceptance, committed head, approved write union, and retained remaining budget.",
             args: { reason: optionalStringSchema }, execute: async (args, context) => {
                 await requireRoot(context.sessionID);
                 const requestedReason = args.reason;
                 if (requestedReason !== undefined && requestedReason !== "review-blocking" && requestedReason !== "acceptance-remediation")
                     throw new Error("operator-cancel-reason-invalid");
-                const current = await operators.required(context.sessionID);
+                const pending = await operators.read(context.sessionID);
+                if (!pending) {
+                    // A pre-approval proposal owns no execution lane. Its admitted child can never be rebound, so without
+                    // this release the root can neither resume, redispatch, nor start any replacement investigation.
+                    const proposal = await proposals.read(context.sessionID);
+                    if (!proposal || proposal.phase === "approved")
+                        throw new Error("operator-run-missing");
+                    if (requestedReason !== undefined)
+                        throw new Error("operator-cancel-reason-invalid");
+                    await stop(context.sessionID, "explicit-cancellation", false);
+                    const discarded = await proposals.discardPreApproval(context.sessionID);
+                    return JSON.stringify({ profile: profile.id, status: "cancelled", scope: "proposal",
+                        released_proposal: discarded ? proposals.packet(discarded) : null,
+                        next_action: "the bounded proposal grant is released and its spent reads/submissions are not restored; " +
+                            "begin a new proposal investigation only on an explicit root decision to retry, and never reuse the cancelled child" });
+                }
+                const current = pending;
                 if (requestedReason === "acceptance-remediation" && current.decision !== "operator-acceptance-remediation-required")
                     throw new Error("operator-cancel-reason-invalid");
                 if (requestedReason === "review-blocking" && current.phase !== "awaiting-acceptance")
@@ -610,7 +637,10 @@ export function createProfiledPlugin(profile, assetVersion) {
                 if (!root)
                     throw new Error("operator-proposal-session-inactive");
                 try {
-                    return JSON.stringify(proposals.packet(await proposals.submit(root, context.sessionID, JSON.parse(args.proposal_json))));
+                    const submitted = await proposals.submitJSON(root, context.sessionID, args.proposal_json);
+                    return JSON.stringify({ ...proposals.packet(submitted),
+                        next_action: "Proposal submitted. This investigation child must now return to its parent without further tools. " +
+                            "Do not call operator_next, start a worker, or claim approval; the root must compare and approve the proposal." });
                 }
                 catch (error) {
                     const contract = error instanceof OperatorContractError;
@@ -618,6 +648,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                         throw error;
                     const state = await proposals.required(root);
                     return JSON.stringify({ status: "invalid-proposal", code: error.message, actual_reads: state.read_count,
+                        remaining_reads: state.intent.proposal_budget.max_reads - state.read_count,
                         submissions: state.submission_count, remaining_submissions: state.intent.proposal_budget.max_submissions - state.submission_count,
                         ...(contract ? { diagnostics: error.diagnostics, diagnostics_truncated: error.diagnostics_truncated } : {}) });
                 }
@@ -1118,6 +1149,14 @@ export function createProfiledPlugin(profile, assetVersion) {
                 (output.system ??= []).push(`SORTIE_RUNTIME_PROFILE ${profile.id}; marker ${assetVersion}. ` +
                     `Shared MkII protocol role names are logical: ${protocolMap}. Use only ${profile.toolPrefix} tools for this profile. ` +
                     "Never rewrite user acceptance or evidence to rename protocol roles. Final acceptance belongs only to the root coordinator.");
+                const proposal = await proposals.read(root);
+                if (proposal?.phase === "investigating" && proposal.proposal_session_id === request.sessionID) {
+                    (output.system ??= []).push(`SORTIE_PROPOSAL_PHASE investigating; intent=${proposal.intent_id}; root=${root}; child=${request.sessionID}. ` +
+                        `This durable phase remains authoritative after compaction even when the latest message is a generic continuation. ` +
+                        `Continue the admitted read-only investigation and submit through ${submitProposal}. Do not call ${next} or dispatch workers: no execution run exists yet. ` +
+                        `actual_reads=${proposal.read_count}; remaining_reads=${proposal.intent.proposal_budget.max_reads - proposal.read_count}; ` +
+                        `submissions=${proposal.submission_count}; remaining_submissions=${proposal.intent.proposal_budget.max_submissions - proposal.submission_count}.`);
+                }
             },
             "experimental.text.complete": async (request, output) => {
                 const role = (await identity(request.sessionID)).role;
@@ -1142,6 +1181,18 @@ export function createProfiledPlugin(profile, assetVersion) {
                 if (!root)
                     return;
                 if ((await identity(request.sessionID)).role === "dog-operator") {
+                    const proposal = await proposals.read(root);
+                    if (proposal?.phase === "investigating" && proposal.proposal_session_id === request.sessionID) {
+                        (output.context ??= []).push(`Proposal continuation: ${JSON.stringify({
+                            root, child: request.sessionID, intent_id: proposal.intent_id, intent_hash: proposal.intent_hash,
+                            intent: proposal.intent, goal_binding: proposal.goal_binding, read_paths: proposal.read_paths,
+                            actual_reads: proposal.read_count, remaining_reads: proposal.intent.proposal_budget.max_reads - proposal.read_count,
+                            submissions: proposal.submission_count, remaining_submissions: proposal.intent.proposal_budget.max_submissions - proposal.submission_count,
+                        })}. Preserve the latest proposal draft and field diagnostics in the summary. Continue only in this same claimed read-only proposal child. ` +
+                            `Repair only diagnosed fields, then call ${submitProposal}; do not call ${next}, dispatch Tasks, execute work, or reset budgets. ` +
+                            "This is investigation, not an execution run. Compaction grants no new reads or submissions.");
+                        return;
+                    }
                     const state = await operators.required(root);
                     (output.context ??= []).push(`Operator continuation: root=${root}; run=${state.runID}; generation=${state.generation}; contract=${state.planHash}. ` +
                         `Read ${next} for current authoritative state. Do not reconstruct acceptance or reset the queue.`);
@@ -1150,9 +1201,13 @@ export function createProfiledPlugin(profile, assetVersion) {
                 await core["experimental.session.compacting"]?.(request, output);
             },
             "experimental.compaction.autocontinue": async (request, output) => {
-                if (!await rootFor(request.sessionID))
+                const root = await rootFor(request.sessionID);
+                if (!root)
                     return;
                 if ((await identity(request.sessionID)).role === "dog-operator") {
+                    const proposal = await proposals.read(root);
+                    if (proposal?.phase === "investigating" && proposal.proposal_session_id === request.sessionID)
+                        return;
                     output.enabled = false;
                     return;
                 }

package/dist/runtime-assets-v010.js

@@ -102,9 +102,18 @@ their literal ASCII keys; translated prose belongs in the values. Do not guess a
 For a nontrivial request whose source facts, unit boundaries, or exact validation contract still require investigation,
 do not author a giant speculative plan at the root. Freeze the original request once with stable ordered requirement IDs,
 including every negative and quality condition, authoritative references, finite proposal read/submission budgets, and the
-maximum read prefixes. Call ${profile.toolPrefix}begin_operator_proposal. Dispatch its exact ${operator} Task unchanged.
+maximum read prefixes. Call ${profile.toolPrefix}begin_operator_proposal. Dispatch its exact ${operator} Task unchanged.
+Freeze product requirements from the original request, not extra implementation criteria invented from workflow
+bookkeeping. Keep proposal read/submission allowances in proposal_budget and host counters; do not turn spent
+budgets or your own reporting obligations into worker validation commands. Preserve any explicit user requirement.
 That child remains the same logical operations role: it may inspect only the host-approved read prefixes and submit one
 requirement-mapped proposal; it cannot edit, use shell, dispatch a worker/advisor/scout, widen read scope, or execute work.
+An admitted proposal child is never redispatched or replaced. If it terminates without a submitted proposal, report that
+terminal failure first; only an explicit decision to retry may call ${profile.toolPrefix}cancel_operator with no reason to
+release the grant before freezing the requirements again. Spent proposal reads and submissions are never restored.
+Do not cancel/reinvestigate the same known contract defect merely to get another draft. Preserve exact observed
+commands and correction evidence. If a user-only acceptance condition cannot be expressed by the existing contract,
+report that specific limitation for a scope/design decision instead of inventing a passing test or another investigation.
 
 The proposal must map every original requirement ID to approach and validation, explicitly list uncovered IDs, preserve
 negative-condition handling, and include exact read/write/unit/GoalDeclaration plans and budget estimates. Its summary is
@@ -267,10 +276,14 @@ tools:
 # ${operator}
 
 You operate one coordinator-approved serial queue for runtime ${V010_RUNTIME_ASSET_VERSION}. You are not a second coordinator.
-When the prompt starts SORTIE_OPERATOR_PROPOSAL, perform only its bounded read investigation and submit the complete packet
-through ${profile.toolPrefix}submit_operator_proposal before returning; a prose-only return is forbidden. If it returns invalid-proposal,
-repair only the named code (using actual_reads for a budget estimate mismatch) within the finite submission budget. Do not call operator_next or dispatch a worker. Otherwise call
-${profile.toolPrefix}operator_next. If it returns a task, pass its subagent_type, description, and prompt unchanged to Task.
+When the prompt starts SORTIE_OPERATOR_PROPOSAL or the host supplies SORTIE_PROPOSAL_PHASE investigating,
+perform only its bounded read investigation and submit the complete packet
+through ${profile.toolPrefix}submit_operator_proposal before returning; a prose-only return is forbidden. If it returns invalid-proposal,
+repair only the named code (using actual_reads for a budget estimate mismatch) within the finite submission budget.
+A successful status=submitted ends this investigation Task: return to the parent without further tools, even if a generic
+continuation asks for the next step. Submission is not execution admission; never call operator_next or dispatch a worker.
+For an admitted execution queue, call
+${profile.toolPrefix}operator_next. If it returns a task, pass its subagent_type, description, and prompt unchanged to Task.
 After the worker returns, inspect the host's bounded packet and call next again only when the queue still has pending work.
 The worker owns implementation, diagnosis, correction and declared validation inside its Task invocation. Do not duplicate it.
 
@@ -280,8 +293,10 @@ or replace a child to bypass a refusal or a budget. The plugin enforces root/pro
 
 Keep coordination concise and use the handoff's language. Do not return intermediate progress merely to wake the coordinator.
 On awaiting-decision, cancelled, or awaiting-acceptance, stop and return the packet's status and unresolved evidence. Do not
-claim the feature is accepted; only the root coordinator can do that. After compaction, call next to read authoritative state
-and its current short Task reference rather than reconstructing criteria from a summary. Never use a standalone/generic worker as a fallback.
+claim the feature is accepted; only the root coordinator can do that. After compaction in the proposal phase, preserve the
+same child, intent, read evidence and remaining budgets; continue investigation/submission repair, never call next.
+Only in the execution phase, call next to read authoritative queue state and its current short Task reference rather than
+reconstructing criteria from a summary. Never use a standalone/generic worker as a fallback.
 `;
 /**
  * A constraint added to an existing construct is only complete when every existing form that reaches

package/package.json

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