sortie-dogs 0.10.9 → 0.10.11

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";
+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";
 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";
+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";

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/config.js

@@ -33,7 +33,7 @@ export const DEFAULT_PLUGIN_OPTIONS = {
         capability: CONTINUATION_CAPABILITY,
         taskWatchdogMilliseconds: DEFAULT_TASK_WATCHDOG_MILLISECONDS,
     }),
-    reflection: Object.freeze({ enabled: false, layers: Object.freeze({ run: true, project: true, global: false }), maxInjectedEntries: 3, maxInjectedTokens: 500 }),
+    reflection: Object.freeze({ enabled: true, layers: Object.freeze({ run: true, project: true, global: true }), maxInjectedEntries: 3, maxInjectedTokens: 500 }),
     validationProfile: "balanced",
 };
 function isRecord(value) {

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";
@@ -40,7 +40,7 @@ const PREVIEW_ROUTES = Object.freeze([
 ]);
 export function processRemediationReplacementPacket(code, packet, cancelTool, prepareTool) {
     return { status: "operator-process-remediation-replacement-required", code, packet,
-        next_action: `Call ${cancelTool} without a reason, then call ${prepareTool} with the exact same ordered acceptance, ` +
+        next_action: `Call ${cancelTool} with reason=plain, then call ${prepareTool} with the exact same ordered acceptance, ` +
             "the same unit and write scope, and the remaining cumulative budget. Do not call resume_operator again, " +
             "claim evidence, reset spend, or widen scope." };
 }
@@ -546,7 +546,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. 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 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 reason=plain 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"
@@ -562,10 +562,11 @@ 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. 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) => {
+        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 required closed set: use reason=plain 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: { type: "string", enum: ["plain", "review-blocking", "acceptance-remediation"] } }, execute: async (args, context) => {
                 await requireRoot(context.sessionID);
-                const requestedReason = args.reason;
+                const rawReason = args.reason;
+                const requestedReason = rawReason === "plain" || rawReason === undefined ? undefined : rawReason;
                 if (requestedReason !== undefined && requestedReason !== "review-blocking" && requestedReason !== "acceptance-remediation")
                     throw new Error("operator-cancel-reason-invalid");
                 const pending = await operators.read(context.sessionID);
@@ -759,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." });

package/dist/runtime-assets-v010.js

@@ -157,7 +157,7 @@ budgets or your own reporting obligations into worker validation commands. Prese
 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
+terminal failure first; only an explicit decision to retry may call ${profile.toolPrefix}cancel_operator with reason=plain 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,

package/package.json

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