sortie-dogs 0.12.22 → 0.12.23

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.12.22-mission-replacement-v1";
+export declare const V010_RUNTIME_ASSET_VERSION = "0.12.23-mission-budget-recovery-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION | typeof V010_RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -3,4 +3,4 @@
  * installed project marker without importing every asset body.
  */
 export const RUNTIME_ASSET_VERSION = "0.3.89-completion-proof-v1";
-export const V010_RUNTIME_ASSET_VERSION = "0.12.22-mission-replacement-v1";
+export const V010_RUNTIME_ASSET_VERSION = "0.12.23-mission-budget-recovery-v1";

package/dist/plugin/index.js

@@ -7884,6 +7884,32 @@ export const SortieDogsPlugin = async (input, options) => {
                 cost_note: "Worker token-price estimates from complete native usage; missing requests remain unknown and are reconciled on later status. Excludes orchestration/review and external campaign spend. Zero settled cost does not mean free execution." };
             return snapshot;
         },
+        extendMissionUnitBudget: (root, maxUnits) => serializeChatTransition(root, async () => {
+            if (!isCoordinatorSession(root) && !await recoverCoordinatorRoot(root))
+                throw new Error("operator-coordinator-required");
+            await recoverPendingRealGoalTurn(root);
+            await recoverCompletedGoalReservations(root);
+            const ledger = await goalLedger(root), state = (await ledger.readGoal()).state;
+            if (state.phase !== "active" || state.receipt !== null || state.goal_id === null || state.budget === null ||
+                state.latest_user_message_id === null)
+                throw new Error("mission-budget-goal-not-active");
+            if (!Number.isSafeInteger(maxUnits) || maxUnits <= 0 || maxUnits < state.budget.max_units ||
+                maxUnits < state.consumed_units + state.outstanding_reservations.length)
+                throw new Error("mission-budget-limit-invalid");
+            const changed = maxUnits > state.budget.max_units;
+            if (changed) {
+                await ledger.appendGoal({ kind: "goal.revised", at: new Date().toISOString(), goal_id: state.goal_id,
+                    revision: state.revision + 1, scope_epoch: state.scope_epoch + 1,
+                    acceptance_fingerprint: state.acceptance_fingerprint, origin_user_message_id: state.latest_user_message_id,
+                    session_id: root, selected_agent: state.selected_agent, delivery: state.delivery,
+                    budget: { ...state.budget, max_units: maxUnits, source: "user-revision" },
+                    acceptance_contract: state.acceptance_contract });
+            }
+            const updated = (await ledger.readGoal()).state;
+            const reserved = updated.outstanding_reservations.length;
+            return { status: changed ? "extended" : "unchanged", max_units: updated.budget.max_units, consumed_units: updated.consumed_units,
+                reserved_units: reserved, remaining_units: updated.budget.max_units - updated.consumed_units - reserved };
+        }),
         ...{
             missionWorkerTerminal: async (childSessionID, writeScopes) => {
                 const active = activeSessions.get(childSessionID), authorization = sessionAuthorizations.get(childSessionID);

package/dist/plugin/profiled.js

@@ -663,6 +663,14 @@ export function createProfiledPlugin(profile, assetVersion) {
         function missionDispatchPacket(mission, run) {
             const packet = { ...missionPacket(mission, run), project_root: input.directory,
                 coordinator_dispatch: mission.dispatchOpen ? "active" : ["completed", "cancelled"].includes(mission.phase) ? "terminal" : "resumable" };
+            if (mission.phase === "submitted" && mission.submission?.status === "blocked" &&
+                run?.units.some(unit => unit.status === "running")) {
+                return { ...packet, next_action: `If the native Worker Task is still active, wait for it; do not start a duplicate. ` +
+                        `If its parent Task was interrupted and the user chose to stop/replan, Operator root (not Coordinator): ` +
+                        `call ${profile.toolPrefix}cancel_operator with reason=plain to stop owned children, then ` +
+                        `${profile.toolPrefix}start_mission with intent=replace and the saved requirements. ` +
+                        `Use the returned Coordinator Task; the previous Mission is archived and cumulative spend is retained.` };
+            }
             if (sourceReconciliationRequired(mission, run))
                 return { ...packet, status: "mission-source-reconciliation-required",
                     next_action: mission.dispatchOpen ? "The Coordinator Task is still active. Do not redispatch; wait for its native completion and reconcile via operator_status."
@@ -1072,7 +1080,10 @@ export function createProfiledPlugin(profile, assetVersion) {
                 const mission = await missions.read(context.sessionID);
                 if (mission && !["completed", "cancelled"].includes(mission.phase)) {
                     await stop(context.sessionID, "explicit-cancellation", false);
-                    return JSON.stringify(missionPacket(await missions.required(context.sessionID), await operators.read(context.sessionID)));
+                    return JSON.stringify({ ...missionPacket(await missions.required(context.sessionID), await operators.read(context.sessionID)),
+                        next_action: `Owned children were stopped; cumulative spend is retained. To continue the same request, ` +
+                            `Operator root calls ${profile.toolPrefix}start_mission with intent=replace and the saved requirements, ` +
+                            `then dispatches its returned Coordinator Task. The cancelled Mission is historical; do not reuse its Worker.` });
                 }
                 const rawReason = args.reason;
                 const requestedReason = rawReason === "plain" || rawReason === undefined ? undefined : rawReason;
@@ -1471,8 +1482,22 @@ export function createProfiledPlugin(profile, assetVersion) {
                     return JSON.stringify({ ...proposalIdentity(committed), execution: JSON.parse(preparedTask(prepared.state)) });
                 });
             } };
-        const startMission = `${profile.toolPrefix}start_mission`, planUnits = `${profile.toolPrefix}plan_units`, reviewMission = `${profile.toolPrefix}review_mission`, submitMission = `${profile.toolPrefix}submit_mission`, completeMission = `${profile.toolPrefix}complete_mission`, expandUnit = `${profile.toolPrefix}expand_unit`, skipMissionConsultation = `${profile.toolPrefix}skip_mission_consultation`;
+        const startMission = `${profile.toolPrefix}start_mission`, planUnits = `${profile.toolPrefix}plan_units`, reviewMission = `${profile.toolPrefix}review_mission`, submitMission = `${profile.toolPrefix}submit_mission`, completeMission = `${profile.toolPrefix}complete_mission`, expandUnit = `${profile.toolPrefix}expand_unit`, skipMissionConsultation = `${profile.toolPrefix}skip_mission_consultation`, extendMissionBudget = `${profile.toolPrefix}extend_mission_budget`;
         const stringList = { type: "array", items: { type: "string" } };
+        tools[extendMissionBudget] = { description: "Root-only: after the user explicitly approves a cumulative Worker-unit increase, extend the same active Mission's host goal budget. max_units is the new cumulative total, not an increment. Preserve consumed/reserved units, requirements and execution; this does not dispatch a Worker or change the campaign cost cap. Read operator_status for the exact mission ID and counters, then resume its existing Coordinator.",
+            args: { mission_id: stringSchema, max_units: { type: "integer", minimum: 1 } }, execute: async (args, context) => {
+                await requireRoot(context.sessionID);
+                return serializeDispatchTransition(context.sessionID, async () => {
+                    const mission = await missions.required(context.sessionID);
+                    if (mission.id !== args.mission_id || ["cancelled", "completed"].includes(mission.phase))
+                        throw new Error("mission-budget-mission-not-active");
+                    const maxUnits = Number(args.max_units);
+                    const result = await control.extendMissionUnitBudget(context.sessionID, maxUnits);
+                    const { status, ...budget } = result;
+                    return JSON.stringify({ status, mission_id: mission.id, budget,
+                        next_action: "Read operator_status: if the Coordinator dispatch is active, continue it; otherwise dispatch the returned task to resume the same Coordinator. Retain requirements, spend and candidate; no new mission or plan approval." });
+                });
+            } };
         tools[startMission] = { description: "Operator: save the current user requirements. Use intent=replace when the user changes an existing request (version, parallelism, target): host cancels the previous run and archives its requirements/results while retaining spend. If status reports mission-source-reconciliation-required and the saved requirements reflect that changed scope, call intent=replace with those exact requirements: the host repairs this mission in place and keeps its Coordinator. Supply the complete current requirements, retaining constraints the user has not changed. For separate work in a different location use intent=new. Dispatch the Coordinator immediately, or plan_units for a known single-unit procedure; item count and runtime alone do not require a Coordinator.",
             args: { requirements: { ...stringList, minItems: 1, maxItems: 64 },
                 kind: { type: "string", enum: ["implementation", "operation"], description: "Use operation for running an existing benchmark, command or procedure. The host records its actual execution separately from setup and checks.", "x-sortie-optional": true },
@@ -1771,6 +1796,14 @@ export function createProfiledPlugin(profile, assetVersion) {
                     return await serializeDispatchTransition(root, () => declareMissionUnits(root, context.sessionID, mission, args.units, args.reason, args.execution));
                 }
                 catch (error) {
+                    if (error instanceof Error && error.message === "mission-replan-worker-still-active") {
+                        return JSON.stringify({ status: error.message, mission_id: mission.id,
+                            next_action: `Coordinator: do not repeat plan_units or try ${cancel} (root-only). ` +
+                                `If the Worker Task is still active, wait for its native completion. If its parent Task was interrupted, ` +
+                                `submit_mission with status=blocked and report this code, the Worker/Task IDs and what did not run. ` +
+                                `Operator root can then use ${cancel} with reason=plain to stop owned children and resume the request ` +
+                                `through ${startMission} with intent=replace, preserving cumulative spend. No duplicate Worker.` });
+                    }
                     if (!(error instanceof OperatorContractError))
                         throw error;
                     return JSON.stringify({ status: "invalid-plan", diagnostics: error.diagnostics, diagnostics_truncated: error.diagnostics_truncated,

package/dist/plugin/runtime-bridge.d.ts

@@ -105,6 +105,13 @@ export interface RuntimeBridge {
             readonly reserved_units: number;
             readonly remaining_units: number;
         } | null>;
+        extendMissionUnitBudget(rootSessionID: string, maxUnits: number): Promise<{
+            readonly status: "extended" | "unchanged";
+            readonly max_units: number;
+            readonly consumed_units: number;
+            readonly reserved_units: number;
+            readonly remaining_units: number;
+        }>;
         renderReturnReport(rootSessionID: string, text: string, receiptFingerprint: string): Promise<string | undefined>;
         recoverUnitEvidence(rootSessionID: string, request: {
             unitID: string;

package/dist/runtime-mission-assets.js

@@ -42,7 +42,7 @@ permission:
     ${profileAgent(profile, "dog-advisor")}: allow
 tools:
   "sortie_*": false
-${controls(profile, ["start_mission", "plan_units", "operator_next", "operator_status", "expand_unit", "review_mission", "complete_mission", "cancel_operator", "reflection"])}
+${controls(profile, ["start_mission", "plan_units", "operator_next", "operator_status", "extend_mission_budget", "expand_unit", "review_mission", "complete_mission", "cancel_operator", "reflection"])}
 ---
 # ${profileAgent(profile, "dog-coordinator")}
 
@@ -70,6 +70,12 @@ quality threshold and explicit model/budget choice. Follow AGENTS.md and use the
     SAME mission before any Worker starts, retains its Coordinator and cumulative spend, and checks
     old children before preparing a Worker. This is not permission to discard unchanged acceptance:
     if the scope is uncertain, ask the user which requirements remain instead of inferring a replacement.
+    If a Coordinator reports mission-replan-worker-still-active after an interrupted native Task,
+    it cannot call cancel_operator (root-only). Inspect operator_status and the native Task outcome.
+    If the Worker is still active, wait, not duplicate. If the user chose to stop/replan, root calls
+    ${profile.toolPrefix}cancel_operator with reason: "plain" to stop its owned children, then
+    ${profile.toolPrefix}start_mission with intent: "replace" and the saved requirements. The cancelled
+    Mission is archived; cumulative spend is retained. Dispatch only the returned Coordinator Task.
 2. Dispatch the returned ${profileAgent(profile, "dog-operator")} task immediately. It owns investigation,
    unit boundaries, Worker/Scout/Advisor/independent Reviewer calls, write-scope extensions and corrections
    within the original request and cumulative budget. Do not investigate or approve each unit at the root.
@@ -107,7 +113,10 @@ Use foreground delegation. Unit progress is displayed on the running Task withou
 Do not poll or re-run successful checks. Inspect operator_status only to recover missing durable state.
 Ordinary defects return to Coordinator, not the user. Ask through question only for a user-only choice,
 an extension beyond the original requirements, or a cumulative budget increase. Resume the same work after
-the answer. Do not reset spend, silently shrink acceptance, or create substitute goals.
+the answer. For an approved Mission Worker-unit increase, root calls ${profile.toolPrefix}extend_mission_budget
+with operator_status.mission_id and the new cumulative max_units (not the increment), then resumes the same
+Coordinator. This does not change a separate campaign dollar cap or dispatch a Worker. Do not reset spend,
+silently shrink acceptance, or create substitute goals.
 
 When bounded process reflections are injected, pass the relevant prevention in Coordinator feedback while
 preserving the original requirements. After a resolved repeated process failure, record its verified cause/prevention

package/package.json

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