sortie-dogs 0.3.21 → 0.4.0

package/README.md

@@ -20,7 +20,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.3.21](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.3.21)
+Release: [v0.4.0](https://github.com/zufall-upon/Sortie-dogs/releases/tag/v0.4.0)
 
 ## Quick start
 

package/dist/asset-version.d.ts

@@ -2,5 +2,5 @@
  * Version of the installable runtime assets. Kept in its own module so the plugin can compare an
  * installed project marker without importing every asset body.
  */
-export declare const RUNTIME_ASSET_VERSION = "0.3.6-card43";
+export declare const RUNTIME_ASSET_VERSION = "0.3.7-fast-lane-v1";
 export type RuntimeAssetVersion = typeof RUNTIME_ASSET_VERSION;

package/dist/asset-version.js

@@ -2,4 +2,4 @@
  * Version of the installable runtime assets. Kept in its own module so the plugin can compare an
  * installed project marker without importing every asset body.
  */
-export const RUNTIME_ASSET_VERSION = "0.3.6-card43";
+export const RUNTIME_ASSET_VERSION = "0.3.7-fast-lane-v1";

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

@@ -0,0 +1,21 @@
+export declare const BACKLOG_DRAIN_CAPABILITY = "sortie_enable_backlog_drain";
+export type FastLaneDenialCode = "TURN_STATE_REQUIRED" | "ROLE_FORBIDDEN" | "WORKER_LIMIT" | "SCOUT_GAP_REQUIRED" | "SCOUT_LIMIT" | "SCOUT_TOO_LATE" | "REVIEW_EVIDENCE_REQUIRED" | "REVIEW_PHASE_INVALID" | "REVIEW_LIMIT" | "ADVISOR_TRIGGER_REQUIRED" | "ADVISOR_LIMIT" | "CONSULTATION_RETRY_INVALID" | "CONSULTATION_RETRY_UNAUTHORIZED" | "CONSULTATION_RETRY_MISMATCH" | "BACKLOG_DRAIN_INVALID" | "BACKLOG_DRAIN_TOO_LATE" | "MANUAL_COMPACTION_FORBIDDEN";
+export declare class FastLaneDeniedError extends Error {
+    readonly code: FastLaneDenialCode;
+    constructor(code: FastLaneDenialCode);
+}
+export interface FastLaneToolOptions {
+    readonly consultationFallbackAuthorized?: boolean;
+}
+export declare class FastLaneController {
+    private readonly sessions;
+    private setSession;
+    beginTurn(sessionID: string, synthetic: boolean): void;
+    forget(sessionID: string): void;
+    manualCompactionForbidden(sessionID: string): boolean;
+    backlogDrainEnabled(sessionID: string): boolean;
+    backlogContinuationAllowed(sessionID: string): boolean;
+    enableBacklogDrain(sessionID: string, maxUnits: number): void;
+    continuationQueued(sessionID: string): void;
+    beforeTool(sessionID: string, tool: string, args: unknown, options?: FastLaneToolOptions): void;
+}

package/dist/plugin/fast-lane.js

@@ -0,0 +1,230 @@
+import { isSourceReviewRiskTag, STRATEGY_TRIGGERS } from "../core/consultation.js";
+const MAX_SESSIONS = 256;
+const GAP_CODES = new Set(["manifest", "validation", "owner-risk"]);
+const STRATEGY_TRIGGER_SET = new Set(STRATEGY_TRIGGERS);
+const MANUAL_COMPACTION_TOOLS = new Set(["compact_and_continue", "sortie_compact_and_continue"]);
+export const BACKLOG_DRAIN_CAPABILITY = "sortie_enable_backlog_drain";
+export class FastLaneDeniedError extends Error {
+    code;
+    constructor(code) {
+        super(`SORTIE_FAST_LANE_DENIED: ${code}`);
+        this.name = "FastLaneDeniedError";
+        this.code = code;
+    }
+}
+function taskArgument(args, key) {
+    if (args === null || typeof args !== "object" || Array.isArray(args))
+        return undefined;
+    const value = args[key];
+    return typeof value === "string" ? value : undefined;
+}
+function lineValue(prompt, key) {
+    const values = [...prompt.matchAll(new RegExp(`^\\s*${key}\\s*:\\s*(.+?)\\s*$`, "gmu"))];
+    return values.length === 1 ? values[0][1] : undefined;
+}
+function hasReviewEvidence(prompt) {
+    if (lineValue(prompt, "canonical_validation_exit") !== "0")
+        return false;
+    const rawTags = lineValue(prompt, "risk_tags");
+    if (rawTags === undefined || !/^\[[^\[\]]+\]$/u.test(rawTags))
+        return false;
+    const tags = rawTags.slice(1, -1).split(",").map((tag) => tag.trim());
+    return tags.length > 0 && tags.every((tag) => tag.length > 0) &&
+        new Set(tags).size === tags.length && tags.every(isSourceReviewRiskTag);
+}
+function freshState() {
+    return {
+        advisorDispatches: 0,
+        backlogDrain: false,
+        continuationPending: false,
+        initialReviewDispatches: 0,
+        verificationReviewDispatches: 0,
+        scoutDispatches: 0,
+        totalWorkerDispatches: 0,
+        workerLimit: 1,
+        workerDispatches: 0,
+    };
+}
+function lockedState() {
+    return {
+        advisorDispatches: 2,
+        backlogDrain: false,
+        continuationPending: false,
+        initialReviewDispatches: 2,
+        verificationReviewDispatches: 2,
+        scoutDispatches: 1,
+        totalWorkerDispatches: 1,
+        workerLimit: 1,
+        workerDispatches: 1,
+    };
+}
+function fallbackBasis(prompt) {
+    return prompt.replace(/\r\n?/gu, "\n")
+        .split("\n")
+        .filter((line) => !/^\s*fallback_retry\s*:\s*true\s*$/u.test(line))
+        .join("\n")
+        .trimEnd();
+}
+export class FastLaneController {
+    sessions = new Map();
+    setSession(sessionID, state) {
+        this.sessions.delete(sessionID);
+        this.sessions.set(sessionID, state);
+        while (this.sessions.size > MAX_SESSIONS)
+            this.sessions.delete(this.sessions.keys().next().value);
+    }
+    beginTurn(sessionID, synthetic) {
+        if (synthetic) {
+            const state = this.sessions.get(sessionID);
+            if (state === undefined) {
+                this.setSession(sessionID, lockedState());
+            }
+            else if (state.backlogDrain && state.continuationPending) {
+                state.advisorDispatches = 0;
+                delete state.advisorPrompt;
+                state.continuationPending = false;
+                state.initialReviewDispatches = 0;
+                delete state.initialReviewPrompt;
+                state.verificationReviewDispatches = 0;
+                delete state.verificationReviewPrompt;
+                state.scoutDispatches = 0;
+                state.workerDispatches = 0;
+            }
+            return;
+        }
+        this.setSession(sessionID, freshState());
+    }
+    forget(sessionID) {
+        this.sessions.delete(sessionID);
+    }
+    manualCompactionForbidden(sessionID) {
+        const state = this.sessions.get(sessionID);
+        return state !== undefined && state.workerDispatches > 0 &&
+            (!state.backlogDrain || state.totalWorkerDispatches >= state.workerLimit);
+    }
+    backlogDrainEnabled(sessionID) {
+        return this.sessions.get(sessionID)?.backlogDrain === true;
+    }
+    backlogContinuationAllowed(sessionID) {
+        const state = this.sessions.get(sessionID);
+        return state?.backlogDrain === true && state.workerDispatches === 1 &&
+            state.totalWorkerDispatches < state.workerLimit && !state.continuationPending;
+    }
+    enableBacklogDrain(sessionID, maxUnits) {
+        const state = this.sessions.get(sessionID);
+        if (state === undefined)
+            throw new FastLaneDeniedError("TURN_STATE_REQUIRED");
+        if (!Number.isInteger(maxUnits) || maxUnits < 4 || maxUnits > 11) {
+            throw new FastLaneDeniedError("BACKLOG_DRAIN_INVALID");
+        }
+        if (state.backlogDrain || state.totalWorkerDispatches > 0) {
+            throw new FastLaneDeniedError("BACKLOG_DRAIN_TOO_LATE");
+        }
+        state.backlogDrain = true;
+        state.workerLimit = maxUnits;
+    }
+    continuationQueued(sessionID) {
+        const state = this.sessions.get(sessionID);
+        if (this.backlogContinuationAllowed(sessionID) && state !== undefined) {
+            state.continuationPending = true;
+        }
+    }
+    beforeTool(sessionID, tool, args, options = {}) {
+        const state = this.sessions.get(sessionID);
+        if (state === undefined) {
+            if (tool === "task" || MANUAL_COMPACTION_TOOLS.has(tool)) {
+                throw new FastLaneDeniedError("TURN_STATE_REQUIRED");
+            }
+            return;
+        }
+        if (MANUAL_COMPACTION_TOOLS.has(tool)) {
+            if (!this.backlogContinuationAllowed(sessionID)) {
+                throw new FastLaneDeniedError("MANUAL_COMPACTION_FORBIDDEN");
+            }
+            return;
+        }
+        if (tool !== "task")
+            return;
+        const role = taskArgument(args, "subagent_type");
+        const prompt = taskArgument(args, "prompt") ?? "";
+        if (role === "dog-worker") {
+            if (state.workerDispatches >= 1 || state.totalWorkerDispatches >= state.workerLimit) {
+                throw new FastLaneDeniedError("WORKER_LIMIT");
+            }
+            state.workerDispatches += 1;
+            state.totalWorkerDispatches += 1;
+            return;
+        }
+        if (role === "dog-scout") {
+            if (state.workerDispatches > 0)
+                throw new FastLaneDeniedError("SCOUT_TOO_LATE");
+            const gap = lineValue(prompt, "missing_evidence_code");
+            if (gap === undefined || !GAP_CODES.has(gap))
+                throw new FastLaneDeniedError("SCOUT_GAP_REQUIRED");
+            if (state.scoutDispatches >= 1)
+                throw new FastLaneDeniedError("SCOUT_LIMIT");
+            state.scoutDispatches += 1;
+            return;
+        }
+        if (role === "dog-reviewer") {
+            if (!hasReviewEvidence(prompt))
+                throw new FastLaneDeniedError("REVIEW_EVIDENCE_REQUIRED");
+            const phase = lineValue(prompt, "review_phase");
+            if (phase !== "initial" && phase !== "verification") {
+                throw new FastLaneDeniedError("REVIEW_PHASE_INVALID");
+            }
+            const retry = lineValue(prompt, "fallback_retry");
+            const count = phase === "initial" ? state.initialReviewDispatches : state.verificationReviewDispatches;
+            const previousPrompt = phase === "initial" ? state.initialReviewPrompt : state.verificationReviewPrompt;
+            if (phase === "initial" && state.verificationReviewDispatches > 0) {
+                throw new FastLaneDeniedError("REVIEW_PHASE_INVALID");
+            }
+            if (phase === "verification" && state.initialReviewDispatches === 0) {
+                throw new FastLaneDeniedError("REVIEW_PHASE_INVALID");
+            }
+            if ((count === 0 && retry !== undefined) || (count === 1 && retry !== "true")) {
+                throw new FastLaneDeniedError("CONSULTATION_RETRY_INVALID");
+            }
+            if (count === 1 && options.consultationFallbackAuthorized !== true) {
+                throw new FastLaneDeniedError("CONSULTATION_RETRY_UNAUTHORIZED");
+            }
+            if (count === 1 && previousPrompt !== fallbackBasis(prompt)) {
+                throw new FastLaneDeniedError("CONSULTATION_RETRY_MISMATCH");
+            }
+            if (count >= 2)
+                throw new FastLaneDeniedError("REVIEW_LIMIT");
+            if (phase === "initial") {
+                state.initialReviewPrompt ??= fallbackBasis(prompt);
+                state.initialReviewDispatches += 1;
+            }
+            else {
+                state.verificationReviewPrompt ??= fallbackBasis(prompt);
+                state.verificationReviewDispatches += 1;
+            }
+            return;
+        }
+        if (role === "dog-advisor") {
+            const trigger = lineValue(prompt, "strategy_trigger");
+            if (trigger === undefined || !STRATEGY_TRIGGER_SET.has(trigger)) {
+                throw new FastLaneDeniedError("ADVISOR_TRIGGER_REQUIRED");
+            }
+            const retry = lineValue(prompt, "fallback_retry");
+            if ((state.advisorDispatches === 0 && retry !== undefined) ||
+                (state.advisorDispatches === 1 && retry !== "true")) {
+                throw new FastLaneDeniedError("CONSULTATION_RETRY_INVALID");
+            }
+            if (state.advisorDispatches === 1 && options.consultationFallbackAuthorized !== true) {
+                throw new FastLaneDeniedError("CONSULTATION_RETRY_UNAUTHORIZED");
+            }
+            if (state.advisorDispatches === 1 && state.advisorPrompt !== fallbackBasis(prompt)) {
+                throw new FastLaneDeniedError("CONSULTATION_RETRY_MISMATCH");
+            }
+            if (state.advisorDispatches >= 2)
+                throw new FastLaneDeniedError("ADVISOR_LIMIT");
+            state.advisorPrompt ??= fallbackBasis(prompt);
+            state.advisorDispatches += 1;
+            return;
+        }
+        throw new FastLaneDeniedError("ROLE_FORBIDDEN");
+    }
+}

package/dist/plugin/index.js

@@ -6,10 +6,11 @@ import { normalizeRelativePath, RelativePathError } from "../core/path.js";
 import { validateManifest } from "../core/validate-manifest.js";
 import { safeSchemaPointer, validateHandoffSchema, validateOperationManifestSchema, } from "../core/validate-schema.js";
 import { DEFAULT_PLUGIN_OPTIONS, resolvePluginConfiguration, resolvePluginConfigurationSourcesWithGlobal, } from "./config.js";
-import { CONTINUATION_CAPABILITY, createContinuationHooks, } from "./continuation.js";
+import { CONTINUATION_CAPABILITY, CONTINUATION_MARKER, ROLLOVER_MARKER, createContinuationHooks, } from "./continuation.js";
 import { WriteDeniedError, canonicalManifestReadScopes, canonicalManifestWriteScopes, createProjectPaths, createWriteGate, describeUnclassifiedCommand, isGitMutation, isKnownReadOnlyTool, isRemoteMutation, normalizeCommand, resolveProjectRoot, safePath, writeScopesOverlap, } from "./gate.js";
+import { BACKLOG_DRAIN_CAPABILITY, FastLaneController } from "./fast-lane.js";
 import { createModelRoutingHook, } from "./model-routing-hook.js";
-import { createTaskResultRepairHook, markConsultationFallbackRetry, } from "./task-result-repair.js";
+import { createTaskResultRepairHook, markConsultationFallbackRetry, taskChildSessionID, } from "./task-result-repair.js";
 import { configRoot, nearestPackageVersion, reflectionEnabled, ReflectionError, ReflectionStore } from "../reflection/index.js";
 const INPUT_LIMITS = { config: 64 * 1024, manifest: 512 * 1024, handoff: 2 * 1024 * 1024 };
 const INSPECTION_CACHE = { maximum: 256, ttlMilliseconds: 30 * 60 * 1000 };
@@ -592,6 +593,7 @@ export const SortieDogsPlugin = async (input, options) => {
     const bindingOperations = new Set();
     const activeSessions = new Map();
     const coordinatorRoots = new Map();
+    const coordinatorTaskCalls = new Map();
     const reflectionOwnedRoots = new Set();
     const reflectionClosingRoots = new Set();
     const reflectionInFlight = new Map();
@@ -602,6 +604,34 @@ export const SortieDogsPlugin = async (input, options) => {
     const sessionRoots = new Map();
     const consultationRetries = new Map();
     const taskResultRepair = createTaskResultRepairHook(input.client);
+    const fastLane = new FastLaneController();
+    function beginCoordinatorTask(sessionID, callID) {
+        const calls = coordinatorTaskCalls.get(sessionID) ?? new Set();
+        calls.add(callID);
+        coordinatorTaskCalls.set(sessionID, calls);
+    }
+    function finishCoordinatorTask(sessionID, callID) {
+        if (sessionID === undefined || callID === undefined)
+            return;
+        const calls = coordinatorTaskCalls.get(sessionID);
+        if (calls === undefined)
+            return;
+        calls.delete(callID);
+        if (calls.size === 0)
+            coordinatorTaskCalls.delete(sessionID);
+    }
+    function childHasInFlightParentTask(sessionID) {
+        const parentID = sessionParents.get(sessionID);
+        return parentID !== undefined && (coordinatorTaskCalls.get(parentID)?.size ?? 0) > 0;
+    }
+    function abortCoordinatorTasks(sessionID) {
+        if (!coordinatorTaskCalls.delete(sessionID))
+            return;
+        for (const [childID, parentID] of [...sessionParents]) {
+            if (parentID === sessionID)
+                evictSession(childID);
+        }
+    }
     function hasSessionEnforcementState(sessionID) {
         return sessionAuthorizations.has(sessionID) || bindingPins.has(sessionID);
     }
@@ -1465,7 +1495,20 @@ export const SortieDogsPlugin = async (input, options) => {
                 async execute(_args, context) {
                     // A configuration failure must not remove the loop; the shipped default still resolves.
                     await ensureLoaded().catch(() => undefined);
-                    return await continuation.tool.execute({}, context);
+                    const result = await continuation.tool.execute({}, context);
+                    if (result === "SORTIE_COMPACT_AND_CONTINUE_QUEUED") {
+                        fastLane.continuationQueued(context.sessionID);
+                    }
+                    return result;
+                },
+            }),
+            [BACKLOG_DRAIN_CAPABILITY]: defineTool({
+                description: "Enable one explicit bounded backlog drain before its first worker dispatch.",
+                args: { max_units: defineTool.schema.string() },
+                async execute(args, context) {
+                    const maxUnits = Number(args.max_units);
+                    fastLane.enableBacklogDrain(context.sessionID, maxUnits);
+                    return JSON.stringify({ status: "enabled", max_units: maxUnits });
                 },
             }),
             ...(reflectionStartup ? {
@@ -1506,7 +1549,19 @@ export const SortieDogsPlugin = async (input, options) => {
             } : {}),
         },
         "experimental.text.complete": async (textInput, textOutput) => {
+            const backlogMarker = fastLane.backlogContinuationAllowed(textInput.sessionID) &&
+                textOutput.text.includes(CONTINUATION_MARKER);
+            if (fastLane.manualCompactionForbidden(textInput.sessionID)) {
+                textOutput.text = textOutput.text
+                    .replaceAll(ROLLOVER_MARKER, "")
+                    .replaceAll(CONTINUATION_MARKER, "")
+                    .trimEnd();
+                return;
+            }
             await continuation.textComplete(textInput, textOutput);
+            if (backlogMarker && continuation.blocksTool(textInput.sessionID)) {
+                fastLane.continuationQueued(textInput.sessionID);
+            }
         },
         "experimental.session.compacting": async (compactInput, compactOutput) => {
             await continuation.sessionCompacting(compactInput, compactOutput);
@@ -1516,10 +1571,12 @@ export const SortieDogsPlugin = async (input, options) => {
         },
         "chat.message": async (chatInput, output) => {
             const parentID = chatParentID(chatInput);
+            const synthetic = output.parts.some((part) => isRecord(part) && part.synthetic === true);
             if (parentID !== undefined)
                 rememberParent(chatInput.sessionID, parentID);
             const coordinatorOrigin = chatInput.agent === COORDINATOR_AGENT || output.message.agent === COORDINATOR_AGENT;
             if (coordinatorOrigin) {
+                fastLane.beginTurn(chatInput.sessionID, synthetic);
                 releaseSessionEnforcement(chatInput.sessionID);
                 await rememberCoordinatorRoot(chatInput.sessionID);
             }
@@ -1566,31 +1623,36 @@ export const SortieDogsPlugin = async (input, options) => {
                 }
             }
             if (coordinatorOrigin) {
-                const synthetic = output.parts.some((part) => isRecord(part) && part.synthetic === true);
                 continuation.observeModel(chatInput.sessionID, output.message.model, synthetic);
             }
         },
-        ...(reflectionStartup ? { "experimental.chat.system.transform": async (transformInput, transformOutput) => {
-                if (!(await beginReflection(transformInput.sessionID)))
+        "experimental.chat.system.transform": async (transformInput, transformOutput) => {
+            if (fastLane.manualCompactionForbidden(transformInput.sessionID)) {
+                transformOutput.system = [...(transformOutput.system ?? []),
+                    "SORTIE_FAST_LANE_TERMINAL\nA worker was already dispatched in this normal lane. " +
+                        "Do not call a compaction capability or emit a continuation marker. " +
+                        "After any required risk-based review or coordinator-owned finalization, return the terminal report and stop."];
+            }
+            if (!reflectionStartup || !(await beginReflection(transformInput.sessionID)))
+                return;
+            const config = reflectionConfiguration;
+            try {
+                if (!config)
                     return;
-                const config = reflectionConfiguration;
-                try {
-                    if (!config)
-                        return;
-                    const heading = "SORTIE_PROCESS_REFLECTIONS";
-                    const buckets = ["run", "project", "global"]
-                        .filter((layer) => config.layers[layer])
-                        .map((layer) => ({ layer, ...(layer === "global" ? {} : { run: transformInput.sessionID }) }));
-                    const budget = Math.max(0, config.maxInjectedTokens - Buffer.byteLength(`${heading}\n`, "utf8"));
-                    const text = await reflectionStore.injectBuckets(buckets, config.maxInjectedEntries, budget, reflectionVersion);
-                    if (text)
-                        transformOutput.system = [...(transformOutput.system ?? []), `${heading}\n${text}`];
-                }
-                catch { /* reflection is strictly non-invasive */ }
-                finally {
-                    endReflection(transformInput.sessionID);
-                }
-            } } : {}),
+                const heading = "SORTIE_PROCESS_REFLECTIONS";
+                const buckets = ["run", "project", "global"]
+                    .filter((layer) => config.layers[layer])
+                    .map((layer) => ({ layer, ...(layer === "global" ? {} : { run: transformInput.sessionID }) }));
+                const budget = Math.max(0, config.maxInjectedTokens - Buffer.byteLength(`${heading}\n`, "utf8"));
+                const text = await reflectionStore.injectBuckets(buckets, config.maxInjectedEntries, budget, reflectionVersion);
+                if (text)
+                    transformOutput.system = [...(transformOutput.system ?? []), `${heading}\n${text}`];
+            }
+            catch { /* reflection is strictly non-invasive */ }
+            finally {
+                endReflection(transformInput.sessionID);
+            }
+        },
         "permission.ask": async (permission) => {
             if (permission.permission !== "edit")
                 return;
@@ -1626,6 +1688,7 @@ export const SortieDogsPlugin = async (input, options) => {
          * erases an answer the worker already produced and the coordinator re-dispatches the same work.
          */
         "tool.execute.after": async (toolInput, output) => {
+            const completedChildSessionID = toolInput.tool === "task" ? taskChildSessionID(output) : undefined;
             try {
                 const repair = await taskResultRepair(toolInput, output);
                 if (repair.kind === "unrecoverable-empty" && toolInput.sessionID !== undefined) {
@@ -1643,6 +1706,10 @@ export const SortieDogsPlugin = async (input, options) => {
             }
             finally {
                 activeSessions.get(toolInput.sessionID ?? "")?.inFlightCalls.delete(toolInput.callID ?? "");
+                if (toolInput.tool === "task")
+                    finishCoordinatorTask(toolInput.sessionID, toolInput.callID);
+                if (completedChildSessionID !== undefined)
+                    evictSession(completedChildSessionID);
             }
         },
         "tool.execute.before": async (toolInput, output) => {
@@ -1650,6 +1717,18 @@ export const SortieDogsPlugin = async (input, options) => {
                 if (continuation.blocksTool(toolInput.sessionID)) {
                     throw new Error("SORTIE_ROLLOVER_PENDING: stop this turn and wait for compaction");
                 }
+                const taskRole = isRecord(output.args) && typeof output.args.subagent_type === "string"
+                    ? output.args.subagent_type
+                    : undefined;
+                const role = consultationAgent(taskRole);
+                const consultationFallbackAuthorized = role !== undefined &&
+                    consultationRetries.get(consultationRetryKey(toolInput.sessionID, role))?.phase === "pending";
+                fastLane.beforeTool(toolInput.sessionID, toolInput.tool, output.args, {
+                    consultationFallbackAuthorized,
+                });
+                if (toolInput.tool === "task" && taskRole === "dog-worker") {
+                    beginCoordinatorTask(toolInput.sessionID, toolInput.callID);
+                }
                 return;
             }
             const status = activeSessionStatus(toolInput.sessionID);
@@ -1747,6 +1826,8 @@ export const SortieDogsPlugin = async (input, options) => {
                 return;
             }
             if (event.type === "session.deleted") {
+                fastLane.forget(eventSessionID);
+                abortCoordinatorTasks(eventSessionID);
                 if (reflectionStore !== undefined && reflectionConfiguration?.layers.run && reflectionOwnedRoots.has(eventSessionID)) {
                     reflectionClosingRoots.add(eventSessionID);
                     await waitForReflections(eventSessionID);
@@ -1785,18 +1866,24 @@ export const SortieDogsPlugin = async (input, options) => {
                 await continuation.sessionCompacted(eventSessionID);
             if (event.type === "session.idle")
                 await continuation.sessionIdle(eventSessionID);
+            if (event.type === "session.idle" && isCoordinatorSession(eventSessionID)) {
+                abortCoordinatorTasks(eventSessionID);
+            }
             if (!isActiveSession(eventSessionID))
                 return;
             if (event.type !== "session.idle")
                 touchActiveSession(eventSessionID);
             if (event.type === "session.idle" && eventSessionID !== undefined) {
                 activeSessions.get(eventSessionID)?.inFlightCalls.clear();
+                if (childHasInFlightParentTask(eventSessionID)) {
+                    touchActiveSession(eventSessionID);
+                    return;
+                }
                 const authorization = sessionAuthorizations.get(eventSessionID);
                 if (authorization === undefined)
                     return;
                 try {
-                    // Idle revalidates the pinned handoff but always releases write ownership. A resumed
-                    // worker must bind again, so a completed serial worker cannot block later work.
+                    // Idle is the abnormal-exit fallback when the parent Task completion hook never arrives.
                     await inspect(authorization.handoffPath, eventSessionID);
                 }
                 catch {

package/dist/plugin/task-result-repair.d.ts

@@ -56,6 +56,7 @@ export type TaskResultRepairOutcome = {
 export declare const CONSULTATION_FALLBACK_RETRY_MARKER = "SORTIE_CONSULTATION_FALLBACK_RETRY";
 /** Assistant text the child actually produced, ignoring the empty tail that caused the defect. */
 export declare function lastAssistantText(messages: readonly SessionMessage[]): string | undefined;
+export declare function taskChildSessionID(output: TaskToolExecuteOutput): string | undefined;
 /**
  * Repair only the exact defect: a completed `task` call whose result body is empty while the child
  * session holds real assistant text. Everything else is left byte-identical.

package/dist/plugin/task-result-repair.js

@@ -36,7 +36,7 @@ export function lastAssistantText(messages) {
     }
     return undefined;
 }
-function childSessionID(output) {
+export function taskChildSessionID(output) {
     const metadata = output.metadata;
     if (metadata === null || typeof metadata !== "object")
         return undefined;
@@ -72,7 +72,7 @@ export function createTaskResultRepairHook(client) {
         const match = emptyResultMatch(output);
         if (match === undefined)
             return unchanged;
-        const sessionID = childSessionID(output);
+        const sessionID = taskChildSessionID(output);
         if (sessionID === undefined)
             return unchanged;
         let recovered;