@wrongstack/core 0.63.4 → 0.66.13

package/dist/{events-k8CHjcrN.d.ts → events-CIplI98R.d.ts}

@@ -1,4 +1,4 @@
-import { $ as Usage, d as Context, X as ToolProgressEvent, Q as Tool } from './context-iFMEO2rN.js';
+import { $ as Usage, d as Context, X as ToolProgressEvent, Q as Tool } from './context-y87Jc5ei.js';
 
 /**
  * Brain coordination primitives.

package/dist/execution/index.d.ts

@@ -1,24 +1,24 @@
-export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, H as HybridCompactor, T as ToolExecutor } from '../tool-executor-CIjpGaRA.js';
-import { m as Provider, d as Context } from '../context-iFMEO2rN.js';
-import { a as Compactor, C as CompactReport } from '../compactor-0vjZ8KTk.js';
-import { M as MessageSelector } from '../selector-DxhW7ML3.js';
-import { E as EventBus } from '../events-k8CHjcrN.js';
-import { b as MiddlewareHandler } from '../system-prompt-7LHyBbIf.js';
-import { a as SessionEventBridge, J as JournalEntry } from '../goal-store-iHltMi5n.js';
-import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config-BdDuaZmB.js';
-import { c as Agent, R as RunResult, C as SystemPromptContributor } from '../index-Bc6BiP5q.js';
-import { D as DoneCondition } from '../multi-agent-SASYOrWA.js';
-import { A as AgentFactory } from '../agent-subagent-runner-Zc3f37Sg.js';
-import { f as DispatchClassifier, d as DefaultMultiAgentCoordinator } from '../multi-agent-coordinator-CNUJYq7U.js';
+export { C as CompactorOptions, a as DefaultErrorHandler, b as DefaultRetryPolicy, E as EternalAutonomyEngine, c as EternalAutonomyOptions, d as EternalEngineState, H as HybridCompactor, I as IterationStage, P as ParallelEngineState, e as ParallelEternalEngine, f as ParallelEternalOptions, g as ParallelIterationStage, T as ToolExecutor } from '../parallel-eternal-engine-0UwotoSx.js';
+import { m as Provider, d as Context } from '../context-y87Jc5ei.js';
+import { a as Compactor, C as CompactReport } from '../compactor-D_ExJajC.js';
+import { M as MessageSelector } from '../selector-RvBR_YRW.js';
+import { E as EventBus } from '../events-CIplI98R.js';
+import { b as MiddlewareHandler } from '../system-prompt-b61lOd49.js';
+import { a as SessionEventBridge } from '../session-event-bridge-CDHxcmQU.js';
+import { e as ContextWindowAggressiveOn, i as ContextWindowPolicy } from '../config--86aHSln.js';
+import { A as Agent, D as DoneCondition } from '../agent-subagent-runner-DRZ9-NnR.js';
+import { R as RunResult, S as SystemPromptContributor } from '../index-DKUvyTvV.js';
 import { a as SkillLoader, b as SkillManifest, S as SkillEntry } from '../skill-CxuWrsKK.js';
 import { a as WstackPaths } from '../wstack-paths-eMXnY1_X.js';
-import '../retry-policy-BfBScewS.js';
+import '../retry-policy-CG3qvH_e.js';
 import '../models-registry-BcYJDKLm.js';
+import '../goal-store-C7jcumEh.js';
+import '../multi-agent-coordinator-CWnH-CiX.js';
+import 'node:events';
 import '../logger-DDd5C--Z.js';
 import '../observability-BhnVLBLS.js';
+import '../permission-C1A5whY5.js';
 import '../secret-scrubber-3MHDDAtm.js';
-import '../permission-Ld-i5ugf.js';
-import 'node:events';
 
 interface SkillLoaderOptions {
     paths: WstackPaths;
@@ -316,375 +316,6 @@ declare class AutonomousRunner {
     stop(): void;
 }
 
-/**
- * Sense-decide-execute-reflect loop on top of a long-running Goal.
- *
- * Each iteration:
- *   1. Sense   — read goal, pending todos, `git status --porcelain`.
- *   2. Decide  — pick a source (todo / git / brainstorm) and a task.
- *   3. Execute — single agent.run with a directive prompt.
- *   4. Reflect — append a journal entry, persist state to disk.
- *
- * The loop runs forever until `stop()` is called externally (REPL SIGINT
- * handler, /autonomy stop). No internal time/cost cap by design — the
- * user wants "sittin sene". Failures are logged and the loop continues
- * with a different source on the next tick.
- */
-interface EternalAutonomyOptions {
-    agent: Agent;
-    projectRoot: string;
-    /**
-     * Per-iteration agent timeout. Defaults to 5 minutes. A single hung
-     * provider call should not freeze the whole eternal loop.
-     */
-    iterationTimeoutMs?: number;
-    /**
-     * Maximum number of internal agent.run iterations the engine grants per
-     * eternal-loop tick. The engine sets `autonomousContinue: true` so the
-     * agent can run multi-step tasks end-to-end within one tick instead of
-     * bouncing back to the engine after every single tool call. Default 500.
-     * Previous 50 was far too low — agents hit the limit and restart constantly.
-     */
-    iterationMaxAgentSteps?: number;
-    /**
-     * Minimum sleep between iterations. Defaults to 1 s — enough for
-     * SIGINT handlers to fire mid-loop without pegging a core when the
-     * provider is being rate-limited.
-     */
-    cycleGapMs?: number;
-    /**
-     * Maximum consecutive failures before the source rotation forces a
-     * brainstorm cycle. Default 3. Acts as a soft-recovery, not a stop.
-     */
-    failureBudget?: number;
-    /**
-     * Per-todo failed-attempt ceiling. When the engine picks the same todo
-     * and the iteration fails this many times in total, the todo is taken
-     * out of rotation (engine prefers other sources) until it changes
-     * status. Default 3. Prevents the loop from spinning forever on one
-     * stuck task.
-     */
-    todoMaxAttempts?: number;
-    /**
-     * Consecutive brainstorm-DONE responses required to consider the goal
-     * complete and stop the engine. When the LLM's brainstorm step keeps
-     * answering `DONE`, the engine treats that as "no more work" and, after
-     * this many in a row, marks the goal as completed instead of sleeping
-     * forever. Default 3.
-     */
-    brainstormDoneStopThreshold?: number;
-    /** Side-channel notifications (logging, UI updates). */
-    onIteration?: (entry: JournalEntry) => void;
-    onError?: (err: Error, iteration: number) => void;
-    /**
-     * Per-iteration phase notifications for live UI updates (TUI status bar,
-     * etc.). Fires at each major stage transition: idle → decide → execute →
-     * reflect → (sleep | paused | stopped). Fire-and-forget — the engine
-     * does not await the callback.
-     */
-    onStage?: (stage: IterationStage) => void;
-    /**
-     * Optional injected git status reader — production code uses git, tests
-     * stub this out so they don't shell out.
-     */
-    gitStatusReader?: () => Promise<string>;
-    /**
-     * Optional clock — tests stub for deterministic timestamps.
-     */
-    now?: () => Date;
-    /**
-     * Optional compactor. When provided, the engine runs compaction every
-     * `compactEveryNIterations` iterations to keep the agent's message
-     * history under control during multi-day eternal loops. Without
-     * compaction, an infinite loop will eventually overflow the provider's
-     * context window and start failing.
-     */
-    compactor?: Compactor;
-    /** How many iterations between compaction calls. Default 25. */
-    compactEveryNIterations?: number;
-    /**
-     * Aggressive compaction threshold. When ctx token usage exceeds this
-     * fraction of `maxContextTokens`, compaction runs in aggressive mode
-     * regardless of the iteration cadence. 0.85 by default.
-     */
-    aggressiveCompactRatio?: number;
-    /**
-     * Model's max context window in tokens. When set, the engine watches
-     * `currentRequestTokens()` against this and triggers aggressive compact
-     * before the next iteration would overflow. Omit to disable threshold
-     * checks (iteration cadence still applies).
-     */
-    maxContextTokens?: number;
-    /**
-     * Base delay (ms) for the first transient-error backoff. Subsequent
-     * transient failures double this, capped at `transientBackoffMaxMs`.
-     * Default 2_000.
-     *
-     * "Transient" means the underlying error is recoverable per
-     * `WrongStackError.recoverable` (ProviderError sets this for 429/529/5xx
-     * /network errors). Permanent errors (auth/invalid request) skip the
-     * backoff and count toward `failureBudget` like before — backing off
-     * on a permanent failure is wasted time.
-     */
-    transientBackoffBaseMs?: number;
-    /** Ceiling for the exponential backoff. Default 60_000 (60 s). */
-    transientBackoffMaxMs?: number;
-    /** Called when the eternal loop stops for any reason (manual stop, goal complete, etc.). */
-    onEternalStop?: () => void;
-}
-type EternalEngineState = 'idle' | 'running' | 'stopped';
-/**
- * Per-iteration phase emitted via `onStage` so UIs can render the
- * engine's live location in the sense-decide-execute-reflect loop.
- */
-type IterationStage = {
-    phase: 'idle';
-} | {
-    phase: 'decide';
-    reason: string;
-} | {
-    phase: 'execute';
-    task: string;
-} | {
-    phase: 'reflect';
-    status: 'success' | 'failure' | 'aborted' | 'skipped';
-    note?: string;
-} | {
-    phase: 'sleep';
-    ms: number;
-} | {
-    phase: 'paused';
-} | {
-    phase: 'stopped';
-} | {
-    phase: 'error';
-    message: string;
-};
-declare class EternalAutonomyEngine {
-    private readonly opts;
-    private state;
-    private stopRequested;
-    private consecutiveFailures;
-    private consecutiveBrainstormDone;
-    /**
-     * Count of consecutive transient (recoverable) provider failures. Drives
-     * the exponential backoff between iterations. Reset on the first
-     * successful iteration so a single bad afternoon doesn't permanently
-     * slow the loop down.
-     */
-    private consecutiveTransientRetries;
-    private currentCtrl;
-    private iterationsSinceCompact;
-    private readonly goalPath;
-    constructor(opts: EternalAutonomyOptions);
-    /** Current engine state — readable for UIs. */
-    get currentState(): EternalEngineState;
-    /** Synchronously request stop. Resolves once the running iteration aborts. */
-    stop(): void;
-    /**
-     * Mark the engine as 'running' on disk + reset stop state so a new
-     * batch of `runOneIteration()` calls can proceed. Called by the REPL
-     * when the user invokes `/autonomy eternal`. Idempotent.
-     */
-    prime(): Promise<void>;
-    /**
-     * Main loop. Returns when stop() is called or the goal file is removed.
-     * Does NOT throw — every iteration is wrapped to keep the loop alive.
-     */
-    run(): Promise<void>;
-    /**
-     * Execute a single sense-decide-execute-reflect cycle.
-     * Returns true on success, false on handled failure / no-op.
-     *
-     * Exposed publicly so the REPL can pace iterations from its main loop
-     * — running the engine and the REPL as a single sequential consumer of
-     * `agent.run()` avoids race conditions on the shared Context.
-     */
-    runOneIteration(): Promise<boolean>;
-    /**
-     * Run compaction when either trigger fires:
-     *   - We've done >= compactEveryNIterations since the last compact.
-     *   - Current request tokens exceed aggressiveCompactRatio * maxContext.
-     *
-     * The second check uses *aggressive* mode to free more headroom; the
-     * cadence check uses non-aggressive (cheaper).
-     */
-    private maybeCompact;
-    /**
-     * Hybrid idea source.
-     *   1. Pending todos on the agent's context.
-     *   2. Dirty git working tree → propose a "review and finish this" task.
-     *   3. Otherwise: brainstorm via the LLM against the goal.
-     *
-     * After failureBudget consecutive failures, force brainstorm so the
-     * engine doesn't loop on the same broken todo or stuck git state.
-     */
-    private decide;
-    private pickPendingTodo;
-    private pickGitTask;
-    private readGitStatus;
-    private brainstormTask;
-    private buildDirective;
-    /**
-     * Exponential backoff for transient provider errors. `2^N * base`
-     * capped at `transientBackoffMaxMs`. Zero base disables backoff.
-     * Public-private to keep `runOneIteration` readable; the value is
-     * recomputed each call from the current retry count, so callers
-     * don't have to track state.
-     */
-    private computeTransientBackoffMs;
-    /**
-     * Sleep that wakes early if `stopRequested` flips. Polls every 250 ms
-     * so SIGINT / `/autonomy stop` can land in the middle of a long
-     * backoff instead of waiting up to a minute for the timer.
-     */
-    private sleepInterruptible;
-    private appendIterationEntry;
-    /**
-     * Persistent per-todo failure counter. Skipped silently when the goal
-     * file has been removed (graceful clear). Each non-success iteration
-     * against a todo source bumps the counter by 1; `pickPendingTodo` reads
-     * the counter to rotate past stuck todos once they cross `todoMaxAttempts`.
-     */
-    private bumpTodoAttempt;
-    /**
-     * Flip the mission to `completed` and journal it. Called from two
-     * paths: (a) `[GOAL_COMPLETE]` marker in a successful iteration's
-     * finalText, (b) `brainstorm` returning DONE consecutively past the
-     * configured threshold. Idempotent — re-entry is a no-op once the
-     * goal is already `completed`.
-     */
-    private markGoalCompleted;
-    /**
-     * Manually clear the goal — equivalent to `/goal clear` typed by the user.
-     * Sets goalState to `abandoned`, removes the goal file, and fires
-     * `onEternalStop` so the REPL returns to normal mode.
-     */
-    private clearGoalManually;
-    private appendFailure;
-    private persistEngineState;
-}
-
-type ParallelEngineState = 'idle' | 'running' | 'stopped';
-type ParallelIterationStage = {
-    phase: 'idle';
-} | {
-    phase: 'decompose';
-} | {
-    phase: 'fanout';
-    slots: number;
-} | {
-    phase: 'await';
-    taskIds: string[];
-} | {
-    phase: 'aggregate';
-    successCount: number;
-    total: number;
-    goalComplete: boolean;
-} | {
-    phase: 'sleep';
-    ms: number;
-} | {
-    phase: 'stopped';
-} | {
-    phase: 'error';
-    message: string;
-};
-interface ParallelEternalOptions {
-    /** The coordinating agent — NOT a subagent. Owns container/tools/providers. */
-    agent: Agent;
-    /** Project root (used for goal.json path). */
-    projectRoot: string;
-    /**
-     * Override the resolved goal.json path. Defaults to
-     * `goalFilePath(projectRoot)` (a hashed location under the home dir).
-     * Primarily for tests that want an isolated goal file under a temp dir.
-     */
-    goalPath?: string;
-    /**
-     * Number of parallel subagent slots per tick.
-     * Default: 4. Range 1–16; values >8 are for high-throughput machines.
-     */
-    parallelSlots?: number;
-    /** Per-subagent default timeout in ms. Default: 300_000 (5 min). */
-    iterationTimeoutMs?: number;
-    onIteration?: (entry: JournalEntry) => void;
-    onError?: (err: Error, iteration: number) => void;
-    /** Per-tick phase notifications for live UI/status updates. */
-    onStage?: (stage: ParallelIterationStage) => void;
-    gitStatusReader?: () => Promise<string>;
-    now?: () => Date;
-    compactor?: Compactor;
-    compactEveryNIterations?: number;
-    aggressiveCompactRatio?: number;
-    maxContextTokens?: number;
-    /** Override the default agent factory (uses main agent if not provided). */
-    subagentFactory?: AgentFactory;
-    /**
-     * Route each decomposed slot task to the best-fit catalog agent via the
-     * smart dispatcher (heuristic keyword scoring). When enabled (default), each
-     * slot spawns in-role — the role's budget tier applies and a persona line is
-     * injected into the task — instead of as a faceless generic worker. Set
-     * false to keep the legacy generic spawn.
-     */
-    dispatch?: boolean;
-    /**
-     * Optional LLM fallback for ambiguous tasks. Passed straight to
-     * `dispatchAgent`; when omitted, routing is pure heuristic (instant, no
-     * provider call — preferred for a continuously-ticking autonomous loop).
-     */
-    dispatchClassifier?: DispatchClassifier;
-}
-/**
- * Sense → Decide → Fan-out (4–8 parallel agents) → Aggregate → Loop.
- *
- * Each tick:
- *   1. Sense    — load goal, todos, git status
- *   2. Decide   — decompose goal into N parallel sub-tasks
- *   3. Fan-out  — spawn N subagents simultaneously, await all
- *   4. Aggregate — write journal, update todos, check [GOAL_COMPLETE]
- *   5. Loop     — continue until stop() or mission complete
- *
- * Uses DefaultMultiAgentCoordinator + AgentSubagentRunner for subagent lifecycle.
- */
-declare class ParallelEternalEngine {
-    private readonly opts;
-    private state;
-    private stopRequested;
-    private iterationsSinceCompact;
-    private iterations;
-    private consecutiveFailures;
-    private readonly goalPath;
-    private readonly slots;
-    private readonly timeoutMs;
-    private coordinator;
-    private agentFactory;
-    private readonly dispatchEnabled;
-    private readonly dispatchClassifier?;
-    constructor(opts: ParallelEternalOptions);
-    get currentState(): ParallelEngineState;
-    /**
-     * Get the underlying coordinator for stats/monitoring.
-     */
-    getCoordinator(): DefaultMultiAgentCoordinator | null;
-    stop(): void;
-    prime(): Promise<void>;
-    run(): Promise<void>;
-    /**
-     * Execute one tick: decompose → fan-out → aggregate → compact.
-     * Called by the REPL in its main loop (REPL drives, engine is stateless per tick).
-     */
-    runOneIteration(): Promise<boolean>;
-    private fanOut;
-    private decomposeGoal;
-    private readGitStatus;
-    private brainstormSubtasks;
-    private maybeCompact;
-    private appendIterationEntry;
-    private appendFailure;
-    private persistState;
-}
-
 /**
  * System-prompt contributor that surfaces eternal-autonomy state to the
  * model on every turn.
@@ -754,4 +385,4 @@ declare function makeAutonomyPromptContributor(opts: AutonomyPromptContributorOp
  */
 declare function buildGoalPreamble(goal: string): string;
 
-export { AutoCompactionMiddleware, AutonomousRunner, type AutonomousRunnerOptions, type AutonomyPromptContributorOptions, DefaultSkillLoader, type DoneCheckResult, DoneConditionChecker, EternalAutonomyEngine, type EternalAutonomyOptions, type EternalEngineState, IntelligentCompactor, type IntelligentCompactorOptions, type IterationStage, type ParallelEngineState, ParallelEternalEngine, type ParallelEternalOptions, type ParallelIterationStage, SelectiveCompactor, type SelectiveCompactorOptions, type SkillLoaderOptions, buildGoalPreamble, makeAutonomyPromptContributor };
+export { AutoCompactionMiddleware, AutonomousRunner, type AutonomousRunnerOptions, type AutonomyPromptContributorOptions, DefaultSkillLoader, type DoneCheckResult, DoneConditionChecker, IntelligentCompactor, type IntelligentCompactorOptions, SelectiveCompactor, type SelectiveCompactorOptions, type SkillLoaderOptions, buildGoalPreamble, makeAutonomyPromptContributor };

package/dist/execution/index.js

@@ -3014,15 +3014,22 @@ var SubagentBudget = class _SubagentBudget {
     void this.checkLimits();
   }
   /**
-   * Wall-clock budget check. Unlike other limits, timeout is always a hard stop
-   * — wall-clock time cannot be "extended" by the coordinator, so it throws
-   * synchronously rather than entering the negotiation flow.
+   * Wall-clock / idle budget check. Delegates to `checkLimits(elapsed)`, so
+   * `timeout` and `idle_timeout` follow the SAME negotiation path as the other
+   * kinds — they are NOT a special-cased hard stop. This is deliberate: a
+   * heartbeat-aware policy (see `attachAutoExtend` and `CollabSession`) grants
+   * a timeout extension only while the agent is making progress and denies it
+   * once the agent is genuinely stuck, which is safer than an unconditional
+   * hard kill of a long-but-working agent. The runner translates the resulting
+   * `BudgetThresholdSignal` decision (`extend` → patch limits in place,
+   * `stop` → abort) just like every other kind.
    *
-   * Decision table:
-   * - no `onThreshold` handler         → throw `BudgetExceededError`
-   * - `mode === 'sync'`               → throw `BudgetExceededError`
-   * - `mode === 'auto'` + no listener  → throw `BudgetExceededError`
-   * - `mode === 'auto'` + listener     → throw `BudgetExceededError` (timeout is not extendable)
+   * Decision table (same as `checkLimits`):
+   * - no `onThreshold` handler        → throw `BudgetExceededError` (hard stop)
+   * - `mode === 'sync'`               → throw `BudgetExceededError` (hard stop)
+   * - `mode === 'auto'` + no listener → throw `BudgetExceededError` (no one to ask)
+   * - `mode === 'auto'` + listener    → throw `BudgetThresholdSignal` (negotiated;
+   *                                     a heartbeat-aware policy may extend the timeout)
    */
   checkTimeout() {
     if (this.startTime === null) return;
@@ -5710,7 +5717,10 @@ var NICKNAME_POOL = {
   "lavoisier": { name: "Lavoisier", domain: "chemistry" },
   "mendeleev": { name: "Mendeleev", domain: "chemistry" }
 };
-var ALL_NICKNAMES = Object.values(NICKNAME_POOL);
+var ALL_NICKNAMES = Object.entries(NICKNAME_POOL);
+Object.fromEntries(
+  ALL_NICKNAMES.map(([key, entry]) => [entry.name, key])
+);
 var DOMAIN_PREFERENCES = {
   "security": ["shannon", "turing", "lamarr", "stallman"],
   "bug-hunter": ["darwin", "curie", "feynman", "fermi"],
@@ -5743,17 +5753,16 @@ function assignNickname(role, used) {
   for (const key of preferences) {
     const entry = NICKNAME_POOL[key];
     if (entry && !used.has(key)) {
-      return `${entry.name} (${formatRole(role)})`;
+      return { key, display: `${entry.name} (${formatRole(role)})` };
     }
   }
-  for (const entry of ALL_NICKNAMES) {
-    const key = Object.entries(NICKNAME_POOL).find(([, v]) => v.name === entry.name)?.[0];
-    if (key && !used.has(key)) {
-      return `${entry.name} (${formatRole(role)})`;
+  for (const [key, entry] of ALL_NICKNAMES) {
+    if (!used.has(key)) {
+      return { key, display: `${entry.name} (${formatRole(role)})` };
     }
   }
   const counter = used.size + 1;
-  return `Scientist #${counter} (${formatRole(role)})`;
+  return { key: `scientist-${counter}`, display: `Scientist #${counter} (${formatRole(role)})` };
 }
 function formatRole(role) {
   return role.split(/[-_]/).map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
@@ -5840,11 +5849,10 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     const name = subagent.name?.trim() ?? "";
     const isPlaceholder = name === "" || name.toLowerCase() === role.toLowerCase() || name === "subagent" || name === "adhoc" || name === "generic" || /^slot-/.test(name);
     if (!isPlaceholder) return subagent;
-    const nickname = assignNickname(role, this.usedNicknames);
-    const baseKey = nickname.split(" ")[0].toLowerCase().replace(/[^a-z0-9-]/g, "-");
-    this.usedNicknames.add(baseKey);
-    this.subagentNicknames.set(subagentId, baseKey);
-    return { ...subagent, name: nickname };
+    const { key, display } = assignNickname(role, this.usedNicknames);
+    this.usedNicknames.add(key);
+    this.subagentNicknames.set(subagentId, key);
+    return { ...subagent, name: display };
   }
   async spawn(subagent) {
     const id = subagent.id || randomUUID();
@@ -6096,23 +6104,32 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
    */
   drainPendingAsAborted(message) {
     const dropped = this.pendingTasks.splice(0, this.pendingTasks.length);
-    for (const t of dropped) {
-      const synthetic = {
-        subagentId: t.subagentId ?? "unassigned",
-        taskId: t.id,
-        status: "stopped",
-        error: {
-          kind: "aborted_by_parent",
-          message,
-          retryable: false
-        },
-        iterations: 0,
-        toolCalls: 0,
-        durationMs: 0
-      };
-      this.completedResults.push(synthetic);
-      this.emit("task.completed", { task: t, result: synthetic });
-    }
+    for (const t of dropped) this.emitPendingAborted(t, message);
+  }
+  /**
+   * Emit a synthetic `stopped`/`aborted_by_parent` completion for a single
+   * PENDING task — one that was never counted in `inFlight`. This MUST bypass
+   * `recordCompletion`: that path does `inFlight--`, which for a pending task
+   * steals a decrement from a genuinely in-flight task and trips the underflow
+   * guard — suppressing that real task's `task.completed` and hanging its
+   * `awaitTasks()` caller. Pushes the result and fires the event directly.
+   */
+  emitPendingAborted(task, message) {
+    const synthetic = {
+      subagentId: task.subagentId ?? "unassigned",
+      taskId: task.id,
+      status: "stopped",
+      error: {
+        kind: "aborted_by_parent",
+        message,
+        retryable: false
+      },
+      iterations: 0,
+      toolCalls: 0,
+      durationMs: 0
+    };
+    this.completedResults.push(synthetic);
+    this.emit("task.completed", { task, result: synthetic });
   }
   async runDispatched(subagentId, task) {
     const subagent = this.subagents.get(subagentId);
@@ -6373,20 +6390,10 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     const orphaned = this.pendingTasks.filter((t) => t.subagentId === subagentId);
     this.pendingTasks = this.pendingTasks.filter((t) => t.subagentId !== subagentId);
     for (const t of orphaned) {
-      const synthetic = {
-        subagentId,
-        taskId: t.id,
-        status: "stopped",
-        error: {
-          kind: "aborted_by_parent",
-          message: `Subagent "${subagentId}" was removed while task "${t.id}" was pending`,
-          retryable: false
-        },
-        iterations: 0,
-        toolCalls: 0,
-        durationMs: 0
-      };
-      this.recordCompletion(synthetic);
+      this.emitPendingAborted(
+        t,
+        `Subagent "${subagentId}" was removed while task "${t.id}" was pending`
+      );
     }
     this.fleetBus?.emit({
       subagentId,
@@ -6764,6 +6771,7 @@ ${personaLine}Task: ${task}
     } catch {
       results = coordinator.results().slice(-taskIds.length);
     }
+    await Promise.allSettled(subagentIds.map((id) => coordinator.remove(id)));
     const allSuccessful = results.length > 0 && results.every((r) => r.status === "success");
     const goalComplete = results.some(
       (r) => r.status === "success" && typeof r.result === "string" && GOAL_COMPLETE_MARKER2.test(r.result)