@gaberrb/polypus 0.4.0 → 0.4.2

package/dist/index.js

@@ -143,6 +143,7 @@ var en = {
   "repl.allowShow": "mode={mode} allow=[{allow}]",
   "repl.historyCleared": "history cleared",
   "repl.unknown": "Unknown command /{cmd}. Type /help.",
+  "repl.pasted": "[Pasted text #{id} +{lines} lines]",
   "repl.agentSwitched": "active agent \u2192 {name}",
   "repl.switchedTo": "active agent is now {name}",
   "repl.noAgentsLeft": "No agents left. Use /add to create one.",
@@ -156,6 +157,7 @@ var en = {
     "  /plan            switch to plan mode (read-only)",
     "  /review          switch to review mode (confirm each action)",
     "  /bypass          switch to bypass mode (auto-approve)",
+    "  /swarm <task>    run a task as a parallel swarm (needs 3+ agents)",
     "  /allow <glob>    add a path glob to the allow-list",
     "  /allow           show the current allow-list and mode",
     "  /reset           clear the conversation history",
@@ -359,6 +361,7 @@ var ptBR = {
   "repl.allowShow": "modo={mode} allow=[{allow}]",
   "repl.historyCleared": "hist\xF3rico limpo",
   "repl.unknown": "Comando desconhecido /{cmd}. Digite /help.",
+  "repl.pasted": "[Texto colado #{id} +{lines} linhas]",
   "repl.agentSwitched": "agente ativo \u2192 {name}",
   "repl.switchedTo": "agente ativo agora \xE9 {name}",
   "repl.noAgentsLeft": "Nenhum agente restante. Use /add para criar um.",
@@ -372,6 +375,7 @@ var ptBR = {
     "  /plan            muda para o modo plan (somente leitura)",
     "  /review          muda para o modo review (confirma cada a\xE7\xE3o)",
     "  /bypass          muda para o modo bypass (aprova automaticamente)",
+    "  /swarm <task>    roda a tarefa como swarm paralelo (requer 3+ agentes)",
     "  /allow <glob>    adiciona um glob de caminho \xE0 allow-list",
     "  /allow           mostra a allow-list e o modo atuais",
     "  /reset           limpa o hist\xF3rico da conversa",
@@ -688,7 +692,7 @@ async function listAgents() {
 }
 
 // src/cli/commands/run.ts
-import pc7 from "picocolors";
+import pc8 from "picocolors";
 import * as p2 from "@clack/prompts";
 
 // src/core/providers/anthropic.ts
@@ -1431,6 +1435,116 @@ function clamp(s) {
   return s.length > MAX_OUTPUT ? s.slice(0, MAX_OUTPUT) + "\n\u2026[truncated]" : s;
 }
 
+// src/core/tools/search-file.ts
+import { readdir as readdir2, readFile as readFile4, stat } from "fs/promises";
+import { join as join2, resolve as resolve5 } from "path";
+import { z as z6 } from "zod";
+var Args5 = z6.object({
+  query: z6.string().min(1),
+  path: z6.string().optional(),
+  glob: z6.string().optional(),
+  max_results: z6.number().int().positive().max(1e3).optional()
+});
+var DEFAULT_MAX_RESULTS = 50;
+var MAX_OUTPUT2 = 2e4;
+var MAX_FILE_BYTES = 2e6;
+var SNIPPET_CHARS = 200;
+var NUL = String.fromCharCode(0);
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next", "coverage", ".turbo"]);
+var searchTool = {
+  mutating: false,
+  spec: {
+    name: "search",
+    description: "Search file contents by regular expression across the workspace (like grep/ripgrep). Returns matches as 'path:line: snippet'. Respects the allow/deny-list and skips node_modules/.git. Use this to find where a symbol is defined or used instead of reading files blindly.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Regular expression to match against each line" },
+        path: { type: "string", description: "Workspace-relative directory to search in (default '.')" },
+        glob: {
+          type: "string",
+          description: "Optional glob to limit files, e.g. 'src/**/*.ts'"
+        },
+        max_results: {
+          type: "number",
+          description: `Maximum number of matches to return (default ${DEFAULT_MAX_RESULTS})`
+        }
+      },
+      required: ["query"]
+    }
+  },
+  async run(rawArgs, ctx) {
+    const parsed = Args5.safeParse(rawArgs);
+    if (!parsed.success) return { ok: false, output: "Invalid args: 'query' is required." };
+    const { query, path = ".", glob, max_results } = parsed.data;
+    let regex;
+    try {
+      regex = new RegExp(query);
+    } catch (err) {
+      return { ok: false, output: `Invalid regular expression: ${err.message}` };
+    }
+    if (path !== ".") {
+      const decision = ctx.permissions.authorizeRead(path);
+      if (!decision.allowed) return { ok: false, output: `Search denied: ${decision.reason}` };
+    }
+    const globRe = glob ? globToRegExp(glob) : void 0;
+    const limit = max_results ?? DEFAULT_MAX_RESULTS;
+    const root = resolve5(ctx.workspace, path);
+    const matches = [];
+    let truncated = false;
+    const walk = async (dir) => {
+      if (matches.length >= limit) return;
+      let entries;
+      try {
+        entries = await readdir2(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (matches.length >= limit) return;
+        const abs = join2(dir, entry.name);
+        const rel = toPosix(abs.slice(ctx.workspace.length + 1));
+        if (entry.isDirectory()) {
+          if (SKIP_DIRS.has(entry.name)) continue;
+          await walk(abs);
+          continue;
+        }
+        if (!entry.isFile()) continue;
+        if (globRe && !globRe.test(rel)) continue;
+        if (!ctx.permissions.authorizeRead(rel).allowed) continue;
+        try {
+          const info = await stat(abs);
+          if (info.size > MAX_FILE_BYTES) continue;
+          const content = await readFile4(abs, "utf8");
+          if (content.includes(NUL)) continue;
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            if (matches.length >= limit) {
+              truncated = true;
+              return;
+            }
+            if (regex.test(lines[i])) {
+              const snippet = lines[i].trim().slice(0, SNIPPET_CHARS);
+              matches.push(`${rel}:${i + 1}: ${snippet}`);
+            }
+          }
+        } catch {
+        }
+      }
+    };
+    await walk(root);
+    if (matches.length === 0) {
+      return { ok: true, output: `No matches for /${query}/${glob ? ` in ${glob}` : ""}.` };
+    }
+    const header = `${matches.length}${truncated ? "+" : ""} match(es) for /${query}/:`;
+    const body = [header, ...matches].join("\n");
+    return {
+      ok: true,
+      output: body.length > MAX_OUTPUT2 ? body.slice(0, MAX_OUTPUT2) + "\n\u2026[truncated]" : body
+    };
+  }
+};
+
 // src/core/tools/types.ts
 var FINISH_TOOL = {
   name: "finish",
@@ -1446,9 +1560,9 @@ var FINISH_TOOL = {
 
 // src/core/tools/write-file.ts
 import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
-import { dirname, resolve as resolve5 } from "path";
-import { z as z6 } from "zod";
-var Args5 = z6.object({ path: z6.string().min(1), content: z6.string() });
+import { dirname, resolve as resolve6 } from "path";
+import { z as z7 } from "zod";
+var Args6 = z7.object({ path: z7.string().min(1), content: z7.string() });
 var writeFileTool = {
   mutating: true,
   spec: {
@@ -1464,7 +1578,7 @@ var writeFileTool = {
     }
   },
   async run(rawArgs, ctx) {
-    const args = Args5.safeParse(rawArgs);
+    const args = Args6.safeParse(rawArgs);
     if (!args.success) {
       const got = Object.keys(rawArgs ?? {});
       return {
@@ -1476,7 +1590,7 @@ var writeFileTool = {
     const decision = await ctx.permissions.authorizeWrite(args.data.path, preview);
     if (!decision.allowed) return { ok: false, output: `Write denied: ${decision.reason}` };
     try {
-      const abs = resolve5(ctx.workspace, args.data.path);
+      const abs = resolve6(ctx.workspace, args.data.path);
       await mkdir2(dirname(abs), { recursive: true });
       await writeFile3(abs, args.data.content, "utf8");
       const lines = args.data.content.split("\n").length;
@@ -1495,6 +1609,7 @@ function previewContent(content) {
 var TOOLS = {
   [readFileTool.spec.name]: readFileTool,
   [listDirTool.spec.name]: listDirTool,
+  [searchTool.spec.name]: searchTool,
   [writeFileTool.spec.name]: writeFileTool,
   [editFileTool.spec.name]: editFileTool,
   [runCommandTool.spec.name]: runCommandTool
@@ -1507,8 +1622,8 @@ function getTool(name) {
 }
 
 // src/core/agent/correction.ts
-import { readFile as readFile4, readdir as readdir2 } from "fs/promises";
-import { dirname as dirname2, resolve as resolve6 } from "path";
+import { readFile as readFile5, readdir as readdir3 } from "fs/promises";
+import { dirname as dirname2, resolve as resolve7 } from "path";
 function truncationGuidance(toolName) {
   const fileHint = toolName === "write_file" || toolName === "edit_file" ? " Write large files in parts: create the file with the first chunk via write_file, then append the rest with edit_file in the next steps." : "";
   return [
@@ -1608,7 +1723,7 @@ ${text2}` : null;
 }
 async function readWorkspaceFile(workspace, path) {
   try {
-    return await readFile4(resolve6(workspace, path), "utf8");
+    return await readFile5(resolve7(workspace, path), "utf8");
   } catch {
     return null;
   }
@@ -1666,11 +1781,11 @@ async function occurrenceLines(workspace, path, search) {
   return out;
 }
 async function listNearest(workspace, path) {
-  let dir = dirname2(resolve6(workspace, path));
+  let dir = dirname2(resolve7(workspace, path));
   for (let i = 0; i < 8; i++) {
     try {
-      const entries = await readdir2(dir, { withFileTypes: true });
-      const rel = dir === resolve6(workspace) ? "." : dir;
+      const entries = await readdir3(dir, { withFileTypes: true });
+      const rel = dir === resolve7(workspace) ? "." : dir;
       const names = entries.slice(0, 40).map((e) => e.isDirectory() ? `${e.name}/` : e.name);
       return `${rel}:
   ${names.join("  ") || "(empty)"}`;
@@ -1692,14 +1807,14 @@ function formatSchema(spec) {
 }
 
 // src/core/agent/project-context.ts
-import { readFile as readFile5 } from "fs/promises";
-import { join as join2 } from "path";
-var INSTRUCTION_FILES = [join2(".poly", "agents.md"), "AGENTS.md"];
+import { readFile as readFile6 } from "fs/promises";
+import { join as join3 } from "path";
+var INSTRUCTION_FILES = [join3(".poly", "agents.md"), "AGENTS.md"];
 var MAX_CHARS2 = 8e3;
 async function loadProjectInstructions(workspace) {
   for (const rel of INSTRUCTION_FILES) {
     try {
-      const raw = (await readFile5(join2(workspace, rel), "utf8")).trim();
+      const raw = (await readFile6(join3(workspace, rel), "utf8")).trim();
       if (!raw) continue;
       return raw.length > MAX_CHARS2 ? raw.slice(0, MAX_CHARS2) + "\n\u2026(truncated)" : raw;
     } catch {
@@ -1860,8 +1975,6 @@ ${guidance}`;
 }
 
 // src/ui/repl.ts
-import * as readline from "readline/promises";
-import { stdin, stdout } from "process";
 import pc6 from "picocolors";
 
 // src/ui/wizard.ts
@@ -2383,6 +2496,136 @@ function promptLabel(mode) {
   return c2("\u{1F419} polypus") + pc5.dim(`(${mode})`) + c3(" \u203A ");
 }
 
+// src/ui/line-reader.ts
+import * as readline from "readline/promises";
+import { PassThrough } from "stream";
+import { stdin, stdout } from "process";
+
+// src/ui/paste.ts
+var PASTE_START = "\x1B[200~";
+var PASTE_END = "\x1B[201~";
+var PasteStore = class {
+  /** `format(id, lines)` builds the placeholder (localized by the caller). */
+  constructor(format) {
+    this.format = format;
+  }
+  format;
+  seq = 0;
+  map = /* @__PURE__ */ new Map();
+  /** Register pasted text, returning the placeholder to display in its place. */
+  add(text2) {
+    const lines = text2.split(/\r\n|\r|\n/).length;
+    const placeholder = this.format(++this.seq, lines);
+    this.map.set(placeholder, text2);
+    return placeholder;
+  }
+  /** Replace any known placeholders in `line` with their full pasted text. */
+  expand(line) {
+    let out = line;
+    for (const [placeholder, full] of this.map) {
+      if (out.includes(placeholder)) out = out.split(placeholder).join(full);
+    }
+    return out;
+  }
+  get size() {
+    return this.map.size;
+  }
+};
+var PasteFilter = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  buf = "";
+  inPaste = false;
+  pasteBuf = "";
+  push(chunk) {
+    this.buf += chunk;
+    let out = "";
+    for (; ; ) {
+      if (!this.inPaste) {
+        const i = this.buf.indexOf(PASTE_START);
+        if (i === -1) {
+          const keep = partialSuffix(this.buf, PASTE_START);
+          out += this.buf.slice(0, this.buf.length - keep);
+          this.buf = this.buf.slice(this.buf.length - keep);
+          return out;
+        }
+        out += this.buf.slice(0, i);
+        this.buf = this.buf.slice(i + PASTE_START.length);
+        this.inPaste = true;
+      } else {
+        const j = this.buf.indexOf(PASTE_END);
+        if (j === -1) {
+          const keep = partialSuffix(this.buf, PASTE_END);
+          this.pasteBuf += this.buf.slice(0, this.buf.length - keep);
+          this.buf = this.buf.slice(this.buf.length - keep);
+          return out;
+        }
+        this.pasteBuf += this.buf.slice(0, j);
+        this.buf = this.buf.slice(j + PASTE_END.length);
+        this.inPaste = false;
+        out += this.emit(this.pasteBuf);
+        this.pasteBuf = "";
+      }
+    }
+  }
+  /** Multi-line pastes become a placeholder; single-line pastes pass through. */
+  emit(text2) {
+    return /\r|\n/.test(text2) ? this.store.add(text2) : text2;
+  }
+};
+function partialSuffix(s, marker) {
+  const max = Math.min(s.length, marker.length - 1);
+  for (let n = max; n > 0; n--) {
+    if (s.slice(s.length - n) === marker.slice(0, n)) return n;
+  }
+  return 0;
+}
+
+// src/ui/line-reader.ts
+var ENABLE_BRACKETED_PASTE = "\x1B[?2004h";
+var DISABLE_BRACKETED_PASTE = "\x1B[?2004l";
+async function readLine(prompt) {
+  if (!stdin.isTTY) {
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    try {
+      return await rl.question(prompt);
+    } catch {
+      return null;
+    } finally {
+      rl.close();
+    }
+  }
+  return readLineTTY(prompt);
+}
+async function readLineTTY(prompt) {
+  const store = new PasteStore((id, lines) => t("repl.pasted", { id, lines }));
+  const filter = new PasteFilter(store);
+  const proxy = new PassThrough();
+  const rl = readline.createInterface({ input: proxy, output: stdout, terminal: true });
+  const onData = (buf) => {
+    proxy.write(filter.push(buf.toString("utf8")));
+  };
+  stdout.write(ENABLE_BRACKETED_PASTE);
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.on("data", onData);
+  try {
+    const line = await new Promise((resolve9) => {
+      rl.question(prompt).then(resolve9, () => resolve9(null));
+      rl.on("SIGINT", () => resolve9(null));
+      rl.on("close", () => resolve9(null));
+    });
+    return line === null ? null : store.expand(line);
+  } finally {
+    stdin.off("data", onData);
+    if (stdin.isTTY) stdin.setRawMode(false);
+    stdout.write(DISABLE_BRACKETED_PASTE);
+    rl.close();
+  }
+}
+
 // src/ui/repl.ts
 async function startRepl(ctx) {
   for (; ; ) {
@@ -2412,16 +2655,6 @@ async function startRepl(ctx) {
     await handleCommand(cmd, arg, ctx);
   }
 }
-async function readLine(prompt) {
-  const rl = readline.createInterface({ input: stdin, output: stdout });
-  try {
-    return await rl.question(prompt);
-  } catch {
-    return null;
-  } finally {
-    rl.close();
-  }
-}
 async function handleCommand(cmd, arg, ctx) {
   const { session } = ctx;
   switch (cmd) {
@@ -2446,6 +2679,18 @@ async function handleCommand(cmd, arg, ctx) {
       session.history = [];
       console.log(pc6.dim(t("repl.historyCleared")));
       return;
+    case "swarm": {
+      if (!arg) {
+        console.log(pc6.yellow(t("repl.needName", { usage: "/swarm <task>" })));
+        return;
+      }
+      try {
+        await ctx.runSwarm(arg);
+      } catch (e) {
+        console.log(pc6.red(`\u2717 ${e.message}`));
+      }
+      return;
+    }
     case "agents":
       printAgents(ctx.getConfig(), session.agentName);
       return;
@@ -2509,113 +2754,525 @@ async function removeAgent2(name, ctx) {
   }
 }
 
-// src/ui/spinner.ts
-var RESET2 = "\x1B[0m";
-var isTTY = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
-var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-var violet = (s) => isTTY ? `\x1B[38;2;167;139;250m${s}${RESET2}` : s;
-var dim = (s) => isTTY ? `\x1B[2m${s}${RESET2}` : s;
-var Spinner = class {
-  timer;
-  frame = 0;
-  startedAt = 0;
-  label = "";
-  suffix = "";
-  /** Extra dim text appended after the elapsed time (e.g. token count). */
-  setSuffix(suffix) {
-    this.suffix = suffix;
+// src/cli/commands/swarm.ts
+import pc7 from "picocolors";
+
+// src/core/git/worktree.ts
+import { mkdtemp } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join4 } from "path";
+import { simpleGit } from "simple-git";
+async function ensureRepo(workspace) {
+  const git = simpleGit(workspace);
+  if (!await git.checkIsRepo()) {
+    await git.init();
   }
-  /** Start (or, if already running, just update the label). */
-  start(label) {
-    this.label = label;
-    if (!isTTY) return;
-    if (this.timer) return;
-    this.startedAt = Date.now();
-    this.render();
-    this.timer = setInterval(() => this.render(), 90);
-    this.timer.unref?.();
+  const identity = await identityArgs(git);
+  const hasHead = await git.raw(["rev-parse", "--verify", "HEAD"]).then(() => true).catch(() => false);
+  if (!hasHead) {
+    await git.raw([...identity, "commit", "--allow-empty", "-m", "polypus: initial commit"]);
   }
-  /** Erase the spinner line and stop animating. */
-  stop() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = void 0;
+  return git;
+}
+async function identityArgs(git) {
+  const email = await git.raw(["config", "user.email"]).catch(() => "");
+  if (email.trim()) return [];
+  return ["-c", "user.email=polypus@local", "-c", "user.name=Polypus"];
+}
+async function createWorktree(git, label) {
+  const branch = `polypus/${label}-${Date.now().toString(36)}`;
+  const path = await mkdtemp(join4(tmpdir(), "polypus-wt-"));
+  await git.raw(["worktree", "add", "-b", branch, path, "HEAD"]);
+  return { path, branch };
+}
+async function commitWorktree(wt, message) {
+  const wtGit = simpleGit(wt.path);
+  await wtGit.add(["-A"]);
+  const status = await wtGit.status();
+  if (status.staged.length === 0 && status.files.length === 0) return false;
+  const identity = await identityArgs(wtGit);
+  await wtGit.raw([...identity, "commit", "-m", message]);
+  return true;
+}
+async function mergeWorktreeBranch(git, branch) {
+  try {
+    const identity = await identityArgs(git);
+    await git.raw([...identity, "merge", "--no-edit", branch]);
+    return { branch, ok: true, conflicts: [] };
+  } catch (err) {
+    const status = await git.status().catch(() => void 0);
+    const conflicts = status?.conflicted ?? [];
+    await git.raw(["merge", "--abort"]).catch(() => void 0);
+    if (conflicts.length === 0) {
+      throw err;
     }
-    if (isTTY) process.stdout.write("\r\x1B[K");
-  }
-  render() {
-    const f = violet(FRAMES[this.frame = (this.frame + 1) % FRAMES.length]);
-    const secs = Math.floor((Date.now() - this.startedAt) / 1e3);
-    const time = secs > 0 ? dim(` (${secs}s)`) : "";
-    const suffix = this.suffix ? dim(` \xB7 ${this.suffix}`) : "";
-    process.stdout.write(`\r\x1B[K${f} \u{1F419} ${dim(this.label + "\u2026")}${time}${suffix}`);
+    return { branch, ok: false, conflicts };
   }
-};
+}
+async function removeWorktree(git, wt) {
+  await git.raw(["worktree", "remove", wt.path, "--force"]).catch(() => void 0);
+  await git.raw(["branch", "-D", wt.branch]).catch(() => void 0);
+}
 
-// src/cli/commands/run.ts
-async function run(task, opts) {
-  let config = await loadConfig();
-  const agentConfig = resolveAgent(config, opts.agent);
-  const workspace = process.cwd();
-  const session = {
-    agentName: agentConfig.name,
-    mode: opts.mode ?? config.permissions.mode,
-    allow: config.permissions.allow,
-    deny: config.permissions.deny,
-    allowedCommands: config.permissions.allowedCommands,
-    maxSteps: opts.maxSteps ? Number(opts.maxSteps) : void 0,
-    history: []
-  };
-  const runTask = async (taskText) => {
-    const active = resolveAgent(config, session.agentName);
-    const resolved2 = createProvider(active);
-    await executeTask(taskText, resolved2, workspace, session);
-  };
-  if (task) {
-    const resolved2 = createProvider(agentConfig);
-    console.log(
-      pc7.dim(
-        t("run.status", {
-          name: resolved2.config.name,
-          provider: resolved2.config.provider,
-          model: resolved2.config.model,
-          toolMode: resolved2.toolMode,
-          mode: session.mode
-        })
-      )
-    );
-    await executeTask(task, resolved2, workspace, session);
-    return;
-  }
-  const resolved = createProvider(agentConfig);
-  await printWelcome({
-    agentName: resolved.config.name,
-    provider: resolved.config.provider,
-    model: resolved.config.model,
-    toolMode: resolved.toolMode,
-    mode: session.mode,
-    workspace
+// src/core/agent/worker.ts
+async function runWorker(subtask, agent, wt, allow, deny, events) {
+  const permissions = new PermissionEngine({
+    mode: "bypass",
+    policy: { workspace: wt.path, allow, deny },
+    allowedCommands: []
   });
-  const ctx = {
-    session,
-    runTask,
-    getConfig: () => config,
-    reload: async () => {
-      config = await loadConfig();
-    }
+  const result = await runAgent({
+    task: subtask.brief,
+    workspace: wt.path,
+    agent,
+    permissions,
+    promptContext: { workspace: wt.path, mode: "bypass", allow, briefing: subtask.brief },
+    events
+  });
+  const committed = await commitWorktree(wt, `polypus(${subtask.id}): ${subtask.title}`);
+  return {
+    subtask,
+    agentName: agent.config.name,
+    branch: wt.branch,
+    finished: result.finished,
+    summary: result.summary,
+    committed,
+    steps: result.steps
   };
-  await startRepl(ctx);
 }
-async function executeTask(task, resolved, workspace, session) {
-  const spinner3 = new Spinner();
-  const controller = new AbortController();
-  const cancel2 = listenForCancel(controller);
-  const permissions = new PermissionEngine({
-    mode: session.mode,
-    policy: { workspace, allow: session.allow, deny: session.deny },
-    allowedCommands: session.allowedCommands,
-    confirm: async (req) => {
-      spinner3.stop();
+
+// src/core/agent/orchestrator.ts
+async function runSwarm(opts) {
+  const lead = opts.agents[0];
+  if (!lead) throw new Error("Swarm requires at least one agent.");
+  const maxSubtasks = opts.maxSubtasks ?? Math.max(opts.agents.length, 2);
+  const git = await ensureRepo(opts.workspace);
+  const subtasks = await decompose(lead, opts.task, maxSubtasks);
+  opts.events?.onDecomposed?.(subtasks);
+  const worktrees = [];
+  for (const subtask of subtasks) {
+    worktrees.push(await createWorktree(git, subtask.id));
+  }
+  const outcomes = await Promise.all(
+    subtasks.map(async (subtask, i) => {
+      const agent = opts.agents[i % opts.agents.length];
+      const wt = worktrees[i];
+      opts.events?.onWorkerStart?.(subtask, agent.config.name);
+      const outcome = await runWorker(
+        subtask,
+        agent,
+        wt,
+        opts.allow,
+        opts.deny,
+        opts.events?.workerEvents?.(subtask)
+      );
+      opts.events?.onWorkerDone?.(outcome);
+      return outcome;
+    })
+  );
+  const merges = [];
+  for (const outcome of outcomes) {
+    if (!outcome.committed) continue;
+    const merge = await mergeWorktreeBranch(git, outcome.branch);
+    merges.push(merge);
+    opts.events?.onMerge?.(merge);
+  }
+  const conflicted = new Set(merges.filter((m) => !m.ok).map((m) => m.branch));
+  for (const wt of worktrees) {
+    if (conflicted.has(wt.branch)) {
+      await git.raw(["worktree", "remove", wt.path, "--force"]).catch(() => void 0);
+    } else {
+      await removeWorktree(git, wt);
+    }
+  }
+  return { subtasks, outcomes, merges };
+}
+var DECOMPOSE_SYSTEM = [
+  "You are a tech lead splitting a coding task into independent subtasks that can be done in parallel.",
+  'Return ONLY a JSON array. Each item: {"title": string, "brief": string}.',
+  "Make subtasks touch DIFFERENT files/areas to minimize merge conflicts.",
+  "Keep the list small (prefer 2-4 items). Each brief must be self-contained and actionable."
+].join("\n");
+async function decompose(lead, task, maxSubtasks) {
+  try {
+    const res = await lead.provider.chat({
+      messages: [
+        { role: "system", content: DECOMPOSE_SYSTEM },
+        { role: "user", content: `Task:
+${task}
+
+Return at most ${maxSubtasks} subtasks as a JSON array.` }
+      ],
+      params: { temperature: 0 }
+    });
+    const parsed = extractJsonArray(res.content);
+    if (parsed && parsed.length > 0) {
+      return parsed.slice(0, maxSubtasks).map((item, i) => ({
+        id: `t${i + 1}`,
+        title: String(item.title ?? `subtask ${i + 1}`),
+        brief: String(item.brief ?? item.title ?? task)
+      }));
+    }
+  } catch {
+  }
+  return [{ id: "t1", title: "task", brief: task }];
+}
+function extractJsonArray(text2) {
+  const start = text2.indexOf("[");
+  const end = text2.lastIndexOf("]");
+  if (start === -1 || end <= start) return null;
+  try {
+    const parsed = JSON.parse(text2.slice(start, end + 1));
+    return Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/ui/swarm-view.ts
+var RESET2 = "\x1B[0m";
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function describeToolCall(call) {
+  const raw = call.name === "run_command" ? call.arguments.command : call.arguments.path;
+  const arg = typeof raw === "string" ? raw : "";
+  const short = arg.length > 40 ? arg.slice(0, 39) + "\u2026" : arg;
+  return short ? `${call.name} ${short}` : call.name;
+}
+var SwarmView = class {
+  constructor(leadName, opts = {}) {
+    this.leadName = leadName;
+    this.tty = opts.tty ?? (Boolean(process.stdout.isTTY) && !process.env.NO_COLOR);
+    this.color = opts.color ?? this.tty;
+    this.write = opts.sink ?? ((s) => process.stdout.write(s));
+  }
+  leadName;
+  tty;
+  color;
+  write;
+  workers = /* @__PURE__ */ new Map();
+  order = [];
+  phase = "decomposing";
+  frame = 0;
+  lastLines = 0;
+  timer;
+  start() {
+    if (!this.tty) {
+      this.write(`\u{1F419} ${t("swarm.view.header", { lead: this.leadName })} \u2014 ${t("swarm.view.decomposing")}
+`);
+      return;
+    }
+    this.flush();
+    this.timer = setInterval(() => {
+      this.frame = (this.frame + 1) % FRAMES.length;
+      this.flush();
+    }, 110);
+    this.timer.unref?.();
+  }
+  setSubtasks(subtasks) {
+    this.phase = "running";
+    for (const s of subtasks) {
+      this.workers.set(s.id, { id: s.id, title: s.title, agent: "", status: "pending", action: "", steps: 0 });
+      this.order.push(s.id);
+    }
+    if (!this.tty) {
+      this.write(`  ${t("swarm.decomposed", { n: subtasks.length })}
+`);
+      for (const s of subtasks) this.write(`  ${s.id}: ${s.title}
+`);
+    }
+    this.flush();
+  }
+  workerStart(id, agent) {
+    const w = this.workers.get(id);
+    if (!w) return;
+    w.agent = agent;
+    w.status = "running";
+    if (!this.tty) this.write(`  \u25B6 ${id} [${agent}] ${w.title}
+`);
+    this.flush();
+  }
+  workerAction(id, action) {
+    const w = this.workers.get(id);
+    if (!w) return;
+    w.action = action;
+    this.flush();
+  }
+  workerStep(id, n) {
+    const w = this.workers.get(id);
+    if (!w) return;
+    w.steps = n;
+    this.flush();
+  }
+  workerDone(o) {
+    const w = this.workers.get(o.subtask.id);
+    if (!w) return;
+    w.status = o.finished ? "done" : "stopped";
+    w.steps = o.steps;
+    w.branch = o.branch;
+    w.action = "";
+    if (!this.tty) {
+      const tag = o.finished ? "\u2713" : "\u25A0";
+      const changes = o.committed ? t("swarm.changesCommitted") : t("swarm.noChanges");
+      this.write(`  ${tag} ${o.subtask.id} (${t("swarm.view.steps", { n: o.steps })}, ${changes})
+`);
+    }
+    this.flush();
+  }
+  merge(r) {
+    for (const w of this.workers.values()) {
+      if (w.branch === r.branch) w.merge = r.ok ? "ok" : "conflict";
+    }
+    if (!this.tty) {
+      this.write(r.ok ? `  \u2935 ${t("swarm.merged", { branch: r.branch })}
+` : `  \u2717 ${t("swarm.mergeConflict", { branch: r.branch })}
+`);
+    }
+    this.flush();
+  }
+  stop() {
+    this.phase = "done";
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    this.flush();
+  }
+  /** Content lines of the dashboard (no cursor control). Exposed for tests. */
+  frameLines() {
+    const spin = this.dim(FRAMES[this.frame]);
+    const lead = `\u{1F419} ${t("swarm.view.header", { lead: this.leadName })}`;
+    const lines = [];
+    if (this.phase === "decomposing") {
+      lines.push(`${spin} ${lead}`);
+      lines.push("  " + this.dim(t("swarm.view.decomposing")));
+      return lines;
+    }
+    lines.push(`${this.phase === "running" ? spin : "  "} ${lead}`);
+    lines.push("");
+    for (const id of this.order) {
+      const w = this.workers.get(id);
+      lines.push(this.row(w, spin));
+    }
+    return lines;
+  }
+  // -------------------------------------------------------------------------
+  row(w, spin) {
+    const icon = w.status === "running" ? spin : w.status === "done" ? this.c("\u2713", "32") : w.status === "stopped" ? this.c("\u25A0", "33") : this.dim("\xB7");
+    const status = this.statusLabel(w);
+    const meta = w.steps > 0 ? this.dim(" \xB7 " + (w.status === "running" ? t("swarm.view.step", { n: w.steps }) : t("swarm.view.steps", { n: w.steps }))) : "";
+    const action = w.action ? w.action : this.dim("\u2014");
+    return `  ${icon} ${pad(w.id, 4)} ${pad(status, 12)} ${pad(`[${w.agent}]`, 14)} ${action}${meta}`;
+  }
+  statusLabel(w) {
+    if (w.merge === "conflict") return this.c(t("swarm.view.conflict"), "31");
+    if (w.status === "running") return this.c(t("swarm.view.running"), "36");
+    if (w.status === "done") return this.c(t("swarm.view.done"), "32");
+    if (w.status === "stopped") return this.c(t("swarm.view.stopped"), "33");
+    return this.dim(t("swarm.view.pending"));
+  }
+  /** Redraw the block in place (TTY) by clearing the previous frame first. */
+  flush() {
+    if (!this.tty) return;
+    const lines = this.frameLines();
+    let s = "";
+    if (this.lastLines > 0) s += `\x1B[${this.lastLines}A`;
+    s += "\x1B[0J";
+    s += lines.join("\n") + "\n";
+    this.write(s);
+    this.lastLines = lines.length;
+  }
+  c(s, code) {
+    return this.color ? `\x1B[${code}m${s}${RESET2}` : s;
+  }
+  dim(s) {
+    return this.color ? `\x1B[2m${s}${RESET2}` : s;
+  }
+};
+function pad(s, n) {
+  return s.length >= n ? s : s + " ".repeat(n - s.length);
+}
+
+// src/cli/commands/swarm.ts
+var MIN_SWARM_AGENTS = 3;
+function canSwarm(agentCount) {
+  return agentCount >= MIN_SWARM_AGENTS;
+}
+async function runSwarmSession(task, config, opts = {}) {
+  if (!canSwarm(config.agents.length)) {
+    throw new Error(t("swarm.needsAgents", { min: MIN_SWARM_AGENTS, have: config.agents.length }));
+  }
+  const workspace = opts.workspace ?? process.cwd();
+  const selected = opts.agents?.length ? opts.agents : config.agents.map((a) => a.name);
+  if (selected.length === 0) {
+    throw new Error(t("swarm.noAgents"));
+  }
+  const resolved = selected.map((name) => {
+    const a = config.agents.find((x) => x.name === name);
+    if (!a) throw new Error(t("agent.notFound", { name }));
+    return createProvider(a);
+  });
+  console.log(
+    pc7.dim(t("swarm.status", { agents: resolved.map((a) => a.config.name).join(", "), workspace }))
+  );
+  console.log(pc7.yellow(t("swarm.bypassNote") + "\n"));
+  const view = new SwarmView(resolved[0].config.name);
+  view.start();
+  let result;
+  try {
+    result = await runSwarm({
+      task,
+      workspace,
+      agents: resolved,
+      allow: config.permissions.allow,
+      deny: config.permissions.deny,
+      maxSubtasks: opts.maxSubtasks,
+      events: {
+        onDecomposed: (subtasks) => view.setSubtasks(subtasks),
+        onWorkerStart: (subtask, agentName) => view.workerStart(subtask.id, agentName),
+        onWorkerDone: (outcome) => view.workerDone(outcome),
+        onMerge: (merge) => view.merge(merge),
+        workerEvents: (subtask) => ({
+          onToolCall: (call) => view.workerAction(subtask.id, describeToolCall(call)),
+          onStep: (step) => view.workerStep(subtask.id, step)
+        })
+      }
+    });
+  } finally {
+    view.stop();
+  }
+  console.log("");
+  console.log(pc7.bold("\n" + t("swarm.summary")));
+  for (const o of result.outcomes) {
+    const status = o.finished ? pc7.green(t("swarm.statusDone")) : pc7.yellow(t("swarm.statusIncomplete"));
+    const committed = o.committed ? "" : pc7.dim(` (${t("swarm.noChanges")})`);
+    console.log(`  ${pc7.bold(o.subtask.id)} [${o.agentName}] ${status}${committed} \u2014 ${o.subtask.title}`);
+  }
+  const conflicts = result.merges.filter((m) => !m.ok);
+  if (conflicts.length > 0) {
+    console.log(pc7.red("\n" + t("swarm.conflictsHeader", { n: conflicts.length })));
+    for (const m of conflicts) {
+      console.log(pc7.red(`  ${m.branch}: ${m.conflicts.join(", ")}`));
+    }
+  } else {
+    console.log(pc7.green("\n" + t("swarm.allMerged")));
+  }
+}
+async function swarm(task, opts) {
+  const config = await loadConfig();
+  await runSwarmSession(task, config, {
+    agents: opts.agents ? opts.agents.split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+    maxSubtasks: opts.maxSubtasks ? Number(opts.maxSubtasks) : void 0
+  });
+}
+
+// src/ui/spinner.ts
+var RESET3 = "\x1B[0m";
+var isTTY = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+var FRAMES2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var violet = (s) => isTTY ? `\x1B[38;2;167;139;250m${s}${RESET3}` : s;
+var dim = (s) => isTTY ? `\x1B[2m${s}${RESET3}` : s;
+var Spinner = class {
+  timer;
+  frame = 0;
+  startedAt = 0;
+  label = "";
+  suffix = "";
+  /** Extra dim text appended after the elapsed time (e.g. token count). */
+  setSuffix(suffix) {
+    this.suffix = suffix;
+  }
+  /** Start (or, if already running, just update the label). */
+  start(label) {
+    this.label = label;
+    if (!isTTY) return;
+    if (this.timer) return;
+    this.startedAt = Date.now();
+    this.render();
+    this.timer = setInterval(() => this.render(), 90);
+    this.timer.unref?.();
+  }
+  /** Erase the spinner line and stop animating. */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    if (isTTY) process.stdout.write("\r\x1B[K");
+  }
+  render() {
+    const f = violet(FRAMES2[this.frame = (this.frame + 1) % FRAMES2.length]);
+    const secs = Math.floor((Date.now() - this.startedAt) / 1e3);
+    const time = secs > 0 ? dim(` (${secs}s)`) : "";
+    const suffix = this.suffix ? dim(` \xB7 ${this.suffix}`) : "";
+    process.stdout.write(`\r\x1B[K${f} \u{1F419} ${dim(this.label + "\u2026")}${time}${suffix}`);
+  }
+};
+
+// src/cli/commands/run.ts
+async function run(task, opts) {
+  let config = await loadConfig();
+  const agentConfig = resolveAgent(config, opts.agent);
+  const workspace = process.cwd();
+  const session = {
+    agentName: agentConfig.name,
+    mode: opts.mode ?? config.permissions.mode,
+    allow: config.permissions.allow,
+    deny: config.permissions.deny,
+    allowedCommands: config.permissions.allowedCommands,
+    maxSteps: opts.maxSteps ? Number(opts.maxSteps) : void 0,
+    history: []
+  };
+  const runTask = async (taskText) => {
+    const active = resolveAgent(config, session.agentName);
+    const resolved2 = createProvider(active);
+    await executeTask(taskText, resolved2, workspace, session);
+  };
+  if (task) {
+    const resolved2 = createProvider(agentConfig);
+    console.log(
+      pc8.dim(
+        t("run.status", {
+          name: resolved2.config.name,
+          provider: resolved2.config.provider,
+          model: resolved2.config.model,
+          toolMode: resolved2.toolMode,
+          mode: session.mode
+        })
+      )
+    );
+    await executeTask(task, resolved2, workspace, session);
+    return;
+  }
+  const resolved = createProvider(agentConfig);
+  await printWelcome({
+    agentName: resolved.config.name,
+    provider: resolved.config.provider,
+    model: resolved.config.model,
+    toolMode: resolved.toolMode,
+    mode: session.mode,
+    workspace
+  });
+  const ctx = {
+    session,
+    runTask,
+    runSwarm: (taskText) => runSwarmSession(taskText, config, { workspace }),
+    getConfig: () => config,
+    reload: async () => {
+      config = await loadConfig();
+    }
+  };
+  await startRepl(ctx);
+}
+async function executeTask(task, resolved, workspace, session) {
+  const spinner3 = new Spinner();
+  const controller = new AbortController();
+  const cancel2 = listenForCancel(controller);
+  const permissions = new PermissionEngine({
+    mode: session.mode,
+    policy: { workspace, allow: session.allow, deny: session.deny },
+    allowedCommands: session.allowedCommands,
+    confirm: async (req) => {
+      spinner3.stop();
       cancel2.pause();
       const ok = await confirmAction(req);
       cancel2.resume();
@@ -2642,16 +3299,16 @@ async function executeTask(task, resolved, workspace, session) {
   }
   session.history = result.messages;
   if (result.reason === "finished") {
-    console.log(pc7.green("\n" + t("run.done", { steps: result.steps })) + (result.summary ? ` ${result.summary}` : ""));
+    console.log(pc8.green("\n" + t("run.done", { steps: result.steps })) + (result.summary ? ` ${result.summary}` : ""));
   } else if (result.reason === "cancelled") {
-    console.log(pc7.dim("\n" + t("run.cancelled")));
+    console.log(pc8.dim("\n" + t("run.cancelled")));
   } else if (result.reason === "stalled" || result.reason === "maxsteps") {
-    console.log(pc7.yellow("\n" + t("run.stopped", { steps: result.steps })));
+    console.log(pc8.yellow("\n" + t("run.stopped", { steps: result.steps })));
   }
   if (result.usage.promptTokens || result.usage.completionTokens) {
     const total = result.usage.promptTokens + result.usage.completionTokens;
     console.log(
-      pc7.dim(
+      pc8.dim(
         "\u21B3 " + t("ui.tokens", {
           total: fmtTokens(total),
           in: fmtTokens(result.usage.promptTokens),
@@ -2692,7 +3349,7 @@ function listenForCancel(controller) {
   return { pause: detach, resume: attach, dispose: detach };
 }
 async function confirmAction(req) {
-  if (req.preview) console.log(pc7.dim(req.preview));
+  if (req.preview) console.log(pc8.dim(req.preview));
   const answer = await p2.confirm({ message: t("run.confirm", { summary: req.summary }) });
   if (p2.isCancel(answer)) return false;
   return answer === true;
@@ -2708,26 +3365,26 @@ function renderEvents(spinner3) {
     },
     onAssistantText(text2) {
       spinner3.stop();
-      if (text2.trim()) console.log(pc7.cyan(text2.trim()));
+      if (text2.trim()) console.log(pc8.cyan(text2.trim()));
     },
     onToolCall(call) {
       spinner3.stop();
       const arg = call.name === "run_command" ? call.arguments.command : call.arguments.path;
-      console.log(pc7.dim(`  \u2192 ${call.name}${arg ? ` ${String(arg)}` : ""}`));
+      console.log(pc8.dim(`  \u2192 ${call.name}${arg ? ` ${String(arg)}` : ""}`));
       spinner3.start(t("ui.running", { tool: call.name }));
     },
     onToolResult(_call, result) {
       spinner3.stop();
       const head = result.output.split("\n")[0] ?? "";
-      console.log((result.ok ? pc7.green("    \u2713 ") : pc7.red("    \u2717 ")) + pc7.dim(head.slice(0, 120)));
+      console.log((result.ok ? pc8.green("    \u2713 ") : pc8.red("    \u2717 ")) + pc8.dim(head.slice(0, 120)));
     },
     onReprompt(attempt) {
       spinner3.stop();
-      console.log(pc7.yellow("  " + t("run.reprompt", { attempt })));
+      console.log(pc8.yellow("  " + t("run.reprompt", { attempt })));
     },
     onCorrection() {
       spinner3.stop();
-      console.log(pc7.yellow("    \u21BB " + t("run.autocorrect")));
+      console.log(pc8.yellow("    \u21BB " + t("run.autocorrect")));
     }
   };
 }
@@ -2738,11 +3395,11 @@ async function setup() {
 }
 
 // src/cli/commands/init.ts
-import pc8 from "picocolors";
+import pc9 from "picocolors";
 
 // src/core/scaffold/init.ts
 import { mkdir as mkdir3, writeFile as writeFile4, access } from "fs/promises";
-import { dirname as dirname3, join as join3 } from "path";
+import { dirname as dirname3, join as join5 } from "path";
 
 // src/core/scaffold/templates.ts
 function polyTemplates(locale) {
@@ -2976,458 +3633,54 @@ A mudan\xE7a em termos simples \u2014 o comportamento que o usu\xE1rio vai realm
 
 - \u2026
 `
-};
-
-// src/core/scaffold/init.ts
-async function scaffoldPoly(workspace, opts) {
-  const templates = polyTemplates(opts.locale);
-  const created = [];
-  const skipped = [];
-  for (const [rel, content] of Object.entries(templates)) {
-    const display = `.poly/${rel}`;
-    const abs = join3(workspace, ".poly", ...rel.split("/"));
-    if (!opts.force && await exists(abs)) {
-      skipped.push(display);
-      continue;
-    }
-    await mkdir3(dirname3(abs), { recursive: true });
-    await writeFile4(abs, content, "utf8");
-    created.push(display);
-  }
-  return { created, skipped };
-}
-async function exists(path) {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/cli/commands/init.ts
-async function init(opts) {
-  const { created, skipped } = await scaffoldPoly(process.cwd(), {
-    force: Boolean(opts.force),
-    locale: getLocale()
-  });
-  if (created.length === 0) {
-    console.log(pc8.yellow(t("init.allExist")));
-    for (const f of skipped) console.log(pc8.dim(`  ${f}`));
-    console.log(pc8.dim(t("init.forceHint")));
-    return;
-  }
-  console.log(pc8.green(t("init.created")));
-  for (const f of created) console.log(pc8.dim(`  ${f}`));
-  if (skipped.length > 0) {
-    console.log(pc8.dim(t("init.skipped")));
-    for (const f of skipped) console.log(pc8.dim(`  ${f}`));
-  }
-  console.log("\n" + t("init.tip"));
-}
-
-// src/cli/commands/swarm.ts
-import pc9 from "picocolors";
-
-// src/core/git/worktree.ts
-import { mkdtemp } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join4 } from "path";
-import { simpleGit } from "simple-git";
-async function ensureRepo(workspace) {
-  const git = simpleGit(workspace);
-  if (!await git.checkIsRepo()) {
-    await git.init();
-  }
-  const identity = await identityArgs(git);
-  const hasHead = await git.raw(["rev-parse", "--verify", "HEAD"]).then(() => true).catch(() => false);
-  if (!hasHead) {
-    await git.raw([...identity, "commit", "--allow-empty", "-m", "polypus: initial commit"]);
-  }
-  return git;
-}
-async function identityArgs(git) {
-  const email = await git.raw(["config", "user.email"]).catch(() => "");
-  if (email.trim()) return [];
-  return ["-c", "user.email=polypus@local", "-c", "user.name=Polypus"];
-}
-async function createWorktree(git, label) {
-  const branch = `polypus/${label}-${Date.now().toString(36)}`;
-  const path = await mkdtemp(join4(tmpdir(), "polypus-wt-"));
-  await git.raw(["worktree", "add", "-b", branch, path, "HEAD"]);
-  return { path, branch };
-}
-async function commitWorktree(wt, message) {
-  const wtGit = simpleGit(wt.path);
-  await wtGit.add(["-A"]);
-  const status = await wtGit.status();
-  if (status.staged.length === 0 && status.files.length === 0) return false;
-  const identity = await identityArgs(wtGit);
-  await wtGit.raw([...identity, "commit", "-m", message]);
-  return true;
-}
-async function mergeWorktreeBranch(git, branch) {
-  try {
-    const identity = await identityArgs(git);
-    await git.raw([...identity, "merge", "--no-edit", branch]);
-    return { branch, ok: true, conflicts: [] };
-  } catch (err) {
-    const status = await git.status().catch(() => void 0);
-    const conflicts = status?.conflicted ?? [];
-    await git.raw(["merge", "--abort"]).catch(() => void 0);
-    if (conflicts.length === 0) {
-      throw err;
-    }
-    return { branch, ok: false, conflicts };
-  }
-}
-async function removeWorktree(git, wt) {
-  await git.raw(["worktree", "remove", wt.path, "--force"]).catch(() => void 0);
-  await git.raw(["branch", "-D", wt.branch]).catch(() => void 0);
-}
-
-// src/core/agent/worker.ts
-async function runWorker(subtask, agent, wt, allow, deny, events) {
-  const permissions = new PermissionEngine({
-    mode: "bypass",
-    policy: { workspace: wt.path, allow, deny },
-    allowedCommands: []
-  });
-  const result = await runAgent({
-    task: subtask.brief,
-    workspace: wt.path,
-    agent,
-    permissions,
-    promptContext: { workspace: wt.path, mode: "bypass", allow, briefing: subtask.brief },
-    events
-  });
-  const committed = await commitWorktree(wt, `polypus(${subtask.id}): ${subtask.title}`);
-  return {
-    subtask,
-    agentName: agent.config.name,
-    branch: wt.branch,
-    finished: result.finished,
-    summary: result.summary,
-    committed,
-    steps: result.steps
-  };
-}
-
-// src/core/agent/orchestrator.ts
-async function runSwarm(opts) {
-  const lead = opts.agents[0];
-  if (!lead) throw new Error("Swarm requires at least one agent.");
-  const maxSubtasks = opts.maxSubtasks ?? Math.max(opts.agents.length, 2);
-  const git = await ensureRepo(opts.workspace);
-  const subtasks = await decompose(lead, opts.task, maxSubtasks);
-  opts.events?.onDecomposed?.(subtasks);
-  const worktrees = [];
-  for (const subtask of subtasks) {
-    worktrees.push(await createWorktree(git, subtask.id));
-  }
-  const outcomes = await Promise.all(
-    subtasks.map(async (subtask, i) => {
-      const agent = opts.agents[i % opts.agents.length];
-      const wt = worktrees[i];
-      opts.events?.onWorkerStart?.(subtask, agent.config.name);
-      const outcome = await runWorker(
-        subtask,
-        agent,
-        wt,
-        opts.allow,
-        opts.deny,
-        opts.events?.workerEvents?.(subtask)
-      );
-      opts.events?.onWorkerDone?.(outcome);
-      return outcome;
-    })
-  );
-  const merges = [];
-  for (const outcome of outcomes) {
-    if (!outcome.committed) continue;
-    const merge = await mergeWorktreeBranch(git, outcome.branch);
-    merges.push(merge);
-    opts.events?.onMerge?.(merge);
-  }
-  const conflicted = new Set(merges.filter((m) => !m.ok).map((m) => m.branch));
-  for (const wt of worktrees) {
-    if (conflicted.has(wt.branch)) {
-      await git.raw(["worktree", "remove", wt.path, "--force"]).catch(() => void 0);
-    } else {
-      await removeWorktree(git, wt);
-    }
-  }
-  return { subtasks, outcomes, merges };
-}
-var DECOMPOSE_SYSTEM = [
-  "You are a tech lead splitting a coding task into independent subtasks that can be done in parallel.",
-  'Return ONLY a JSON array. Each item: {"title": string, "brief": string}.',
-  "Make subtasks touch DIFFERENT files/areas to minimize merge conflicts.",
-  "Keep the list small (prefer 2-4 items). Each brief must be self-contained and actionable."
-].join("\n");
-async function decompose(lead, task, maxSubtasks) {
-  try {
-    const res = await lead.provider.chat({
-      messages: [
-        { role: "system", content: DECOMPOSE_SYSTEM },
-        { role: "user", content: `Task:
-${task}
+};
 
-Return at most ${maxSubtasks} subtasks as a JSON array.` }
-      ],
-      params: { temperature: 0 }
-    });
-    const parsed = extractJsonArray(res.content);
-    if (parsed && parsed.length > 0) {
-      return parsed.slice(0, maxSubtasks).map((item, i) => ({
-        id: `t${i + 1}`,
-        title: String(item.title ?? `subtask ${i + 1}`),
-        brief: String(item.brief ?? item.title ?? task)
-      }));
+// src/core/scaffold/init.ts
+async function scaffoldPoly(workspace, opts) {
+  const templates = polyTemplates(opts.locale);
+  const created = [];
+  const skipped = [];
+  for (const [rel, content] of Object.entries(templates)) {
+    const display = `.poly/${rel}`;
+    const abs = join5(workspace, ".poly", ...rel.split("/"));
+    if (!opts.force && await exists(abs)) {
+      skipped.push(display);
+      continue;
     }
-  } catch {
+    await mkdir3(dirname3(abs), { recursive: true });
+    await writeFile4(abs, content, "utf8");
+    created.push(display);
   }
-  return [{ id: "t1", title: "task", brief: task }];
+  return { created, skipped };
 }
-function extractJsonArray(text2) {
-  const start = text2.indexOf("[");
-  const end = text2.lastIndexOf("]");
-  if (start === -1 || end <= start) return null;
+async function exists(path) {
   try {
-    const parsed = JSON.parse(text2.slice(start, end + 1));
-    return Array.isArray(parsed) ? parsed : null;
+    await access(path);
+    return true;
   } catch {
-    return null;
-  }
-}
-
-// src/ui/swarm-view.ts
-var RESET3 = "\x1B[0m";
-var FRAMES2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-function describeToolCall(call) {
-  const raw = call.name === "run_command" ? call.arguments.command : call.arguments.path;
-  const arg = typeof raw === "string" ? raw : "";
-  const short = arg.length > 40 ? arg.slice(0, 39) + "\u2026" : arg;
-  return short ? `${call.name} ${short}` : call.name;
-}
-var SwarmView = class {
-  constructor(leadName, opts = {}) {
-    this.leadName = leadName;
-    this.tty = opts.tty ?? (Boolean(process.stdout.isTTY) && !process.env.NO_COLOR);
-    this.color = opts.color ?? this.tty;
-    this.write = opts.sink ?? ((s) => process.stdout.write(s));
-  }
-  leadName;
-  tty;
-  color;
-  write;
-  workers = /* @__PURE__ */ new Map();
-  order = [];
-  phase = "decomposing";
-  frame = 0;
-  lastLines = 0;
-  timer;
-  start() {
-    if (!this.tty) {
-      this.write(`\u{1F419} ${t("swarm.view.header", { lead: this.leadName })} \u2014 ${t("swarm.view.decomposing")}
-`);
-      return;
-    }
-    this.flush();
-    this.timer = setInterval(() => {
-      this.frame = (this.frame + 1) % FRAMES2.length;
-      this.flush();
-    }, 110);
-    this.timer.unref?.();
-  }
-  setSubtasks(subtasks) {
-    this.phase = "running";
-    for (const s of subtasks) {
-      this.workers.set(s.id, { id: s.id, title: s.title, agent: "", status: "pending", action: "", steps: 0 });
-      this.order.push(s.id);
-    }
-    if (!this.tty) {
-      this.write(`  ${t("swarm.decomposed", { n: subtasks.length })}
-`);
-      for (const s of subtasks) this.write(`  ${s.id}: ${s.title}
-`);
-    }
-    this.flush();
-  }
-  workerStart(id, agent) {
-    const w = this.workers.get(id);
-    if (!w) return;
-    w.agent = agent;
-    w.status = "running";
-    if (!this.tty) this.write(`  \u25B6 ${id} [${agent}] ${w.title}
-`);
-    this.flush();
-  }
-  workerAction(id, action) {
-    const w = this.workers.get(id);
-    if (!w) return;
-    w.action = action;
-    this.flush();
-  }
-  workerStep(id, n) {
-    const w = this.workers.get(id);
-    if (!w) return;
-    w.steps = n;
-    this.flush();
-  }
-  workerDone(o) {
-    const w = this.workers.get(o.subtask.id);
-    if (!w) return;
-    w.status = o.finished ? "done" : "stopped";
-    w.steps = o.steps;
-    w.branch = o.branch;
-    w.action = "";
-    if (!this.tty) {
-      const tag = o.finished ? "\u2713" : "\u25A0";
-      const changes = o.committed ? t("swarm.changesCommitted") : t("swarm.noChanges");
-      this.write(`  ${tag} ${o.subtask.id} (${t("swarm.view.steps", { n: o.steps })}, ${changes})
-`);
-    }
-    this.flush();
-  }
-  merge(r) {
-    for (const w of this.workers.values()) {
-      if (w.branch === r.branch) w.merge = r.ok ? "ok" : "conflict";
-    }
-    if (!this.tty) {
-      this.write(r.ok ? `  \u2935 ${t("swarm.merged", { branch: r.branch })}
-` : `  \u2717 ${t("swarm.mergeConflict", { branch: r.branch })}
-`);
-    }
-    this.flush();
-  }
-  stop() {
-    this.phase = "done";
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = void 0;
-    }
-    this.flush();
-  }
-  /** Content lines of the dashboard (no cursor control). Exposed for tests. */
-  frameLines() {
-    const spin = this.dim(FRAMES2[this.frame]);
-    const lead = `\u{1F419} ${t("swarm.view.header", { lead: this.leadName })}`;
-    const lines = [];
-    if (this.phase === "decomposing") {
-      lines.push(`${spin} ${lead}`);
-      lines.push("  " + this.dim(t("swarm.view.decomposing")));
-      return lines;
-    }
-    lines.push(`${this.phase === "running" ? spin : "  "} ${lead}`);
-    lines.push("");
-    for (const id of this.order) {
-      const w = this.workers.get(id);
-      lines.push(this.row(w, spin));
-    }
-    return lines;
-  }
-  // -------------------------------------------------------------------------
-  row(w, spin) {
-    const icon = w.status === "running" ? spin : w.status === "done" ? this.c("\u2713", "32") : w.status === "stopped" ? this.c("\u25A0", "33") : this.dim("\xB7");
-    const status = this.statusLabel(w);
-    const meta = w.steps > 0 ? this.dim(" \xB7 " + (w.status === "running" ? t("swarm.view.step", { n: w.steps }) : t("swarm.view.steps", { n: w.steps }))) : "";
-    const action = w.action ? w.action : this.dim("\u2014");
-    return `  ${icon} ${pad(w.id, 4)} ${pad(status, 12)} ${pad(`[${w.agent}]`, 14)} ${action}${meta}`;
-  }
-  statusLabel(w) {
-    if (w.merge === "conflict") return this.c(t("swarm.view.conflict"), "31");
-    if (w.status === "running") return this.c(t("swarm.view.running"), "36");
-    if (w.status === "done") return this.c(t("swarm.view.done"), "32");
-    if (w.status === "stopped") return this.c(t("swarm.view.stopped"), "33");
-    return this.dim(t("swarm.view.pending"));
-  }
-  /** Redraw the block in place (TTY) by clearing the previous frame first. */
-  flush() {
-    if (!this.tty) return;
-    const lines = this.frameLines();
-    let s = "";
-    if (this.lastLines > 0) s += `\x1B[${this.lastLines}A`;
-    s += "\x1B[0J";
-    s += lines.join("\n") + "\n";
-    this.write(s);
-    this.lastLines = lines.length;
-  }
-  c(s, code) {
-    return this.color ? `\x1B[${code}m${s}${RESET3}` : s;
-  }
-  dim(s) {
-    return this.color ? `\x1B[2m${s}${RESET3}` : s;
+    return false;
   }
-};
-function pad(s, n) {
-  return s.length >= n ? s : s + " ".repeat(n - s.length);
 }
 
-// src/cli/commands/swarm.ts
-var MIN_SWARM_AGENTS = 3;
-function canSwarm(agentCount) {
-  return agentCount >= MIN_SWARM_AGENTS;
-}
-async function swarm(task, opts) {
-  const config = await loadConfig();
-  if (!canSwarm(config.agents.length)) {
-    throw new Error(t("swarm.needsAgents", { min: MIN_SWARM_AGENTS, have: config.agents.length }));
-  }
-  const selected = opts.agents ? opts.agents.split(",").map((s) => s.trim()).filter(Boolean) : config.agents.map((a) => a.name);
-  if (selected.length === 0) {
-    throw new Error(t("swarm.noAgents"));
-  }
-  const resolved = selected.map((name) => {
-    const a = config.agents.find((x) => x.name === name);
-    if (!a) throw new Error(t("agent.notFound", { name }));
-    return createProvider(a);
+// src/cli/commands/init.ts
+async function init(opts) {
+  const { created, skipped } = await scaffoldPoly(process.cwd(), {
+    force: Boolean(opts.force),
+    locale: getLocale()
   });
-  console.log(
-    pc9.dim(t("swarm.status", { agents: resolved.map((a) => a.config.name).join(", "), workspace: process.cwd() }))
-  );
-  console.log(pc9.yellow(t("swarm.bypassNote") + "\n"));
-  const view = new SwarmView(resolved[0].config.name);
-  view.start();
-  let result;
-  try {
-    result = await runSwarm({
-      task,
-      workspace: process.cwd(),
-      agents: resolved,
-      allow: config.permissions.allow,
-      deny: config.permissions.deny,
-      maxSubtasks: opts.maxSubtasks ? Number(opts.maxSubtasks) : void 0,
-      events: {
-        onDecomposed: (subtasks) => view.setSubtasks(subtasks),
-        onWorkerStart: (subtask, agentName) => view.workerStart(subtask.id, agentName),
-        onWorkerDone: (outcome) => view.workerDone(outcome),
-        onMerge: (merge) => view.merge(merge),
-        workerEvents: (subtask) => ({
-          onToolCall: (call) => view.workerAction(subtask.id, describeToolCall(call)),
-          onStep: (step) => view.workerStep(subtask.id, step)
-        })
-      }
-    });
-  } finally {
-    view.stop();
-  }
-  console.log("");
-  console.log(pc9.bold("\n" + t("swarm.summary")));
-  for (const o of result.outcomes) {
-    const status = o.finished ? pc9.green(t("swarm.statusDone")) : pc9.yellow(t("swarm.statusIncomplete"));
-    const committed = o.committed ? "" : pc9.dim(` (${t("swarm.noChanges")})`);
-    console.log(`  ${pc9.bold(o.subtask.id)} [${o.agentName}] ${status}${committed} \u2014 ${o.subtask.title}`);
+  if (created.length === 0) {
+    console.log(pc9.yellow(t("init.allExist")));
+    for (const f of skipped) console.log(pc9.dim(`  ${f}`));
+    console.log(pc9.dim(t("init.forceHint")));
+    return;
   }
-  const conflicts = result.merges.filter((m) => !m.ok);
-  if (conflicts.length > 0) {
-    console.log(pc9.red("\n" + t("swarm.conflictsHeader", { n: conflicts.length })));
-    for (const m of conflicts) {
-      console.log(pc9.red(`  ${m.branch}: ${m.conflicts.join(", ")}`));
-    }
-  } else {
-    console.log(pc9.green("\n" + t("swarm.allMerged")));
+  console.log(pc9.green(t("init.created")));
+  for (const f of created) console.log(pc9.dim(`  ${f}`));
+  if (skipped.length > 0) {
+    console.log(pc9.dim(t("init.skipped")));
+    for (const f of skipped) console.log(pc9.dim(`  ${f}`));
   }
+  console.log("\n" + t("init.tip"));
 }
 
 // src/cli/commands/models.ts
@@ -3489,7 +3742,7 @@ async function resolveOpenRouterKey() {
 }
 
 // src/cli/commands/prd.ts
-import { writeFile as writeFile5, readFile as readFile6 } from "fs/promises";
+import { writeFile as writeFile5, readFile as readFile7 } from "fs/promises";
 import { execFile } from "child_process";
 import { promisify as promisify2 } from "util";
 import pc11 from "picocolors";
@@ -3581,13 +3834,13 @@ async function withRetry(fn, opts = {}) {
 
 // src/cli/commands/cli-io.ts
 import { readFileSync, existsSync as existsSync2 } from "fs";
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 var GUIDE_MAX = 12e3;
 function readProjectGuide(files) {
   const parts = [];
   for (const file of files) {
     try {
-      const path = resolve7(process.cwd(), file);
+      const path = resolve8(process.cwd(), file);
       if (existsSync2(path)) parts.push(`# ${file}
 ${readFileSync(path, "utf8").trim()}`);
     } catch {
@@ -3628,7 +3881,7 @@ async function prd(issueRef, opts) {
 }
 async function loadIssue(issueRef, input) {
   if (input) {
-    const raw = input === "-" ? await readStdin() : await readFile6(input, "utf8");
+    const raw = input === "-" ? await readStdin() : await readFile7(input, "utf8");
     return normalize2(JSON.parse(stripBom(raw)));
   }
   const num = numericRef(issueRef);
@@ -3647,7 +3900,7 @@ function normalize2(raw) {
 }
 
 // src/cli/commands/review.ts
-import { writeFile as writeFile6, readFile as readFile7 } from "fs/promises";
+import { writeFile as writeFile6, readFile as readFile8 } from "fs/promises";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify3 } from "util";
 import pc12 from "picocolors";
@@ -3723,7 +3976,7 @@ async function review(prRef, opts) {
   }
 }
 async function loadDiff(num, input) {
-  if (input) return input === "-" ? readStdin() : readFile7(input, "utf8");
+  if (input) return input === "-" ? readStdin() : readFile8(input, "utf8");
   const { stdout: stdout2 } = await exec3("gh", ["pr", "diff", num]);
   return stdout2;
 }
@@ -3735,7 +3988,7 @@ async function loadMeta(num, input) {
 }
 
 // src/cli/index.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/core/config/dotenv.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
@@ -3804,7 +4057,7 @@ function buildProgram() {
 }
 async function main() {
   try {
-    loadDotenv([join5(configDir(), ".env"), join5(process.cwd(), ".env")]);
+    loadDotenv([join6(configDir(), ".env"), join6(process.cwd(), ".env")]);
     await resolveLocale();
     await buildProgram().parseAsync(process.argv);
   } catch (err) {