sortie-dogs 0.10.10 → 0.10.12

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-ref2-proposal1-review-remediation1-surface4-proposal-recovery2-quality1-terminal2-route1-path1-permission2-prerequisite1-v2-bridge1-intent1-reflection1-cancel1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.10.0-v0912-language4-cost-rpt10-compaction-ref2-proposal1-review-remediation1-surface4-proposal-recovery2-quality1-terminal2-route1-path1-permission2-prerequisite1-v2-bridge1-intent1-reflection1-cancel1-proposal-budget1-goal-recovery1-delegate-execute1";
 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-ref2-proposal1-review-remediation1-surface4-proposal-recovery2-quality1-terminal2-route1-path1-permission2-prerequisite1-v2-bridge1-intent1-reflection1-cancel1";
+export const V010_RUNTIME_ASSET_VERSION = "0.10.0-v0912-language4-cost-rpt10-compaction-ref2-proposal1-review-remediation1-surface4-proposal-recovery2-quality1-terminal2-route1-path1-permission2-prerequisite1-v2-bridge1-intent1-reflection1-cancel1-proposal-budget1-goal-recovery1-delegate-execute1";

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

@@ -86,6 +86,24 @@ export interface OperatorProposalState {
     proposal: OperatorProposalPacket | null;
     approval_rationale: string | null;
 }
+export interface OperatorProposalBudgetDiagnostic {
+    readonly status: "proposal-budget-exhausted";
+    readonly code: "operator-proposal-read-budget-exhausted" | "operator-proposal-submission-budget-exhausted";
+    readonly reads: number;
+    readonly max_reads: number;
+    readonly remaining_reads: number;
+    readonly submissions: number;
+    readonly max_submissions: number;
+    readonly remaining_submissions: number;
+    readonly required_minimum_budget: {
+        readonly max_reads: number;
+        readonly max_submissions: number;
+    };
+}
+export declare class OperatorProposalBudgetError extends Error {
+    readonly diagnostic: OperatorProposalBudgetDiagnostic;
+    constructor(diagnostic: OperatorProposalBudgetDiagnostic);
+}
 /** Durable pre-execution lane. It grants investigation and submission, never source mutation or execution. */
 export declare class OperatorProposalRuntime {
     readonly profile: RuntimeProfile;
@@ -101,6 +119,7 @@ export declare class OperatorProposalRuntime {
     read(root: string): Promise<OperatorProposalState | undefined>;
     private readUnlocked;
     private save;
+    private assertBudgetAvailable;
     task(state: OperatorProposalState): OperatorTask;
     /** Root-visible bounded handle; the canonical prompt remains only in durable host state. */
     referenceTask(state: OperatorProposalState): OperatorTask;

package/dist/core/operator-proposal.js

@@ -93,6 +93,13 @@ const normalizedRelativePath = (value) => {
         return false;
     }
 };
+export class OperatorProposalBudgetError extends Error {
+    diagnostic;
+    constructor(diagnostic) {
+        super(diagnostic.code);
+        this.diagnostic = diagnostic;
+    }
+}
 function parseIntent(value) {
     const proposalBudget = record(value) && Object.hasOwn(value, "proposal_budget")
         ? value.proposal_budget
@@ -366,6 +373,18 @@ export class OperatorProposalRuntime {
         }
         this.states.set(state.root_session_id, structuredClone(state));
     }
+    assertBudgetAvailable(state) {
+        const remainingReads = state.intent.proposal_budget.max_reads - state.read_count;
+        const remainingSubmissions = state.intent.proposal_budget.max_submissions - state.submission_count;
+        if (remainingReads > 0 && remainingSubmissions > 0)
+            return;
+        throw new OperatorProposalBudgetError({ status: "proposal-budget-exhausted",
+            code: remainingReads <= 0 ? "operator-proposal-read-budget-exhausted" : "operator-proposal-submission-budget-exhausted",
+            reads: state.read_count, max_reads: state.intent.proposal_budget.max_reads, remaining_reads: Math.max(0, remainingReads),
+            submissions: state.submission_count, max_submissions: state.intent.proposal_budget.max_submissions,
+            remaining_submissions: Math.max(0, remainingSubmissions),
+            required_minimum_budget: { max_reads: state.read_count + 1, max_submissions: state.submission_count + 1 } });
+    }
     task(state) {
         return { subagent_type: this.profile.agentNames["dog-operator"], description: "承認前の調査と実行契約案作成",
             prompt: [`SORTIE_OPERATOR_PROPOSAL ${JSON.stringify({ root: state.root_session_id, intent_id: state.intent_id, intent_hash: state.intent_hash })}`,
@@ -435,8 +454,10 @@ export class OperatorProposalRuntime {
     async beginUnlocked(root, raw) {
         const intent = parseIntent(raw), intentHash = hash(JSON.stringify(intent)), previous = await this.readUnlocked(root);
         if (previous) {
-            if (previous.intent_hash === intentHash)
+            if (previous.intent_hash === intentHash) {
+                this.assertBudgetAvailable(previous);
                 return previous;
+            }
             if (previous.phase !== "approved")
                 throw new Error("operator-proposal-active-intent-immutable");
             throw new Error("operator-proposal-new-intent-requires-explicit-root-revision");
@@ -446,6 +467,7 @@ export class OperatorProposalRuntime {
             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: spend.reads, read_paths: [], submission_count: spend.submissions, proposal_id: null,
             proposal_revision: null, proposal_hash: null, proposal: null, approval_rationale: null };
+        this.assertBudgetAvailable(state);
         await this.save(state);
         return state;
     }
@@ -474,6 +496,7 @@ export class OperatorProposalRuntime {
         const state = await this.requiredUnlocked(root);
         if (state.phase !== "investigating" || state.proposal_call_id !== null)
             throw new Error("operator-proposal-dispatch-not-authorized");
+        this.assertBudgetAvailable(state);
         const canonical = this.resolveTask(state, args);
         // Reserve only after the grant check, while competing admissions remain queued.
         await reserveBudget?.();

package/dist/plugin/index.js

@@ -7573,6 +7573,10 @@ export const SortieDogsPlugin = async (input, options) => {
         registerGoalDeclaration: async (root, prompt) => {
             if (!isCoordinatorSession(root) && !await recoverCoordinatorRoot(root))
                 throw new Error("operator-coordinator-required");
+            // In one-shot CLI turns OpenCode may persist the user message only after chat.message returns.
+            // Proposal preparation can reach registration first, so recover that exact pending real turn here
+            // instead of freezing a prepared contract that can never consume its user revision authority.
+            await recoverPendingRealGoalTurn(root);
             const registered = await bindGoalDeclaration(root, prompt);
             if (registered?.goal_id === null || registered === undefined)
                 throw new Error("operator-goal-registration-unavailable");
@@ -7588,6 +7592,7 @@ export const SortieDogsPlugin = async (input, options) => {
         relinkRegisteredGoal: async (root, request) => {
             if (!isCoordinatorSession(root) && !await recoverCoordinatorRoot(root))
                 throw new Error("operator-coordinator-required");
+            await recoverPendingRealGoalTurn(root);
             await recoverCompletedGoalReservations(root);
             const ledger = await goalLedger(root), snapshot = await ledger.readGoal(), state = snapshot.state;
             if (state.phase !== "active" || state.receipt !== null)

package/dist/plugin/profiled.js

@@ -1,6 +1,6 @@
 import { V010_RUNTIME_ASSET_VERSION } from "../asset-version.js";
 import { OperatorContractError, OperatorRuntime } from "../core/operator-runtime.js";
-import { DEFAULT_OPERATOR_PROPOSAL_BUDGET, OPERATOR_APPROVAL_CONTRACT, OPERATOR_PROPOSAL_BUDGET_CAPS, OperatorProposalRuntime } from "../core/operator-proposal.js";
+import { DEFAULT_OPERATOR_PROPOSAL_BUDGET, OPERATOR_APPROVAL_CONTRACT, OPERATOR_PROPOSAL_BUDGET_CAPS, OperatorProposalBudgetError, OperatorProposalRuntime } from "../core/operator-proposal.js";
 import { CANONICAL_AGENT_ROLES, canonicalAgent, profileAgent, profileTool, V010_RUNTIME_PROFILE } from "../core/runtime-profile.js";
 import { SortieDogsPlugin as canonicalPlugin } from "./index.js";
 import { taskChildSessionID } from "./task-result-repair.js";
@@ -760,7 +760,15 @@ export function createProfiledPlugin(profile, assetVersion) {
         tools[beginProposal] = { description: `Root-only: freeze original ordered requirements and grant one bounded read-only proposal investigation to dogs-coordinator. The result contains one exact short Task reference; pass task.subagent_type, task.description, and task.prompt byte-for-byte without appending or paraphrasing. The native parent retains that reference; the host expands it only inside the directly claimed proposal child. ${OPERATOR_INTENT_CONTRACT}`,
             args: { intent_json: intentSchema }, execute: async (args, context) => {
                 await requireRoot(context.sessionID);
-                let state = await proposals.begin(context.sessionID, JSON.parse(args.intent_json));
+                let state;
+                try {
+                    state = await proposals.begin(context.sessionID, JSON.parse(args.intent_json));
+                }
+                catch (error) {
+                    if (error instanceof OperatorProposalBudgetError)
+                        return JSON.stringify(error.diagnostic);
+                    throw error;
+                }
                 state = await proposals.bindGoal(context.sessionID, await control.proposalGoalBinding(context.sessionID));
                 return JSON.stringify({ ...proposals.packet(state), task: proposals.referenceTask(state),
                     dispatch_instruction: "Pass this short Task reference verbatim; do not append or paraphrase it." });
@@ -1108,6 +1116,16 @@ export function createProfiledPlugin(profile, assetVersion) {
                     await proposals.accountRead(root, request.sessionID, normalizeRelativePath(relative(input.directory, resolve(input.directory, args.filePath))));
                     return;
                 }
+                if (who.role === "dog-operator" && request.tool === "execute") {
+                    const state = await operators.required(root);
+                    // OpenCode V2 exposes the delegate's operator_next capability through Code Mode's
+                    // execute conduit. Nested Sortie tools still enforce their own root/delegate identity;
+                    // denying the conduit prevents a valid multi-unit delegate from creating any worker.
+                    if (state.phase !== "running" || state.operatorSessionID !== request.sessionID) {
+                        throw new Error("operator-execute-owner-mismatch");
+                    }
+                    return;
+                }
                 if (who.role === "dog-operator" && request.tool === "read") {
                     if (typeof args.filePath !== "string")
                         throw new Error("operator-read-path-required");

package/package.json

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