@wrongstack/core 0.6.3 → 0.6.5

package/dist/{agent-bridge-eb7qnNrd.d.ts → agent-bridge-BBXK_ppx.d.ts}

@@ -1,4 +1,4 @@
-import { B as BridgeTransport, l as BridgeMessage, A as AgentBridge, m as AgentBridgeConfig } from './multi-agent-CxSb-9dQ.js';
+import { B as BridgeTransport, l as BridgeMessage, A as AgentBridge, m as AgentBridgeConfig } from './multi-agent-D5IbASk_.js';
 
 /**
  * In-memory pub/sub transport for agent-to-agent messaging.

package/dist/agent-subagent-runner-DsSm9lKN.d.ts

@@ -0,0 +1,174 @@
+import { A as Agent, k as AgentInput } from './index-DcnXDPdY.js';
+import { E as EventBus } from './events-CJqwQl8G.js';
+import { c as SubagentConfig, k as TaskSpec, i as SubagentRunner } from './multi-agent-D5IbASk_.js';
+
+/**
+ * Single fleet-wide event with subagent attribution. Whatever a child
+ * agent emits on its own EventBus gets re-published here, prefixed with
+ * `subagentId` so a single subscriber can multiplex across the fleet.
+ *
+ * The director uses `FleetBus.filter('tool.executed', …)` to see every
+ * tool call across the fleet; the TUI uses
+ * `FleetBus.subscribe(id, handler)` to render a per-subagent panel.
+ */
+interface FleetEvent {
+    subagentId: string;
+    taskId?: string;
+    ts: number;
+    type: string;
+    payload: unknown;
+}
+type FleetHandler = (event: FleetEvent) => void;
+/**
+ * Fan-in for per-subagent EventBuses. Each subagent's bus is plugged in
+ * via `attach()`; the FleetBus re-emits every event with subagent
+ * attribution. Detachment is automatic via the returned disposer — call
+ * it when a subagent terminates so we don't leak listeners.
+ *
+ * The bus exposes two subscription modes: by `subagentId` (everything
+ * from one child) and by `type` (one event-type across the fleet). They
+ * compose — if you need a per-subagent + per-type slice, subscribe by
+ * type and filter on `event.subagentId` in your handler.
+ */
+declare class FleetBus {
+    private readonly byId;
+    private readonly byType;
+    private readonly any;
+    /**
+     * Hook a subagent's EventBus into the fleet. EventBus is strongly
+     * typed and doesn't expose an `onAny` hook, so we subscribe to the
+     * canonical set of event types a subagent emits during a run. New
+     * event types added to the kernel must be added here too — but the
+     * cost is a tiny single line per type, and the explicit list keeps
+     * the wire format clear.
+     *
+     * Returns a disposer that detaches every subscription; call on
+     * subagent teardown so the listeners don't outlive the run.
+     */
+    attach(subagentId: string, bus: EventBus, taskId?: string): () => void;
+    /** Subscribe to every event from one subagent. */
+    subscribe(subagentId: string, handler: FleetHandler): () => void;
+    /** Subscribe to one event type across all subagents. */
+    filter(type: string, handler: FleetHandler): () => void;
+    /** Subscribe to literally everything. The fleet roll-up uses this. */
+    onAny(handler: FleetHandler): () => void;
+    emit(event: FleetEvent): void;
+}
+/**
+ * Roll-up of token usage + cost across an entire director run. The
+ * director's `fleet_status` tool returns this so the model can reason
+ * about budget in its next turn ("the researcher already burned $0.40,
+ * lean on summaries for the next task").
+ */
+interface FleetUsage {
+    total: {
+        input: number;
+        output: number;
+        cacheRead: number;
+        cacheWrite: number;
+        cost: number;
+    };
+    perSubagent: Record<string, SubagentUsageSnapshot>;
+}
+interface SubagentUsageSnapshot {
+    subagentId: string;
+    provider?: string;
+    model?: string;
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+    cost: number;
+    toolCalls: number;
+    iterations: number;
+    startedAt: number;
+    lastEventAt: number;
+}
+/**
+ * Aggregates provider.response + tool.executed events from the FleetBus
+ * into a live `FleetUsage` snapshot. Costs are computed by the caller
+ * via a `priceLookup(subagentId)` so we don't bake provider-pricing
+ * coupling into core; the CLI/tests supply a function that resolves
+ * each subagent's per-token rates from the models registry.
+ */
+declare class FleetUsageAggregator {
+    private readonly bus;
+    private readonly priceLookup?;
+    private readonly metaLookup?;
+    private readonly perSubagent;
+    private readonly total;
+    constructor(bus: FleetBus, priceLookup?: ((subagentId: string) => {
+        input?: number;
+        output?: number;
+        cacheRead?: number;
+        cacheWrite?: number;
+    } | undefined) | undefined, metaLookup?: ((subagentId: string) => {
+        provider?: string;
+        model?: string;
+    } | undefined) | undefined);
+    /** Live snapshot — safe to call from a tool's execute() body. */
+    snapshot(): FleetUsage;
+    private ensure;
+    private onProviderResponse;
+    private onToolExecuted;
+    private onIterationStarted;
+}
+
+/**
+ * Caller-supplied factory that builds an isolated `Agent` for a subagent.
+ * The factory MUST construct a fresh `Context` per call — sharing context
+ * between subagents defeats isolation. Each Agent should also use either
+ * its own `EventBus` or a forwarded view, so per-subagent metrics can be
+ * attributed correctly.
+ */
+type AgentFactory = (config: SubagentConfig) => Promise<AgentFactoryResult>;
+interface AgentFactoryResult {
+    agent: Agent;
+    /** Event bus the factory wired to this agent — required for budget hookup. */
+    events: EventBus;
+    /**
+     * Optional cleanup hook invoked in the runner's `finally` block once
+     * the task ends (success, failure, abort — same exit path). Factories
+     * that own resources scoped to a single task (per-subagent JSONL
+     * writers, transient providers, throwaway containers) implement this
+     * to close them deterministically instead of relying on GC. Errors
+     * thrown here are swallowed so a flaky cleanup can't mask the task's
+     * real result.
+     */
+    dispose?: () => Promise<void> | void;
+}
+interface AgentRunnerOptions {
+    factory: AgentFactory;
+    /**
+     * Format a TaskSpec into the user input the agent will receive. Defaults
+     * to `task.description ?? ''`. Override when subagents expect structured
+     * input (e.g. JSON contracts, role-prefixed prompts).
+     */
+    formatTaskInput?: (task: TaskSpec, config: SubagentConfig) => AgentInput;
+    /**
+     * When set, the runner attaches the subagent's EventBus to this FleetBus
+     * on task start and detaches it when the task finishes. This is the
+     * injection seam that lets the TUI fleet panel observe subagent activity
+     * live — without it, FleetBus stays empty.
+     */
+    fleetBus?: FleetBus;
+}
+/**
+ * Builds a `SubagentRunner` that drives a real `Agent` per task while honoring
+ * the coordinator's budget and abort signal. This is the production adapter —
+ * the coordinator's `runner` option in CLI/TUI assemblies points here.
+ *
+ * Lifecycle per task:
+ *   1. factory(config) → fresh Agent + EventBus.
+ *   2. Subscribe to events to feed the budget (tool calls, token usage).
+ *   3. Call agent.run(input, { signal }) — the coordinator's signal cancels.
+ *   4. Map RunResult.status onto a `SubagentRunOutcome` or throw on failure.
+ *   5. Unsubscribe and let the factory's resources be GC'd.
+ *
+ * The budget is checked synchronously from event handlers — a runaway agent
+ * that crosses its tool-call limit triggers `BudgetExceededError`, which the
+ * coordinator surfaces as `status: 'failed'` on the task result.
+ */
+declare function makeAgentSubagentRunner(opts: AgentRunnerOptions): SubagentRunner;
+
+export { type AgentFactory as A, FleetBus as F, type SubagentUsageSnapshot as S, type AgentFactoryResult as a, type AgentRunnerOptions as b, type FleetEvent as c, type FleetHandler as d, type FleetUsage as e, FleetUsageAggregator as f, makeAgentSubagentRunner as m };

package/dist/{compactor-RIPuTtWK.d.ts → compactor-C8NhpSt5.d.ts}

@@ -1,4 +1,4 @@
-import { a2 as Context } from './context-CDRyrkKQ.js';
+import { a2 as Context } from './context-DN5v-uQX.js';
 
 interface CompactRepairReport {
     removedToolUses: string[];

package/dist/{config-BGGuP_Ar.d.ts → config-DfC6g6KV.d.ts}

@@ -1,5 +1,5 @@
 import { W as WireFamily } from './models-registry-Y2xbog0E.js';
-import { P as Permission } from './context-CDRyrkKQ.js';
+import { P as Permission } from './context-DN5v-uQX.js';
 
 type ContextWindowModeId = 'balanced' | 'frugal' | 'deep' | 'archival';
 type ContextWindowAggressiveOn = 'hard' | 'soft' | 'warn';

package/dist/{context-CDRyrkKQ.d.ts → context-DN5v-uQX.d.ts}

@@ -696,6 +696,12 @@ interface SessionStore {
     resume(id: string): Promise<ResumedSession>;
     list(limit?: number): Promise<SessionSummary[]>;
     delete(id: string): Promise<void>;
+    /**
+     * Rewrite the session JSONL file to contain only a fresh session_start
+     * event, effectively clearing all conversation history for that session.
+     * Called by /clear to wipe persistent chat history.
+     */
+    clearHistory(id: string): Promise<void>;
 }
 interface SessionWriter {
     readonly id: string;
@@ -736,6 +742,11 @@ interface SessionWriter {
      * Returns the number of events removed.
      */
     truncateToCheckpoint(promptIndex: number): Promise<number>;
+    /**
+     * Clear the session transcript file, resetting the on-disk history.
+     * Called by /clear to wipe chat history from persistent storage.
+     */
+    clearSession(): Promise<void>;
 }
 
 interface CacheStats {

package/dist/coordination/index.d.ts

@@ -1,14 +1,15 @@
-export { A as ALL_FLEET_AGENTS, a as AUDIT_LOG_AGENT, b as AgentFactory, c as AgentFactoryResult, d as AgentRunnerOptions, B as BUG_HUNTER_AGENT, C as CreateDelegateToolOptions, D as DEFAULT_DIRECTOR_PREAMBLE, e as DEFAULT_SUBAGENT_BASELINE, f as DefaultMultiAgentCoordinator, g as DelegateHost, h as Director, i as DirectorPromptParts, j as DirectorSessionFactory, k as DirectorSessionFactoryOptions, F as FLEET_ROSTER, m as FleetBus, K as FleetCostCapError, n as FleetEvent, o as FleetHandler, p as FleetManager, q as FleetManagerOptions, r as FleetSpawnBudgetError, s as FleetUsage, t as FleetUsageAggregator, I as ICoordinator, u as IFleetManager, M as MultiAgentCoordinatorOptions, N as NULL_FLEET_BUS, R as REFACTOR_PLANNER_AGENT, S as SECURITY_SCANNER_AGENT, v as SubagentPromptParts, w as SubagentUsageSnapshot, y as composeDirectorPrompt, z as composeSubagentPrompt, E as createDelegateTool, G as makeAgentSubagentRunner, H as makeDirectorSessionFactory, J as rosterSummaryFromConfigs } from '../index-CPcDqvZh.js';
-export { n as BudgetExceededError, o as BudgetKind, p as BudgetLimits, s as BudgetThresholdDecision, t as BudgetThresholdHandler, u as BudgetThresholdSignal, q as BudgetUsage, r as SubagentBudget } from '../multi-agent-CxSb-9dQ.js';
-export { I as InMemoryAgentBridge, a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-eb7qnNrd.js';
+export { A as ALL_FLEET_AGENTS, a as AUDIT_LOG_AGENT, B as BUG_HUNTER_AGENT, C as CreateDelegateToolOptions, D as DEFAULT_DIRECTOR_PREAMBLE, b as DEFAULT_SUBAGENT_BASELINE, c as DefaultMultiAgentCoordinator, d as DelegateHost, e as Director, f as DirectorPromptParts, g as DirectorSessionFactory, h as DirectorSessionFactoryOptions, F as FLEET_ROSTER, u as FleetCostCapError, j as FleetManager, k as FleetManagerOptions, l as FleetSpawnBudgetError, I as ICoordinator, m as IFleetManager, M as MultiAgentCoordinatorOptions, N as NULL_FLEET_BUS, R as REFACTOR_PLANNER_AGENT, S as SECURITY_SCANNER_AGENT, n as SubagentPromptParts, p as composeDirectorPrompt, q as composeSubagentPrompt, r as createDelegateTool, s as makeDirectorSessionFactory, t as rosterSummaryFromConfigs } from '../index-CXnWsGBp.js';
+export { n as BudgetExceededError, o as BudgetKind, p as BudgetLimits, s as BudgetThresholdDecision, t as BudgetThresholdHandler, u as BudgetThresholdSignal, q as BudgetUsage, r as SubagentBudget } from '../multi-agent-D5IbASk_.js';
+export { A as AgentFactory, a as AgentFactoryResult, b as AgentRunnerOptions, F as FleetBus, c as FleetEvent, d as FleetHandler, e as FleetUsage, f as FleetUsageAggregator, S as SubagentUsageSnapshot, m as makeAgentSubagentRunner } from '../agent-subagent-runner-DsSm9lKN.js';
+export { I as InMemoryAgentBridge, a as InMemoryBridgeTransport, c as createMessage } from '../agent-bridge-BBXK_ppx.js';
 import '../director-state-BmYi3DGA.js';
-import '../context-CDRyrkKQ.js';
-import '../events-BHuIHekD.js';
+import '../context-DN5v-uQX.js';
 import 'node:events';
-import '../index-BOn9NK7D.js';
+import '../events-CJqwQl8G.js';
+import '../index-DcnXDPdY.js';
 import '../logger-BMQgxvdy.js';
-import '../system-prompt-Dl2QY1_B.js';
+import '../system-prompt-gL06H9P4.js';
 import '../observability-BhnVLBLS.js';
-import '../secret-scrubber-CfMdAJ_l.js';
-import '../config-BGGuP_Ar.js';
+import '../secret-scrubber-CT7wefiO.js';
+import '../config-DfC6g6KV.js';
 import '../models-registry-Y2xbog0E.js';

package/dist/coordination/index.js

@@ -832,7 +832,7 @@ var SubagentBudget = class _SubagentBudget {
    * is dispatched as a fire-and-forget promise.
    */
   checkLimit(kind, used, limit) {
-    if (kind === "timeout" || !this._onThreshold) {
+    if (!this._onThreshold) {
       throw new BudgetExceededError(kind, limit, used);
     }
     const bus = this._events;
@@ -948,14 +948,18 @@ var SubagentBudget = class _SubagentBudget {
     }
   }
   /**
-   * Throws if the wall-clock budget is exhausted. Call this from the iteration
-   * loop so a hung tool can't keep a subagent running past its deadline.
+   * Wall-clock budget check. Unlike other limits, timeout is treated as a
+   * warning-only event — it NEVER hard-stops the subagent. When the
+   * elapsed time exceeds timeoutMs, emits `budget.threshold_reached` with
+   * kind='timeout' so the Director can decide whether to extend or warn.
+   * Call this from the iteration loop so a hung tool gets a chance to
+   * negotiate more time before the coordinator's Promise.race kills it.
    */
   checkTimeout() {
     if (this.startTime === null || this.limits.timeoutMs === void 0) return;
     const elapsed = Date.now() - this.startTime;
     if (elapsed > this.limits.timeoutMs) {
-      throw new BudgetExceededError("timeout", this.limits.timeoutMs, elapsed);
+      void this.checkLimit("timeout", elapsed, this.limits.timeoutMs);
     }
   }
   /** Returns true if a timeout has occurred without throwing. Useful for races. */
@@ -1151,10 +1155,10 @@ var FLEET_ROSTER = {
   "security-scanner": SECURITY_SCANNER_AGENT
 };
 var FLEET_ROSTER_BUDGETS = {
-  "audit-log": { timeoutMs: 5 * 60 * 1e3, maxIterations: 80, maxToolCalls: 300 },
-  "bug-hunter": { timeoutMs: 10 * 60 * 1e3, maxIterations: 120, maxToolCalls: 400 },
-  "refactor-planner": { timeoutMs: 8 * 60 * 1e3, maxIterations: 100, maxToolCalls: 350 },
-  "security-scanner": { timeoutMs: 10 * 60 * 1e3, maxIterations: 120, maxToolCalls: 400 }
+  "audit-log": { timeoutMs: 8 * 60 * 1e3, maxIterations: 150, maxToolCalls: 500 },
+  "bug-hunter": { timeoutMs: 15 * 60 * 1e3, maxIterations: 200, maxToolCalls: 600 },
+  "refactor-planner": { timeoutMs: 12 * 60 * 1e3, maxIterations: 180, maxToolCalls: 550 },
+  "security-scanner": { timeoutMs: 15 * 60 * 1e3, maxIterations: 200, maxToolCalls: 600 }
 };
 function applyRosterBudget(cfg) {
   const defaultBudget = FLEET_ROSTER_BUDGETS[cfg.role ?? ""];
@@ -1294,6 +1298,33 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   results() {
     return this.completedResults;
   }
+  /**
+   * Wait for one or more tasks to complete and return their results.
+   * If a task is already done when called, returns immediately.
+   * Resolves to an array in the same order as `taskIds`.
+   */
+  async awaitTasks(taskIds) {
+    return Promise.all(
+      taskIds.map((id) => {
+        const cached = this.completedResults.find((r) => r.taskId === id);
+        if (cached) return cached;
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            this.off("task.completed", handler);
+            reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
+          }, this.config.timeoutMs ?? 3e5);
+          const handler = ({ result }) => {
+            if (result.taskId === id) {
+              clearTimeout(timeout);
+              this.off("task.completed", handler);
+              resolve(result);
+            }
+          };
+          this.on("task.completed", handler);
+        });
+      })
+    );
+  }
   /**
    * Manual completion — for callers that drive subagents without a runner
    * (e.g. external orchestrators). When a runner is configured the coordinator
@@ -1512,8 +1543,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
               return;
             }
             if (decision === "throw" || decision === "stop") {
-              this.subagents.get(ctx.subagentId)?.abortController.abort();
-              reject(new BudgetExceededError("timeout", limit, elapsed));
+              armFor(Math.max(1e3, limit));
               return;
             }
             if (decision.extend.timeoutMs !== void 0) {
@@ -2060,7 +2090,7 @@ var Director = class {
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
     this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
-    this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 2;
+    this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 5;
     this.sessionsRoot = opts.sessionsRoot;
     this.directorRunId = opts.directorRunId ?? this.id;
     this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(opts.stateCheckpointPath, {
@@ -2148,19 +2178,19 @@ var Director = class {
         const extra = {};
         switch (payload.kind) {
           case "iterations":
-            extra.maxIterations = Math.min(payload.used + 50, 500);
+            extra.maxIterations = Math.min(payload.used + 100, 800);
             break;
           case "tool_calls":
-            extra.maxToolCalls = Math.min(Math.ceil(payload.limit * 1.5), 1e3);
+            extra.maxToolCalls = Math.min(Math.ceil(payload.limit * 2), 1500);
             break;
           case "tokens":
-            extra.maxTokens = Math.min(Math.ceil(payload.limit * 1.5), 5e5);
+            extra.maxTokens = Math.min(Math.ceil(payload.limit * 2), 8e5);
             break;
           case "cost":
-            extra.maxCostUsd = Math.min(payload.limit * 1.5, 10);
+            extra.maxCostUsd = Math.min(payload.limit * 2, 25);
             break;
           case "timeout":
-            extra.timeoutMs = Math.min(Math.ceil(payload.limit * 1.5), 60 * 6e4);
+            extra.timeoutMs = Math.min(Math.ceil(payload.limit * 2), 2 * 60 * 6e4);
             break;
         }
         payload.extend(extra);
@@ -3009,10 +3039,22 @@ function makeAgentSubagentRunner(opts) {
       events.on("iteration.started", () => {
         try {
           ctx.budget.recordIteration();
-          ctx.budget.checkTimeout();
         } catch (e) {
           void onBudgetError(e);
         }
+        const u = ctx.budget.usage();
+        const since = u.iterations - lastSummaryAtIteration;
+        if (since >= SUMMARY_INTERVAL) {
+          lastSummaryAtIteration = u.iterations;
+          events.emit("subagent.iteration_summary", {
+            subagentId: ctx.subagentId,
+            iteration: u.iterations,
+            toolCalls: u.toolCalls,
+            costUsd: u.costUsd,
+            currentTool: currentToolName,
+            partialText: streamingTextAcc.trim() || void 0
+          });
+        }
       }),
       // D3: cooperative timeout enforcement DURING a long tool call.
       // The iteration-loop checkTimeout() only fires between agent
@@ -3035,6 +3077,18 @@ function makeAgentSubagentRunner(opts) {
         }
       })
     );
+    let currentToolName;
+    let streamingTextAcc = "";
+    let lastSummaryAtIteration = 0;
+    const SUMMARY_INTERVAL = 25;
+    unsub.push(
+      events.on("tool.started", (e) => {
+        currentToolName = e.name;
+      }),
+      events.on("provider.text_delta", (e) => {
+        streamingTextAcc = (streamingTextAcc + e.text).slice(-200);
+      })
+    );
     const onParentAbort = () => aborter.abort();
     ctx.signal.addEventListener("abort", onParentAbort);
     let result;
@@ -3051,7 +3105,21 @@ function makeAgentSubagentRunner(opts) {
         }
       }
     }
-    if (budgetError) throw budgetError;
+    if (budgetError) {
+      if ("decision" in budgetError) {
+        const decision = await budgetError.decision;
+        if (decision === "stop") {
+          budgetError = new BudgetExceededError(
+            budgetError.kind,
+            budgetError.limit,
+            budgetError.used
+          );
+        } else {
+          budgetError = null;
+        }
+      }
+      if (budgetError) throw budgetError;
+    }
     if (result.status === "failed") {
       throw result.error instanceof Error ? result.error : new Error(String(result.error ?? "agent failed"));
     }
@@ -3293,6 +3361,20 @@ var DefaultSessionStore = class {
     await fsp4.unlink(path4.join(this.dir, `${id}.jsonl`));
     await fsp4.unlink(path4.join(this.dir, `${id}.summary.json`)).catch(() => void 0);
   }
+  async clearHistory(id) {
+    const file = path4.join(this.dir, `${id}.jsonl`);
+    const meta = path4.join(this.dir, `${id}.summary.json`);
+    const record = `${JSON.stringify({
+      type: "session_start",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      id,
+      model: "unknown",
+      provider: "unknown"
+    })}
+`;
+    await fsp4.writeFile(file, record, "utf8");
+    await fsp4.unlink(meta).catch(() => void 0);
+  }
   async summarize(id, mtime) {
     try {
       const data = await this.load(id);
@@ -3598,10 +3680,21 @@ var FileSessionWriter = class {
     });
     return removedCount;
   }
+  async clearSession() {
+    if (!this.filePath) return;
+    const record = `${JSON.stringify({
+      type: "session_start",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      id: this.id,
+      model: this.meta.model ?? "unknown",
+      provider: this.meta.provider ?? "unknown"
+    })}
+`;
+    await fsp4.writeFile(this.filePath, record, "utf8");
+  }
 };
 function userInputTitle(content) {
-  if (typeof content === "string") return content.slice(0, 60);
-  const text = content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
+  const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
   return (text || "(non-text input)").slice(0, 60);
 }