@wrongstack/core 0.5.5 → 0.5.7

package/dist/defaults/index.js

@@ -6,7 +6,12 @@ import * as fsp from 'fs/promises';
 import * as os from 'os';
 import { EventEmitter } from 'events';
 
-// src/infrastructure/logger.ts
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/utils/color.ts
 var isColorTty = () => {
@@ -2153,9 +2158,149 @@ function matchIndex(plan, idOrIndex) {
   const lower = idOrIndex.toLowerCase();
   return plan.items.findIndex((it) => it.title.toLowerCase().includes(lower));
 }
+function deriveTodosFromPlanItem(plan, idOrIndex, subtasks) {
+  const idx = matchIndex(plan, idOrIndex);
+  if (idx === -1) return null;
+  const item = plan.items[idx];
+  if (!item) return null;
+  let updatedPlan = plan;
+  if (item.status !== "done") {
+    updatedPlan = setPlanItemStatus(plan, idOrIndex, "in_progress");
+  }
+  const todos = [];
+  todos.push({
+    id: `todo_${Date.now()}_plan`,
+    content: item.title,
+    status: "in_progress",
+    activeForm: item.title
+  });
+  if (subtasks && subtasks.length > 0) {
+    for (const st of subtasks) {
+      todos.push({
+        id: `todo_${Date.now()}_${randomUUID().slice(0, 6)}`,
+        content: st,
+        status: "pending"
+      });
+    }
+  }
+  return { plan: updatedPlan, todos };
+}
 function attachPlanCheckpoint(_state, _filePath, _sessionId) {
   return () => void 0;
 }
+
+// src/storage/plan-templates.ts
+var templates = {
+  "new-feature": {
+    name: "new-feature",
+    description: "Standard workflow for adding a new feature",
+    category: "development",
+    items: [
+      { title: "Write specification / design doc", details: "Define scope, acceptance criteria, edge cases" },
+      { title: "Set up feature branch", details: "git checkout -b feature/..." },
+      { title: "Implement core logic", details: "TDD preferred \u2014 write tests first" },
+      { title: "Add unit tests", details: ">= 80% coverage for new code" },
+      { title: "Add integration tests", details: "End-to-end happy path + error paths" },
+      { title: "Update documentation", details: "README, API docs, changelog" },
+      { title: "Code review", details: "Self-review before requesting review" },
+      { title: "Merge and deploy", details: "CI green, tag release" }
+    ]
+  },
+  "bug-fix": {
+    name: "bug-fix",
+    description: "Systematic approach to fixing bugs",
+    category: "maintenance",
+    items: [
+      { title: "Reproduce the bug", details: "Minimal reproduction case" },
+      { title: "Root cause analysis", details: "Trace through logs, debugger" },
+      { title: "Write failing test", details: "Test must fail before fix" },
+      { title: "Implement fix", details: "Smallest possible change" },
+      { title: "Verify fix", details: "Test passes, reproduction no longer fails" },
+      { title: "Regression test", details: "Ensure no related tests broken" },
+      { title: "Document in changelog", details: "Brief description + issue link" }
+    ]
+  },
+  "refactor": {
+    name: "refactor",
+    description: "Safe refactoring workflow",
+    category: "maintenance",
+    items: [
+      { title: "Identify refactoring target", details: "Code smell, performance bottleneck, or tech debt" },
+      { title: "Ensure test coverage", details: "Existing tests must pass before and after" },
+      { title: "Write characterization tests", details: "Capture current behavior if tests weak" },
+      { title: "Apply refactoring", details: "Small steps, frequent commits" },
+      { title: "Run full test suite", details: "All tests must pass" },
+      { title: "Performance check", details: "Ensure no regression" },
+      { title: "Code review", details: "Explain the why, not just the what" }
+    ]
+  },
+  "release": {
+    name: "release",
+    description: "Preparing a new release",
+    category: "release",
+    items: [
+      { title: "Version bump", details: "package.json, lockfiles, tags" },
+      { title: "Update changelog", details: "All changes since last release" },
+      { title: "Run full test suite", details: "Unit + integration + e2e" },
+      { title: "Build artifacts", details: "Docker images, bundles, binaries" },
+      { title: "Staging smoke tests", details: "Deploy to staging, verify" },
+      { title: "Production deploy", details: "Blue-green or canary" },
+      { title: "Post-deploy verification", details: "Health checks, error rates" },
+      { title: "Announce release", details: "Slack, email, GitHub release notes" }
+    ]
+  },
+  "security-audit": {
+    name: "security-audit",
+    description: "Security review and hardening",
+    category: "infrastructure",
+    items: [
+      { title: "Dependency audit", details: "npm audit, Snyk, Dependabot alerts" },
+      { title: "Secret scan", details: "git-secrets, truffleHog, manual review" },
+      { title: "Access control review", details: "IAM, roles, least privilege" },
+      { title: "Input validation audit", details: "SQL injection, XSS, path traversal" },
+      { title: "Authentication review", details: "Session management, MFA, password policy" },
+      { title: "Logging and monitoring", details: "PII in logs, audit trails" },
+      { title: "Incident response plan", details: "Runbooks, contacts, escalation" }
+    ]
+  },
+  "onboarding": {
+    name: "onboarding",
+    description: "New developer onboarding checklist",
+    category: "infrastructure",
+    items: [
+      { title: "Repository access", details: "GitHub/GitLab permissions" },
+      { title: "Local environment setup", details: "Docker, dependencies, env files" },
+      { title: "Run tests locally", details: "Verify green suite" },
+      { title: "Read architecture docs", details: "ADR, README, onboarding guide" },
+      { title: "First commit", details: "Docs fix or small improvement" },
+      { title: "Pair programming session", details: "Walk through codebase with buddy" },
+      { title: "Deploy to staging", details: "Verify CI/CD access" }
+    ]
+  }
+};
+function listPlanTemplates() {
+  return Object.values(templates);
+}
+function getPlanTemplate(name) {
+  return templates[name];
+}
+function formatPlanTemplates() {
+  const cats = /* @__PURE__ */ new Map();
+  for (const t of Object.values(templates)) {
+    const arr = cats.get(t.category) ?? [];
+    arr.push(t);
+    cats.set(t.category, arr);
+  }
+  const lines = ["Available plan templates:"];
+  for (const [cat, items] of cats) {
+    lines.push(`
+${cat}:`);
+    for (const t of items) {
+      lines.push(`  ${t.name.padEnd(18)} \u2014 ${t.description}`);
+    }
+  }
+  return lines.join("\n");
+}
 async function loadDirectorState(filePath) {
   let raw;
   try {
@@ -2171,15 +2316,48 @@ async function loadDirectorState(filePath) {
     return null;
   }
 }
+async function acquireDirectorStateLock(lockPath, processId = process.pid) {
+  let existing;
+  try {
+    existing = await fsp.readFile(lockPath, "utf8");
+  } catch {
+  }
+  if (existing) {
+    try {
+      const lock2 = JSON.parse(existing);
+      try {
+        process.kill(lock2.pid, 0);
+        return false;
+      } catch {
+      }
+    } catch {
+    }
+  }
+  const lock = {
+    pid: processId,
+    hostname: __require("os").hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await atomicWrite(lockPath, JSON.stringify(lock), { mode: 384 });
+  return true;
+}
+async function releaseDirectorStateLock(lockPath) {
+  try {
+    await fsp.unlink(lockPath);
+  } catch {
+  }
+}
 var DirectorStateCheckpoint = class {
   snapshot;
   filePath;
+  lockPath;
   timer = null;
   debounceMs;
   writing = false;
   rewriteRequested = false;
   constructor(filePath, init, debounceMs = 250) {
     this.filePath = filePath;
+    this.lockPath = `${filePath}.lock`;
     this.debounceMs = debounceMs;
     this.snapshot = {
       version: 1,
@@ -2189,10 +2367,36 @@ var DirectorStateCheckpoint = class {
       maxSpawns: init.maxSpawns,
       spawnDepth: init.spawnDepth,
       maxSpawnDepth: init.maxSpawnDepth,
+      directorBudget: init.directorBudget,
       subagents: [],
       tasks: []
     };
   }
+  /**
+   * Attempt to acquire the lock for this checkpoint. Call this before
+   * resuming a crashed director run. If it returns false, another
+   * director process is still running this fleet — do not resume.
+   */
+  async acquireLock() {
+    return acquireDirectorStateLock(this.lockPath);
+  }
+  /**
+   * Release the lock on graceful shutdown. Call `flush()` first to ensure
+   * the final checkpoint state is on disk before removing the lock.
+   * Without this, the next resume will see a stale-lock and refuse.
+   */
+  async releaseLock() {
+    return releaseDirectorStateLock(this.lockPath);
+  }
+  /**
+   * Resume from a snapshot previously loaded via `loadDirectorState()`.
+   * Use this when `--resume <runId>` is triggered — the snapshot has
+   * the full fleet state (subagents, tasks) from before the crash; the
+   * checkpoint continues from there.
+   */
+  resume(snapshot) {
+    this.snapshot = snapshot;
+  }
   current() {
     return this.snapshot;
   }
@@ -4833,6 +5037,14 @@ var DoneConditionChecker = class {
           };
         }
         break;
+      case "directive":
+        if (this.condition.maxIterations && state.iterations >= this.condition.maxIterations) {
+          return { done: true, reason: `max iterations (${this.condition.maxIterations}) reached`, ...state };
+        }
+        if (this.condition.maxToolCalls && state.toolCalls >= this.condition.maxToolCalls) {
+          return { done: true, reason: `max tool calls (${this.condition.maxToolCalls}) reached`, ...state };
+        }
+        break;
     }
     return { done: false, iterations: state.iterations, toolCalls: state.toolCalls };
   }
@@ -4852,10 +5064,16 @@ var AutonomousRunner = class {
     const offToolExecuted = this.opts.agent.events?.on?.("tool.executed", () => {
       this.toolCalls++;
     });
+    const offIterationCompleted = this.opts.agent.events?.on?.("iteration.completed", () => {
+      if (this.opts.enableAutonomousContinue && this.opts.doneCondition.type === "directive") {
+        this.iterations++;
+      }
+    });
     try {
       return await this.runLoop();
     } finally {
       offToolExecuted?.();
+      offIterationCompleted?.();
     }
   }
   async runLoop() {
@@ -4879,12 +5097,14 @@ var AutonomousRunner = class {
       const ctrl = new AbortController();
       const timeout = setTimeout(() => ctrl.abort(), this.opts.iterationTimeoutMs ?? 3e4);
       try {
+        const isDirectiveMode = this.opts.doneCondition.type === "directive" && this.opts.enableAutonomousContinue;
         const result = await this.opts.agent.run("", {
           signal: ctrl.signal,
-          maxIterations: 1,
-          executionStrategy: "sequential"
+          maxIterations: isDirectiveMode ? this.opts.doneCondition.maxIterations ?? 100 : 1,
+          executionStrategy: "sequential",
+          autonomousContinue: isDirectiveMode ? true : void 0
         });
-        this.iterations++;
+        if (!isDirectiveMode) this.iterations++;
         if (result.status === "done") {
           this.lastOutput = result.finalText;
         }
@@ -6227,7 +6447,10 @@ function makeSpawnTool(director, roster) {
         const subagentId = await director.spawn(cfg);
         return { subagentId, provider: cfg.provider, model: cfg.model, name: cfg.name };
       } catch (err) {
-        if (err instanceof DirectorBudgetError) {
+        if (err instanceof FleetSpawnBudgetError) {
+          return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
+        }
+        if (err instanceof FleetCostCapError) {
           return { error: err.message, kind: err.kind, limit: err.limit, observed: err.observed };
         }
         return { error: err instanceof Error ? err.message : String(err) };
@@ -6367,9 +6590,68 @@ function makeFleetUsageTool(director) {
     }
   };
 }
+function makeFleetSessionTool(director) {
+  return {
+    name: "fleet_session",
+    description: "Read a subagent's JSONL transcript and extract its last assistant text, stop reason, and tool-use count. Use this to see what a running or timed-out subagent actually produced.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: {
+      type: "object",
+      properties: {
+        subagentId: { type: "string", description: "Subagent id to read the transcript of." },
+        /** Number of trailing lines to return (last N JSONL lines). Default: all. */
+        tail: { type: "number", description: "Number of trailing JSONL lines to return. Omit for the full transcript." }
+      },
+      required: ["subagentId"]
+    },
+    async execute(input) {
+      const i = input;
+      const result = await director.readSession(i.subagentId, i.tail);
+      if (!result) {
+        return {
+          error: `fleet_session: transcript unavailable for "${i.subagentId}". Is sessionsRoot configured?`
+        };
+      }
+      return result;
+    }
+  };
+}
+function makeFleetHealthTool(director) {
+  return {
+    name: "fleet_health",
+    description: "Per-subagent health report: budget pressure (pct of limits consumed), last activity timestamp, and current status. Use to decide whether to assign more work to a subagent or spawn a fresh one.",
+    permission: "auto",
+    mutating: false,
+    inputSchema: { type: "object", properties: {}, required: [] },
+    async execute() {
+      const status = director.status();
+      const snapshot = director.snapshot();
+      const subagents = status.subagents ?? [];
+      const perSubagent = snapshot.perSubagent ?? {};
+      return {
+        subagents: subagents.map((s) => {
+          const usage = perSubagent[s.id];
+          return {
+            id: s.id,
+            status: s.status,
+            lastEventAt: usage?.lastEventAt,
+            // Budget pressure: fraction of each limit consumed if we have it.
+            // BudgetWarning events carry used/limit ratios; surface them here.
+            budgetPressure: {
+              iterations: usage?.iterations,
+              toolCalls: usage?.toolCalls,
+              costUsd: usage?.cost
+            }
+          };
+        })
+      };
+    }
+  };
+}
 
 // src/coordination/director.ts
-var DirectorBudgetError = class extends Error {
+var FleetSpawnBudgetError = class extends Error {
   kind;
   limit;
   observed;
@@ -6377,16 +6659,48 @@ var DirectorBudgetError = class extends Error {
     super(
       kind === "max_spawns" ? `Director spawn budget exceeded: tried to spawn #${observed} but maxSpawns is ${limit}` : `Director spawn depth budget exceeded: this director is at depth ${observed} and maxSpawnDepth is ${limit}`
     );
-    this.name = "DirectorBudgetError";
+    this.name = "FleetSpawnBudgetError";
     this.kind = kind;
     this.limit = limit;
     this.observed = observed;
   }
 };
+var FleetCostCapError = class extends Error {
+  kind;
+  limit;
+  observed;
+  constructor(limit, observed) {
+    super(
+      `Director cost cap exceeded: total fleet spend ${observed.toFixed(4)} exceeds maxCostUsd ${limit.toFixed(4)}`
+    );
+    this.name = "FleetCostCapError";
+    this.kind = "max_cost_usd";
+    this.limit = limit;
+    this.observed = observed;
+  }
+};
 var Director = class {
+  /** Alias for the ICoordinator contract. `id` is retained for backward compatibility. */
+  get coordinatorId() {
+    return this.id;
+  }
   id;
+  /**
+   * The fleet event bus. Backed by `fleetManager?.fleet` when a FleetManager
+   * is injected; otherwise own FleetBus instance (preserves existing behavior).
+   */
   fleet;
+  /**
+   * Usage rollup. Backed by `fleetManager?.usage` when a FleetManager is
+   * injected; otherwise own FleetUsageAggregator.
+   */
   usage;
+  /**
+   * Optional fleet-level policy container. When provided the Director
+   * delegates spawn budgeting, manifest entries, and checkpointing to it
+   * instead of managing those internally. All other behavior is unchanged.
+   */
+  fleetManager;
   /**
    * Director-side bridge endpoint. Subagents are wired to the same
    * in-memory transport so the director can `ask()` them synchronously
@@ -6437,6 +6751,14 @@ var Director = class {
   /** Debounce timer for periodic manifest writes. */
   manifestTimer = null;
   manifestDebounceMs;
+  /** Fleet-wide cost cap (entire fleet total, distinct from SubagentBudget limits). Infinity means no cap. */
+  maxFleetCostUsd;
+  /** Max auto-extensions per subagent per budget kind before denying. */
+  maxBudgetExtensions;
+  /** Sessions root for direct subagent JSONL reads (fleet_session tool). */
+  sessionsRoot;
+  /** Director run id for JSONL path resolution. */
+  directorRunId;
   /** Resolves task descriptions back from `assign()` so completion events
    *  can also carry a human-readable title. */
   taskDescriptions = /* @__PURE__ */ new Map();
@@ -6463,12 +6785,18 @@ var Director = class {
     this.spawnDepth = opts.spawnDepth ?? 0;
     this.sessionWriter = opts.sessionWriter ?? null;
     this.manifestDebounceMs = opts.manifestDebounceMs ?? 2e3;
+    this.maxFleetCostUsd = opts.directorBudget?.maxCostUsd ?? Number.POSITIVE_INFINITY;
+    this.maxBudgetExtensions = opts.maxBudgetExtensions ?? 2;
+    this.sessionsRoot = opts.sessionsRoot;
+    this.directorRunId = opts.directorRunId ?? this.id;
     this.stateCheckpoint = opts.stateCheckpointPath ? new DirectorStateCheckpoint(opts.stateCheckpointPath, {
       directorRunId: this.id,
       maxSpawns: opts.maxSpawns,
       spawnDepth: this.spawnDepth,
-      maxSpawnDepth: this.maxSpawnDepth
-    }) : null;
+      maxSpawnDepth: this.maxSpawnDepth,
+      directorBudget: opts.directorBudget
+    }, opts.checkpointDebounceMs ?? 250) : null;
+    this.fleetManager = opts.fleetManager;
     if (this.sharedScratchpadPath) {
       void fsp.mkdir(this.sharedScratchpadPath, { recursive: true }).catch(() => void 0);
     }
@@ -6477,12 +6805,17 @@ var Director = class {
       { agentId: this.id, coordinatorId: this.id },
       this.transport
     );
-    this.fleet = new FleetBus();
-    this.usage = new FleetUsageAggregator(
-      this.fleet,
-      (id) => this.priceLookups.get(id),
-      (id) => this.subagentMeta.get(id)
-    );
+    if (this.fleetManager) {
+      this.fleet = this.fleetManager.fleet;
+      this.usage = this.fleetManager.usage;
+    } else {
+      this.fleet = new FleetBus();
+      this.usage = new FleetUsageAggregator(
+        this.fleet,
+        (id) => this.priceLookups.get(id),
+        (id) => this.subagentMeta.get(id)
+      );
+    }
     this.coordinator = new DefaultMultiAgentCoordinator(
       { ...opts.config, coordinatorId: this.id },
       { runner: opts.runner }
@@ -6529,7 +6862,7 @@ var Director = class {
       const payload = e.payload;
       const guardKey = `${e.subagentId}:${payload.kind}`;
       const prior = extendCounts.get(guardKey) ?? 0;
-      if (prior >= 2) {
+      if (prior >= this.maxBudgetExtensions) {
         payload.deny();
         extendCounts.delete(guardKey);
         return;
@@ -6584,52 +6917,73 @@ var Director = class {
    * it the `cost` column in `usage.snapshot()` stays at 0.
    */
   async spawn(config, priceLookup) {
-    if (this.spawnDepth >= this.maxSpawnDepth) {
-      throw new DirectorBudgetError("max_spawn_depth", this.maxSpawnDepth, this.spawnDepth);
-    }
-    if (this.spawnCount >= this.maxSpawns) {
-      throw new DirectorBudgetError("max_spawns", this.maxSpawns, this.spawnCount + 1);
+    if (this.fleetManager) {
+      const rejection = this.fleetManager.canSpawn(config);
+      if (rejection) {
+        if (rejection.kind === "max_spawn_depth") throw new FleetSpawnBudgetError("max_spawn_depth", rejection.limit, rejection.observed);
+        if (rejection.kind === "max_spawns") throw new FleetSpawnBudgetError("max_spawns", rejection.limit, rejection.observed);
+        if (rejection.kind === "max_cost_usd") throw new FleetCostCapError(rejection.limit, rejection.observed);
+      }
+    } else {
+      if (this.spawnDepth >= this.maxSpawnDepth) {
+        throw new FleetSpawnBudgetError("max_spawn_depth", this.maxSpawnDepth, this.spawnDepth);
+      }
+      if (this.spawnCount >= this.maxSpawns) {
+        throw new FleetSpawnBudgetError("max_spawns", this.maxSpawns, this.spawnCount + 1);
+      }
+      if (this.maxFleetCostUsd < Number.POSITIVE_INFINITY) {
+        const totalCost = this.usage.snapshot().total?.cost ?? 0;
+        if (totalCost >= this.maxFleetCostUsd) {
+          throw new FleetCostCapError(this.maxFleetCostUsd, totalCost);
+        }
+      }
     }
     const result = await this.coordinator.spawn(config);
-    this.spawnCount += 1;
-    this.subagentMeta.set(result.subagentId, {
-      provider: config.provider,
-      model: config.model
-    });
-    if (priceLookup) this.priceLookups.set(result.subagentId, priceLookup);
+    if (this.fleetManager) {
+      this.fleetManager.recordSpawn(result.subagentId, config, priceLookup);
+    } else {
+      this.spawnCount += 1;
+      this.subagentMeta.set(result.subagentId, {
+        provider: config.provider,
+        model: config.model
+      });
+      if (priceLookup) this.priceLookups.set(result.subagentId, priceLookup);
+    }
     const subagentBridge = new InMemoryAgentBridge(
       { agentId: result.subagentId, coordinatorId: this.id },
       this.transport
     );
     this.coordinator.setSubagentBridge(result.subagentId, subagentBridge);
     this.subagentBridges.set(result.subagentId, subagentBridge);
-    this.manifestEntries.set(result.subagentId, {
-      subagentId: result.subagentId,
-      name: config.name,
-      role: config.role,
-      provider: config.provider,
-      model: config.model,
-      taskIds: []
-    });
-    const spawnedAt = (/* @__PURE__ */ new Date()).toISOString();
-    this.stateCheckpoint?.recordSpawn(
-      {
-        id: result.subagentId,
+    if (!this.fleetManager) {
+      this.manifestEntries.set(result.subagentId, {
+        subagentId: 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();
+        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;
   }
   /**
@@ -6769,6 +7123,7 @@ var Director = class {
     if (this.stateCheckpoint) {
       this.stateCheckpoint.setUsage(this.usage.snapshot());
       await this.stateCheckpoint.flush().catch((err) => this.logShutdownError("state_checkpoint_flush", err));
+      await this.stateCheckpoint.releaseLock().catch((err) => this.logShutdownError("state_checkpoint_lock_release", err));
     }
   }
   /**
@@ -6795,8 +7150,12 @@ var Director = class {
   async assign(task) {
     const taskWithId = task.id ? task : { ...task, id: randomUUID() };
     if (task.subagentId) {
-      const entry = this.manifestEntries.get(task.subagentId);
-      if (entry) entry.taskIds.push(taskWithId.id);
+      if (this.fleetManager) {
+        this.fleetManager.addTaskToSubagent(task.subagentId, taskWithId.id);
+      } else {
+        const entry = this.manifestEntries.get(task.subagentId);
+        if (entry) entry.taskIds.push(taskWithId.id);
+      }
     }
     await this.coordinator.assign(taskWithId);
     this.taskDescriptions.set(taskWithId.id, taskWithId.description);
@@ -6872,6 +7231,58 @@ var Director = class {
   completedResults() {
     return Array.from(this.completed.values());
   }
+  /**
+   * Inject a previously-saved checkpoint snapshot. Call this right after
+   * constructing a Director during a `--resume` run so the in-memory state
+   * (subagents, tasks, waiters) reflects the pre-crash reality instead of
+   * starting from a blank slate. The director then resumes from there —
+   * completing any in-flight tasks and ignoring tasks that already reached
+   * a terminal state in the prior run.
+   */
+  setCheckpointState(snapshot) {
+    this.stateCheckpoint?.resume(snapshot);
+  }
+  /**
+   * Read a subagent's JSONL transcript directly from disk (no bridge
+   * round-trip needed). Returns the last assistant text, stop reason,
+   * tool-use count, and line count — or null if the file is unavailable.
+   * Requires `sessionsRoot` to be set on construction.
+   */
+  async readSession(subagentId, tail) {
+    if (!this.sessionsRoot) return null;
+    const filePath = path3.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
+    let raw;
+    try {
+      raw = await fsp.readFile(filePath, "utf8");
+    } catch {
+      return null;
+    }
+    const lines = raw.split("\n").filter((l) => l.trim());
+    const targetLines = tail ? lines.slice(-tail) : lines;
+    let lastAssistantText;
+    let lastStopReason;
+    let toolUses = 0;
+    for (const line of targetLines) {
+      try {
+        const ev = JSON.parse(line);
+        if (ev.type === "assistant" && typeof ev.text === "string") {
+          lastAssistantText = ev.text;
+        } else if (ev.type === "stop" && ev.stopReason) {
+          lastStopReason = ev.stopReason;
+        } else if (ev.type === "tool_use") {
+          toolUses++;
+        }
+      } catch {
+      }
+    }
+    return {
+      lastAssistantText,
+      lastStopReason,
+      toolUsesObserved: toolUses,
+      events: targetLines.length,
+      path: filePath
+    };
+  }
   snapshot() {
     return this.usage.snapshot();
   }
@@ -6942,18 +7353,37 @@ var Director = class {
    * still permission-checked normally.
    */
   tools(roster) {
+    const effectiveRoster = roster ?? this.roster;
     const t = [
-      makeSpawnTool(this, roster),
+      makeSpawnTool(this, effectiveRoster),
       makeAssignTool(this),
       makeAwaitTasksTool(this),
       makeAskTool(this),
       makeRollUpTool(this),
       makeTerminateTool(this),
       makeFleetStatusTool(this),
-      makeFleetUsageTool(this)
+      makeFleetUsageTool(this),
+      makeFleetSessionTool(this),
+      makeFleetHealthTool(this)
     ];
     return t;
   }
+  /**
+   * Attempt to acquire the checkpoint lock. Must be called before
+   * resuming — if another director process is alive, this returns
+   * false and the caller should not proceed with the resume.
+   */
+  async acquireCheckpointLock() {
+    return this.stateCheckpoint ? this.stateCheckpoint.acquireLock() : true;
+  }
+  /**
+   * Resume from a prior checkpoint snapshot (loaded via
+   * `loadDirectorState()`). Re-attach to the fleet mid-flight so
+   * subsequent spawn/assign calls update the checkpoint normally.
+   */
+  resumeFromCheckpoint(snapshot) {
+    this.stateCheckpoint?.resume(snapshot);
+  }
 };
 function createDelegateTool(opts) {
   const defaultTimeoutMs = opts.defaultTimeoutMs ?? 4 * 60 * 60 * 1e3;
@@ -7059,7 +7489,7 @@ function createDelegateTool(opts) {
         if (typeof i.maxToolCalls === "number" && i.maxToolCalls > 0) {
           cfg.maxToolCalls = i.maxToolCalls;
         }
-        const SUBAGENT_TIMEOUT_BUFFER_MS = 3e4;
+        const SUBAGENT_TIMEOUT_BUFFER_MS = opts.subagentTimeoutBufferMs ?? 3e4;
         const desiredSubTimeout = Math.max(3e4, timeoutMs - SUBAGENT_TIMEOUT_BUFFER_MS);
         if (!cfg.timeoutMs || cfg.timeoutMs > desiredSubTimeout) {
           cfg.timeoutMs = desiredSubTimeout;
@@ -7111,7 +7541,7 @@ function createDelegateTool(opts) {
           toolCalls: result.toolCalls,
           durationMs: result.durationMs,
           ...partial ? { partial } : {},
-          ...hintForKind(errorKind, retryable, backoffMs) ? { hint: hintForKind(errorKind, retryable, backoffMs) } : {}
+          ...hintForKind(errorKind, retryable, backoffMs, partial) ? { hint: hintForKind(errorKind, retryable, backoffMs, partial) } : {}
         };
       } catch (err) {
         return {
@@ -7131,7 +7561,7 @@ function instantiateRosterConfig2(role, base) {
     id: `${role}-${randomUUID().slice(0, 8)}`
   };
 }
-function hintForKind(kind, retryable, backoffMs) {
+function hintForKind(kind, retryable, backoffMs, partial) {
   if (!kind) return void 0;
   switch (kind) {
     case "provider_rate_limit":
@@ -7147,16 +7577,40 @@ function hintForKind(kind, retryable, backoffMs) {
     case "budget_iterations":
     case "budget_tool_calls":
     case "budget_tokens":
-    case "budget_cost":
-      return "Subagent exhausted its budget. The coordinator may auto-extend; otherwise raise the matching `max*` field (e.g. maxToolCalls: 600) on the next delegate, or split the task.";
-    case "budget_timeout":
-      return "Subagent hit its wall-clock budget. Raise `timeoutMs` on the next delegate or split the task.";
+    case "budget_cost": {
+      const base = "Subagent exhausted its budget. The coordinator may auto-extend; otherwise raise the matching `max*` field (e.g. maxToolCalls: 600) on the next delegate, or split the task.";
+      if (partial?.lastAssistantText) {
+        return `${base}
+
+Partial output produced before budget hit:
+${partial.lastAssistantText}`;
+      }
+      return base;
+    }
+    case "budget_timeout": {
+      const base = "Subagent hit its wall-clock budget. Raise `timeoutMs` on the next delegate or split the task.";
+      if (partial?.lastAssistantText) {
+        return `${base}
+
+Partial output produced before timeout:
+${partial.lastAssistantText}`;
+      }
+      return base;
+    }
     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 "tool_failed": {
+      const base = "A tool inside the subagent returned ok:false. Retry with corrected inputs.";
+      if (partial?.lastAssistantText) {
+        return `${base}
+
+Agent reasoning before failure:
+${partial.lastAssistantText}`;
+      }
+      return base;
+    }
     case "bridge_failed":
       return "Parent-child bridge transport failed. This is rare \u2014 restart the session and retry.";
     default:
@@ -7367,6 +7821,9 @@ function makeDirectorSessionFactory(opts) {
     }
   };
 }
+
+// src/coordination/null-fleet-bus.ts
+var NULL_FLEET_BUS = new FleetBus();
 var DEFAULT_URL = "https://models.dev/api.json";
 var DEFAULT_TTL_SECONDS = 24 * 3600;
 var FAMILY_BY_NPM = {
@@ -11286,6 +11743,6 @@ var allServers = () => ({
   "minimax-vision": { ...miniMaxVisionServer(), enabled: false }
 });
 
-export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorBudgetError, DirectorStateCheckpoint, DoneConditionChecker, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, getTemplate, githubServer, googleMapsServer, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeDirectorSessionFactory, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
+export { AISpecBuilder, ALL_FLEET_AGENTS, AUDIT_LOG_AGENT, AutoApprovePermissionPolicy, AutoCompactionMiddleware, AutoExecutor, AutonomousRunner, BUG_HUNTER_AGENT, BudgetExceededError, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, DEFAULT_DIRECTOR_PREAMBLE, DEFAULT_SUBAGENT_BASELINE, DefaultAttachmentStore, DefaultConfigLoader, DefaultConfigStore, DefaultErrorHandler, DefaultHealthRegistry, DefaultLogger, DefaultMemoryStore, DefaultModeStore, DefaultModelsRegistry, DefaultMultiAgentCoordinator, DefaultPermissionPolicy, DefaultProviderRunner, DefaultRetryPolicy, DefaultSecretScrubber, DefaultSecretVault, DefaultSessionReader, DefaultSessionStore, DefaultSkillLoader, DefaultTaskStore, Director, DirectorStateCheckpoint, DoneConditionChecker, FLEET_ROSTER, FLEET_ROSTER_BUDGETS, FleetBus, FleetSpawnBudgetError, FleetUsageAggregator, HybridCompactor, InMemoryAgentBridge, InMemoryBridgeTransport, InMemoryMetricsSink, IntelligentCompactor, LLMSelector, NULL_FLEET_BUS, NoopMetricsSink, NoopTracer, OTelTracer, PROMETHEUS_CONTENT_TYPE, QueueStore, REFACTOR_PLANNER_AGENT, RecoveryLock, SECURITY_SCANNER_AGENT, SPEC_TEMPLATES, SelectiveCompactor, SessionAnalyzer, SpecDrivenDev, SpecParser, SpecStore, SpecVersioning, SubagentBudget, TaskFlow, TaskGenerator, TaskGraphStore, TaskTracker, ToolExecutor, addPlanItem, allServers, analyzeCriticalPath, applyRosterBudget, attachPlanCheckpoint, attachTodosCheckpoint, awsServer, blockServer, braveSearchServer, buildOtlpMetricsRequest, buildOtlpTracesRequest, classifyFamily, clearPlan, composeDirectorPrompt, composeSubagentPrompt, context7Server, contextManagerTool, createAutoExecutor, createContextManagerTool, createDelegateTool, createMessage, decryptConfigSecrets2 as decryptConfigSecrets, deriveTodosFromPlanItem, emptyPlan, encryptConfigSecrets, everArtServer, filesystemServer, formatPlan, formatPlanTemplates, getPlanTemplate, getTemplate, githubServer, googleMapsServer, listPlanTemplates, listTemplates, loadDirectorState, loadPlan, loadProjectModes, loadTodosCheckpoint, loadUserModes, makeAgentSubagentRunner, makeDirectorSessionFactory, migratePlaintextSecrets, miniMaxVisionServer, removePlanItem, renderProgress, renderPrometheus, renderSpecAnalysis, renderTaskGraph, renderTaskList, rewriteConfigEncrypted, rosterSummaryFromConfigs, runConfigMigrations, savePlan, saveTodosCheckpoint, sentinelServer, setPlanItemStatus, slackServer, startMetricsServer, startOtlpMetricsExporter, startOtlpTraceExporter, templateToMarkdown, wireMetricsToEvents, zaiVisionServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map