@wrongstack/core 0.1.10 → 0.3.1

package/dist/coordination/index.js

@@ -1,9 +1,175 @@
 import { randomUUID, randomBytes } from 'crypto';
-import * as fsp2 from 'fs/promises';
-import * as path3 from 'path';
+import * as fsp4 from 'fs/promises';
+import * as path4 from 'path';
 import { EventEmitter } from 'events';
 
 // src/coordination/director.ts
+async function atomicWrite(targetPath, content, opts = {}) {
+  const dir = path4.dirname(targetPath);
+  await fsp4.mkdir(dir, { recursive: true });
+  const tmp = path4.join(dir, `.${path4.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    if (typeof content === "string") {
+      await fsp4.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+    } else {
+      await fsp4.writeFile(tmp, content, { flag: "wx" });
+    }
+    try {
+      const fh = await fsp4.open(tmp, "r+");
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    }
+    let mode;
+    try {
+      const stat3 = await fsp4.stat(targetPath);
+      mode = stat3.mode & 511;
+    } catch {
+      mode = opts.mode;
+    }
+    if (mode !== void 0) {
+      await fsp4.chmod(tmp, mode);
+    }
+    await renameWithRetry(tmp, targetPath);
+  } catch (err) {
+    try {
+      await fsp4.unlink(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+async function ensureDir(dir) {
+  await fsp4.mkdir(dir, { recursive: true });
+}
+var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
+async function renameWithRetry(from, to) {
+  if (process.platform !== "win32") {
+    await fsp4.rename(from, to);
+    return;
+  }
+  const delays = [10, 25, 60, 120, 250];
+  let lastErr;
+  for (let i = 0; i <= delays.length; i++) {
+    try {
+      await fsp4.rename(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err?.code;
+      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
+        throw err;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delays[i]));
+    }
+  }
+  throw lastErr;
+}
+
+// src/storage/director-state.ts
+var DirectorStateCheckpoint = class {
+  snapshot;
+  filePath;
+  timer = null;
+  debounceMs;
+  writing = false;
+  rewriteRequested = false;
+  constructor(filePath, init, debounceMs = 250) {
+    this.filePath = filePath;
+    this.debounceMs = debounceMs;
+    this.snapshot = {
+      version: 1,
+      directorRunId: init.directorRunId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      spawnCount: 0,
+      maxSpawns: init.maxSpawns,
+      spawnDepth: init.spawnDepth,
+      maxSpawnDepth: init.maxSpawnDepth,
+      subagents: [],
+      tasks: []
+    };
+  }
+  current() {
+    return this.snapshot;
+  }
+  recordSpawn(sub, spawnCount) {
+    this.snapshot = {
+      ...this.snapshot,
+      spawnCount,
+      subagents: [...this.snapshot.subagents.filter((s) => s.id !== sub.id), sub]
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  recordTaskAssigned(task) {
+    const exists = this.snapshot.tasks.some((t) => t.taskId === task.taskId);
+    this.snapshot = {
+      ...this.snapshot,
+      tasks: exists ? this.snapshot.tasks.map((t) => t.taskId === task.taskId ? { ...t, ...task } : t) : [...this.snapshot.tasks, task]
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  recordTaskStatus(taskId, patch) {
+    this.snapshot = {
+      ...this.snapshot,
+      tasks: this.snapshot.tasks.map(
+        (t) => t.taskId === taskId ? { ...t, ...patch } : t
+      )
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  setUsage(usage) {
+    this.snapshot = { ...this.snapshot, usage };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  /** Force a synchronous flush — used by Director.shutdown(). */
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    await this.persist();
+  }
+  bumpUpdatedAt() {
+    this.snapshot = { ...this.snapshot, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  schedule() {
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.persist();
+    }, this.debounceMs);
+  }
+  async persist() {
+    if (this.writing) {
+      this.rewriteRequested = true;
+      return;
+    }
+    this.writing = true;
+    try {
+      await atomicWrite(this.filePath, JSON.stringify(this.snapshot, null, 2), {
+        mode: 384
+      });
+    } catch (err) {
+      console.warn(
+        "[director-state] checkpoint write failed:",
+        err instanceof Error ? err.message : String(err)
+      );
+    } finally {
+      this.writing = false;
+      if (this.rewriteRequested) {
+        this.rewriteRequested = false;
+        this.schedule();
+      }
+    }
+  }
+};
 
 // src/coordination/in-memory-transport.ts
 var InMemoryBridgeTransport = class {
@@ -260,6 +426,10 @@ var FleetBus = class {
       "iteration.started",
       "iteration.completed",
       "provider.text_delta",
+      // Subagent extended-thinking output. Forwarded so the FleetPanel /
+      // /fleet log can surface "the planner is thinking…" instead of a
+      // silent gap between iteration.started and the first text_delta.
+      "provider.thinking_delta",
       "provider.response",
       "provider.retry",
       "provider.error",
@@ -416,6 +586,108 @@ var FleetUsageAggregator = class {
   }
 };
 
+// src/types/errors.ts
+var WrongStackError = class extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+
+// src/types/provider.ts
+var ProviderError = class extends WrongStackError {
+  status;
+  retryable;
+  providerId;
+  body;
+  constructor(message, status, retryable, providerId, opts = {}) {
+    super({
+      message,
+      code: providerStatusToCode(status, opts.body?.type),
+      subsystem: "provider",
+      severity: status >= 500 ? "error" : "warning",
+      recoverable: retryable,
+      context: { providerId, status },
+      cause: opts.cause
+    });
+    this.name = "ProviderError";
+    this.status = status;
+    this.retryable = retryable;
+    this.providerId = providerId;
+    this.body = opts.body;
+  }
+  /**
+   * Render a one-line, user-facing description. Designed for the CLI/TUI
+   * status line and the agent's retry warning. Avoids dumping raw JSON
+   * (which is what users see today when a 529 lands and the log message
+   * includes the full `{"type":"error",...}` body).
+   *
+   * Examples:
+   *   "minimax-coding-plan overloaded (529): High traffic detected. Upgrade for highspeed model. [req 06534785201de9c0…]"
+   *   "openai rate limited (429): Retry after 12s"
+   *   "anthropic invalid request (400): messages.0.role must be one of 'user'|'assistant'"
+   *   "groq HTTP 500 (server error)"
+   */
+  describe() {
+    const kind = describeStatus(this.status, this.body?.type);
+    const head = `${this.providerId} ${kind}`;
+    const detail = this.body?.message?.trim();
+    const reqId = this.body?.requestId ? ` [req ${this.body.requestId.slice(0, 16)}${this.body.requestId.length > 16 ? "\u2026" : ""}]` : "";
+    if (detail && detail.length > 0) {
+      return `${head}: ${truncate(detail, 240)}${reqId}`;
+    }
+    return `${head}${reqId}`;
+  }
+};
+function describeStatus(status, type) {
+  if (status === 0) return "network error";
+  if (type === "overloaded_error" || status === 529) return `overloaded (${status})`;
+  if (type === "rate_limit_error" || status === 429) return `rate limited (${status})`;
+  if (type === "authentication_error" || status === 401) return `auth failed (${status})`;
+  if (type === "permission_error" || status === 403) return `forbidden (${status})`;
+  if (type === "not_found_error" || status === 404) return `not found (${status})`;
+  if (type === "invalid_request_error" || status === 400) return `invalid request (${status})`;
+  if (status === 408) return `timeout (${status})`;
+  if (status >= 500 && status < 600) return `HTTP ${status} (server error)`;
+  if (type) return `${type} (${status})`;
+  return `HTTP ${status}`;
+}
+function truncate(s, n) {
+  return s.length <= n ? s : `${s.slice(0, n - 1)}\u2026`;
+}
+function providerStatusToCode(status, type) {
+  if (status === 0) return "PROVIDER_NETWORK_ERROR";
+  if (type === "rate_limit_error" || status === 429) return "PROVIDER_RATE_LIMITED";
+  if (type === "authentication_error" || status === 401) return "PROVIDER_AUTH_FAILED";
+  if (type === "overloaded_error" || status === 529) return "PROVIDER_OVERLOADED";
+  if (type === "invalid_request_error" || status === 400) return "PROVIDER_INVALID_REQUEST";
+  if (status === 408) return "PROVIDER_NETWORK_ERROR";
+  if (status >= 500) return "PROVIDER_SERVER_ERROR";
+  return "PROVIDER_INVALID_REQUEST";
+}
+
 // src/coordination/subagent-budget.ts
 var BudgetExceededError = class extends Error {
   kind;
@@ -508,14 +780,34 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   completedResults = [];
   totalIterations = 0;
   inFlight = 0;
+  /**
+   * Subagents currently being stopped. Set on entry to `stop()`, cleared
+   * once `recordCompletion` lands the terminal TaskResult. Used by
+   * `runDispatched` and `findIdleSubagent` to refuse mid-flight dispatch
+   * to a subagent the caller has already asked to terminate — closes the
+   * assign+terminate race where a fresh task could land on a worker that
+   * was about to be killed.
+   */
+  terminating = /* @__PURE__ */ new Set();
   constructor(config, options = {}) {
     super();
     this.coordinatorId = config.coordinatorId;
     this.config = config;
     this.runner = options.runner;
   }
+  /**
+   * Replace the runner after construction. Used when the runner depends
+   * on infrastructure (e.g. FleetBus) that isn't available until after
+   * the coordinator's owning Director is built.
+   */
+  setRunner(runner) {
+    this.runner = runner;
+  }
   async spawn(subagent) {
     const id = subagent.id || randomUUID();
+    if (this.subagents.has(id)) {
+      throw new Error(`Subagent id "${id}" already exists \u2014 refusing to overwrite`);
+    }
     const context = {
       subagentId: id,
       tasks: [],
@@ -559,6 +851,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   async stop(subagentId) {
     const subagent = this.subagents.get(subagentId);
     if (!subagent) return;
+    this.terminating.add(subagentId);
     subagent.abortController.abort();
     subagent.status = "stopped";
     subagent.currentTask = void 0;
@@ -566,6 +859,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     this.emit("subagent.stopped", { subagentId, reason: "stopped by coordinator" });
   }
   async stopAll() {
+    this.drainPendingAsAborted("Coordinator stopAll() drained the pending queue");
     await Promise.allSettled([...this.subagents.keys()].map((id) => this.stop(id)));
   }
   getStatus() {
@@ -599,7 +893,14 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   tryDispatchNext() {
     while (this.canDispatch()) {
       const subagentId = this.findIdleSubagent();
-      if (!subagentId) return;
+      if (!subagentId) {
+        if (this.pendingTasks.length > 0 && !this.hasLiveSubagent()) {
+          this.drainPendingAsAborted(
+            "No live subagent available \u2014 all stopped or mid-termination"
+          );
+        }
+        return;
+      }
       const task = this.pendingTasks.shift();
       if (!task) return;
       this.runDispatched(subagentId, task).catch((err) => {
@@ -607,7 +908,7 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
           subagentId,
           taskId: task.id,
           status: "failed",
-          error: err instanceof Error ? err.message : String(err),
+          error: classifySubagentError(err),
           iterations: 0,
           toolCalls: 0,
           durationMs: 0
@@ -621,13 +922,76 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
   }
   findIdleSubagent() {
     for (const [id, s] of this.subagents) {
-      if (s.status === "idle") return id;
+      if (s.status === "idle" && !this.terminating.has(id)) return id;
     }
     return null;
   }
+  /**
+   * Returns true iff at least one spawned subagent could still
+   * process a task. A "live" subagent is one that is not stopped
+   * AND not mid-termination — `running` workers count because they
+   * will eventually finish and become idle.
+   *
+   * When no subagent has ever been spawned, returns `true` so a
+   * pre-spawn `assign()` simply queues (legacy behaviour). The
+   * dead-end detection only fires after `stop()` has retired every
+   * spawned worker.
+   *
+   * Used by `tryDispatchNext` to detect a dead-end pending queue.
+   */
+  hasLiveSubagent() {
+    if (this.subagents.size === 0) return true;
+    for (const [id, s] of this.subagents) {
+      if (s.status !== "stopped" && !this.terminating.has(id)) return true;
+    }
+    return false;
+  }
+  /**
+   * Drain every pending task with a synthetic `aborted_by_parent`
+   * completion event. Same shape as the `stopAll()` drain — we go
+   * around `recordCompletion` because pending tasks were never
+   * counted in `inFlight` and routing them through would trip the
+   * underflow guard on every task after the first.
+   */
+  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 });
+    }
+  }
   async runDispatched(subagentId, task) {
     const subagent = this.subagents.get(subagentId);
     if (!subagent) return;
+    if (this.terminating.has(subagentId) || subagent.status === "stopped") {
+      this.recordCompletion({
+        subagentId,
+        taskId: task.id,
+        status: "stopped",
+        error: {
+          kind: "aborted_by_parent",
+          message: "Subagent was terminated before task could start",
+          retryable: false
+        },
+        iterations: 0,
+        toolCalls: 0,
+        durationMs: 0
+      });
+      return;
+    }
     subagent.status = "running";
     subagent.currentTask = task.id;
     task.subagentId = subagentId;
@@ -673,7 +1037,9 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
         subagentId,
         taskId: task.id,
         status,
-        error: err instanceof Error ? err.message : String(err),
+        error: classifySubagentError(err, {
+          parentAborted: subagent.abortController.signal.aborted
+        }),
         iterations: usage.iterations,
         toolCalls: usage.toolCalls,
         durationMs: Date.now() - startTime
@@ -712,19 +1078,14 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     }
     const subagent = this.subagents.get(result.subagentId);
     if (subagent && subagent.status !== "stopped") {
-      const failed = result.status === "failed" || result.status === "timeout";
-      subagent.status = failed ? "error" : "idle";
+      result.status === "failed" || result.status === "timeout";
+      subagent.status = "idle";
       subagent.currentTask = void 0;
       if (subagent.abortController.signal.aborted) {
         subagent.abortController = new AbortController();
       }
-      if (subagent.status === "error") {
-        queueMicrotask(() => {
-          if (subagent.status === "error") subagent.status = "idle";
-          this.tryDispatchNext();
-        });
-      }
     }
+    this.terminating.delete(result.subagentId);
     this.emit("task.completed", {
       task: subagent?.context.tasks.find((t) => t.id === result.taskId) ?? { id: result.taskId },
       result
@@ -747,6 +1108,99 @@ var DefaultMultiAgentCoordinator = class extends EventEmitter {
     return false;
   }
 };
+function classifySubagentError(err, hints = {}) {
+  const cause = err instanceof Error ? { name: err.name, message: err.message, stack: err.stack } : void 0;
+  const baseMessage = err instanceof Error ? err.message : String(err);
+  if (err instanceof ProviderError) {
+    return providerErrorToSubagentError(err, baseMessage, cause);
+  }
+  if (err instanceof BudgetExceededError) {
+    const map = {
+      iterations: "budget_iterations",
+      tool_calls: "budget_tool_calls",
+      tokens: "budget_tokens",
+      cost: "budget_cost",
+      timeout: "budget_timeout"
+    };
+    return {
+      kind: map[err.kind],
+      message: baseMessage,
+      // Budgets are user-configured ceilings, not transient failures —
+      // retrying with the same budget will hit the same ceiling. The
+      // orchestrator must raise the budget or narrow the task first.
+      retryable: false,
+      cause
+    };
+  }
+  if (hints.parentAborted) {
+    return {
+      kind: "aborted_by_parent",
+      message: baseMessage,
+      retryable: false,
+      cause
+    };
+  }
+  const lower = baseMessage.toLowerCase();
+  if (/agent aborted$/i.test(baseMessage)) {
+    return {
+      kind: "aborted_by_parent",
+      message: baseMessage,
+      retryable: false,
+      cause
+    };
+  }
+  if (/agent exhausted iteration limit$/i.test(baseMessage)) {
+    return { kind: "budget_iterations", message: baseMessage, retryable: false, cause };
+  }
+  if (/empty response$/i.test(baseMessage)) {
+    return { kind: "empty_response", message: baseMessage, retryable: false, cause };
+  }
+  if (/^tool failed: /i.test(baseMessage)) {
+    return { kind: "tool_failed", message: baseMessage, retryable: false, cause };
+  }
+  if (lower.includes("bridge transport") || /bridge.*(closed|disconnect)/i.test(baseMessage)) {
+    return { kind: "bridge_failed", message: baseMessage, retryable: false, cause };
+  }
+  if (/context length|max.*tokens?.*exceeded|prompt is too long/i.test(baseMessage)) {
+    return { kind: "context_overflow", message: baseMessage, retryable: false, cause };
+  }
+  return {
+    kind: "unknown",
+    message: baseMessage,
+    retryable: false,
+    cause
+  };
+}
+function providerErrorToSubagentError(err, message, cause) {
+  const status = err.status;
+  if (status === 429 || err.body?.type === "rate_limit_error") {
+    return {
+      kind: "provider_rate_limit",
+      message,
+      retryable: true,
+      // Conservative default: 5s. Provider-specific code can override
+      // by emitting an error whose body carries an explicit hint.
+      backoffMs: 5e3,
+      cause
+    };
+  }
+  if (status === 401 || status === 403 || err.body?.type === "authentication_error") {
+    return { kind: "provider_auth", message, retryable: false, cause };
+  }
+  if (status === 408 || status === 0) {
+    return { kind: "provider_timeout", message, retryable: true, cause };
+  }
+  if (status >= 500 && status < 600) {
+    return {
+      kind: "provider_5xx",
+      message,
+      retryable: true,
+      backoffMs: 3e3,
+      cause
+    };
+  }
+  return { kind: "unknown", message, retryable: err.retryable, cause };
+}
 
 // src/coordination/director.ts
 var DirectorBudgetError = class extends Error {
@@ -810,6 +1264,27 @@ var Director = class {
   spawnDepth;
   /** Live spawn counter for `maxSpawns` enforcement. */
   spawnCount = 0;
+  /** Optional checkpoint mirror — writes the live task graph + roster to disk. */
+  stateCheckpoint;
+  /** Optional session writer for emitting task_* / agent_* lifecycle events. */
+  sessionWriter;
+  /** Debounce timer for periodic manifest writes. */
+  manifestTimer = null;
+  manifestDebounceMs;
+  /** Resolves task descriptions back from `assign()` so completion events
+   *  can also carry a human-readable title. */
+  taskDescriptions = /* @__PURE__ */ new Map();
+  /** Snapshot of which subagent owns each task — drives state-checkpoint
+   *  status updates without re-walking the manifest. */
+  taskOwners = /* @__PURE__ */ new Map();
+  /**
+   * Handle to the coordinator-side `task.completed` listener so we can
+   * unsubscribe in `shutdown()`. Without this, repeated Director
+   * construction (e.g. tests, hot reloads) accumulates listeners on a
+   * cached coordinator and slowly drifts the EventEmitter past its
+   * default cap.
+   */
+  taskCompletedListener = null;
   constructor(opts) {
     this.id = opts.config.coordinatorId || randomUUID();
     this.manifestPath = opts.manifestPath;
@@ -820,8 +1295,16 @@ var Director = class {
     this.maxSpawns = opts.maxSpawns ?? Number.POSITIVE_INFINITY;
     this.maxSpawnDepth = opts.maxSpawnDepth ?? 2;
     this.spawnDepth = opts.spawnDepth ?? 0;
+    this.sessionWriter = opts.sessionWriter ?? null;
+    this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
+    this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(opts.stateCheckpointPath, {
+      directorRunId: this.id,
+      maxSpawns: opts.maxSpawns,
+      spawnDepth: this.spawnDepth,
+      maxSpawnDepth: this.maxSpawnDepth
+    }) : null;
     if (this.sharedScratchpadPath) {
-      void fsp2.mkdir(this.sharedScratchpadPath, { recursive: true }).catch(() => void 0);
+      void fsp4.mkdir(this.sharedScratchpadPath, { recursive: true }).catch(() => void 0);
     }
     this.transport = new InMemoryBridgeTransport();
     this.bridge = new InMemoryAgentBridge(
@@ -838,7 +1321,7 @@ var Director = class {
       { ...opts.config, coordinatorId: this.id },
       { runner: opts.runner }
     );
-    this.coordinator.on("task.completed", (payload) => {
+    this.taskCompletedListener = (payload) => {
       const r = payload.result;
       this.completed.set(r.taskId, r);
       const waiter = this.taskWaiters.get(r.taskId);
@@ -846,7 +1329,54 @@ var Director = class {
         waiter.resolve(r);
         this.taskWaiters.delete(r.taskId);
       }
-    });
+      const title = this.taskDescriptions.get(r.taskId) ?? payload.task.description ?? r.taskId;
+      const failed = r.status !== "success";
+      const errorString = r.error ? `${r.error.kind}: ${r.error.message}` : void 0;
+      this.stateCheckpoint?.recordTaskStatus(r.taskId, {
+        status: failed ? r.status : "completed",
+        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        iterations: r.iterations,
+        toolCalls: r.toolCalls,
+        durationMs: r.durationMs,
+        error: errorString
+      });
+      this.stateCheckpoint?.setUsage(this.usage.snapshot());
+      void this.appendSessionEvent(
+        failed ? {
+          type: "task_failed",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          taskId: r.taskId,
+          title,
+          error: errorString ?? r.status
+        } : {
+          type: "task_completed",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          taskId: r.taskId,
+          title
+        }
+      );
+      this.scheduleManifest();
+    };
+    this.coordinator.on("task.completed", this.taskCompletedListener);
+  }
+  /** Best-effort session-writer append. Swallows failures — the director
+   *  must not break a fleet run because the session JSONL handle closed. */
+  async appendSessionEvent(event) {
+    if (!this.sessionWriter) return;
+    try {
+      await this.sessionWriter.append(event);
+    } catch {
+    }
+  }
+  /** Debounced manifest writer. A burst of spawn/assign/complete events
+   *  collapses into one write. Set `manifestDebounceMs` to 0 to disable. */
+  scheduleManifest() {
+    if (!this.manifestPath || this.manifestDebounceMs <= 0) return;
+    if (this.manifestTimer) return;
+    this.manifestTimer = setTimeout(() => {
+      this.manifestTimer = null;
+      void this.writeManifest().catch(() => void 0);
+    }, this.manifestDebounceMs);
   }
   /**
    * Spawn a subagent. Identical to the coordinator's `spawn()` but
@@ -885,6 +1415,25 @@ var Director = class {
       model: config.model,
       taskIds: []
     });
+    const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.stateCheckpoint?.recordSpawn(
+      {
+        id: result.subagentId,
+        name: config.name,
+        role: config.role,
+        provider: config.provider,
+        model: config.model,
+        spawnedAt
+      },
+      this.spawnCount
+    );
+    void this.appendSessionEvent({
+      type: "agent_spawned",
+      ts: spawnedAt,
+      agentId: result.subagentId,
+      role: config.role ?? config.name
+    });
+    this.scheduleManifest();
     return result.subagentId;
   }
   /**
@@ -995,8 +1544,8 @@ var Director = class {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp2.mkdir(path3.dirname(this.manifestPath), { recursive: true });
-    await fsp2.writeFile(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
+    await fsp4.mkdir(path4.dirname(this.manifestPath), { recursive: true });
+    await fsp4.writeFile(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
   /**
@@ -1005,13 +1554,42 @@ var Director = class {
    * — calling shutdown twice is a no-op on the second invocation.
    */
   async shutdown() {
+    if (this.manifestTimer) {
+      clearTimeout(this.manifestTimer);
+      this.manifestTimer = null;
+    }
+    if (this.taskCompletedListener) {
+      this.coordinator.off("task.completed", this.taskCompletedListener);
+      this.taskCompletedListener = null;
+    }
     await this.coordinator.stopAll();
     for (const b of this.subagentBridges.values()) {
-      await b.stop().catch(() => void 0);
+      await b.stop().catch((err) => this.logShutdownError("subagent_bridge_stop", err));
     }
     this.subagentBridges.clear();
-    await this.bridge.stop().catch(() => void 0);
-    if (this.manifestPath) await this.writeManifest().catch(() => void 0);
+    await this.bridge.stop().catch((err) => this.logShutdownError("director_bridge_stop", err));
+    if (this.manifestPath)
+      await this.writeManifest().catch((err) => this.logShutdownError("manifest_write", err));
+    if (this.stateCheckpoint) {
+      this.stateCheckpoint.setUsage(this.usage.snapshot());
+      await this.stateCheckpoint.flush().catch((err) => this.logShutdownError("state_checkpoint_flush", err));
+    }
+  }
+  /**
+   * Funnel for shutdown-phase errors. We can't throw — `shutdown()` is
+   * called from process-exit paths where an uncaught throw would lose
+   * the manifest write that comes after. But we MUST NOT silently
+   * swallow either — a persistent bridge-close failure would otherwise
+   * mask a real bug. `process.emitWarning` is the right tier:
+   * surfaces on stderr by default, lets the host plug a warning
+   * listener for structured collection, and never affects exit code.
+   */
+  logShutdownError(phase, err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    process.emitWarning(
+      `Director shutdown phase "${phase}" failed: ${detail}`,
+      "DirectorShutdownWarning"
+    );
   }
   /**
    * Hand a task to the coordinator. Returns the assigned task id so
@@ -1025,6 +1603,23 @@ var Director = class {
       if (entry) entry.taskIds.push(taskWithId.id);
     }
     await this.coordinator.assign(taskWithId);
+    this.taskDescriptions.set(taskWithId.id, taskWithId.description);
+    if (taskWithId.subagentId) this.taskOwners.set(taskWithId.id, taskWithId.subagentId);
+    const assignedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.stateCheckpoint?.recordTaskAssigned({
+      taskId: taskWithId.id,
+      subagentId: taskWithId.subagentId,
+      description: taskWithId.description,
+      status: "running",
+      assignedAt
+    });
+    void this.appendSessionEvent({
+      type: "task_created",
+      ts: assignedAt,
+      taskId: taskWithId.id,
+      title: taskWithId.description
+    });
+    this.scheduleManifest();
     return taskWithId.id;
   }
   /**
@@ -1084,6 +1679,23 @@ var Director = class {
   snapshot() {
     return this.usage.snapshot();
   }
+  /**
+   * Look up provider/model metadata for a spawned subagent. Returns
+   * undefined when the subagent id is unknown (not yet spawned, or
+   * already torn down). Callers — notably the TUI fleet panel — use
+   * this to render human-readable provider/model tags next to each
+   * subagent row without reaching into private state.
+   */
+  getSubagentMeta(id) {
+    const usage = this.subagentMeta.get(id);
+    const manifest = this.manifestEntries.get(id);
+    if (!usage && !manifest) return void 0;
+    return {
+      provider: usage?.provider ?? manifest?.provider,
+      model: usage?.model ?? manifest?.model,
+      name: manifest?.name
+    };
+  }
   /**
    * Compose the leader/director-agent system prompt: fleet preamble +
    * (optional) roster summary + user base prompt. Pass the result to your
@@ -1383,12 +1995,260 @@ function makeFleetUsageTool(director) {
     }
   };
 }
+function createDelegateTool(opts) {
+  const defaultTimeoutMs = opts.defaultTimeoutMs ?? 4 * 60 * 60 * 1e3;
+  const rosterIds = opts.roster ? Object.keys(opts.roster) : [];
+  const inputSchema = {
+    type: "object",
+    properties: {
+      task: {
+        type: "string",
+        description: "What the subagent should do \u2014 natural language, complete sentence(s). The subagent has its own tool slice, its own LLM call, and returns when its task is done."
+      },
+      role: {
+        type: "string",
+        description: rosterIds.length > 0 ? `Roster role (preferred). One of: ${rosterIds.join(", ")}. Picks a pre-tuned config (prompt, budgets, tools) for that role.` : "No roster is configured \u2014 pass `name` instead.",
+        enum: rosterIds.length > 0 ? rosterIds : void 0
+      },
+      name: {
+        type: "string",
+        description: "Display name for the subagent when not using a roster role. Required when `role` is omitted."
+      },
+      provider: {
+        type: "string",
+        description: 'Provider id (e.g. "anthropic", "openai"). Defaults to the host provider when omitted.'
+      },
+      model: {
+        type: "string",
+        description: "Model id within the provider. Defaults to the host model when omitted."
+      },
+      systemPromptOverride: {
+        type: "string",
+        description: "Optional extra prompt text appended to the role baseline."
+      },
+      timeoutMs: {
+        type: "number",
+        description: `Wall-clock budget for this delegate in milliseconds. No hard cap \u2014 set as high as the task realistically needs (a monorepo audit can take hours, a single-file lint takes seconds). Default ${Math.round(defaultTimeoutMs / 1e3 / 60)} minutes.`
+      },
+      maxIterations: {
+        type: "number",
+        description: "Maximum LLM iterations the subagent may take. Unset = use the role/coordinator default. Raise this for tasks with many tool-think-tool cycles (deep code analysis, multi-file refactors)."
+      },
+      maxToolCalls: {
+        type: "number",
+        description: "Maximum number of tool invocations the subagent may make. Unset = use the role/coordinator default. Raise this for tasks that touch many files (large grep + read + report)."
+      }
+    },
+    required: ["task"]
+  };
+  return {
+    name: "delegate",
+    description: "Hand a discrete piece of work to a dedicated subagent and wait for its result. The subagent has its own context, its own LLM call, and its own budget \u2014 use this when a task is self-contained, would otherwise blow up your context, or benefits from a specialized role (bug-hunter, security-scanner, refactor-planner, audit-log). YOU decide how big the budget is: pass `timeoutMs`, `maxIterations`, and `maxToolCalls` sized to the actual work. There is no hidden cap forcing a 3-minute / 80-iteration limit \u2014 if a monorepo audit needs 2 hours and 500 tool calls, ask for that. Call multiple delegates in parallel through the provider's parallel-tool-call surface to fan work out across roles.",
+    usageHint: "Set `task` to a complete instruction. Either pick `role` from the roster or pass `name` + `provider` + `model`. For non-trivial work, also pass `timeoutMs` (the wall-clock budget you actually need), `maxIterations`, and `maxToolCalls` \u2014 defaults are intentionally generous (4 hours) but the right values depend on scope. Returns the subagent's `TaskResult` \u2014 including the textual `result`, iteration count, tool count, and duration. Auto-promotes the host into director mode on first call.",
+    permission: "auto",
+    mutating: false,
+    inputSchema,
+    async execute(input) {
+      const i = input ?? {};
+      if (typeof i.task !== "string" || !i.task.trim()) {
+        return { ok: false, error: "`task` is required." };
+      }
+      let director = await opts.host.ensureDirector();
+      if (!director) {
+        director = await opts.host.promoteToDirector();
+      }
+      if (!director) {
+        const reason = opts.host.getPromotionBlockReason?.();
+        return {
+          ok: false,
+          error: reason ?? "Director could not be activated \u2014 multi-agent host already running in legacy non-director mode. Restart with `--director` for fleet support."
+        };
+      }
+      const timeoutMs = i.timeoutMs ?? defaultTimeoutMs;
+      let cfg;
+      if (i.role) {
+        const base = opts.roster?.[i.role];
+        if (!base) {
+          return {
+            ok: false,
+            error: `Unknown role "${i.role}". Available: ${rosterIds.join(", ") || "(no roster configured)"}.`
+          };
+        }
+        cfg = { ...base };
+        if (i.systemPromptOverride) cfg.systemPromptOverride = i.systemPromptOverride;
+        if (i.provider) cfg.provider = i.provider;
+        if (i.model) cfg.model = i.model;
+      } else {
+        if (!i.name) {
+          return {
+            ok: false,
+            error: "Either `role` (from the roster) or `name` is required."
+          };
+        }
+        cfg = {
+          name: i.name,
+          provider: i.provider,
+          model: i.model,
+          systemPromptOverride: i.systemPromptOverride
+        };
+      }
+      if (typeof i.maxIterations === "number" && i.maxIterations > 0) {
+        cfg.maxIterations = i.maxIterations;
+      }
+      if (typeof i.maxToolCalls === "number" && i.maxToolCalls > 0) {
+        cfg.maxToolCalls = i.maxToolCalls;
+      }
+      const SUBAGENT_TIMEOUT_BUFFER_MS = 3e4;
+      const desiredSubTimeout = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
+      if (!cfg.timeoutMs || cfg.timeoutMs > desiredSubTimeout) {
+        cfg.timeoutMs = desiredSubTimeout;
+      }
+      try {
+        const subagentId = await director.spawn(cfg);
+        const taskId = await director.assign({
+          id: "",
+          description: i.task,
+          subagentId
+        });
+        const result = await Promise.race([
+          director.awaitTasks([taskId]).then((r) => r[0]),
+          new Promise(
+            (resolve) => setTimeout(() => resolve({ __timeout: true }), timeoutMs)
+          )
+        ]);
+        if ("__timeout" in result) {
+          const partial2 = await readSubagentPartial(opts, subagentId);
+          return {
+            ok: false,
+            stopReason: "host_timeout",
+            error: `Subagent did not finish within ${timeoutMs}ms.`,
+            hint: "Reduce scope of the next delegate, raise timeoutMs, or use spawn_subagent + await_tasks for long-running work.",
+            subagentId,
+            taskId,
+            partial: partial2
+          };
+        }
+        const baseStopReason = result.status === "success" ? "end_turn" : result.status === "timeout" ? "subagent_timeout" : result.status === "stopped" ? "aborted" : "budget_exhausted";
+        const partial = result.status === "success" ? void 0 : await readSubagentPartial(opts, subagentId);
+        const errorKind = result.error?.kind;
+        const retryable = result.error?.retryable;
+        const backoffMs = result.error?.backoffMs;
+        return {
+          ok: result.status === "success",
+          status: result.status,
+          stopReason: baseStopReason,
+          errorKind,
+          retryable,
+          backoffMs,
+          subagentId: result.subagentId,
+          taskId: result.taskId,
+          result: result.result,
+          error: result.error,
+          iterations: result.iterations,
+          toolCalls: result.toolCalls,
+          durationMs: result.durationMs,
+          ...partial ? { partial } : {},
+          ...hintForKind(errorKind, retryable, backoffMs) ? { hint: hintForKind(errorKind, retryable, backoffMs) } : {}
+        };
+      } catch (err) {
+        return {
+          ok: false,
+          stopReason: "error",
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    }
+  };
+}
+function hintForKind(kind, retryable, backoffMs) {
+  if (!kind) return void 0;
+  switch (kind) {
+    case "provider_rate_limit":
+      return `Provider rate-limited. Retry safe after ${backoffMs ?? 5e3}ms backoff. Consider a smaller model or fewer parallel delegates.`;
+    case "provider_5xx":
+      return `Provider server error. Retry safe after ${backoffMs ?? 3e3}ms backoff \u2014 usually transient.`;
+    case "provider_timeout":
+      return "Provider network timeout. Retry safe; reduce input size if it persists.";
+    case "provider_auth":
+      return "Provider rejected credentials. Cannot retry \u2014 fix the API key / config and re-invoke.";
+    case "context_overflow":
+      return "Subagent context exceeded the model limit. Narrow the task, use a larger-context model, or split into multiple delegates.";
+    case "budget_iterations":
+    case "budget_tool_calls":
+    case "budget_tokens":
+    case "budget_cost":
+      return "Subagent exhausted its budget. Raise the matching `max*` field on the next delegate or narrow task scope.";
+    case "budget_timeout":
+      return "Subagent hit its wall-clock budget. Raise `timeoutMs` on the next delegate or split the task.";
+    case "aborted_by_parent":
+      return "Subagent was aborted (user Ctrl+C, parent unwound, or sibling failure cascade). Not retryable until the abort condition is resolved.";
+    case "empty_response":
+      return "Subagent ended its turn with no text and no tool calls. Almost always a prompt / config issue \u2014 clarify the task or check the model.";
+    case "tool_failed":
+      return "A tool inside the subagent returned ok:false. Inspect `partial.lastAssistantText` for the agent reasoning, then retry with corrected inputs.";
+    case "bridge_failed":
+      return "Parent-child bridge transport failed. This is rare \u2014 restart the session and retry.";
+    default:
+      return retryable ? "Failure classified as retryable. Try again with the same input." : void 0;
+  }
+}
+async function readSubagentPartial(opts, subagentId) {
+  if (!opts.sessionsRoot) return void 0;
+  const candidates = [];
+  if (opts.directorRunId) {
+    candidates.push(path4.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
+  } else {
+    try {
+      const runDirs = await fsp4.readdir(opts.sessionsRoot);
+      for (const r of runDirs) {
+        candidates.push(path4.join(opts.sessionsRoot, r, `${subagentId}.jsonl`));
+      }
+    } catch {
+      return void 0;
+    }
+  }
+  for (const file of candidates) {
+    let raw;
+    try {
+      raw = await fsp4.readFile(file, "utf8");
+    } catch {
+      continue;
+    }
+    const lines = raw.split("\n").filter((l) => l.trim());
+    let lastAssistantText;
+    let lastStopReason;
+    let toolUses = 0;
+    for (const line of lines) {
+      try {
+        const ev = JSON.parse(line);
+        if (ev.type === "tool_use") toolUses += 1;
+        if (ev.type === "llm_response") {
+          if (typeof ev.stopReason === "string") lastStopReason = ev.stopReason;
+          if (Array.isArray(ev.content)) {
+            const txt = ev.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("\n").trim();
+            if (txt) lastAssistantText = txt;
+          }
+        }
+      } catch {
+      }
+    }
+    return {
+      lastAssistantText,
+      lastStopReason,
+      toolUsesObserved: toolUses,
+      events: lines.length
+    };
+  }
+  return void 0;
+}
 
 // src/coordination/agent-subagent-runner.ts
 function makeAgentSubagentRunner(opts) {
   const format = opts.formatTaskInput ?? defaultFormatTaskInput;
   return async (task, ctx) => {
-    const { agent, events } = await opts.factory(ctx.config);
+    const factoryResult = await opts.factory(ctx.config);
+    const { agent, events } = factoryResult;
+    const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
     let budgetError = null;
     const onBudgetError = (err) => {
@@ -1402,13 +2262,19 @@ function makeAgentSubagentRunner(opts) {
         budgetError.message += ` (caused by: ${err.message})`;
       }
     };
+    let lastToolFailed = null;
     const unsub = [];
     unsub.push(
-      events.on("tool.started", () => {
+      events.on("tool.executed", (e) => {
         try {
           ctx.budget.recordToolCall();
-        } catch (e) {
-          onBudgetError(e);
+        } catch (eb) {
+          onBudgetError(eb);
+        }
+        if (e.ok === false) {
+          lastToolFailed = e.name;
+        } else if (e.ok === true) {
+          lastToolFailed = null;
         }
       }),
       events.on("provider.response", (e) => {
@@ -1425,6 +2291,26 @@ function makeAgentSubagentRunner(opts) {
         } catch (e) {
           onBudgetError(e);
         }
+      }),
+      // D3: cooperative timeout enforcement DURING a long tool call.
+      // The iteration-loop checkTimeout() only fires between agent
+      // iterations — a single `bash sleep 3600` call would otherwise
+      // park inside one tool execution while the timeout silently
+      // passes, relying solely on the coordinator's hard Promise.race
+      // to interrupt. Tools that emit `tool.progress` (bash chunks,
+      // fetch byte progress, spawn-stream stdout) give us a heartbeat
+      // we can hang the check on. When the budget trips here:
+      //   1. onBudgetError sets budgetError + aborter.abort()
+      //   2. aborter signal propagates to agent.run → tool executor
+      //   3. tool's own signal listener kills the child process
+      // Cheap: O(1) per progress event, and the budget short-circuits
+      // when timeoutMs is unset (most subagents have one set anyway).
+      events.on("tool.progress", () => {
+        try {
+          ctx.budget.checkTimeout();
+        } catch (e) {
+          onBudgetError(e);
+        }
       })
     );
     const onParentAbort = () => aborter.abort();
@@ -1433,8 +2319,15 @@ function makeAgentSubagentRunner(opts) {
     try {
       result = await agent.run(format(task, ctx.config), { signal: aborter.signal });
     } finally {
+      detachFleet?.();
       ctx.signal.removeEventListener("abort", onParentAbort);
       for (const u of unsub) u();
+      if (factoryResult.dispose) {
+        try {
+          await factoryResult.dispose();
+        } catch {
+        }
+      }
     }
     if (budgetError) throw budgetError;
     if (result.status === "failed") {
@@ -1447,6 +2340,13 @@ function makeAgentSubagentRunner(opts) {
       throw new Error("agent exhausted iteration limit");
     }
     const usage = ctx.budget.usage();
+    const finalText = (result.finalText ?? "").trim();
+    if (finalText.length === 0 && usage.toolCalls === 0) {
+      throw new Error("empty response");
+    }
+    if (finalText.length === 0 && lastToolFailed !== null) {
+      throw new Error(`tool failed: ${lastToolFailed}`);
+    }
     return {
       result: result.finalText,
       iterations: result.iterations,
@@ -1457,11 +2357,6 @@ function makeAgentSubagentRunner(opts) {
 function defaultFormatTaskInput(task) {
   return task.description ?? "";
 }
-async function ensureDir(dir) {
-  await fsp2.mkdir(dir, { recursive: true });
-}
-
-// src/storage/session-store.ts
 var DefaultSessionStore = class {
   dir;
   events;
@@ -1473,10 +2368,10 @@ var DefaultSessionStore = class {
     await ensureDir(this.dir);
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const id = meta.id ?? `${startedAt.replace(/[:.]/g, "-")}-${randomBytes(2).toString("hex")}`;
-    const file = path3.join(this.dir, `${id}.jsonl`);
+    const file = path4.join(this.dir, `${id}.jsonl`);
     let handle;
     try {
-      handle = await fsp2.open(file, "a", 384);
+      handle = await fsp4.open(file, "a", 384);
     } catch (err) {
       throw new Error(
         `Failed to open session file: ${err instanceof Error ? err.message : String(err)}`,
@@ -1495,10 +2390,10 @@ var DefaultSessionStore = class {
   }
   async resume(id) {
     const data = await this.load(id);
-    const file = path3.join(this.dir, `${id}.jsonl`);
+    const file = path4.join(this.dir, `${id}.jsonl`);
     let handle;
     try {
-      handle = await fsp2.open(file, "a", 384);
+      handle = await fsp4.open(file, "a", 384);
     } catch (err) {
       throw new Error(
         `Failed to open session "${id}" for append: ${err instanceof Error ? err.message : String(err)}`,
@@ -1519,8 +2414,8 @@ var DefaultSessionStore = class {
     return { writer, data };
   }
   async load(id) {
-    const file = path3.join(this.dir, `${id}.jsonl`);
-    const raw = await fsp2.readFile(file, "utf8");
+    const file = path4.join(this.dir, `${id}.jsonl`);
+    const raw = await fsp4.readFile(file, "utf8");
     const lines = raw.split("\n").filter((l) => l.trim());
     const events = [];
     for (const line of lines) {
@@ -1539,7 +2434,7 @@ var DefaultSessionStore = class {
   async list(limit = 20) {
     try {
       await ensureDir(this.dir);
-      const files = await fsp2.readdir(this.dir);
+      const files = await fsp4.readdir(this.dir);
       const ids = files.filter((f) => f.endsWith(".jsonl")).map((f) => f.replace(/\.jsonl$/, ""));
       const sessions = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
       const out = sessions.filter((s) => s !== null);
@@ -1554,15 +2449,15 @@ var DefaultSessionStore = class {
     }
   }
   async summaryFor(id) {
-    const manifest = path3.join(this.dir, `${id}.summary.json`);
+    const manifest = path4.join(this.dir, `${id}.summary.json`);
     try {
-      const raw = await fsp2.readFile(manifest, "utf8");
+      const raw = await fsp4.readFile(manifest, "utf8");
       return JSON.parse(raw);
     } catch {
-      const full = path3.join(this.dir, `${id}.jsonl`);
-      const stat3 = await fsp2.stat(full);
+      const full = path4.join(this.dir, `${id}.jsonl`);
+      const stat3 = await fsp4.stat(full);
       const summary = await this.summarize(id, stat3.mtime.toISOString());
-      await fsp2.writeFile(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
+      await fsp4.writeFile(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         console.warn(
           `[session-store] Failed to write manifest for "${id}":`,
           err instanceof Error ? err.message : String(err)
@@ -1572,8 +2467,8 @@ var DefaultSessionStore = class {
     }
   }
   async delete(id) {
-    await fsp2.unlink(path3.join(this.dir, `${id}.jsonl`));
-    await fsp2.unlink(path3.join(this.dir, `${id}.summary.json`)).catch(() => void 0);
+    await fsp4.unlink(path4.join(this.dir, `${id}.jsonl`));
+    await fsp4.unlink(path4.join(this.dir, `${id}.summary.json`)).catch(() => void 0);
   }
   async summarize(id, mtime) {
     try {
@@ -1677,7 +2572,7 @@ var FileSessionWriter = class {
     this.startedAt = startedAt;
     this.meta = meta;
     this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path3.join(opts.dir, `${id}.summary.json`) : "";
+    this.manifestFile = opts.dir ? path4.join(opts.dir, `${id}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.summary = {
       id,
@@ -1698,6 +2593,12 @@ var FileSessionWriter = class {
   tokenIn = 0;
   tokenOut = 0;
   filePath;
+  /** Public accessor for the JSONL path — required by SessionWriter so
+   *  observability surfaces (`/fleet log`, FleetPanel) can locate the
+   *  transcript without recomputing the path from session metadata. */
+  get transcriptPath() {
+    return this.filePath || void 0;
+  }
   initDone = false;
   resumed;
   appendFailCount = 0;
@@ -1715,7 +2616,7 @@ var FileSessionWriter = class {
 `;
     try {
       if (this.filePath) {
-        await fsp2.writeFile(this.filePath, record, { flag: "a", mode: 384 });
+        await fsp4.writeFile(this.filePath, record, { flag: "a", mode: 384 });
       }
     } catch {
     }
@@ -1768,7 +2669,7 @@ var FileSessionWriter = class {
     this.closed = true;
     if (this.manifestFile) {
       try {
-        await fsp2.writeFile(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
+        await fsp4.writeFile(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
       } catch {
       }
     }
@@ -1791,9 +2692,9 @@ function makeDirectorSessionFactory(opts) {
   let dir;
   if (opts.store) {
     store = opts.store;
-    dir = opts.sessionsRoot ? path3.join(opts.sessionsRoot, runId) : "(caller-managed)";
+    dir = opts.sessionsRoot ? path4.join(opts.sessionsRoot, runId) : "(caller-managed)";
   } else if (opts.sessionsRoot) {
-    dir = path3.join(opts.sessionsRoot, runId);
+    dir = path4.join(opts.sessionsRoot, runId);
     store = new DefaultSessionStore({ dir });
   } else {
     throw new Error("makeDirectorSessionFactory requires either `store` or `sessionsRoot`");
@@ -1840,10 +2741,12 @@ Working rules:
 - Never fabricate numbers \u2014 read the actual logs first
 - Always include file:line references for errors
 - If sessionPath is missing, ask the director to provide it
-- Report confidence level: high (>90% accuracy), medium, low`,
-  maxIterations: 50,
-  maxToolCalls: 200,
-  timeoutMs: 12e4
+- Report confidence level: high (>90% accuracy), medium, low`
+  // No hardcoded budgets — the orchestrator (delegate tool or
+  // spawn_subagent) decides per-task how much room a subagent gets.
+  // A monorepo audit needs hours; a single-file lint check needs
+  // seconds. Pinning a number here forces the orchestrator to fight
+  // the role's default instead of just asking for what it needs.
 };
 var BUG_HUNTER_AGENT = {
   id: "bug-hunter",
@@ -1883,10 +2786,8 @@ Working rules:
 - Never scan node_modules \u2014 it's noise
 - Always include file:line for every finding
 - If >30% of findings are false positives, note the confidence level
-- Ask director for clarification if paths are ambiguous`,
-  maxIterations: 80,
-  maxToolCalls: 300,
-  timeoutMs: 18e4
+- Ask director for clarification if paths are ambiguous`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
 };
 var REFACTOR_PLANNER_AGENT = {
   id: "refactor-planner",
@@ -1926,10 +2827,8 @@ Working rules:
 - Always include rollback strategy \u2014 every refactor can fail
 - Merge tasks that take <1h into a single phase
 - Respect team constraints (reviewer availability, parallelization)
-- Never plan without analyzing the actual code first`,
-  maxIterations: 60,
-  maxToolCalls: 250,
-  timeoutMs: 15e4
+- Never plan without analyzing the actual code first`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
 };
 var SECURITY_SCANNER_AGENT = {
   id: "security-scanner",
@@ -1977,10 +2876,8 @@ Working rules:
 - Never scan node_modules \u2014 use npm audit instead
 - Always provide remediation steps, not just findings
 - Verify regex-based secrets before flagging (false positive risk)
-- When in doubt, flag as medium rather than ignoring potential issues`,
-  maxIterations: 70,
-  maxToolCalls: 280,
-  timeoutMs: 16e4
+- When in doubt, flag as medium rather than ignoring potential issues`
+  // Budgets are set by the orchestrator per task — see fleet.ts header.
 };
 var FLEET_ROSTER = {
   "audit-log": AUDIT_LOG_AGENT,
@@ -1990,6 +2887,6 @@ var FLEET_ROSTER = {
 };
 var ALL_FLEET_AGENTS = Object.values(FLEET_ROSTER);
 
-export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, BUG_HUNTER_AGENT, BudgetExceededError, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultMultiAgentCoordinator, Director, DirectorBudgetError, FLEET_ROSTER, FleetBus, FleetUsageAggregator, InMemoryAgentBridge, InMemoryBridgeTransport, REFACTOR_PLANNER_AGENT, SECURITY_SCANNER_AGENT, SubagentBudget, composeDirectorPrompt, composeSubagentPrompt, createMessage, makeAgentSubagentRunner, makeDirectorSessionFactory, rosterSummaryFromConfigs };
+export { ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, BUG_HUNTER_AGENT, BudgetExceededError, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultMultiAgentCoordinator, Director, DirectorBudgetError, FLEET_ROSTER, FleetBus, FleetUsageAggregator, InMemoryAgentBridge, InMemoryBridgeTransport, REFACTOR_PLANNER_AGENT, SECURITY_SCANNER_AGENT, SubagentBudget, composeDirectorPrompt, composeSubagentPrompt, createDelegateTool, createMessage, makeAgentSubagentRunner, makeDirectorSessionFactory, rosterSummaryFromConfigs };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map