@wrongstack/cli 0.1.7 → 0.1.9

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import { color, DefaultLogger, DefaultModelsRegistry, Container, DefaultConfigStore, TOKENS, DefaultSecretScrubber, DefaultRetryPolicy, DefaultErrorHandler, DefaultTokenCounter, DefaultModeStore, DefaultSessionStore, DefaultMemoryStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultPermissionPolicy, HybridCompactor, ProviderRegistry, ToolRegistry, createContextManagerTool, EventBus, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, createDefaultPipelines, AutoCompactionMiddleware, Agent, SlashCommandRegistry, loadPlugins, DefaultPathResolver, resolveWstackPaths, DefaultSecretVault, migratePlaintextSecrets, DefaultConfigLoader, InputBuilder, DefaultPluginAPI, atomicWrite, DefaultSessionReader, makeAgentSubagentRunner, DefaultMultiAgentCoordinator, decryptConfigSecrets, encryptConfigSecrets } from '@wrongstack/core';
+import { color, DefaultLogger, DefaultModelsRegistry, Container, DefaultConfigStore, TOKENS, DefaultSecretScrubber, DefaultRetryPolicy, DefaultErrorHandler, DefaultTokenCounter, DefaultModeStore, DefaultSessionStore, DefaultMemoryStore, DefaultSkillLoader, DefaultSystemPromptBuilder, DefaultPermissionPolicy, HybridCompactor, ProviderRegistry, ToolRegistry, createContextManagerTool, EventBus, InMemoryMetricsSink, wireMetricsToEvents, DefaultHealthRegistry, startMetricsServer, RecoveryLock, DefaultAttachmentStore, QueueStore, Context, createDefaultPipelines, AutoCompactionMiddleware, Agent, SlashCommandRegistry, loadPlugins, FLEET_ROSTER, DefaultPathResolver, resolveWstackPaths, DefaultSecretVault, migratePlaintextSecrets, DefaultConfigLoader, makeDirectorSessionFactory, makeAgentSubagentRunner, Director, DefaultMultiAgentCoordinator, InputBuilder, DefaultPluginAPI, atomicWrite, DefaultSessionReader, decryptConfigSecrets, encryptConfigSecrets } from '@wrongstack/core';
 import { WebSocketServer, WebSocket } from 'ws';
 import * as fs6 from 'fs/promises';
 import { writeFileSync } from 'fs';
 import { createRequire } from 'module';
-import * as path5 from 'path';
+import * as path6 from 'path';
 import { MCPRegistry } from '@wrongstack/mcp';
 import { buildProviderFactoriesFromRegistry, makeProviderFromConfig, capabilitiesFor } from '@wrongstack/providers';
 import { rememberTool, forgetTool } from '@wrongstack/tools';
@@ -541,7 +541,7 @@ var ReadlineInputReader = class {
   history = [];
   pending = false;
   constructor(opts = {}) {
-    this.historyFile = opts.historyFile ?? path5.join(os3.homedir(), ".wrongstack", "history");
+    this.historyFile = opts.historyFile ?? path6.join(os3.homedir(), ".wrongstack", "history");
   }
   async loadHistory() {
     try {
@@ -553,7 +553,7 @@ var ReadlineInputReader = class {
   }
   async saveHistory() {
     try {
-      await fs6.mkdir(path5.dirname(this.historyFile), { recursive: true });
+      await fs6.mkdir(path6.dirname(this.historyFile), { recursive: true });
       await fs6.writeFile(this.historyFile, this.history.slice(-1e3).join("\n"));
     } catch {
     }
@@ -1046,6 +1046,7 @@ function buildBuiltinSlashCommands(opts) {
     statsCommand(opts),
     spawnCommand(opts),
     agentsCommand(opts),
+    fleetCommand(opts),
     metricsCommand(opts),
     healthCommand(opts),
     memoryCommand(opts),
@@ -1167,8 +1168,8 @@ function initCommand(opts) {
     description: "Scaffold .wrongstack/AGENTS.md in the current project.",
     async run(args, ctx) {
       const force = args.trim() === "--force";
-      const dir = path5.join(ctx.projectRoot, ".wrongstack");
-      const file = path5.join(dir, "AGENTS.md");
+      const dir = path6.join(ctx.projectRoot, ".wrongstack");
+      const file = path6.join(dir, "AGENTS.md");
       try {
         await fs6.access(file);
         if (!force) {
@@ -1199,7 +1200,7 @@ No project type auto-detected. Edit the file to add build/test commands and conv
 async function detectProjectFacts(root) {
   const facts = { hints: [] };
   try {
-    const pkg = JSON.parse(await fs6.readFile(path5.join(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(await fs6.readFile(path6.join(root, "package.json"), "utf8"));
     const scripts = pkg.scripts ?? {};
     const pm = (pkg.packageManager ?? "npm").split("@")[0] ?? "npm";
     if (scripts["build"]) facts.build = `${pm} run build`;
@@ -1210,28 +1211,28 @@ async function detectProjectFacts(root) {
   } catch {
   }
   try {
-    await fs6.access(path5.join(root, "pyproject.toml"));
+    await fs6.access(path6.join(root, "pyproject.toml"));
     facts.test ??= "pytest";
     facts.lint ??= "ruff check .";
     facts.hints.push("pyproject.toml");
   } catch {
   }
   try {
-    await fs6.access(path5.join(root, "go.mod"));
+    await fs6.access(path6.join(root, "go.mod"));
     facts.build ??= "go build ./...";
     facts.test ??= "go test ./...";
     facts.hints.push("go.mod");
   } catch {
   }
   try {
-    await fs6.access(path5.join(root, "Cargo.toml"));
+    await fs6.access(path6.join(root, "Cargo.toml"));
     facts.build ??= "cargo build";
     facts.test ??= "cargo test";
     facts.hints.push("Cargo.toml");
   } catch {
   }
   try {
-    await fs6.access(path5.join(root, "Makefile"));
+    await fs6.access(path6.join(root, "Makefile"));
     facts.build ??= "make";
     facts.test ??= "make test";
     facts.hints.push("Makefile");
@@ -1673,18 +1674,46 @@ function statusIcon(status) {
   if (status === "degraded") return color.yellow("\u25CF");
   return color.red("\u25CF");
 }
+function parseSpawnFlags(input) {
+  const opts = {};
+  let rest = input;
+  const consume = (re) => {
+    const m = rest.match(re);
+    if (m) {
+      rest = rest.slice(m[0].length).replace(/^\s+/, "");
+      return m;
+    }
+    return null;
+  };
+  while (rest.length > 0) {
+    let m;
+    if (m = consume(/^--provider=(\S+)\s*/)) opts.provider = m[1];
+    else if (m = consume(/^--model=(\S+)\s*/)) opts.model = m[1];
+    else if (m = consume(/^--name=("([^"]+)"|(\S+))\s*/)) opts.name = m[2] ?? m[3];
+    else if (m = consume(/^--tools=(\S+)\s*/)) opts.tools = m[1].split(",").map((t) => t.trim()).filter(Boolean);
+    else if (m = consume(/^-p\s+(\S+)\s*/)) opts.provider = m[1];
+    else if (m = consume(/^-m\s+(\S+)\s*/)) opts.model = m[1];
+    else if (m = consume(/^-n\s+("([^"]+)"|(\S+))\s*/)) opts.name = m[2] ?? m[3];
+    else break;
+  }
+  return { description: rest.trim(), opts };
+}
 function spawnCommand(opts) {
   return {
     name: "spawn",
-    description: "Spawn an isolated subagent to handle a task. Usage: /spawn <task description>",
+    description: "Spawn an isolated subagent to handle a task. Usage: /spawn [--provider=<id>] [--model=<id>] [--name=<label>] [--tools=a,b,c] <task description>",
     async run(args) {
-      const description = args.trim();
-      if (!description) return { message: "Usage: /spawn <task description>" };
+      const { description, opts: parsed } = parseSpawnFlags(args.trim());
+      if (!description) {
+        return {
+          message: "Usage: /spawn [--provider=<id>] [--model=<id>] [--name=<label>] [--tools=a,b,c] <task description>"
+        };
+      }
       if (!opts.onSpawn) {
         return { message: "Multi-agent is not enabled in this session." };
       }
       try {
-        const summary = await opts.onSpawn(description);
+        const summary = Object.keys(parsed).length > 0 ? await opts.onSpawn(description, parsed) : await opts.onSpawn(description);
         return { message: summary };
       } catch (err) {
         return {
@@ -1706,6 +1735,63 @@ function agentsCommand(opts) {
     }
   };
 }
+function fleetCommand(opts) {
+  return {
+    name: "fleet",
+    description: "Inspect or control the subagent fleet: /fleet [status|usage|kill <id>|manifest|help]",
+    help: [
+      "Usage:",
+      "  /fleet                  Show fleet status (alias for /fleet status).",
+      "  /fleet status           Pending + completed subagent task table.",
+      "  /fleet usage            Per-subagent runtime cost \u2014 iterations, tool calls, duration.",
+      "  /fleet kill <id>        Terminate a running subagent by id (or prefix).",
+      "  /fleet manifest         Print the director manifest (only with --director).",
+      "  /fleet help             Show this help.",
+      "",
+      "Subagent ids are returned by /spawn and listed in /fleet status."
+    ].join("\n"),
+    async run(args) {
+      if (!opts.onFleet) {
+        return { message: "Multi-agent is not enabled in this session." };
+      }
+      const trimmed = args.trim();
+      const [verb, ...rest] = trimmed.length === 0 ? ["status"] : trimmed.split(/\s+/);
+      const target = rest.join(" ").trim() || void 0;
+      switch (verb) {
+        case "status":
+        case "usage":
+        case "manifest": {
+          const out = await opts.onFleet(verb, void 0);
+          return { message: out };
+        }
+        case "kill": {
+          if (!target) {
+            return { message: "Usage: /fleet kill <subagent-id>" };
+          }
+          const out = await opts.onFleet("kill", target);
+          return { message: out };
+        }
+        case "help":
+        case "?":
+          return {
+            message: [
+              "/fleet \u2014 inspect or control the subagent fleet",
+              "",
+              "  /fleet                  \u2192 status (default)",
+              "  /fleet status           pending + completed tasks per subagent",
+              "  /fleet usage            iterations, tool calls, duration roll-up",
+              "  /fleet kill <id>        terminate a subagent",
+              "  /fleet manifest         director manifest (requires --director)"
+            ].join("\n")
+          };
+        default:
+          return {
+            message: `Unknown subcommand "${verb}". Try: status | usage | kill <id> | manifest | help`
+          };
+      }
+    }
+  };
+}
 
 // src/pre-launch.ts
 var MANIFESTS = [
@@ -1722,13 +1808,13 @@ var MANIFESTS = [
 ];
 async function detectProjectKind(projectRoot) {
   try {
-    await fs6.access(path5.join(projectRoot, ".wrongstack", "AGENTS.md"));
+    await fs6.access(path6.join(projectRoot, ".wrongstack", "AGENTS.md"));
     return "initialized";
   } catch {
   }
   for (const m of MANIFESTS) {
     try {
-      await fs6.access(path5.join(projectRoot, m));
+      await fs6.access(path6.join(projectRoot, m));
       return "project";
     } catch {
     }
@@ -1736,8 +1822,8 @@ async function detectProjectKind(projectRoot) {
   return "empty";
 }
 async function scaffoldAgentsMd(projectRoot) {
-  const dir = path5.join(projectRoot, ".wrongstack");
-  const file = path5.join(dir, "AGENTS.md");
+  const dir = path6.join(projectRoot, ".wrongstack");
+  const file = path6.join(dir, "AGENTS.md");
   const facts = await detectProjectFacts(projectRoot);
   const body = renderAgentsTemplate(facts);
   await fs6.mkdir(dir, { recursive: true });
@@ -1750,7 +1836,7 @@ async function runProjectCheck(opts) {
   if (kind === "initialized") {
     renderer.write(
       `
-  ${color.green("\u2713")} Project initialized ${color.dim(`(${path5.join(projectRoot, ".wrongstack", "AGENTS.md")})`)}
+  ${color.green("\u2713")} Project initialized ${color.dim(`(${path6.join(projectRoot, ".wrongstack", "AGENTS.md")})`)}
 `
     );
     return true;
@@ -2412,7 +2498,7 @@ function renderProgress2(ratio, width) {
   return FILLED2.repeat(capped) + EMPTY2.repeat(width - capped);
 }
 async function bootConfig(flags) {
-  const cwd = typeof flags["cwd"] === "string" ? path5.resolve(flags["cwd"]) : process.cwd();
+  const cwd = typeof flags["cwd"] === "string" ? path6.resolve(flags["cwd"]) : process.cwd();
   const pathResolver = new DefaultPathResolver(cwd);
   const projectRoot = pathResolver.projectRoot;
   const userHome = os3.homedir();
@@ -2474,31 +2560,71 @@ async function ensureProjectMeta(paths, projectRoot) {
   }
 }
 var MultiAgentHost = class {
-  constructor(deps) {
+  constructor(deps, opts = {}) {
     this.deps = deps;
+    this.opts = opts;
   }
   deps;
   coordinator;
+  /** Lazily built when `opts.directorMode` is set. Owns its own internal
+   *  coordinator; the host's `coordinator` field still points at it so
+   *  the rest of the methods don't need to branch. */
+  director;
+  /** Lazily built alongside the director — produces per-subagent JSONL
+   *  writers under `<sessionsRoot>/<runId>/`. Null in non-director mode. */
+  sessionFactory;
   pending = /* @__PURE__ */ new Map();
   results = [];
+  opts;
+  /**
+   * Force the lazy build path to run *now* and return the live Director,
+   * or null when director mode is off. Used by the CLI to register the
+   * fleet's LLM-callable orchestration tools (spawn_subagent,
+   * assign_task, await_tasks, ask_subagent, roll_up, terminate_subagent,
+   * fleet_status, fleet_usage) into the leader's ToolRegistry before the
+   * agent starts — without this, the leader literally cannot see the
+   * orchestration tools and `--director` becomes a no-op.
+   */
+  async ensureDirector() {
+    if (!this.opts.directorMode) return null;
+    await this.ensureCoordinator();
+    return this.director ?? null;
+  }
   async ensureCoordinator() {
     if (this.coordinator) return this.coordinator;
     const config = this.deps.configStore.get();
+    if (this.opts.directorMode && this.opts.sessionsRoot && !this.sessionFactory) {
+      this.sessionFactory = makeDirectorSessionFactory({
+        sessionsRoot: this.opts.sessionsRoot,
+        directorRunId: this.opts.directorRunId
+      });
+    }
     const factory = async (subCfg) => {
       const events = new EventBus();
-      const provider = await this.buildSubagentProvider(config);
+      const provider = await this.buildSubagentProvider(config, subCfg.provider);
       const baseSystem = await this.deps.systemPromptBuilder.build({
         cwd: this.deps.cwd,
         projectRoot: this.deps.projectRoot,
         tools: this.filterTools(subCfg.tools),
         model: subCfg.model ?? config.model,
-        provider: config.provider
+        provider: subCfg.provider ?? config.provider
       });
-      const parentSession = this.deps.session;
-      const subSession = {
-        id: parentSession.id,
-        append: (ev) => parentSession.append({ ...ev })
-      };
+      let subSession;
+      if (this.sessionFactory) {
+        const subagentName = subCfg.name ?? subCfg.id ?? `sub_${randomUUID().slice(0, 8)}`;
+        subSession = await this.sessionFactory.createSubagentSession({
+          subagentId: subagentName,
+          provider: subCfg.provider ?? config.provider,
+          model: subCfg.model ?? config.model,
+          title: `subagent: ${subagentName}`
+        });
+      } else {
+        const parentSession = this.deps.session;
+        subSession = {
+          id: parentSession.id,
+          append: (ev) => parentSession.append({ ...ev })
+        };
+      }
       const ctx = new Context({
         systemPrompt: baseSystem,
         provider,
@@ -2526,15 +2652,27 @@ var MultiAgentHost = class {
       return { agent, events };
     };
     const runner = makeAgentSubagentRunner({ factory });
-    this.coordinator = new DefaultMultiAgentCoordinator(
-      {
-        coordinatorId: randomUUID(),
-        doneCondition: { type: "all_tasks_done" },
-        maxConcurrent: 2,
-        defaultBudget: { maxToolCalls: 20, maxIterations: 20, timeoutMs: 12e4 }
-      },
-      { runner }
-    );
+    const coordinatorConfig = {
+      coordinatorId: randomUUID(),
+      doneCondition: { type: "all_tasks_done" },
+      maxConcurrent: 2,
+      defaultBudget: { maxToolCalls: 20, maxIterations: 20, timeoutMs: 12e4 }
+    };
+    if (this.opts.directorMode) {
+      this.director = new Director({
+        config: coordinatorConfig,
+        runner,
+        manifestPath: this.opts.manifestPath,
+        sharedScratchpadPath: this.opts.sharedScratchpadPath
+      });
+      this.director.on("task.completed", ({ task, result }) => {
+        this.results.push(result);
+        this.pending.delete(task.id);
+      });
+      this.coordinator = this.director.coordinator;
+      return this.coordinator;
+    }
+    this.coordinator = new DefaultMultiAgentCoordinator(coordinatorConfig, { runner });
     this.coordinator.on(
       "task.completed",
       ({ task, result }) => {
@@ -2544,15 +2682,24 @@ var MultiAgentHost = class {
     );
     return this.coordinator;
   }
-  async buildSubagentProvider(config) {
-    const newCfg = config.providers?.[config.provider] ?? {
-      type: config.provider,
+  /**
+   * Build a Provider for a subagent. When `overrideId` is supplied (from
+   * `SubagentConfig.provider`), looks that provider up in
+   * `config.providers` and constructs it with its own apiKey/baseUrl.
+   * Falls back to the leader's provider when `overrideId` is absent or
+   * not configured (so a typo doesn't crash the whole run — we just
+   * use the leader and the calling code can decide to error later).
+   */
+  async buildSubagentProvider(config, overrideId) {
+    const providerId = overrideId && config.providers?.[overrideId] ? overrideId : config.provider;
+    const newCfg = config.providers?.[providerId] ?? {
+      type: providerId,
       apiKey: config.apiKey,
       baseUrl: config.baseUrl
     };
-    return makeProviderFromConfig(config.provider, {
+    return makeProviderFromConfig(providerId, {
       ...newCfg,
-      type: config.provider
+      type: providerId
     });
   }
   /** Returns a tool slice for the subagent — full set unless restricted. */
@@ -2569,15 +2716,40 @@ var MultiAgentHost = class {
     for (const t of this.filterTools(allow)) sub.register(t);
     return sub;
   }
-  /** Spawn a fresh subagent and assign a single task. Returns task id. */
-  async spawn(description) {
-    const coord = await this.ensureCoordinator();
-    const spawned = await coord.spawn({
-      name: "adhoc",
+  /**
+   * Spawn a fresh subagent and assign a single task. Returns task id.
+   *
+   * Optional `opts` lets the caller (a `/spawn` slash command or the
+   * future director surface) override the subagent's provider, model,
+   * and tool slice on a per-spawn basis. Without options, the legacy
+   * behavior holds: the subagent uses the leader's provider/model and
+   * the full tool registry.
+   */
+  async spawn(description, opts) {
+    await this.ensureCoordinator();
+    const subagentConfig = {
+      name: opts?.name ?? "adhoc",
       role: "general",
       maxToolCalls: 20,
-      maxIterations: 20
-    });
+      maxIterations: 20,
+      provider: opts?.provider,
+      model: opts?.model,
+      tools: opts?.tools
+    };
+    if (this.director) {
+      const subagentId = await this.director.spawn(subagentConfig);
+      const taskId2 = randomUUID();
+      this.pending.set(taskId2, { description, subagentId });
+      await this.director.assign({
+        id: taskId2,
+        description,
+        subagentId,
+        maxToolCalls: 20
+      });
+      return { subagentId, taskId: taskId2 };
+    }
+    const coord = this.coordinator;
+    const spawned = await coord.spawn(subagentConfig);
     const taskId = randomUUID();
     this.pending.set(taskId, { description, subagentId: spawned.subagentId });
     await coord.assign({
@@ -2597,6 +2769,79 @@ var MultiAgentHost = class {
     const summary = !this.coordinator ? "No subagents have been spawned." : `${pending.length} pending, ${this.results.length} completed.`;
     return { pending, completed: this.results, summary };
   }
+  /**
+   * Roll up per-subagent runtime cost from completed TaskResults. We don't
+   * yet have FleetUsageAggregator wired into the simple MultiAgentHost
+   * path (that lives on `Director`), so this aggregates iterations / tool
+   * calls / duration which we *do* have — enough to spot a thrashing
+   * worker without paying for a heavier orchestrator on every /spawn.
+   *
+   * Returns rows sorted by total duration descending (slowest first) so
+   * the table renders the most interesting subagent at the top.
+   */
+  usage() {
+    const bySubagent = /* @__PURE__ */ new Map();
+    for (const r of this.results) {
+      const cur = bySubagent.get(r.subagentId) ?? { tasks: 0, iterations: 0, toolCalls: 0, durationMs: 0, lastStatus: "unknown" };
+      cur.tasks += 1;
+      cur.iterations += r.iterations;
+      cur.toolCalls += r.toolCalls;
+      cur.durationMs += r.durationMs;
+      cur.lastStatus = r.status;
+      bySubagent.set(r.subagentId, cur);
+    }
+    const rows = Array.from(bySubagent.entries()).map(([subagentId, v]) => ({
+      subagentId,
+      tasks: v.tasks,
+      iterations: v.iterations,
+      toolCalls: v.toolCalls,
+      durationMs: v.durationMs,
+      status: v.lastStatus
+    })).sort((a, b) => b.durationMs - a.durationMs);
+    const totals = rows.reduce(
+      (acc, r) => ({
+        tasks: acc.tasks + r.tasks,
+        iterations: acc.iterations + r.iterations,
+        toolCalls: acc.toolCalls + r.toolCalls,
+        durationMs: acc.durationMs + r.durationMs
+      }),
+      { tasks: 0, iterations: 0, toolCalls: 0, durationMs: 0 }
+    );
+    return { rows, totals };
+  }
+  /**
+   * Force the director to write its manifest to disk and return the path,
+   * or `null` when director mode is off (the simple coordinator path has
+   * no manifest). Callers should fall back to a friendly user message
+   * when `null` is returned — e.g. `/fleet manifest` does this already.
+   *
+   * The returned string is the absolute path of the manifest file. The
+   * file contents are JSON; readers can `JSON.parse(fs.readFileSync(...))`
+   * to consume.
+   */
+  async manifest() {
+    if (!this.director) return null;
+    return this.director.writeManifest();
+  }
+  /**
+   * True when this host is running in director mode. Surfaces the mode
+   * to slash commands and tests without exposing the underlying Director
+   * (which would let callers bypass the host's coordination layer).
+   */
+  isDirectorMode() {
+    return !!this.director;
+  }
+  /**
+   * Terminate a single subagent. Returns true when the subagent existed
+   * (regardless of whether stop() succeeded or it was already idle),
+   * false when no coordinator has been created yet — meaning the user
+   * called /fleet kill before any /spawn, and there's nothing to do.
+   */
+  async kill(subagentId) {
+    if (!this.coordinator) return false;
+    await this.coordinator.stop(subagentId);
+    return true;
+  }
   async stopAll() {
     if (this.coordinator) {
       await this.coordinator.stopAll();
@@ -3367,8 +3612,8 @@ async function initCmd(_args, deps) {
   };
   if (apiKey) config.apiKey = apiKey;
   await atomicWrite(deps.paths.globalConfig, JSON.stringify(config, null, 2));
-  await fs6.mkdir(path5.join(deps.projectRoot, ".wrongstack"), { recursive: true });
-  const agentsFile = path5.join(deps.projectRoot, ".wrongstack", "AGENTS.md");
+  await fs6.mkdir(path6.join(deps.projectRoot, ".wrongstack"), { recursive: true });
+  const agentsFile = path6.join(deps.projectRoot, ".wrongstack", "AGENTS.md");
   try {
     await fs6.access(agentsFile);
   } catch {
@@ -3776,7 +4021,7 @@ async function doctorCmd(_args, deps) {
   }
   try {
     await fs6.mkdir(deps.paths.projectSessions, { recursive: true });
-    const probe = path5.join(deps.paths.projectSessions, `.probe-${Date.now()}`);
+    const probe = path6.join(deps.paths.projectSessions, `.probe-${Date.now()}`);
     await fs6.writeFile(probe, "");
     await fs6.unlink(probe);
     checks.push({ name: "sessions writable", status: "ok", detail: deps.paths.projectSessions });
@@ -3879,8 +4124,8 @@ async function exportCmd(args, deps) {
     return 1;
   }
   if (output) {
-    await fs6.mkdir(path5.dirname(path5.resolve(deps.cwd, output)), { recursive: true });
-    await fs6.writeFile(path5.resolve(deps.cwd, output), rendered, "utf8");
+    await fs6.mkdir(path6.dirname(path6.resolve(deps.cwd, output)), { recursive: true });
+    await fs6.writeFile(path6.resolve(deps.cwd, output), rendered, "utf8");
     deps.renderer.write(`Wrote ${rendered.length} bytes to ${output}
 `);
   } else {
@@ -3933,13 +4178,14 @@ async function helpCmd(_args, deps) {
     "  wstack version               Print version",
     "",
     "Global flags:",
-    "  --provider, --model, --cwd, --log-level, --yolo, --verbose, --trace, --config"
+    "  --provider, --model, --cwd, --log-level, --yolo, --verbose, --trace, --config",
+    "  --director                   Run with Director-backed orchestration (writes fleet manifest)"
   ];
   deps.renderer.write(lines.join("\n") + "\n");
   return 0;
 }
 async function projectsCmd(_args, deps) {
-  const projectsRoot = path5.join(deps.paths.globalRoot, "projects");
+  const projectsRoot = path6.join(deps.paths.globalRoot, "projects");
   try {
     const entries = await fs6.readdir(projectsRoot);
     if (entries.length === 0) {
@@ -3949,7 +4195,7 @@ async function projectsCmd(_args, deps) {
     for (const hash of entries) {
       try {
         const meta = JSON.parse(
-          await fs6.readFile(path5.join(projectsRoot, hash, "meta.json"), "utf8")
+          await fs6.readFile(path6.join(projectsRoot, hash, "meta.json"), "utf8")
         );
         deps.renderer.write(
           `  ${color.dim(hash)}  ${color.dim(meta.lastSeen ?? "")}  ${meta.root ?? "?"}
@@ -4040,7 +4286,7 @@ function resolveBundledSkillsDir() {
   try {
     const req2 = createRequire(import.meta.url);
     const corePkg = req2.resolve("@wrongstack/core/package.json");
-    return path5.join(path5.dirname(corePkg), "skills");
+    return path6.join(path6.dirname(corePkg), "skills");
   } catch {
     return void 0;
   }
@@ -4309,7 +4555,7 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
     const dumpMetrics = () => {
       if (!metricsSink) return;
       try {
-        const out = path5.join(wpaths.projectSessions, "metrics.json");
+        const out = path6.join(wpaths.projectSessions, "metrics.json");
         const snap = metricsSink.snapshot();
         writeFileSync(out, JSON.stringify(snap, null, 2));
       } catch {
@@ -4466,10 +4712,10 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
   }
   await recoveryLock.write(session.id).catch(() => void 0);
   const attachments = new DefaultAttachmentStore({
-    spoolDir: path5.join(wpaths.projectSessions, session.id, "attachments")
+    spoolDir: path6.join(wpaths.projectSessions, session.id, "attachments")
   });
   const queueStore = new QueueStore({
-    dir: path5.join(wpaths.projectSessions, session.id)
+    dir: path6.join(wpaths.projectSessions, session.id)
   });
   const tokenCounter = container.resolve(TOKENS.TokenCounter);
   const stats = new SessionStats(events, tokenCounter);
@@ -4677,6 +4923,11 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
       return err instanceof Error ? err.message : String(err);
     }
   };
+  const directorMode = flags["director"] === true;
+  const fleetRoot = directorMode ? path6.join(wpaths.projectSessions, session.id) : void 0;
+  const manifestPath = directorMode ? typeof process.env["WRONGSTACK_FLEET_MANIFEST"] === "string" ? process.env["WRONGSTACK_FLEET_MANIFEST"] : path6.join(fleetRoot, "fleet.json") : void 0;
+  const sharedScratchpadPath = directorMode ? path6.join(fleetRoot, "shared") : void 0;
+  const subagentSessionsRoot = directorMode ? path6.join(fleetRoot, "subagents") : void 0;
   const multiAgentHost = new MultiAgentHost({
     container,
     toolRegistry,
@@ -4688,7 +4939,28 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
     tokenCounter,
     projectRoot,
     cwd
+  }, {
+    directorMode,
+    manifestPath,
+    sharedScratchpadPath,
+    sessionsRoot: subagentSessionsRoot,
+    directorRunId: session.id
   });
+  if (directorMode) {
+    const director = await multiAgentHost.ensureDirector();
+    if (director) {
+      for (const tool of director.tools(FLEET_ROSTER)) {
+        toolRegistry.register(tool);
+      }
+      renderer.writeInfo(`Director mode enabled. Roster: ${Object.keys(FLEET_ROSTER).join(", ")}`);
+      renderer.writeInfo(`  fleet root \u2192 ${fleetRoot}`);
+      renderer.writeInfo(`  manifest   \u2192 ${manifestPath}`);
+      renderer.writeInfo(`  scratchpad \u2192 ${sharedScratchpadPath}`);
+      renderer.writeInfo(`  subagents  \u2192 ${subagentSessionsRoot}`);
+    } else {
+      renderer.writeInfo(`Director mode enabled. Fleet manifest \u2192 ${manifestPath}`);
+    }
+  }
   const slashCmds = buildBuiltinSlashCommands({
     registry: slashRegistry,
     toolRegistry,
@@ -4701,9 +4973,14 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
     context,
     metricsSink,
     healthRegistry,
-    onSpawn: async (description) => {
-      const { subagentId, taskId } = await multiAgentHost.spawn(description);
-      return `Spawned subagent ${subagentId} for task ${taskId}. Use /agents to track progress.`;
+    onSpawn: async (description, spawnOpts) => {
+      const { subagentId, taskId } = await multiAgentHost.spawn(description, spawnOpts);
+      const tags = [];
+      if (spawnOpts?.provider) tags.push(spawnOpts.provider);
+      if (spawnOpts?.model) tags.push(spawnOpts.model);
+      if (spawnOpts?.name) tags.push(`"${spawnOpts.name}"`);
+      const tag = tags.length > 0 ? ` (${tags.join(" / ")})` : "";
+      return `Spawned subagent ${subagentId}${tag} for task ${taskId}. Use /agents to track progress.`;
     },
     onAgents: () => {
       const s = multiAgentHost.status();
@@ -4718,6 +4995,60 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
       }
       return lines.join("\n");
     },
+    onFleet: async (action, target) => {
+      if (action === "status") {
+        const s = multiAgentHost.status();
+        const lines = [color.bold("Fleet status"), `  ${s.summary}`];
+        if (s.pending.length > 0) {
+          lines.push("", color.dim("  Pending"));
+          for (const p of s.pending) {
+            lines.push(`    ${p.taskId.slice(0, 8)} \u2192 ${p.subagentId.slice(0, 8)} \xB7 ${p.description.slice(0, 60)}`);
+          }
+        }
+        if (s.completed.length > 0) {
+          lines.push("", color.dim("  Completed"));
+          for (const r of s.completed) {
+            const mark = r.status === "success" ? color.green("\u2713") : color.red("\u2717");
+            lines.push(`    ${mark} ${r.taskId.slice(0, 8)} \u2192 ${r.subagentId.slice(0, 8)} \xB7 ${r.iterations}it ${r.toolCalls}tc ${r.durationMs}ms`);
+          }
+        }
+        return lines.join("\n");
+      }
+      if (action === "usage") {
+        const u = multiAgentHost.usage();
+        if (u.rows.length === 0) return "No completed subagent tasks yet.";
+        const lines = [
+          color.bold("Fleet usage"),
+          color.dim("  subagent          tasks  iter  tools     ms  status")
+        ];
+        for (const r of u.rows) {
+          lines.push(
+            `  ${r.subagentId.slice(0, 14).padEnd(14)}  ${String(r.tasks).padStart(5)}  ${String(r.iterations).padStart(4)}  ${String(r.toolCalls).padStart(5)}  ${String(r.durationMs).padStart(5)}  ${r.status}`
+          );
+        }
+        lines.push(
+          color.dim("  \u2500".repeat(28)),
+          `  ${"TOTAL".padEnd(14)}  ${String(u.totals.tasks).padStart(5)}  ${String(u.totals.iterations).padStart(4)}  ${String(u.totals.toolCalls).padStart(5)}  ${String(u.totals.durationMs).padStart(5)}`
+        );
+        return lines.join("\n");
+      }
+      if (action === "kill") {
+        if (!target) return "Usage: /fleet kill <subagent-id>";
+        const ok = await multiAgentHost.kill(target);
+        return ok ? `Sent stop signal to ${target}.` : "No coordinator is running yet \u2014 nothing to kill.";
+      }
+      if (action === "manifest") {
+        if (!multiAgentHost.isDirectorMode()) {
+          return "Manifest is only available when the run was started with --director.";
+        }
+        const p = await multiAgentHost.manifest();
+        if (!p) {
+          return "Director is active but no subagents have been spawned \u2014 nothing to record yet.";
+        }
+        return `Manifest written \u2192 ${p}`;
+      }
+      return `Unknown fleet action: ${action}`;
+    },
     onExit: () => {
       void mcpRegistry.stopAll();
     },
@@ -4882,7 +5213,7 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
         tokenCounter,
         attachments,
         effectiveMaxContext,
-        projectName: path5.basename(projectRoot) || void 0
+        projectName: path6.basename(projectRoot) || void 0
       });
       await webuiPromise;
     } else {
@@ -4894,7 +5225,7 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
         tokenCounter,
         attachments,
         effectiveMaxContext,
-        projectName: path5.basename(projectRoot) || void 0
+        projectName: path6.basename(projectRoot) || void 0
       });
     }
   } finally {