sortie-dogs 0.10.14 → 0.10.15

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

@@ -73,6 +73,11 @@ export interface OperatorProposalState {
     readonly intent: OperatorIntent;
     goal_binding: OperatorProposalGoalBinding | null;
     readonly created_at: string;
+    /** Frozen carry-in spend; unlike live counters it must not change the admitted Task identity. */
+    readonly prior_spend?: {
+        readonly reads: number;
+        readonly submissions: number;
+    };
     phase: "investigating" | "submitted" | "approved";
     proposal_call_id: string | null;
     proposal_session_id: string | null;

package/dist/core/operator-proposal.js

@@ -101,6 +101,25 @@ export class OperatorProposalBudgetError extends Error {
     }
 }
 function parseIntent(value) {
+    if (record(value) && Array.isArray(value.allow_read)) {
+        const diagnostics = [];
+        value.allow_read.forEach((path, index) => {
+            if (normalizedRelativePath(path))
+                return;
+            let expected = "existing repository-relative file or directory; external absolute paths are not proposal read scopes";
+            if (typeof path === "string") {
+                try {
+                    expected = normalizeRelativePath(path);
+                }
+                catch { /* Never authorize an external or traversal path. */ }
+            }
+            diagnostics.push({ document: "proposal", pointer: `/allow_read/${index}`, code: "operator-intent-read-path-invalid",
+                rule: "normalized-relative-path", repair_kind: "repair-field", repair_paths: [`/allow_read/${index}`],
+                expected, actual_type: jsonType(path) });
+        });
+        if (diagnostics.length)
+            throw new OperatorContractError(diagnostics);
+    }
     const proposalBudget = record(value) && Object.hasOwn(value, "proposal_budget")
         ? value.proposal_budget
         : DEFAULT_OPERATOR_PROPOSAL_BUDGET;
@@ -392,6 +411,11 @@ export class OperatorProposalRuntime {
                 `original_request: ${state.intent.original_request.text}`, "ordered_requirements:", ...state.intent.requirements.map(item => `- ${item.id} [${item.kind}]: ${item.text}`),
                 `authoritative_refs: ${JSON.stringify(state.intent.authoritative_refs)}`, `allow_read: ${JSON.stringify(state.intent.allow_read)}`,
                 `proposal_budget: ${JSON.stringify(state.intent.proposal_budget)}`,
+                "要件に相談や利用者判断が含まれる場合、workerから追加Taskを呼ぶ計画にしない。rootが派遣前に必要な相談を行い、確認済みの素材許諾・選択・画像参照・決定をunit.objectiveと許可された入力へ明記する。子はroot会話を自動継承しない。未確定の判断だけを未確定として保持し、確認済み事項を再質問させない。実機測定や利用者Goの未達をfixtureで代替しない。",
+                ...(state.prior_spend ? [`prior_proposal_spend: ${JSON.stringify(state.prior_spend)}; remaining_at_start: ${JSON.stringify({
+                        reads: state.intent.proposal_budget.max_reads - state.prior_spend.reads,
+                        submissions: state.intent.proposal_budget.max_submissions - state.prior_spend.submissions
+                    })}. These are cumulative limits, not fresh grants. budget_estimate.proposal_reads must include prior_proposal_spend.reads plus reads charged in this investigation. Prior read paths are not evidence for this new child.`] : []),
                 "proposal packet fields: schema_version, revision, coverage[{requirement_id,approach,validation}], existing_surface[{requirement_id,path,form}], uncovered[{requirement_id,reason}], negative_handling[{requirement_id,handling}], read_scope, write_scope, budget_estimate{proposal_reads,execution_units}, plan{schema_version,acceptance_proof,source_refs,goal_declaration,units, optional git_lifecycle}. revisionは正のJSON整数。例: \"revision\":1。文字列\"revision\":\"1\"は禁止し、hostは型変換しない。plan.acceptanceは生成・提出せず省略し、hostがdurable intent.requirementsのtextを同順・完全一致でmaterializeする。legacy互換として明示する場合だけ同じ全文・順序を完全一致で使い、null・部分集合・並べ替え・空白/大小文字変更は禁止。acceptance_ids等の代替field禁止。",
                 "schema_versionはpacketとplanの両方で必ず文字列\"0.1\"。coverageはnegative/qualityを含む全ordered requirement IDを各1回含める（未対応だけuncoveredへ移す）。全declared criterion IDをacceptance_proofから参照し、各unitのacceptance_indicesはnonempty、全acceptance indexとexact validation commandを既存parser規則どおり完全coverageする。",
                 "plan.acceptance_proofは各acceptanceに対応するcriterion IDの配列を並べた二重配列。複数acceptanceを同じexact commandが証明する場合はcriterion IDを共有可で、acceptanceごとの固有criterion作成は不要。goal_declarationはobject。delivery_intent=\"implementation\", delivery_mode=\"mvp-first\", usable_path_established=false, controlled_change=false, goal_budget_unitsは正整数。criteria各要素はcriterion_idとvalidation_commandを持つ。",
@@ -466,6 +490,7 @@ export class OperatorProposalRuntime {
         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: spend.reads, read_paths: [], submission_count: spend.submissions, proposal_id: null,
+            ...(spend.reads > 0 || spend.submissions > 0 ? { prior_spend: { reads: spend.reads, submissions: spend.submissions } } : {}),
             proposal_revision: null, proposal_hash: null, proposal: null, approval_rationale: null };
         this.assertBudgetAvailable(state);
         await this.save(state);

package/dist/core/operator-runtime.js

@@ -797,6 +797,7 @@ export class OperatorRuntime {
                 "validation:", ...unit.validation.map(value => `  - ${value}`),
                 "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.",
                 ...(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.",

package/dist/plugin/profiled.js

@@ -449,6 +449,7 @@ export function createProfiledPlugin(profile, assetVersion) {
                 return JSON.stringify(operators.packet(state));
             control.enableUnits(state.rootSessionID, state.units.length);
             return JSON.stringify({ profile: profile.id, run_id: state.runID, acceptance_fingerprint: state.acceptanceFingerprint,
+                dispatch_instruction: "Dispatch this exact Task in the foreground. Omit background or set it to false; background=true is not supported by the operator lifecycle. Required consultations belong to the root before dispatch; confirmed user decisions must already be in the approved unit objective and inputs, not appended to this Task reference.",
                 fast_path: state.units.length === 1, task: state.units.length === 1 ? operators.nextWorkerTask(state) : operators.dispatchTask(state) });
         }
         tools[prepare] = { description: `Freeze an approved serial operator plan. Invalid plans return bounded diagnostics and a draft_id for field-only repair; no worker is started. After operator-acceptance-remediation-required, cancel first and prepare only the same exact acceptance, a write scope within the prior approved union, and a Git lifecycle starting at the failed committed head; consumed goal budget is retained. Coordinator only. ${planContract}`,
@@ -549,17 +550,18 @@ 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 reason=plain 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 or was interrupted without submission, an explicit root decision to retry may call cancel_operator with reason=plain to release this grant. Cancellation stops owned children and durably preserves cumulative reads/submissions and goal spend. Pass the returned retry_intent unchanged to begin_operator_proposal, then dispatch only its new exact Task within the remaining budget. Never reuse the terminated child, reset spend, or replace the goal or ordered requirements. Exhaustion requires an explicit cumulative budget revision, not a reset."
                         : 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"
                     : proposal?.phase === "submitted"
-                        ? "compare and approve the exact proposal; do not call operator_next before approval prepares a run"
+                        ? "compare and approve the exact proposal; do not call operator_next before approval prepares a run. Approval authorizes implementation, not product acceptance. Preserve every required live measurement, consultation and user approval as pending acceptance obligations; canonical commands do not substitute for them. Use the host budget counters, not plan.goal_declaration.goal_budget_units, for remaining capacity; approval validates the retained goal binding and execution budget. A bounded diagnostic run may use cancel_operator after admission without inventing a plan validation command for cancellation."
                         : "approved proposal has no operator run; do not call operator_next; reconcile the approval or preparation failure";
                 return JSON.stringify(state ? { ...await operatorPacket(state), ...(draft ? { pending_draft: draft } : {}),
                     ...(proposal ? { proposal: proposalIdentity(proposal) } : {}) }
                     : draft ? { ...draft, ...(proposal ? { proposal: proposals.packet(proposal) } : {}) }
                         : proposal ? { profile: profile.id, proposal: proposals.packet(proposal),
+                            goal_binding: proposal.goal_binding, budget: await control.currentBudget(context.sessionID),
                             ...(proposal.phase === "investigating" && proposal.proposal_call_id === null ? { task: proposals.referenceTask(proposal),
                                 dispatch_instruction: "Pass this short Task reference verbatim; the host expands it only inside the directly claimed proposal child." } : {}),
                             next_action: proposalNextAction }
@@ -587,8 +589,11 @@ export function createProfiledPlugin(profile, assetVersion) {
                     operatorTurnLifecycle.set(context.sessionID, "cancelled");
                     return JSON.stringify({ profile: profile.id, status: "cancelled", scope: "proposal",
                         released_proposal: discarded ? proposals.packet(discarded) : null,
+                        retry_intent: discarded?.intent ?? null,
+                        retained_goal_binding: discarded?.goal_binding ?? 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" });
+                            "cumulative proposal and goal spend are preserved. On an explicit root decision to retry, pass retry_intent unchanged to begin_operator_proposal, " +
+                            "preserve the same goal and ordered requirements, and dispatch only the new exact Task within the remaining budget. Never reuse the cancelled child or reset any budget" });
                 }
                 const current = pending;
                 if (requestedReason === "acceptance-remediation" && current.decision !== "operator-acceptance-remediation-required")
@@ -772,6 +777,9 @@ export function createProfiledPlugin(profile, assetVersion) {
                 catch (error) {
                     if (error instanceof OperatorProposalBudgetError)
                         return JSON.stringify(error.diagnostic);
+                    if (error instanceof OperatorContractError)
+                        return JSON.stringify({ status: "invalid-intent",
+                            diagnostics: error.diagnostics, next_action: "Repair only the diagnosed fields and retry begin_operator_proposal; preserve original_request and every ordered requirement. No proposal was admitted and no budget was spent." });
                     throw error;
                 }
                 state = await proposals.bindGoal(context.sessionID, await control.proposalGoalBinding(context.sessionID));

package/dist/plugin/v2.js

@@ -136,6 +136,11 @@ function legacyToolName(name) {
 function legacyToolInput(name, input) {
     const value = record(input) ? { ...input } : {};
     if (name === "subagent") {
+        if (value.background === true && typeof value.prompt === "string" && value.prompt.startsWith("SORTIE_OPERATOR_")) {
+            throw new Error("operator-background-dispatch-not-supported: retry the same exact Task with background omitted or false; no admission or budget reservation occurred. Operator dispatch requires foreground completion for lifecycle accounting.");
+        }
+        if (value.background === false)
+            delete value.background;
         if (typeof value.agent === "string")
             value.subagent_type = value.agent;
         if (typeof value.sessionID === "string")

package/package.json

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