sortie-dogs 0.9.3 → 0.9.4

package/README.md

@@ -24,7 +24,7 @@ Requirements: Node.js 22.6 or newer, npm, and OpenCode.
 
 Guides: [日本語](docs/guide-ja.md) · [简体中文](docs/guide-zh-CN.md) · [CLI testing](docs/cli-testing.md)
 
-Release: [v0.9.3](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.3)
+Release: [v0.9.4](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.9.4)
 
 ## Quick start
 

package/dist/plugin/fast-lane.d.ts

@@ -4,6 +4,15 @@ export declare class FastLaneDeniedError extends Error {
     readonly code: FastLaneDenialCode;
     constructor(code: FastLaneDenialCode);
 }
+export interface WorkerAccounting {
+    readonly totalWorkerDispatches: number;
+    readonly workerDispatches: number;
+    readonly workerInFlight: boolean;
+    readonly workerResumeUsed: boolean;
+    readonly workerResumeSessionID?: string;
+    readonly workerResumeTaskID?: string;
+    readonly workerTaskID?: string;
+}
 export interface FastLaneToolOptions {
     readonly readonlyDiagnosisAuthorized?: boolean;
     readonly consultationFallbackAuthorized?: boolean;
@@ -25,5 +34,8 @@ export declare class FastLaneController {
     continuationQueued(sessionID: string): void;
     authorizeRecoverableWorkerResume(sessionID: string, taskID: string, childSessionID: string): boolean;
     workerCompleted(sessionID: string): void;
+    /** Snapshot worker accounting so a later denial in the same dispatch cannot leak the slot. */
+    snapshotWorkerAccounting(sessionID: string): WorkerAccounting | undefined;
+    restoreWorkerAccounting(sessionID: string, snapshot: WorkerAccounting | undefined): void;
     beforeTool(sessionID: string, tool: string, args: unknown, options?: FastLaneToolOptions): string | undefined;
 }

package/dist/plugin/fast-lane.js

@@ -199,6 +199,32 @@ export class FastLaneController {
         if (state !== undefined)
             state.workerInFlight = false;
     }
+    /** Snapshot worker accounting so a later denial in the same dispatch cannot leak the slot. */
+    snapshotWorkerAccounting(sessionID) {
+        const state = this.sessions.get(sessionID);
+        if (state === undefined)
+            return undefined;
+        return { totalWorkerDispatches: state.totalWorkerDispatches, workerDispatches: state.workerDispatches,
+            workerInFlight: state.workerInFlight, workerResumeUsed: state.workerResumeUsed,
+            workerResumeSessionID: state.workerResumeSessionID, workerResumeTaskID: state.workerResumeTaskID,
+            workerTaskID: state.workerTaskID };
+    }
+    restoreWorkerAccounting(sessionID, snapshot) {
+        const state = this.sessions.get(sessionID);
+        if (state === undefined || snapshot === undefined)
+            return;
+        state.totalWorkerDispatches = snapshot.totalWorkerDispatches;
+        state.workerDispatches = snapshot.workerDispatches;
+        state.workerInFlight = snapshot.workerInFlight;
+        state.workerResumeUsed = snapshot.workerResumeUsed;
+        for (const [key, value] of Object.entries({ workerResumeSessionID: snapshot.workerResumeSessionID,
+            workerResumeTaskID: snapshot.workerResumeTaskID, workerTaskID: snapshot.workerTaskID })) {
+            if (value === undefined)
+                delete state[key];
+            else
+                state[key] = value;
+        }
+    }
     beforeTool(sessionID, tool, args, options = {}) {
         const state = this.sessions.get(sessionID);
         if (state === undefined) {

package/dist/plugin/index.js

@@ -6231,46 +6231,55 @@ export const SortieDogsPlugin = async (input, options) => {
                     // therefore be repaired by a corrected Task call in this same coordinator turn.
                     await bindGoalDeclaration(toolInput.sessionID, typeof output.args.prompt === "string" ? output.args.prompt : "");
                 }
+                // Accounting is provisional until this dispatch is fully admitted. A later denial such as a
+                // budget stop must release the serial slot, or no worker could be dispatched or resumed again.
+                const workerAccounting = fastLane.snapshotWorkerAccounting(toolInput.sessionID);
                 const resumedWorkerSessionID = fastLane.beforeTool(toolInput.sessionID, toolInput.tool, output.args, {
                     readonlyDiagnosisAuthorized: readonlyDiagnosis,
                     consultationFallbackAuthorized,
                     parallelWorkerAlreadyBound,
                     parallelWorkerAuthorized,
                 });
-                if (toolInput.tool === "task" && taskRole !== undefined && IMPLEMENTATION_AGENTS.has(taskRole) &&
-                    isRecord(output.args)) {
-                    await reserveGoalDispatch(toolInput.sessionID, toolInput.callID, typeof output.args.prompt === "string" ? output.args.prompt : "");
-                }
-                if (validatedRootAcceptance !== undefined && reservedParallelDescriptor === undefined) {
-                    rootAcceptanceContinuity.delete(toolInput.sessionID);
-                    rootAcceptanceContinuity.set(toolInput.sessionID, validatedRootAcceptance);
-                    while (rootAcceptanceContinuity.size > ACTIVE_SESSION_CACHE.maximum) {
-                        rootAcceptanceContinuity.delete(rootAcceptanceContinuity.keys().next().value);
+                try {
+                    if (toolInput.tool === "task" && taskRole !== undefined && IMPLEMENTATION_AGENTS.has(taskRole) &&
+                        isRecord(output.args)) {
+                        await reserveGoalDispatch(toolInput.sessionID, toolInput.callID, typeof output.args.prompt === "string" ? output.args.prompt : "");
                     }
-                }
-                if (resumedWorkerSessionID !== undefined) {
-                    const recoverableParallel = parallelRecoverableChildren.get(resumedWorkerSessionID);
-                    if (recoverableParallel !== undefined) {
-                        parallelCalls.set(toolInput.callID, recoverableParallel);
-                        parallelRecoverableChildren.delete(resumedWorkerSessionID);
+                    if (validatedRootAcceptance !== undefined && reservedParallelDescriptor === undefined) {
+                        rootAcceptanceContinuity.delete(toolInput.sessionID);
+                        rootAcceptanceContinuity.set(toolInput.sessionID, validatedRootAcceptance);
+                        while (rootAcceptanceContinuity.size > ACTIVE_SESSION_CACHE.maximum) {
+                            rootAcceptanceContinuity.delete(rootAcceptanceContinuity.keys().next().value);
+                        }
                     }
-                    recoverableWorkerChildren.delete(resumedWorkerSessionID);
-                }
-                if (toolInput.tool === "task" && taskRole !== undefined && IMPLEMENTATION_AGENTS.has(taskRole)) {
-                    if (readonlyDiagnosis && isRecord(output.args))
-                        await claimDiagnosisTask(toolInput.sessionID, toolInput.callID, output.args, true);
-                    bootstrapRequired = false;
-                    bootstrapCompleted = true;
-                    bootstrapIdleWarnings.delete(toolInput.sessionID);
-                    beginCoordinatorTask(toolInput.sessionID, toolInput.callID);
-                    if (reservedParallelDescriptor !== undefined) {
-                        parallelCalls.set(toolInput.callID, {
-                            ownerRoot: toolInput.sessionID,
-                            descriptor: reservedParallelDescriptor,
-                            completionCallID: toolInput.callID,
-                        });
+                    if (resumedWorkerSessionID !== undefined) {
+                        const recoverableParallel = parallelRecoverableChildren.get(resumedWorkerSessionID);
+                        if (recoverableParallel !== undefined) {
+                            parallelCalls.set(toolInput.callID, recoverableParallel);
+                            parallelRecoverableChildren.delete(resumedWorkerSessionID);
+                        }
+                        recoverableWorkerChildren.delete(resumedWorkerSessionID);
+                    }
+                    if (toolInput.tool === "task" && taskRole !== undefined && IMPLEMENTATION_AGENTS.has(taskRole)) {
+                        if (readonlyDiagnosis && isRecord(output.args))
+                            await claimDiagnosisTask(toolInput.sessionID, toolInput.callID, output.args, true);
+                        bootstrapRequired = false;
+                        bootstrapCompleted = true;
+                        bootstrapIdleWarnings.delete(toolInput.sessionID);
+                        beginCoordinatorTask(toolInput.sessionID, toolInput.callID);
+                        if (reservedParallelDescriptor !== undefined) {
+                            parallelCalls.set(toolInput.callID, {
+                                ownerRoot: toolInput.sessionID,
+                                descriptor: reservedParallelDescriptor,
+                                completionCallID: toolInput.callID,
+                            });
+                        }
                     }
                 }
+                catch (error) {
+                    fastLane.restoreWorkerAccounting(toolInput.sessionID, workerAccounting);
+                    throw error;
+                }
                 return;
             }
             const status = activeSessionStatus(toolInput.sessionID);

package/package.json

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