counselors 0.1.0

package/dist/cli.js

@@ -0,0 +1,2585 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/ui/logger.ts
+function isDebug() {
+  return process.env.DEBUG === "1" || process.env.DEBUG === "counselors";
+}
+function debug(msg) {
+  if (isDebug()) {
+    process.stderr.write(`[debug] ${msg}
+`);
+  }
+}
+function warn(msg) {
+  process.stderr.write(`\u26A0 ${msg}
+`);
+}
+function error(msg) {
+  process.stderr.write(`\u2717 ${msg}
+`);
+}
+function info(msg) {
+  process.stdout.write(`${msg}
+`);
+}
+function success(msg) {
+  process.stdout.write(`\u2713 ${msg}
+`);
+}
+
+// src/commands/agent.ts
+function registerAgentCommand(program2) {
+  program2.command("agent").description("Print setup and skill installation instructions").action(async () => {
+    const instructions = `# Counselors \u2014 Setup & Skill Installation
+
+## 1. Install the CLI
+
+\`\`\`bash
+npm install -g counselors
+\`\`\`
+
+Requires Node 20+.
+
+## 2. Configure tools
+
+Auto-discover and configure all installed AI coding agents:
+
+\`\`\`bash
+counselors init --auto
+\`\`\`
+
+This detects installed agents (Claude, Codex, Gemini, Amp), configures them with recommended models, and writes your config to \`~/.config/counselors/config.json\`. The output is JSON listing what was configured.
+
+You can also manage tools individually:
+
+\`\`\`bash
+counselors tools discover   # Find available agents
+counselors tools add        # Add a tool (interactive)
+counselors tools remove <id>  # Remove a tool
+counselors tools rename <old> <new>  # Rename a tool
+counselors ls               # List configured tools
+counselors doctor           # Verify tools are working
+\`\`\`
+
+## 3. Install the skill
+
+The \`/counselors\` skill lets AI coding agents invoke counselors directly via a slash command. To install it, copy the skill template into your agent's skill directory.
+
+### Claude Code
+
+\`\`\`bash
+# Print the skill template
+counselors skill
+
+# Save it to Claude Code's skill directory
+counselors skill > ~/.claude/commands/counselors.md
+\`\`\`
+
+### Other agents
+
+Save the output of \`counselors skill\` to the appropriate skill/command directory for your agent.
+
+## 4. Verify
+
+\`\`\`bash
+counselors doctor
+\`\`\`
+
+Then use \`/counselors\` from your AI coding agent to fan out a prompt for parallel review.
+`;
+    info(instructions);
+  });
+}
+
+// src/commands/doctor.ts
+import { existsSync as existsSync4 } from "fs";
+
+// src/adapters/amp.ts
+import { existsSync } from "fs";
+
+// src/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+var CONFIG_DIR = join(xdgConfig, "counselors");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var AMP_SETTINGS_FILE = join(CONFIG_DIR, "amp-readonly-settings.json");
+var AMP_DEEP_SETTINGS_FILE = join(
+  CONFIG_DIR,
+  "amp-deep-settings.json"
+);
+var KILL_GRACE_PERIOD = 15e3;
+var TEST_TIMEOUT = 3e4;
+var DISCOVERY_TIMEOUT = 5e3;
+var VERSION_TIMEOUT = 1e4;
+var DEFAULT_MAX_CONTEXT_KB = 50;
+function getExtendedSearchPaths() {
+  const home = homedir();
+  const paths = [
+    join(home, ".local", "bin"),
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    join(home, ".npm-global", "bin"),
+    join(home, ".volta", "bin"),
+    join(home, ".bun", "bin")
+  ];
+  const nvmBin = process.env.NVM_BIN;
+  if (nvmBin) paths.push(nvmBin);
+  const fnmMultishell = process.env.FNM_MULTISHELL_PATH;
+  if (fnmMultishell) paths.push(join(fnmMultishell, "bin"));
+  return paths;
+}
+var MAX_SLUG_LENGTH = 40;
+var CONFIG_FILE_MODE = 384;
+function sanitizeId(id) {
+  return id.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+var SAFE_ID_RE = /^[a-zA-Z0-9._-]+$/;
+var VERSION = true ? "0.1.0" : "0.0.0-dev";
+
+// src/adapters/base.ts
+var BaseAdapter = class {
+  parseResult(result) {
+    return {
+      status: result.timedOut ? "timeout" : result.exitCode === 0 ? "success" : "error",
+      exitCode: result.exitCode,
+      durationMs: result.durationMs,
+      wordCount: result.stdout.split(/\s+/).filter(Boolean).length
+    };
+  }
+};
+
+// src/adapters/amp.ts
+var AmpAdapter = class extends BaseAdapter {
+  id = "amp";
+  displayName = "Amp CLI";
+  commands = ["amp"];
+  installUrl = "https://ampcode.com";
+  readOnly = { level: "enforced" };
+  models = [
+    {
+      id: "smart",
+      name: "Smart \u2014 Opus 4.6, most capable",
+      recommended: true,
+      extraFlags: ["-m", "smart"]
+    },
+    {
+      id: "deep",
+      name: "Deep \u2014 GPT-5.2 Codex, extended thinking",
+      extraFlags: ["-m", "deep"]
+    }
+  ];
+  buildInvocation(req) {
+    const args = ["-x"];
+    if (req.extraFlags) {
+      args.push(...req.extraFlags);
+    }
+    const isDeep = req.extraFlags?.includes("deep") && req.extraFlags?.[req.extraFlags.indexOf("deep") - 1] === "-m";
+    const settingsFile = isDeep ? AMP_DEEP_SETTINGS_FILE : AMP_SETTINGS_FILE;
+    if (req.readOnlyPolicy !== "none" && existsSync(settingsFile)) {
+      args.push("--settings-file", settingsFile);
+    }
+    const deepSafetyPrompt = isDeep ? "\n\nMANDATORY: Do not change any files. You are in read-only mode." : "";
+    const stdinContent = req.prompt + deepSafetyPrompt + "\n\nUse the oracle tool to provide deeper reasoning and analysis on the most complex or critical aspects of this review.";
+    return {
+      cmd: req.binary ?? "amp",
+      args,
+      stdin: stdinContent,
+      cwd: req.cwd
+    };
+  }
+  parseResult(result) {
+    return {
+      ...super.parseResult(result)
+    };
+  }
+};
+function parseAmpUsage(output) {
+  const freeMatch = output.match(/Amp Free: \$([0-9.]+)\/\$([0-9.]+)/);
+  const creditsMatch = output.match(/Individual credits: \$([0-9.]+)/);
+  return {
+    freeRemaining: freeMatch ? parseFloat(freeMatch[1]) : 0,
+    freeTotal: freeMatch ? parseFloat(freeMatch[2]) : 0,
+    creditsRemaining: creditsMatch ? parseFloat(creditsMatch[1]) : 0
+  };
+}
+function computeAmpCost(before, after) {
+  const freeUsed = Math.max(0, before.freeRemaining - after.freeRemaining);
+  const creditsUsed = Math.max(
+    0,
+    before.creditsRemaining - after.creditsRemaining
+  );
+  const totalCost = freeUsed + creditsUsed;
+  const source = creditsUsed > 0 ? "credits" : "free";
+  return {
+    cost_usd: Math.round(totalCost * 100) / 100,
+    free_used_usd: Math.round(freeUsed * 100) / 100,
+    credits_used_usd: Math.round(creditsUsed * 100) / 100,
+    source,
+    free_remaining_usd: after.freeRemaining,
+    free_total_usd: after.freeTotal,
+    credits_remaining_usd: after.creditsRemaining
+  };
+}
+
+// src/adapters/claude.ts
+var ClaudeAdapter = class extends BaseAdapter {
+  id = "claude";
+  displayName = "Claude Code";
+  commands = ["claude"];
+  installUrl = "https://docs.anthropic.com/en/docs/claude-code";
+  readOnly = { level: "enforced" };
+  models = [
+    {
+      id: "opus",
+      name: "Opus 4.6 \u2014 most capable",
+      recommended: true,
+      extraFlags: ["--model", "opus"]
+    },
+    {
+      id: "sonnet",
+      name: "Sonnet 4.5 \u2014 fast and capable",
+      extraFlags: ["--model", "sonnet"]
+    },
+    {
+      id: "haiku",
+      name: "Haiku 4.5 \u2014 fastest, most affordable",
+      extraFlags: ["--model", "haiku"]
+    }
+  ];
+  buildInvocation(req) {
+    const instruction = `Read the file at ${req.promptFilePath} and follow the instructions within it.`;
+    const args = ["-p", "--output-format", "text"];
+    if (req.extraFlags) {
+      args.push(...req.extraFlags);
+    }
+    if (req.readOnlyPolicy !== "none") {
+      args.push(
+        "--tools",
+        "Read,Glob,Grep,WebFetch,WebSearch",
+        "--allowedTools",
+        "Read,Glob,Grep,WebFetch,WebSearch",
+        "--strict-mcp-config"
+      );
+    }
+    args.push(instruction);
+    return { cmd: req.binary ?? "claude", args, cwd: req.cwd };
+  }
+};
+
+// src/adapters/codex.ts
+var CodexAdapter = class extends BaseAdapter {
+  id = "codex";
+  displayName = "OpenAI Codex";
+  commands = ["codex"];
+  installUrl = "https://github.com/openai/codex";
+  readOnly = { level: "enforced" };
+  models = [
+    {
+      id: "gpt-5.3-codex",
+      compoundId: "codex-5.3-high",
+      name: "GPT-5.3 Codex \u2014 high reasoning",
+      recommended: true,
+      extraFlags: ["-m", "gpt-5.3-codex", "-c", "model_reasoning_effort=high"]
+    },
+    {
+      id: "gpt-5.3-codex",
+      compoundId: "codex-5.3-xhigh",
+      name: "GPT-5.3 Codex \u2014 xhigh reasoning",
+      extraFlags: ["-m", "gpt-5.3-codex", "-c", "model_reasoning_effort=xhigh"]
+    },
+    {
+      id: "gpt-5.3-codex",
+      compoundId: "codex-5.3-medium",
+      name: "GPT-5.3 Codex \u2014 medium reasoning",
+      extraFlags: [
+        "-m",
+        "gpt-5.3-codex",
+        "-c",
+        "model_reasoning_effort=medium"
+      ]
+    }
+  ];
+  buildInvocation(req) {
+    const instruction = `Read the file at ${req.promptFilePath} and follow the instructions within it.`;
+    const args = ["exec"];
+    if (req.readOnlyPolicy !== "none") {
+      args.push("--sandbox", "read-only");
+    }
+    args.push("-c", "web_search=live", "--skip-git-repo-check");
+    if (req.extraFlags) {
+      args.push(...req.extraFlags);
+    }
+    args.push(instruction);
+    return { cmd: req.binary ?? "codex", args, cwd: req.cwd };
+  }
+};
+
+// src/adapters/custom.ts
+var CustomAdapter = class extends BaseAdapter {
+  id;
+  displayName;
+  commands;
+  installUrl = "";
+  readOnly;
+  models = [];
+  config;
+  constructor(id, config) {
+    super();
+    this.id = id;
+    this.displayName = id;
+    this.commands = [config.binary];
+    this.readOnly = { level: config.readOnly.level };
+    this.config = config;
+  }
+  buildInvocation(req) {
+    const args = [];
+    if (req.extraFlags) {
+      args.push(...req.extraFlags);
+    }
+    if (req.readOnlyPolicy !== "none" && this.config.readOnly.flags) {
+      args.push(...this.config.readOnly.flags);
+    }
+    const cmd = req.binary ?? this.config.binary;
+    if (this.config.stdin === true) {
+      return { cmd, args, stdin: req.prompt, cwd: req.cwd };
+    }
+    const instruction = `Read the file at ${req.promptFilePath} and follow the instructions within it.`;
+    args.push(instruction);
+    return { cmd, args, cwd: req.cwd };
+  }
+};
+
+// src/adapters/gemini.ts
+var GeminiAdapter = class extends BaseAdapter {
+  id = "gemini";
+  displayName = "Gemini CLI";
+  commands = ["gemini"];
+  installUrl = "https://github.com/google-gemini/gemini-cli";
+  readOnly = { level: "bestEffort" };
+  models = [
+    {
+      id: "gemini-3-pro-preview",
+      name: "Gemini 3 Pro Preview \u2014 latest",
+      recommended: true,
+      extraFlags: ["-m", "gemini-3-pro-preview"]
+    },
+    {
+      id: "gemini-2.5-pro",
+      name: "Gemini 2.5 Pro \u2014 stable GA",
+      extraFlags: ["-m", "gemini-2.5-pro"]
+    },
+    {
+      id: "gemini-3-flash-preview",
+      name: "Gemini 3 Flash Preview \u2014 fast",
+      extraFlags: ["-m", "gemini-3-flash-preview"]
+    },
+    {
+      id: "gemini-2.5-flash",
+      name: "Gemini 2.5 Flash \u2014 fast GA",
+      extraFlags: ["-m", "gemini-2.5-flash"]
+    }
+  ];
+  buildInvocation(req) {
+    const args = ["-p", ""];
+    if (req.extraFlags) {
+      args.push(...req.extraFlags);
+    }
+    if (req.readOnlyPolicy !== "none") {
+      args.push(
+        "--extensions",
+        "",
+        "--allowed-tools",
+        "read_file",
+        "list_directory",
+        "search_file_content",
+        "glob",
+        "google_web_search",
+        "codebase_investigator"
+      );
+    }
+    args.push("--output-format", "text");
+    return {
+      cmd: req.binary ?? "gemini",
+      args,
+      stdin: req.prompt,
+      cwd: req.cwd
+    };
+  }
+};
+
+// src/adapters/index.ts
+var builtInAdapters = {
+  claude: () => new ClaudeAdapter(),
+  codex: () => new CodexAdapter(),
+  gemini: () => new GeminiAdapter(),
+  amp: () => new AmpAdapter()
+};
+function getAdapter(id, config) {
+  if (builtInAdapters[id]) {
+    return builtInAdapters[id]();
+  }
+  if (config) {
+    return new CustomAdapter(id, config);
+  }
+  throw new Error(
+    `Unknown tool: ${id}. Use "counselors tools add" to configure it.`
+  );
+}
+function getAllBuiltInAdapters() {
+  return Object.values(builtInAdapters).map((fn) => fn());
+}
+function isBuiltInTool(id) {
+  return id in builtInAdapters;
+}
+function resolveAdapter(id, toolConfig) {
+  const baseId = toolConfig.adapter ?? id;
+  return isBuiltInTool(baseId) ? getAdapter(baseId) : new CustomAdapter(id, toolConfig);
+}
+
+// src/core/config.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { z as z2 } from "zod";
+
+// src/types.ts
+import { z } from "zod";
+var ToolConfigSchema = z.object({
+  binary: z.string(),
+  adapter: z.string().optional(),
+  readOnly: z.object({
+    level: z.enum(["enforced", "bestEffort", "none"]),
+    flags: z.array(z.string()).optional()
+  }),
+  extraFlags: z.array(z.string()).optional(),
+  timeout: z.number().optional(),
+  stdin: z.boolean().optional(),
+  custom: z.boolean().optional()
+});
+var ConfigSchema = z.object({
+  version: z.literal(1),
+  defaults: z.object({
+    timeout: z.number().default(540),
+    outputDir: z.string().default("./agents/counselors"),
+    readOnly: z.enum(["enforced", "bestEffort", "none"]).default("bestEffort"),
+    maxContextKb: z.number().default(50),
+    maxParallel: z.number().default(4)
+  }).default({}),
+  tools: z.record(z.string(), ToolConfigSchema).default({})
+});
+
+// src/core/fs-utils.ts
+import { renameSync, unlinkSync, writeFileSync } from "fs";
+function safeWriteFile(path, content, options) {
+  const tmp = `${path}.tmp.${process.pid}`;
+  try {
+    writeFileSync(tmp, content, { encoding: "utf-8", mode: options?.mode });
+    renameSync(tmp, path);
+  } catch (e) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw e;
+  }
+}
+
+// src/core/config.ts
+var DEFAULT_CONFIG = {
+  version: 1,
+  defaults: {
+    timeout: 540,
+    outputDir: "./agents/counselors",
+    readOnly: "bestEffort",
+    maxContextKb: 50,
+    maxParallel: 4
+  },
+  tools: {}
+};
+function loadConfig(globalPath) {
+  const path = globalPath ?? CONFIG_FILE;
+  if (!existsSync2(path)) return { ...DEFAULT_CONFIG };
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (e) {
+    throw new Error(
+      `Invalid JSON in ${path}: ${e instanceof Error ? e.message : e}`
+    );
+  }
+  return ConfigSchema.parse(raw);
+}
+var ProjectConfigSchema = z2.object({
+  defaults: z2.object({
+    timeout: z2.number().optional(),
+    outputDir: z2.string().optional(),
+    readOnly: z2.enum(["enforced", "bestEffort", "none"]).optional(),
+    maxContextKb: z2.number().optional(),
+    maxParallel: z2.number().optional()
+  }).optional()
+});
+function loadProjectConfig(cwd) {
+  const path = resolve(cwd, ".counselors.json");
+  if (!existsSync2(path)) return null;
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, "utf-8"));
+  } catch (e) {
+    throw new Error(
+      `Invalid JSON in ${path}: ${e instanceof Error ? e.message : e}`
+    );
+  }
+  return ProjectConfigSchema.parse(raw);
+}
+function mergeConfigs(global, project, cliFlags) {
+  const merged = {
+    version: 1,
+    defaults: { ...global.defaults },
+    tools: { ...global.tools }
+  };
+  if (project) {
+    if (project.defaults) {
+      merged.defaults = { ...merged.defaults, ...project.defaults };
+    }
+  }
+  if (cliFlags) {
+    merged.defaults = { ...merged.defaults, ...cliFlags };
+  }
+  return merged;
+}
+function saveConfig(config, path) {
+  const filePath = path ?? CONFIG_FILE;
+  mkdirSync(dirname(filePath), { recursive: true });
+  safeWriteFile(filePath, `${JSON.stringify(config, null, 2)}
+`, {
+    mode: CONFIG_FILE_MODE
+  });
+}
+function addToolToConfig(config, id, tool) {
+  return {
+    ...config,
+    tools: { ...config.tools, [id]: tool }
+  };
+}
+function removeToolFromConfig(config, id) {
+  const tools2 = { ...config.tools };
+  delete tools2[id];
+  return { ...config, tools: tools2 };
+}
+function renameToolInConfig(config, oldId, newId) {
+  const tools2 = { ...config.tools };
+  tools2[newId] = tools2[oldId];
+  delete tools2[oldId];
+  return { ...config, tools: tools2 };
+}
+
+// src/core/discovery.ts
+import { execFileSync } from "child_process";
+import {
+  accessSync,
+  constants,
+  existsSync as existsSync3,
+  readdirSync,
+  readFileSync as readFileSync2,
+  statSync
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+function findBinary(command) {
+  const lookupCmd = process.platform === "win32" ? "where" : "which";
+  try {
+    const result = execFileSync(lookupCmd, [command], {
+      timeout: DISCOVERY_TIMEOUT,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8"
+    }).trim().split("\n")[0].trim();
+    if (result) return result;
+  } catch {
+  }
+  const searchPaths = [
+    ...getExtendedSearchPaths(),
+    ...getNvmPaths(),
+    ...getFnmPaths()
+  ];
+  for (const dir of searchPaths) {
+    const fullPath = join2(dir, command);
+    try {
+      accessSync(fullPath, constants.X_OK);
+      return fullPath;
+    } catch {
+    }
+  }
+  return null;
+}
+function getNvmPaths() {
+  const home = homedir2();
+  const nvmDir = join2(home, ".nvm");
+  const aliasFile = join2(nvmDir, "alias", "default");
+  if (!existsSync3(aliasFile)) return [];
+  try {
+    let alias = readFileSync2(aliasFile, "utf-8").trim();
+    if (alias.startsWith("lts/")) {
+      const ltsName = alias.slice(4);
+      const ltsFile = join2(nvmDir, "alias", "lts", ltsName);
+      if (existsSync3(ltsFile)) {
+        alias = readFileSync2(ltsFile, "utf-8").trim();
+      }
+    }
+    const versionsDir = join2(nvmDir, "versions", "node");
+    if (!existsSync3(versionsDir)) return [];
+    const versions = readdirSync(versionsDir);
+    const match = versions.find((v) => v.startsWith(`v${alias}`));
+    if (match) {
+      return [join2(versionsDir, match, "bin")];
+    }
+  } catch {
+  }
+  return [];
+}
+function getFnmPaths() {
+  const home = homedir2();
+  const multishellDir = join2(home, ".local", "state", "fnm_multishells");
+  const paths = [];
+  const fnmDir = join2(home, ".local", "share", "fnm");
+  if (existsSync3(fnmDir)) {
+    const aliasDir = join2(fnmDir, "aliases");
+    if (existsSync3(aliasDir)) {
+      try {
+        for (const alias of readdirSync(aliasDir)) {
+          const binDir = join2(aliasDir, alias, "bin");
+          if (existsSync3(binDir)) paths.push(binDir);
+        }
+      } catch {
+      }
+    }
+  }
+  if (!existsSync3(multishellDir)) return paths;
+  try {
+    const entries = readdirSync(multishellDir).map((name) => {
+      const full = join2(multishellDir, name);
+      try {
+        return { name: full, mtime: statSync(full).mtimeMs };
+      } catch {
+        return null;
+      }
+    }).filter((e) => e !== null).sort((a, b) => b.mtime - a.mtime).slice(0, 5);
+    for (const entry of entries) {
+      const binDir = join2(entry.name, "bin");
+      if (existsSync3(binDir)) {
+        paths.push(binDir);
+      }
+    }
+  } catch {
+  }
+  return paths;
+}
+function getBinaryVersion(binaryPath) {
+  try {
+    const output = execFileSync(binaryPath, ["--version"], {
+      timeout: VERSION_TIMEOUT,
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf-8"
+    }).trim();
+    const firstLine = output.split("\n")[0].trim();
+    return firstLine || null;
+  } catch {
+    return null;
+  }
+}
+function discoverTool(commands) {
+  for (const cmd of commands) {
+    const path = findBinary(cmd);
+    if (path) {
+      const version = getBinaryVersion(path);
+      return { toolId: cmd, found: true, path, version, command: cmd };
+    }
+  }
+  return {
+    toolId: commands[0],
+    found: false,
+    path: null,
+    version: null,
+    command: commands[0]
+  };
+}
+
+// src/ui/output.ts
+import ora from "ora";
+function createSpinner(text) {
+  return ora({ text, stream: process.stderr });
+}
+function formatDiscoveryResults(results) {
+  const lines = ["", "Discovered tools:", ""];
+  for (const r of results) {
+    const name = r.displayName || r.toolId;
+    if (r.found) {
+      lines.push(`  \u2713 ${name}`);
+      lines.push(`    Path: ${r.path}`);
+      if (r.version) lines.push(`    Version: ${r.version}`);
+    } else {
+      lines.push(`  \u2717 ${name} \u2014 not found`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatDoctorResults(checks) {
+  const lines = ["", "Doctor results:", ""];
+  for (const c of checks) {
+    const icon = c.status === "pass" ? "\u2713" : c.status === "warn" ? "\u26A0" : "\u2717";
+    lines.push(`  ${icon} ${c.name}: ${c.message}`);
+  }
+  const failures = checks.filter((c) => c.status === "fail").length;
+  const warnings = checks.filter((c) => c.status === "warn").length;
+  lines.push("");
+  if (failures > 0) {
+    lines.push(`${failures} check(s) failed.`);
+  } else if (warnings > 0) {
+    lines.push(`All checks passed with ${warnings} warning(s).`);
+  } else {
+    lines.push("All checks passed.");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatToolList(tools2, verbose) {
+  if (tools2.length === 0) {
+    return '\nNo tools configured. Run "counselors init" to get started.\n';
+  }
+  const lines = ["", "Configured tools:", ""];
+  for (const t of tools2) {
+    if (!verbose) {
+      lines.push(`  \x1B[1m${t.id}\x1B[0m (${t.binary})`);
+      continue;
+    }
+    const bold = "\x1B[1m";
+    const reset = "\x1B[0m";
+    lines.push(`  ${bold}${t.id}${reset}`);
+    const raw = t.args ?? [];
+    const quote = (a) => a.includes(" ") ? `"${a}"` : a;
+    const allParts = [t.binary, ...raw].map(quote);
+    let line = "    ";
+    for (const part of allParts) {
+      if (part.startsWith("-") && line.trim().length > 0) {
+        lines.push(line);
+        line = `    ${part}`;
+      } else {
+        line += (line.trim().length > 0 ? " " : "") + part;
+      }
+    }
+    if (line.trim().length > 0) lines.push(line);
+  }
+  if (!verbose) {
+    const dim = "\x1B[2m";
+    const reset = "\x1B[0m";
+    lines.push("");
+    lines.push(`${dim}(Use -v to show flags)${reset}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatTestResults(results) {
+  const lines = ["", "Test results:", ""];
+  for (const r of results) {
+    const icon = r.passed ? "\u2713" : "\u2717";
+    lines.push(`  ${icon} ${r.toolId} (${r.durationMs}ms)`);
+    if (!r.passed && r.error) {
+      lines.push(`    Error: ${r.error}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatRunSummary(manifest) {
+  const lines = ["", `Run complete: ${manifest.slug}`, ""];
+  for (const r of manifest.tools) {
+    const icon = r.status === "success" ? "\u2713" : r.status === "timeout" ? "\u23F1" : "\u2717";
+    const duration = (r.durationMs / 1e3).toFixed(1);
+    lines.push(`  ${icon} ${r.toolId} \u2014 ${r.wordCount} words, ${duration}s`);
+    if (r.cost) {
+      lines.push(`    Cost: $${r.cost.cost_usd.toFixed(2)} (${r.cost.source})`);
+    }
+    if (r.status === "error" && r.error) {
+      lines.push(`    Error: ${r.error}`);
+    }
+  }
+  lines.push("");
+  lines.push(
+    `Reports saved to: ${manifest.tools[0]?.outputFile ? manifest.tools[0].outputFile.replace(/\/[^/]+$/, "/") : "output dir"}`
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+function formatDryRun(invocations) {
+  const lines = ["", "Dry run \u2014 would dispatch:", ""];
+  for (const inv of invocations) {
+    lines.push(`  ${inv.toolId}`);
+    lines.push(`    $ ${inv.cmd} ${inv.args.join(" ")}`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/commands/doctor.ts
+function registerDoctorCommand(program2) {
+  program2.command("doctor").description("Check tool configuration and health").action(async () => {
+    const checks = [];
+    if (existsSync4(CONFIG_FILE)) {
+      checks.push({
+        name: "Config file",
+        status: "pass",
+        message: CONFIG_FILE
+      });
+    } else {
+      checks.push({
+        name: "Config file",
+        status: "warn",
+        message: 'Not found. Run "counselors init" to create one.'
+      });
+    }
+    let config;
+    try {
+      config = loadConfig();
+    } catch (e) {
+      checks.push({
+        name: "Config parse",
+        status: "fail",
+        message: `Invalid config: ${e}`
+      });
+      info(formatDoctorResults(checks));
+      process.exitCode = 1;
+      return;
+    }
+    const toolIds = Object.keys(config.tools);
+    if (toolIds.length === 0) {
+      checks.push({
+        name: "Tools configured",
+        status: "warn",
+        message: 'No tools configured. Run "counselors init".'
+      });
+    }
+    for (const id of toolIds) {
+      const toolConfig = config.tools[id];
+      const binaryPath = findBinary(toolConfig.binary);
+      if (binaryPath) {
+        checks.push({
+          name: `${id}: binary`,
+          status: "pass",
+          message: binaryPath
+        });
+      } else {
+        checks.push({
+          name: `${id}: binary`,
+          status: "fail",
+          message: `"${toolConfig.binary}" not found in PATH`
+        });
+        continue;
+      }
+      const version = getBinaryVersion(binaryPath);
+      if (version) {
+        checks.push({
+          name: `${id}: version`,
+          status: "pass",
+          message: version
+        });
+      } else {
+        checks.push({
+          name: `${id}: version`,
+          status: "warn",
+          message: "Could not determine version"
+        });
+      }
+      const adapter = resolveAdapter(id, toolConfig);
+      checks.push({
+        name: `${id}: read-only`,
+        status: adapter.readOnly.level === "enforced" ? "pass" : adapter.readOnly.level === "bestEffort" ? "warn" : "fail",
+        message: adapter.readOnly.level
+      });
+    }
+    const hasAmp = Object.entries(config.tools).some(
+      ([id, t]) => (t.adapter ?? id) === "amp"
+    );
+    if (hasAmp) {
+      if (existsSync4(AMP_SETTINGS_FILE)) {
+        checks.push({
+          name: "Amp settings file",
+          status: "pass",
+          message: AMP_SETTINGS_FILE
+        });
+      } else {
+        checks.push({
+          name: "Amp settings file",
+          status: "warn",
+          message: "Not found. Amp read-only mode may not work."
+        });
+      }
+      if (existsSync4(AMP_DEEP_SETTINGS_FILE)) {
+        checks.push({
+          name: "Amp deep settings file",
+          status: "pass",
+          message: AMP_DEEP_SETTINGS_FILE
+        });
+      } else {
+        checks.push({
+          name: "Amp deep settings file",
+          status: "warn",
+          message: "Not found. Amp deep mode may not work."
+        });
+      }
+    }
+    info(formatDoctorResults(checks));
+    if (checks.some((c) => c.status === "fail")) {
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/core/amp-utils.ts
+import { copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+function copyAmpSettings() {
+  mkdirSync2(CONFIG_DIR, { recursive: true });
+  const assetsDir = resolve2(
+    dirname2(fileURLToPath(import.meta.url)),
+    "..",
+    "assets"
+  );
+  const bundledSettings = resolve2(assetsDir, "amp-readonly-settings.json");
+  if (existsSync5(bundledSettings)) {
+    copyFileSync(bundledSettings, AMP_SETTINGS_FILE);
+  }
+  const bundledDeepSettings = resolve2(assetsDir, "amp-deep-settings.json");
+  if (existsSync5(bundledDeepSettings)) {
+    copyFileSync(bundledDeepSettings, AMP_DEEP_SETTINGS_FILE);
+  }
+}
+
+// src/core/executor.ts
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+import stripAnsi from "strip-ansi";
+var execFileAsync = promisify(execFile);
+var MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
+var activeChildren = /* @__PURE__ */ new Set();
+process.on("SIGINT", () => {
+  for (const child of activeChildren) {
+    child.kill("SIGTERM");
+  }
+  setTimeout(() => process.exit(1), 2e3);
+});
+var ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "USER",
+  "TERM",
+  "LANG",
+  "SHELL",
+  "TMPDIR",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  // Node version managers
+  "NVM_BIN",
+  "NVM_DIR",
+  "FNM_MULTISHELL_PATH",
+  // API keys for adapters
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "OPENAI_ORG_ID",
+  "GEMINI_API_KEY",
+  "GOOGLE_API_KEY",
+  "GOOGLE_APPLICATION_CREDENTIALS",
+  "AMP_API_KEY",
+  // Proxy
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "NO_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy",
+  // Node runtime
+  "NODE_OPTIONS"
+];
+function buildSafeEnv(extra) {
+  const env = {};
+  for (const key of ENV_ALLOWLIST) {
+    if (process.env[key]) env[key] = process.env[key];
+  }
+  if (extra) Object.assign(env, extra);
+  env.CI = "true";
+  env.NO_COLOR = "1";
+  return env;
+}
+function execute(invocation, timeoutMs) {
+  return new Promise((resolve6) => {
+    const start = Date.now();
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let killed = false;
+    let killTimer;
+    let truncated = false;
+    debug(`Executing: ${invocation.cmd} ${invocation.args.join(" ")}`);
+    const child = spawn(invocation.cmd, invocation.args, {
+      cwd: invocation.cwd,
+      env: buildSafeEnv(invocation.env),
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    activeChildren.add(child);
+    child.stdout.on("data", (data) => {
+      if (!truncated && stdout.length < MAX_OUTPUT_BYTES) {
+        stdout += data.toString();
+        if (stdout.length >= MAX_OUTPUT_BYTES) {
+          truncated = true;
+          stdout = `${stdout.slice(0, MAX_OUTPUT_BYTES)}
+[output truncated at 10MB]`;
+        }
+      }
+    });
+    child.stderr.on("data", (data) => {
+      if (stderr.length < MAX_OUTPUT_BYTES) {
+        stderr += data.toString();
+      }
+    });
+    if (invocation.stdin) {
+      child.stdin.write(invocation.stdin);
+      child.stdin.end();
+    } else {
+      child.stdin.end();
+    }
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      killTimer = setTimeout(() => {
+        if (!killed) {
+          child.kill("SIGKILL");
+        }
+      }, KILL_GRACE_PERIOD);
+    }, timeoutMs);
+    child.on("close", (code) => {
+      killed = true;
+      clearTimeout(timer);
+      if (killTimer) clearTimeout(killTimer);
+      activeChildren.delete(child);
+      resolve6({
+        exitCode: code ?? 1,
+        stdout: stripAnsi(stdout),
+        stderr: stripAnsi(stderr),
+        timedOut,
+        durationMs: Date.now() - start
+      });
+    });
+    child.on("error", (err) => {
+      killed = true;
+      clearTimeout(timer);
+      if (killTimer) clearTimeout(killTimer);
+      activeChildren.delete(child);
+      resolve6({
+        exitCode: 1,
+        stdout: "",
+        stderr: err.message,
+        timedOut: false,
+        durationMs: Date.now() - start
+      });
+    });
+  });
+}
+async function captureAmpUsage() {
+  try {
+    const { stdout } = await execFileAsync("amp", ["usage"], {
+      timeout: 1e4,
+      encoding: "utf-8"
+    });
+    return stdout;
+  } catch {
+    return null;
+  }
+}
+function computeAmpCostFromSnapshots(before, after) {
+  try {
+    const beforeParsed = parseAmpUsage(before);
+    const afterParsed = parseAmpUsage(after);
+    return computeAmpCost(beforeParsed, afterParsed);
+  } catch {
+    return null;
+  }
+}
+async function executeTest(adapter, toolConfig, toolName) {
+  const prompt = "Reply with exactly: OK";
+  const start = Date.now();
+  const invocation = adapter.buildInvocation({
+    prompt,
+    promptFilePath: "",
+    toolId: adapter.id,
+    outputDir: "",
+    readOnlyPolicy: "none",
+    timeout: TEST_TIMEOUT / 1e3,
+    cwd: process.cwd(),
+    extraFlags: toolConfig.extraFlags
+  });
+  if (invocation.stdin != null) {
+    invocation.stdin = prompt;
+    invocation.args = invocation.args.filter((a, i, arr) => {
+      if (a === "--settings-file") return false;
+      if (i > 0 && arr[i - 1] === "--settings-file") return false;
+      return true;
+    });
+  } else {
+    const lastArgIdx = invocation.args.length - 1;
+    invocation.args[lastArgIdx] = prompt;
+  }
+  const result = await execute(invocation, TEST_TIMEOUT);
+  const passed = result.stdout.includes("OK");
+  return {
+    toolId: toolName ?? adapter.id,
+    passed,
+    output: result.stdout.slice(0, 500),
+    error: !passed ? result.stderr.slice(0, 500) || 'Output did not contain "OK"' : void 0,
+    durationMs: Date.now() - start
+  };
+}
+
+// src/ui/prompts.ts
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
+async function selectModelDetails(toolId, models) {
+  const choices = models.map((m, i) => ({
+    name: m.recommended ? `${m.name} (Recommended)` : m.name,
+    value: String(i)
+  }));
+  const idx = await select({
+    message: `Select model for ${toolId}:`,
+    choices
+  });
+  const model = models[Number(idx)];
+  return {
+    id: model.id,
+    compoundId: model.compoundId,
+    extraFlags: model.extraFlags
+  };
+}
+async function selectModels(toolId, models) {
+  const choices = models.map((m) => ({
+    name: m.recommended ? `${m.name} (Recommended)` : m.name,
+    value: { id: m.id, compoundId: m.compoundId, extraFlags: m.extraFlags },
+    checked: m.recommended
+  }));
+  return checkbox({
+    message: `Select models for ${toolId}:`,
+    choices
+  });
+}
+async function selectTools(tools2) {
+  const choices = tools2.map((t) => ({
+    name: t.found ? `${t.name} \u2014 found` : `${t.name} \u2014 not found`,
+    value: t.id,
+    checked: t.found,
+    disabled: !t.found ? "(not installed)" : void 0
+  }));
+  return checkbox({
+    message: "Which tools should be configured?",
+    choices
+  });
+}
+async function confirmOverwrite(toolId) {
+  return confirm({
+    message: `Tool "${toolId}" already exists. Overwrite?`,
+    default: false
+  });
+}
+async function selectRunTools(tools2) {
+  const choices = tools2.map((id) => ({
+    name: id,
+    value: id,
+    checked: true
+  }));
+  return checkbox({
+    message: "Select tools to dispatch:",
+    choices
+  });
+}
+async function confirmAction(message) {
+  return confirm({ message, default: true });
+}
+async function promptInput(message, defaultValue) {
+  return input({ message, default: defaultValue });
+}
+async function promptSelect(message, choices) {
+  return select({ message, choices });
+}
+
+// src/commands/init.ts
+function buildToolConfig(id, adapter, binaryPath) {
+  return {
+    binary: binaryPath,
+    readOnly: { level: adapter.readOnly.level },
+    ...id === "gemini" || id === "codex" ? { timeout: 900 } : {}
+  };
+}
+function compoundId(adapterId, modelId) {
+  if (modelId.startsWith(`${adapterId}-`)) return modelId;
+  return `${adapterId}-${modelId}`;
+}
+function registerInitCommand(program2) {
+  program2.command("init").description("Interactive setup wizard").option(
+    "--auto",
+    "Non-interactive mode: discover tools, use recommended models, output JSON"
+  ).action(async (opts) => {
+    if (opts.auto) {
+      const adapters2 = getAllBuiltInAdapters();
+      const discoveries2 = adapters2.map((adapter) => {
+        const result = discoverTool(adapter.commands);
+        return { adapter, discovery: result };
+      });
+      const foundTools2 = discoveries2.filter((d) => d.discovery.found);
+      if (foundTools2.length === 0) {
+        info(
+          JSON.stringify(
+            {
+              configured: [],
+              notFound: adapters2.map((a) => a.id),
+              configPath: CONFIG_DIR
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      let config2 = loadConfig();
+      const configured = [];
+      const notFound = [];
+      for (const { adapter, discovery } of discoveries2) {
+        if (!discovery.found) {
+          notFound.push(adapter.id);
+          continue;
+        }
+        for (const model of adapter.models) {
+          const cid = model.compoundId ?? compoundId(adapter.id, model.id);
+          const toolConfig = {
+            ...buildToolConfig(adapter.id, adapter, discovery.path),
+            adapter: adapter.id,
+            ...model.extraFlags ? { extraFlags: model.extraFlags } : {}
+          };
+          config2 = addToolToConfig(config2, cid, toolConfig);
+          configured.push({
+            id: cid,
+            adapter: adapter.id,
+            binary: discovery.path,
+            version: discovery.version
+          });
+        }
+      }
+      if (configured.some((t) => t.adapter === "amp")) {
+        copyAmpSettings();
+      }
+      saveConfig(config2);
+      info(
+        JSON.stringify(
+          { configured, notFound, configPath: CONFIG_DIR },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    info("\nCounselors \u2014 setup wizard\n");
+    const existingConfig = loadConfig();
+    const existingTools = Object.keys(existingConfig.tools);
+    if (existingTools.length > 0) {
+      warn(
+        `Existing config has ${existingTools.length} tool(s). Re-running init will overwrite any tools with the same name.`
+      );
+    }
+    const spinner = createSpinner("Discovering installed tools...").start();
+    const adapters = getAllBuiltInAdapters();
+    const discoveries = adapters.map((adapter) => {
+      const result = discoverTool(adapter.commands);
+      return { adapter, discovery: result };
+    });
+    spinner.stop();
+    info(
+      formatDiscoveryResults(
+        discoveries.map((d) => ({
+          ...d.discovery,
+          toolId: d.adapter.id,
+          displayName: d.adapter.displayName
+        }))
+      )
+    );
+    const foundTools = discoveries.filter((d) => d.discovery.found);
+    if (foundTools.length === 0) {
+      warn(
+        "No AI CLI tools found. Install at least one before running init."
+      );
+      return;
+    }
+    const selectedIds = await selectTools(
+      discoveries.map((d) => ({
+        id: d.adapter.id,
+        name: d.adapter.displayName,
+        found: d.discovery.found
+      }))
+    );
+    if (selectedIds.length === 0) {
+      info("No tools selected. Exiting.");
+      return;
+    }
+    let config = loadConfig();
+    const configuredIds = [];
+    for (const id of selectedIds) {
+      const d = discoveries.find((x) => x.adapter.id === id);
+      const models = await selectModels(id, d.adapter.models);
+      for (const model of models) {
+        const cid = model.compoundId ?? compoundId(id, model.id);
+        const toolConfig = {
+          ...buildToolConfig(id, d.adapter, d.discovery.path),
+          adapter: id,
+          ...model.extraFlags ? { extraFlags: model.extraFlags } : {}
+        };
+        config = addToolToConfig(config, cid, toolConfig);
+        configuredIds.push(cid);
+      }
+    }
+    if (selectedIds.includes("amp")) {
+      copyAmpSettings();
+      success(`Copied amp settings to ${AMP_SETTINGS_FILE}`);
+    }
+    saveConfig(config);
+    success(`Config saved to ${CONFIG_DIR}`);
+    const runTests = await confirmAction("Run tool tests now?");
+    if (runTests) {
+      const testResults = [];
+      for (const id of configuredIds) {
+        const toolConfig = config.tools[id];
+        const adapter = resolveAdapter(id, toolConfig);
+        const spinner2 = createSpinner(`Testing ${id}...`).start();
+        const result = await executeTest(adapter, toolConfig, id);
+        spinner2.stop();
+        testResults.push(result);
+      }
+      info(formatTestResults(testResults));
+    }
+  });
+}
+
+// src/commands/run.ts
+import { copyFileSync as copyFileSync2, readFileSync as readFileSync5 } from "fs";
+import { basename as basename2, join as join6, resolve as resolve4 } from "path";
+
+// src/core/context.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+function gatherContext(cwd, paths, maxKb = DEFAULT_MAX_CONTEXT_KB) {
+  const parts = [];
+  let totalBytes = 0;
+  const maxBytes = maxKb * 1024;
+  if (paths.length > 0) {
+    parts.push("### Files Referenced", "");
+    for (const p of paths) {
+      if (totalBytes >= maxBytes) {
+        debug(`Context limit reached (${maxKb}KB), skipping remaining files`);
+        break;
+      }
+      const fullPath = resolve3(cwd, p);
+      try {
+        const stat = statSync2(fullPath);
+        if (!stat.isFile()) continue;
+        if (stat.size > maxBytes - totalBytes) {
+          debug(`Skipping ${p} \u2014 too large (${stat.size} bytes)`);
+          continue;
+        }
+        const content = readFileSync3(fullPath, "utf-8");
+        parts.push(`#### ${p}`, "", "```", content, "```", "");
+        totalBytes += Buffer.byteLength(content);
+      } catch {
+        debug(`Could not read ${p}`);
+      }
+    }
+  }
+  if (totalBytes < maxBytes) {
+    const diff = getGitDiff(cwd);
+    if (diff) {
+      const diffBytes = Buffer.byteLength(diff);
+      if (totalBytes + diffBytes <= maxBytes) {
+        parts.push(
+          "### Recent Changes (Git Diff)",
+          "",
+          "```diff",
+          diff,
+          "```",
+          ""
+        );
+        totalBytes += diffBytes;
+      } else {
+        const remaining = maxBytes - totalBytes;
+        const truncated = Buffer.from(diff).subarray(0, remaining).toString("utf-8");
+        parts.push(
+          "### Recent Changes (Git Diff) [truncated]",
+          "",
+          "```diff",
+          truncated,
+          "```",
+          ""
+        );
+        totalBytes = maxBytes;
+      }
+    }
+  }
+  return parts.join("\n");
+}
+function getGitDiff(cwd) {
+  try {
+    const staged = execFileSync2("git", ["diff", "--staged"], {
+      cwd,
+      encoding: "utf-8",
+      timeout: 1e4,
+      maxBuffer: 10 * 1024 * 1024,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const unstaged = execFileSync2("git", ["diff"], {
+      cwd,
+      encoding: "utf-8",
+      timeout: 1e4,
+      maxBuffer: 10 * 1024 * 1024,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const parts = [];
+    if (staged) parts.push(staged);
+    if (unstaged) parts.push(unstaged);
+    return parts.length > 0 ? parts.join("\n") : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/core/dispatcher.ts
+import { join as join3 } from "path";
+import pLimit from "p-limit";
+async function dispatch(options) {
+  const {
+    config,
+    toolIds,
+    promptFilePath,
+    promptContent,
+    outputDir,
+    readOnlyPolicy,
+    cwd,
+    onProgress
+  } = options;
+  const limit = pLimit(config.defaults.maxParallel);
+  const eligibleTools = toolIds.filter((id) => {
+    const toolConfig = config.tools[id];
+    if (!toolConfig) {
+      warn(`Tool "${id}" not configured, skipping.`);
+      return false;
+    }
+    if (readOnlyPolicy === "enforced") {
+      const adapter = resolveAdapter(id, toolConfig);
+      if (adapter.readOnly.level !== "enforced") {
+        warn(
+          `Skipping "${id}" \u2014 read-only level is "${adapter.readOnly.level}", policy requires "enforced".`
+        );
+        return false;
+      }
+    }
+    return true;
+  });
+  if (eligibleTools.length === 0) {
+    throw new Error("No eligible tools after read-only policy filtering.");
+  }
+  const tasks = eligibleTools.map(
+    (id) => limit(async () => {
+      const toolConfig = config.tools[id];
+      const adapter = resolveAdapter(id, toolConfig);
+      const toolTimeout = toolConfig.timeout ?? config.defaults.timeout;
+      const toolTimeoutMs = toolTimeout * 1e3;
+      const req = {
+        prompt: promptContent,
+        promptFilePath,
+        toolId: id,
+        outputDir,
+        readOnlyPolicy,
+        timeout: toolTimeout,
+        cwd,
+        binary: toolConfig.binary,
+        extraFlags: toolConfig.extraFlags
+      };
+      const invocation = adapter.buildInvocation(req);
+      const isAmp = (toolConfig.adapter ?? id) === "amp";
+      const usageBefore = isAmp ? await captureAmpUsage() : null;
+      debug(`Dispatching ${id}`);
+      onProgress?.({ toolId: id, event: "started" });
+      const result = await execute(invocation, toolTimeoutMs);
+      const usageAfter = isAmp ? await captureAmpUsage() : null;
+      const cost = isAmp && usageBefore && usageAfter ? computeAmpCostFromSnapshots(usageBefore, usageAfter) : void 0;
+      const safeId = sanitizeId(id);
+      const outputFile = join3(outputDir, `${safeId}.md`);
+      const stderrFile = join3(outputDir, `${safeId}.stderr`);
+      safeWriteFile(outputFile, result.stdout);
+      safeWriteFile(stderrFile, result.stderr);
+      if (cost) {
+        const statsFile = join3(outputDir, `${safeId}.stats.json`);
+        safeWriteFile(statsFile, JSON.stringify({ cost }, null, 2));
+      }
+      const parsed = adapter.parseResult?.(result) ?? {};
+      const report = {
+        toolId: id,
+        status: result.timedOut ? "timeout" : result.exitCode === 0 ? "success" : "error",
+        exitCode: result.exitCode,
+        durationMs: result.durationMs,
+        wordCount: result.stdout.split(/\s+/).filter(Boolean).length,
+        outputFile,
+        stderrFile,
+        cost: cost ?? void 0,
+        error: result.exitCode !== 0 ? result.stderr.slice(0, 500) : void 0,
+        ...parsed
+      };
+      onProgress?.({ toolId: id, event: "completed", report });
+      return report;
+    })
+  );
+  const results = await Promise.allSettled(tasks);
+  return results.map((r, i) => {
+    if (r.status === "fulfilled") return r.value;
+    return {
+      toolId: eligibleTools[i],
+      status: "error",
+      exitCode: 1,
+      durationMs: 0,
+      wordCount: 0,
+      outputFile: "",
+      stderrFile: "",
+      error: r.reason?.message ?? "Unknown error"
+    };
+  });
+}
+
+// src/core/prompt-builder.ts
+import { mkdirSync as mkdirSync3 } from "fs";
+import { basename, dirname as dirname3, join as join4 } from "path";
+function generateSlug(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, MAX_SLUG_LENGTH);
+}
+function generateSlugFromFile(filePath) {
+  const dir = dirname3(filePath);
+  const dirName = basename(dir);
+  if (dirName && dirName !== "." && dirName !== "..") {
+    return generateSlug(dirName);
+  }
+  return generateSlug(basename(filePath, ".md"));
+}
+function resolveOutputDir(baseDir, slug) {
+  let outputDir = join4(baseDir, slug);
+  try {
+    mkdirSync3(outputDir, { recursive: false });
+  } catch (e) {
+    if (e.code === "EEXIST") {
+      outputDir = `${outputDir}-${Date.now()}`;
+      mkdirSync3(outputDir, { recursive: true });
+    } else {
+      mkdirSync3(outputDir, { recursive: true });
+    }
+  }
+  return outputDir;
+}
+function buildPrompt(question, context) {
+  const parts = [
+    "# Second Opinion Request",
+    "",
+    "## Question",
+    question,
+    ""
+  ];
+  if (context) {
+    parts.push("## Context", "", context, "");
+  }
+  parts.push(
+    "## Instructions",
+    "You are providing an independent second opinion. Be critical and thorough.",
+    "- Analyze the question in the context provided",
+    "- Identify risks, tradeoffs, and blind spots",
+    "- Suggest alternatives if you see better approaches",
+    "- Be direct and opinionated \u2014 don't hedge",
+    "- Structure your response with clear headings",
+    "- Keep your response focused and actionable",
+    ""
+  );
+  return parts.join("\n");
+}
+
+// src/core/synthesis.ts
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
+function synthesize(manifest, outputDir) {
+  const parts = [
+    "# Run Summary",
+    "",
+    `**Prompt:** ${manifest.prompt.slice(0, 100)}${manifest.prompt.length > 100 ? "..." : ""}`,
+    `**Tools:** ${manifest.tools.map((t) => t.toolId).join(", ")}`,
+    `**Policy:** read-only=${manifest.readOnlyPolicy}`,
+    ""
+  ];
+  parts.push("## Results", "");
+  for (const report of manifest.tools) {
+    const icon = report.status === "success" ? "\u2713" : report.status === "timeout" ? "\u23F1" : "\u2717";
+    const duration = (report.durationMs / 1e3).toFixed(1);
+    parts.push(`### ${icon} ${report.toolId}`);
+    parts.push("");
+    parts.push(`- Status: ${report.status}`);
+    parts.push(`- Duration: ${duration}s`);
+    parts.push(`- Word count: ${report.wordCount}`);
+    if (report.cost) {
+      parts.push(
+        `- Cost: $${report.cost.cost_usd.toFixed(2)} (${report.cost.source})`
+      );
+    }
+    if (report.status === "error" && report.error) {
+      parts.push(`- Error: ${report.error}`);
+    }
+    if (report.status === "success") {
+      const headings = extractHeadings(outputDir, report);
+      if (headings.length > 0) {
+        parts.push("- Key sections:");
+        for (const h of headings) {
+          parts.push(`  - ${h}`);
+        }
+      }
+    }
+    parts.push("");
+  }
+  const costsAvailable = manifest.tools.filter((t) => t.cost);
+  if (costsAvailable.length > 0) {
+    parts.push("## Cost Summary", "");
+    parts.push("| Tool | Cost | Source | Remaining |");
+    parts.push("|------|------|--------|-----------|");
+    for (const t of costsAvailable) {
+      const c = t.cost;
+      parts.push(
+        `| ${t.toolId} | $${c.cost_usd.toFixed(2)} | ${c.source} | $${c.source === "credits" ? c.credits_remaining_usd.toFixed(2) : c.free_remaining_usd.toFixed(2)} |`
+      );
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function extractHeadings(outputDir, report) {
+  const filePath = join5(outputDir, `${sanitizeId(report.toolId)}.md`);
+  if (!existsSync6(filePath)) return [];
+  try {
+    const content = readFileSync4(filePath, "utf-8");
+    const headings = [];
+    for (const line of content.split("\n")) {
+      const match = line.match(/^#{1,3}\s+(.+)/);
+      if (match) {
+        headings.push(match[1].trim());
+        if (headings.length >= 10) break;
+      }
+    }
+    return headings;
+  } catch {
+    return [];
+  }
+}
+
+// src/ui/progress.ts
+var SPINNER_FRAMES = ["\u25D0", "\u25D3", "\u25D1", "\u25D2"];
+var TICK_INTERVAL = 200;
+var RED = "\x1B[31m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var ProgressDisplay = class {
+  tools;
+  order;
+  outputDir;
+  timer = null;
+  frame = 0;
+  lineCount = 0;
+  isTTY;
+  constructor(toolIds, outputDir) {
+    this.isTTY = Boolean(process.stderr.isTTY);
+    this.outputDir = outputDir;
+    this.tools = /* @__PURE__ */ new Map();
+    this.order = [];
+    for (const id of toolIds) {
+      this.tools.set(id, {
+        toolId: id,
+        status: "pending"
+      });
+      this.order.push(id);
+    }
+    if (this.isTTY) {
+      this.render();
+      this.timer = setInterval(() => {
+        this.frame++;
+        this.render();
+      }, TICK_INTERVAL);
+    } else {
+      process.stderr.write(`  Output: ${this.outputDir}
+`);
+    }
+  }
+  start(toolId) {
+    const tool = this.tools.get(toolId);
+    if (!tool) return;
+    tool.status = "running";
+    tool.startedAt = Date.now();
+    if (!this.isTTY) {
+      process.stderr.write(`  \u25B8 ${toolId} started
+`);
+    }
+  }
+  complete(toolId, report) {
+    const tool = this.tools.get(toolId);
+    if (!tool) return;
+    tool.status = "done";
+    tool.report = report;
+    if (!this.isTTY) {
+      const duration = (report.durationMs / 1e3).toFixed(1);
+      const icon = report.status === "success" ? "\u2713" : report.status === "timeout" ? "\u23F1" : "\u2717";
+      process.stderr.write(
+        `  ${icon} ${toolId} done  ${duration}s  ${report.wordCount.toLocaleString()} words
+`
+      );
+      if (report.status !== "success" && report.error) {
+        process.stderr.write(
+          `    \u2514 ${report.error.split("\n")[0].slice(0, 120)}
+`
+        );
+      }
+    }
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.isTTY) {
+      this.render();
+    }
+  }
+  render() {
+    const lines = [];
+    lines.push(`  ${DIM}Output: ${this.outputDir}${RESET}`);
+    for (const id of this.order) {
+      const tool = this.tools.get(id);
+      lines.push(this.formatLine(tool));
+      if (tool.status === "done" && tool.report?.status !== "success" && tool.report?.error) {
+        const msg = tool.report.error.split("\n")[0].slice(0, 120);
+        lines.push(`    ${RED}\u2514 ${msg}${RESET}`);
+      }
+    }
+    if (this.lineCount > 0) {
+      process.stderr.write(`\x1B[${this.lineCount}A`);
+    }
+    for (const line of lines) {
+      process.stderr.write(`\x1B[K${line}
+`);
+    }
+    this.lineCount = lines.length;
+  }
+  formatLine(tool) {
+    const label = tool.toolId;
+    switch (tool.status) {
+      case "pending": {
+        const pad = " ".repeat(Math.max(0, 40 - label.length));
+        return `  \u23F3 ${label}${pad}pending`;
+      }
+      case "running": {
+        const spinner = SPINNER_FRAMES[this.frame % SPINNER_FRAMES.length];
+        const elapsed = tool.startedAt ? ((Date.now() - tool.startedAt) / 1e3).toFixed(1) : "0.0";
+        const pad = " ".repeat(Math.max(0, 40 - label.length));
+        return `  ${spinner} ${label}${pad}running  ${elapsed.padStart(6)}s`;
+      }
+      case "done": {
+        const r = tool.report;
+        const icon = r.status === "success" ? "\u2713" : r.status === "timeout" ? "\u23F1" : "\u2717";
+        const duration = (r.durationMs / 1e3).toFixed(1);
+        const pad = " ".repeat(Math.max(0, 40 - label.length));
+        return `  ${icon} ${label}${pad}done    ${duration.padStart(6)}s  ${r.wordCount.toLocaleString()} words`;
+      }
+    }
+  }
+};
+
+// src/commands/run.ts
+function registerRunCommand(program2) {
+  program2.command("run [prompt]").description("Dispatch prompt to configured AI tools in parallel").option("-f, --file <path>", "Use a pre-built prompt file (no wrapping)").option("-t, --tools <tools>", "Comma-separated list of tools to use").option(
+    "--context <paths>",
+    'Gather context from paths (comma-separated, or "." for git diff)'
+  ).option("--read-only <level>", "Read-only policy: strict, best-effort, off").option("--dry-run", "Show what would be dispatched without running").option("--json", "Output manifest as JSON").option("-o, --output-dir <dir>", "Base output directory").action(
+    async (promptArg, opts) => {
+      const cwd = process.cwd();
+      const globalConfig = loadConfig();
+      const projectConfig = loadProjectConfig(cwd);
+      const config = mergeConfigs(globalConfig, projectConfig);
+      let toolIds;
+      const explicitTools = Boolean(opts.tools);
+      if (opts.tools) {
+        toolIds = opts.tools.split(",").map((t) => t.trim());
+      } else {
+        toolIds = Object.keys(config.tools);
+      }
+      if (toolIds.length === 0) {
+        error('No tools configured. Run "counselors init" first.');
+        process.exitCode = 1;
+        return;
+      }
+      for (const id of toolIds) {
+        if (!config.tools[id]) {
+          error(
+            `Tool "${id}" not configured. Run "counselors tools add ${id}".`
+          );
+          process.exitCode = 1;
+          return;
+        }
+      }
+      if (!explicitTools && !opts.dryRun && process.stderr.isTTY && toolIds.length > 1) {
+        const selected = await selectRunTools(toolIds);
+        if (selected.length === 0) {
+          error("No tools selected.");
+          process.exitCode = 1;
+          return;
+        }
+        toolIds = selected;
+      }
+      const internalToCliMap = {
+        enforced: "strict",
+        bestEffort: "best-effort",
+        none: "off"
+      };
+      const readOnlyInput = opts.readOnly ?? internalToCliMap[config.defaults.readOnly] ?? "best-effort";
+      const readOnlyMap = {
+        strict: "enforced",
+        "best-effort": "bestEffort",
+        off: "none"
+      };
+      const readOnlyPolicy = readOnlyMap[readOnlyInput];
+      if (!readOnlyPolicy) {
+        error(
+          `Invalid --read-only value "${readOnlyInput}". Must be: strict, best-effort, or off.`
+        );
+        process.exitCode = 1;
+        return;
+      }
+      let promptContent;
+      let promptSource;
+      let slug;
+      if (opts.file) {
+        const filePath = resolve4(cwd, opts.file);
+        try {
+          promptContent = readFileSync5(filePath, "utf-8");
+        } catch {
+          error(`Cannot read prompt file: ${filePath}`);
+          process.exitCode = 1;
+          return;
+        }
+        promptSource = "file";
+        slug = generateSlugFromFile(filePath);
+      } else if (promptArg) {
+        promptSource = "inline";
+        slug = generateSlug(promptArg);
+        const context = opts.context ? gatherContext(
+          cwd,
+          opts.context === "." ? [] : opts.context.split(","),
+          config.defaults.maxContextKb
+        ) : void 0;
+        promptContent = buildPrompt(promptArg, context);
+      } else {
+        if (process.stdin.isTTY) {
+          error(
+            "No prompt provided. Pass as argument, use -f <file>, or pipe via stdin."
+          );
+          process.exitCode = 1;
+          return;
+        }
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+          chunks.push(chunk);
+        }
+        const stdinContent = Buffer.concat(chunks).toString("utf-8").trim();
+        if (!stdinContent) {
+          error("Empty prompt from stdin.");
+          process.exitCode = 1;
+          return;
+        }
+        promptSource = "stdin";
+        slug = generateSlug(stdinContent);
+        const context = opts.context ? gatherContext(
+          cwd,
+          opts.context === "." ? [] : opts.context.split(","),
+          config.defaults.maxContextKb
+        ) : void 0;
+        promptContent = buildPrompt(stdinContent, context);
+      }
+      if (!slug) slug = `run-${Date.now()}`;
+      if (opts.dryRun) {
+        const baseDir2 = opts.outputDir || config.defaults.outputDir;
+        const dryOutputDir = join6(baseDir2, slug);
+        const dryPromptFile = resolve4(dryOutputDir, "prompt.md");
+        const invocations = toolIds.map((id) => {
+          const toolConfig = config.tools[id];
+          const adapter = resolveAdapter(id, toolConfig);
+          const inv = adapter.buildInvocation({
+            prompt: promptContent,
+            promptFilePath: dryPromptFile,
+            toolId: id,
+            outputDir: dryOutputDir,
+            readOnlyPolicy,
+            timeout: config.defaults.timeout,
+            cwd,
+            binary: toolConfig.binary,
+            extraFlags: toolConfig.extraFlags
+          });
+          return {
+            toolId: id,
+            cmd: inv.cmd,
+            args: inv.args
+          };
+        });
+        info(formatDryRun(invocations));
+        return;
+      }
+      const baseDir = opts.outputDir || config.defaults.outputDir;
+      const outputDir = resolveOutputDir(baseDir, slug);
+      const promptFilePath = resolve4(outputDir, "prompt.md");
+      if (opts.file) {
+        copyFileSync2(resolve4(cwd, opts.file), promptFilePath);
+      } else {
+        safeWriteFile(promptFilePath, promptContent);
+      }
+      const display = new ProgressDisplay(toolIds, outputDir);
+      let reports;
+      try {
+        reports = await dispatch({
+          config,
+          toolIds,
+          promptFilePath,
+          promptContent,
+          outputDir,
+          readOnlyPolicy,
+          cwd,
+          onProgress: (event) => {
+            if (event.event === "started") display.start(event.toolId);
+            if (event.event === "completed")
+              display.complete(event.toolId, event.report);
+          }
+        });
+      } finally {
+        display.stop();
+      }
+      const manifest = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        slug,
+        prompt: promptArg || (opts.file ? `file:${basename2(opts.file)}` : "stdin"),
+        promptSource,
+        readOnlyPolicy,
+        tools: reports
+      };
+      safeWriteFile(
+        resolve4(outputDir, "run.json"),
+        JSON.stringify(manifest, null, 2)
+      );
+      const summary = synthesize(manifest, outputDir);
+      safeWriteFile(resolve4(outputDir, "summary.md"), summary);
+      if (opts.json) {
+        info(JSON.stringify(manifest, null, 2));
+      } else {
+        info(formatRunSummary(manifest));
+      }
+    }
+  );
+}
+
+// src/commands/skill.ts
+function registerSkillCommand(program2) {
+  program2.command("skill").description("Print a skill/slash-command template for coding agents").action(async () => {
+    const template = `---
+name: counselors
+description: Get parallel second opinions from multiple AI coding agents. Use when the user wants independent reviews, architecture feedback, or a sanity check from other AI models.
+---
+
+# Counselors \u2014 Multi-Agent Review Skill
+
+> **Note:** This is a reference skill template. Your agent system may use a different skill/command format. Adapt the structure and frontmatter below to match your system's conventions \u2014 the workflow and phases are what matter.
+
+Fan out a prompt to multiple AI coding agents in parallel and synthesize their responses.
+
+Arguments: $ARGUMENTS
+
+**If no arguments provided**, ask the user what they want reviewed.
+
+---
+
+## Phase 1: Context Gathering
+
+Parse \`$ARGUMENTS\` to understand what the user wants reviewed. Then auto-gather relevant context:
+
+1. **Files mentioned in the prompt**: Use Glob/Grep to find files referenced by name, class, function, or keyword
+2. **Recent changes**: Run \`git diff HEAD\` and \`git diff --staged\` to capture recent work
+3. **Related code**: Search for key terms from the prompt and read the most relevant files (up to 5 files, ~50KB total cap)
+
+Be selective \u2014 don't dump the entire codebase. Pick the most relevant code sections.
+
+---
+
+## Phase 2: Agent Selection
+
+1. **Discover available agents** by running via Bash:
+   \`\`\`bash
+   counselors ls
+   \`\`\`
+   This lists all configured agents with their IDs and binaries.
+
+2. **MANDATORY: Print the full agent list, then ask the user which to use.**
+
+   **Always print the full \`counselors ls\` output as inline text** (not inside AskUserQuestion). Just show the raw output from the command so the user sees every agent with its ID and binary. Do NOT reformat or abbreviate it.
+
+   Then ask the user to pick:
+
+   **If 4 or fewer agents**: Use AskUserQuestion with \`multiSelect: true\`, one option per agent.
+
+   **If more than 4 agents**: AskUserQuestion only supports 4 options. Use these fixed options:
+   - Option 1: "All [N] agents" \u2014 sends to every configured agent
+   - Option 2-4: The first 3 individual agents by ID
+   - The user can always select "Other" to type a comma-separated list of agent IDs from the printed list above
+
+   Do NOT combine agents into preset groups (e.g. "claude + codex + gemini"). Each option must be a single agent or "All".
+
+3. Wait for the user's selection before proceeding.
+
+4. **MANDATORY: Confirm the selection before continuing.** After the user picks agents, echo back the exact list you will dispatch to:
+
+   > Dispatching to: **claude-opus**, **codex-5.3-high**, **gemini-pro**
+
+   Then ask the user to confirm (e.g. "Look good?") before proceeding to Phase 3. This prevents silent tool omissions. If the user corrects the list, update your selection accordingly.
+
+---
+
+## Phase 3: Prompt Assembly
+
+1. **Generate a slug** from the topic (lowercase, hyphens, max 40 chars)
+   - "review the auth flow" \u2192 \`auth-flow-review\`
+   - "is this migration safe" \u2192 \`migration-safety-review\`
+
+2. **Create the output directory** via Bash. The directory name MUST always be prefixed with a millisecond-precision UNIX timestamp so runs are lexically sortable and never collide:
+   \`\`\`
+   ./agents/counselors/TIMESTAMP-[slug]
+   \`\`\`
+   For example: \`./agents/counselors/1770676882780-auth-flow-review\`
+
+3. **Write the prompt file** using the Write tool to \`./agents/counselors/TIMESTAMP-[slug]/prompt.md\`:
+
+\`\`\`markdown
+# Review Request
+
+## Question
+[User's original prompt/question from $ARGUMENTS]
+
+## Context
+
+### Files Referenced
+[Contents of the most relevant files found in Phase 1]
+
+### Recent Changes
+[git diff output, if any]
+
+### Related Code
+[Related files discovered via search]
+
+## Instructions
+You are providing an independent review. Be critical and thorough.
+- Analyze the question in the context provided
+- Identify risks, tradeoffs, and blind spots
+- Suggest alternatives if you see better approaches
+- Be direct and opinionated \u2014 don't hedge
+- Structure your response with clear headings
+\`\`\`
+
+---
+
+## Phase 4: Dispatch
+
+Run counselors via Bash with the prompt file, passing the user's selected agents:
+
+\`\`\`bash
+counselors run -f ./agents/counselors/[slug]/prompt.md --tools [comma-separated-selections] --json
+\`\`\`
+
+Example: \`--tools claude,codex,gemini\`
+
+Use \`timeout: 600000\` (10 minutes). Counselors dispatches to the selected agents in parallel and writes results to the output directory shown in the JSON output.
+
+**Important**: Use \`-f\` (file mode) so the prompt is sent as-is without wrapping. Use \`--json\` to get structured output for parsing.
+
+---
+
+## Phase 5: Read Results
+
+1. **Parse the JSON output** from stdout \u2014 it contains the run manifest with status, duration, word count, and output file paths for each agent
+2. **Read each agent's response** from the \`outputFile\` path in the manifest
+3. **Check \`stderrFile\` paths** for any agent that failed or returned empty output
+4. **Skip empty or error-only reports** \u2014 note which agents failed
+
+---
+
+## Phase 6: Synthesize and Present
+
+Combine all agent responses into a synthesis:
+
+\`\`\`markdown
+## Counselors Review
+
+**Agents consulted:** [list of agents that responded]
+
+**Consensus:** [What most agents agree on \u2014 key takeaways]
+
+**Disagreements:** [Where they differ, and reasoning behind each position]
+
+**Key Risks:** [Risks or concerns flagged by any agent]
+
+**Blind Spots:** [Things none of the agents addressed that seem important]
+
+**Recommendation:** [Your synthesized recommendation based on all inputs]
+
+---
+Reports saved to: [output directory from manifest]
+\`\`\`
+
+Present this synthesis to the user. Be concise \u2014 the individual reports are saved for deep reading.
+
+---
+
+## Phase 7: Action (Optional)
+
+After presenting the synthesis, ask the user what they'd like to address. Offer the top 2-3 actionable items from the synthesis as options. If the user wants to act on findings, plan the implementation before making changes.
+
+---
+
+## Error Handling
+
+- **counselors not installed**: Tell the user to install it (\`npm install -g counselors\`)
+- **No tools configured**: Tell the user to run \`counselors init\` or \`counselors add\`
+- **Agent fails**: Note it in the synthesis and continue with other agents' results
+- **All agents fail**: Report errors from stderr files and suggest checking \`counselors doctor\`
+`;
+    info(template);
+  });
+}
+
+// src/commands/tools/add.ts
+import { accessSync as accessSync2, constants as constants2 } from "fs";
+import { resolve as resolve5 } from "path";
+var CUSTOM_TOOL_VALUE = "__custom__";
+async function runAddWizard() {
+  const spinner = createSpinner("Discovering installed tools...").start();
+  const adapters = getAllBuiltInAdapters();
+  const discovered = [];
+  for (const adapter of adapters) {
+    const result = discoverTool(adapter.commands);
+    discovered.push({
+      id: adapter.id,
+      name: adapter.displayName,
+      found: result.found,
+      version: result.version
+    });
+  }
+  spinner.stop();
+  const choices = discovered.map((d) => ({
+    name: d.found ? `${d.name} (${d.id})${d.version ? ` \u2014 ${d.version}` : ""}` : `${d.name} (${d.id}) \u2014 not installed`,
+    value: d.id,
+    disabled: !d.found ? "(not installed)" : void 0
+  }));
+  choices.push({
+    name: "Custom tool \u2014 provide a binary path",
+    value: CUSTOM_TOOL_VALUE,
+    disabled: void 0
+  });
+  const selected = await promptSelect(
+    "Which tool would you like to add?",
+    choices
+  );
+  if (selected === CUSTOM_TOOL_VALUE) {
+    return { toolId: "", isCustom: true };
+  }
+  return { toolId: selected, isCustom: false };
+}
+function validateBinary(input2) {
+  const resolved = resolve5(input2);
+  try {
+    accessSync2(resolved, constants2.X_OK);
+    return resolved;
+  } catch {
+  }
+  const found = findBinary(input2);
+  if (found) return found;
+  return null;
+}
+async function addBuiltInTool(toolId, config, nameOverride) {
+  const adapter = getAdapter(toolId);
+  const discovery = discoverTool(adapter.commands);
+  if (!discovery.found) {
+    error(
+      `"${toolId}" binary not found. Install it from: ${adapter.installUrl}`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const selectedModel = await selectModelDetails(toolId, adapter.models);
+  const defaultName = nameOverride ?? selectedModel.compoundId ?? `${toolId}-${selectedModel.id}`;
+  let name = nameOverride ?? await promptInput("Tool name:", defaultName);
+  if (!SAFE_ID_RE.test(name)) {
+    error(
+      `Invalid tool name "${name}". Use only letters, numbers, dots, hyphens, and underscores.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (config.tools[name]) {
+    const overwrite = await confirmOverwrite(name);
+    if (!overwrite) {
+      name = await promptInput("Pick a different name:");
+      if (!SAFE_ID_RE.test(name)) {
+        error(
+          `Invalid tool name "${name}". Use only letters, numbers, dots, hyphens, and underscores.`
+        );
+        process.exitCode = 1;
+        return;
+      }
+      if (config.tools[name]) {
+        error(`"${name}" also exists. Run "counselors tools add" again.`);
+        process.exitCode = 1;
+        return;
+      }
+    }
+  }
+  const toolConfig = {
+    binary: discovery.path,
+    readOnly: { level: adapter.readOnly.level },
+    adapter: toolId,
+    ...selectedModel.extraFlags ? { extraFlags: selectedModel.extraFlags } : {}
+  };
+  const updated = addToolToConfig(config, name, toolConfig);
+  saveConfig(updated);
+  if (toolId === "amp") {
+    copyAmpSettings();
+  }
+  success(`Added "${name}" to config.`);
+}
+async function collectCustomConfig(config, presetId) {
+  let binaryPath = null;
+  while (!binaryPath) {
+    const binaryInput = await promptInput("Binary path or command:");
+    binaryPath = validateBinary(binaryInput);
+    if (!binaryPath) {
+      warn(`"${binaryInput}" not found or not executable. Please try again.`);
+    }
+  }
+  const useStdin = await confirmAction(
+    "Does this tool receive prompts via stdin?"
+  );
+  info("");
+  info("  Counselors runs tools non-interactively. Your flags MUST include:");
+  info(
+    "    1. Headless/non-interactive mode (e.g. -p, --non-interactive, --headless)"
+  );
+  info("    2. Model selection if needed (e.g. --model gpt-4o)");
+  info("    3. Output format if needed (e.g. --output-format text)");
+  info("");
+  if (!useStdin) {
+    info("  Counselors will append the prompt as the last CLI argument:");
+    info(
+      '    "Read the file at <path> and follow the instructions within it."'
+    );
+  } else {
+    info("  Counselors will pipe the prompt text to stdin.");
+  }
+  info("");
+  info("  Example: -p --model gpt-4o --output-format text");
+  info("");
+  let extraFlags;
+  const flagsInput = await promptInput("Flags (space-separated):");
+  if (flagsInput.trim()) {
+    extraFlags = flagsInput.trim().split(/\s+/);
+  }
+  const readOnlyLevel = await promptSelect(
+    "Read-only capability:",
+    [
+      { name: "Enforced \u2014 tool guarantees read-only", value: "enforced" },
+      {
+        name: "Best effort \u2014 tool tries but may not guarantee",
+        value: "bestEffort"
+      },
+      { name: "None \u2014 tool has full access", value: "none" }
+    ]
+  );
+  const defaultId = presetId ?? binaryPath.split("/").pop()?.replace(/\.[^.]+$/, "") ?? "custom";
+  const toolId = await promptInput(
+    "Tool name (used in config and output filenames):",
+    defaultId
+  );
+  if (!SAFE_ID_RE.test(toolId)) {
+    error(
+      `Invalid tool name "${toolId}". Use only letters, numbers, dots, hyphens, and underscores.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  info("");
+  info("  Tool will be invoked as:");
+  const previewArgs = [
+    ...extraFlags ?? [],
+    useStdin ? "< prompt.md" : '"Read the file at <path> and follow the instructions..."'
+  ];
+  info(`    ${binaryPath} ${previewArgs.join(" ")}`);
+  info("");
+  if (config.tools[toolId]) {
+    const overwrite = await confirmOverwrite(toolId);
+    if (!overwrite) {
+      const newId = await promptInput("Pick a different name:");
+      if (!SAFE_ID_RE.test(newId)) {
+        error(
+          `Invalid tool name "${newId}". Use only letters, numbers, dots, hyphens, and underscores.`
+        );
+        process.exitCode = 1;
+        return;
+      }
+      if (config.tools[newId]) {
+        error(`"${newId}" also exists. Run "counselors tools add" again.`);
+        process.exitCode = 1;
+        return;
+      }
+      const toolConfig2 = {
+        binary: binaryPath,
+        readOnly: { level: readOnlyLevel },
+        ...useStdin ? { stdin: true } : {},
+        extraFlags,
+        custom: true
+      };
+      const updated2 = addToolToConfig(config, newId, toolConfig2);
+      saveConfig(updated2);
+      success(`Added "${newId}" to config.`);
+      return;
+    }
+  }
+  const toolConfig = {
+    binary: binaryPath,
+    readOnly: { level: readOnlyLevel },
+    ...useStdin ? { stdin: true } : {},
+    extraFlags,
+    custom: true
+  };
+  const updated = addToolToConfig(config, toolId, toolConfig);
+  saveConfig(updated);
+  success(`Added "${toolId}" to config.`);
+}
+function registerAddCommand(program2) {
+  program2.command("add [tool]").description("Add a tool (claude, codex, gemini, amp, or custom)").action(async (toolId) => {
+    const config = loadConfig();
+    if (!toolId) {
+      const result = await runAddWizard();
+      if (result.isCustom) {
+        await collectCustomConfig(config);
+      } else {
+        await addBuiltInTool(result.toolId, config);
+      }
+      return;
+    }
+    if (isBuiltInTool(toolId)) {
+      await addBuiltInTool(toolId, config, toolId);
+    } else {
+      await collectCustomConfig(config, toolId);
+    }
+  });
+}
+
+// src/commands/tools/discover.ts
+function registerDiscoverCommand(program2) {
+  program2.command("discover").description("Discover installed AI CLI tools").action(async () => {
+    const spinner = createSpinner("Scanning for AI CLI tools...").start();
+    const adapters = getAllBuiltInAdapters();
+    const results = [];
+    for (const adapter of adapters) {
+      const result = discoverTool(adapter.commands);
+      results.push({
+        ...result,
+        toolId: adapter.id,
+        displayName: adapter.displayName
+      });
+    }
+    spinner.stop();
+    info(formatDiscoveryResults(results));
+  });
+}
+
+// src/commands/tools/list.ts
+function registerListCommand(program2) {
+  program2.command("list").alias("ls").description("List configured tools").option("-v, --verbose", "Show full tool configuration including flags").action(async (opts) => {
+    const config = loadConfig();
+    const tools2 = Object.entries(config.tools).map(([id, t]) => {
+      const entry = {
+        id,
+        binary: t.binary
+      };
+      if (opts.verbose) {
+        const adapter = resolveAdapter(id, t);
+        const inv = adapter.buildInvocation({
+          prompt: "<prompt>",
+          promptFilePath: "<prompt-file>",
+          toolId: id,
+          outputDir: ".",
+          readOnlyPolicy: t.readOnly.level,
+          timeout: t.timeout ?? config.defaults.timeout,
+          cwd: process.cwd(),
+          binary: t.binary,
+          extraFlags: t.extraFlags
+        });
+        entry.args = inv.args;
+      }
+      return entry;
+    });
+    info(formatToolList(tools2, opts.verbose));
+  });
+}
+
+// src/commands/tools/remove.ts
+import { checkbox as checkbox2 } from "@inquirer/prompts";
+function registerRemoveCommand(program2) {
+  program2.command("remove [tool]").description("Remove a configured tool").action(async (toolId) => {
+    const config = loadConfig();
+    const toolIds = Object.keys(config.tools);
+    if (toolIds.length === 0) {
+      error("No tools configured.");
+      process.exitCode = 1;
+      return;
+    }
+    let toRemove;
+    if (toolId) {
+      if (!config.tools[toolId]) {
+        error(`Tool "${toolId}" is not configured.`);
+        process.exitCode = 1;
+        return;
+      }
+      toRemove = [toolId];
+    } else {
+      toRemove = await checkbox2({
+        message: "Select tools to remove:",
+        choices: toolIds.map((id) => ({
+          name: `${id} (${config.tools[id].binary})`,
+          value: id
+        }))
+      });
+      if (toRemove.length === 0) {
+        info("No tools selected.");
+        return;
+      }
+    }
+    const confirmed = await confirmAction(
+      toRemove.length === 1 ? `Remove "${toRemove[0]}" from config?` : `Remove ${toRemove.length} tools from config?`
+    );
+    if (!confirmed) return;
+    let updated = config;
+    for (const id of toRemove) {
+      updated = removeToolFromConfig(updated, id);
+    }
+    saveConfig(updated);
+    success(`Removed ${toRemove.join(", ")}.`);
+  });
+}
+
+// src/commands/tools/rename.ts
+function registerRenameCommand(program2) {
+  program2.command("rename <old> <new>").description("Rename a configured tool").action(async (oldId, newId) => {
+    const config = loadConfig();
+    if (!config.tools[oldId]) {
+      error(`Tool "${oldId}" is not configured.`);
+      process.exitCode = 1;
+      return;
+    }
+    if (config.tools[newId]) {
+      error(`Tool "${newId}" already exists.`);
+      process.exitCode = 1;
+      return;
+    }
+    if (!SAFE_ID_RE.test(newId)) {
+      error(
+        `Invalid tool name "${newId}". Use only letters, numbers, dots, hyphens, and underscores.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const updated = renameToolInConfig(config, oldId, newId);
+    saveConfig(updated);
+    success(`Renamed "${oldId}" \u2192 "${newId}".`);
+  });
+}
+
+// src/commands/tools/test.ts
+function registerTestCommand(program2) {
+  program2.command("test [tools...]").description('Test configured tools with a "reply OK" prompt').action(async (toolIds) => {
+    const config = loadConfig();
+    const idsToTest = toolIds.length > 0 ? toolIds : Object.keys(config.tools);
+    if (idsToTest.length === 0) {
+      error('No tools configured. Run "counselors init" first.');
+      process.exitCode = 1;
+      return;
+    }
+    const results = [];
+    for (const id of idsToTest) {
+      const toolConfig = config.tools[id];
+      if (!toolConfig) {
+        results.push({
+          toolId: id,
+          passed: false,
+          output: "",
+          error: "Not configured",
+          durationMs: 0
+        });
+        continue;
+      }
+      const spinner = createSpinner(`Testing ${id}...`).start();
+      const adapter = resolveAdapter(id, toolConfig);
+      const result = await executeTest(adapter, toolConfig, id);
+      spinner.stop();
+      results.push(result);
+    }
+    info(formatTestResults(results));
+    if (results.some((r) => !r.passed)) {
+      process.exitCode = 1;
+    }
+  });
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("counselors").description("Fan out prompts to multiple AI coding agents in parallel").version(VERSION);
+registerRunCommand(program);
+registerDoctorCommand(program);
+registerInitCommand(program);
+registerAgentCommand(program);
+registerSkillCommand(program);
+var tools = program.command("tools").description("Manage AI tool configurations");
+registerDiscoverCommand(tools);
+registerAddCommand(tools);
+registerRemoveCommand(tools);
+registerRenameCommand(tools);
+registerListCommand(tools);
+registerTestCommand(tools);
+program.command("add [tool]").description('Alias for "tools add"').action(async (tool) => {
+  const args = tool ? ["add", tool] : ["add"];
+  await tools.parseAsync(args, { from: "user" });
+});
+program.command("ls").description('Alias for "tools list"').option("-v, --verbose", "Show full tool configuration including flags").action(async (opts) => {
+  const args = ["list"];
+  if (opts.verbose) args.push("--verbose");
+  await tools.parseAsync(args, { from: "user" });
+});
+program.parseAsync(process.argv).catch((err) => {
+  process.stderr.write(`\u2717 ${err.message}
+`);
+  process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map