@wrongstack/cli 0.1.7 → 0.1.8

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/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, DefaultPathResolver, resolveWstackPaths, DefaultSecretVault, migratePlaintextSecrets, DefaultConfigLoader, InputBuilder, DefaultPluginAPI, atomicWrite, DefaultSessionReader, makeAgentSubagentRunner, Director, DefaultMultiAgentCoordinator, decryptConfigSecrets, encryptConfigSecrets } from '@wrongstack/core';
 import { WebSocketServer, WebSocket } from 'ws';
 import * as fs6 from 'fs/promises';
 import { writeFileSync } from 'fs';
@@ -1046,6 +1046,7 @@ function buildBuiltinSlashCommands(opts) {
     statsCommand(opts),
     spawnCommand(opts),
     agentsCommand(opts),
+    fleetCommand(opts),
     metricsCommand(opts),
     healthCommand(opts),
     memoryCommand(opts),
@@ -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 = [
@@ -2474,25 +2560,31 @@ 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;
   pending = /* @__PURE__ */ new Map();
   results = [];
+  opts;
   async ensureCoordinator() {
     if (this.coordinator) return this.coordinator;
     const config = this.deps.configStore.get();
     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 = {
@@ -2526,15 +2618,26 @@ 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
+      });
+      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 +2647,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 +2681,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 +2734,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();
@@ -3933,7 +4143,8 @@ 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;
@@ -4677,6 +4888,8 @@ 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 manifestPath = directorMode ? typeof process.env["WRONGSTACK_FLEET_MANIFEST"] === "string" ? process.env["WRONGSTACK_FLEET_MANIFEST"] : path5.join(wpaths.projectSessions, session.id, "fleet.json") : void 0;
   const multiAgentHost = new MultiAgentHost({
     container,
     toolRegistry,
@@ -4688,7 +4901,10 @@ Try \`wstack models refresh\` once you have network access, or run with --no-fea
     tokenCounter,
     projectRoot,
     cwd
-  });
+  }, { directorMode, manifestPath });
+  if (directorMode) {
+    renderer.writeInfo(`Director mode enabled. Fleet manifest \u2192 ${manifestPath}`);
+  }
   const slashCmds = buildBuiltinSlashCommands({
     registry: slashRegistry,
     toolRegistry,
@@ -4701,9 +4917,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 +4939,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();
     },