@gaberrb/polypus 0.3.0 → 0.4.1

package/dist/index.js

@@ -2,8 +2,7 @@
 
 // src/cli/index.ts
 import { Command } from "commander";
-import { createRequire } from "module";
-import pc12 from "picocolors";
+import pc13 from "picocolors";
 
 // src/cli/commands/add-agent.ts
 import pc from "picocolors";
@@ -74,11 +73,13 @@ var en = {
   "cli.description": "Agentic coding harness that makes any AI API generate and apply code \u2014 OpenRouter, Ollama, and any OpenAI-compatible endpoint.",
   "cli.opt.lang": "interface language: pt-BR | en",
   "cli.cmd.setup": "Interactive setup wizard (configure agents, keys, permissions)",
+  "cli.cmd.init": "Scaffold a .poly/ workspace (agents.md, skills, SDD spec template, README)",
+  "cli.opt.force": "overwrite files that already exist",
   "cli.cmd.addAgent": "Register a new agent (API key + model)",
   "cli.cmd.removeAgent": "Remove a configured agent",
   "cli.cmd.listAgents": "List configured agents",
   "cli.cmd.run": "Run a coding task with an agent",
-  "cli.cmd.swarm": "Split a task across multiple agents working in parallel git worktrees",
+  "cli.cmd.swarm": "Split a task across multiple agents working in parallel git worktrees (requires 3+ configured agents)",
   "cli.cmd.models": "Browse OpenRouter models (price, context, tool support)",
   "cli.cmd.prd": "Generate a PRD from a GitHub issue (uses a free OpenRouter model)",
   "cli.arg.prdIssue": "issue number to turn into a PRD",
@@ -142,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.",
@@ -155,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",
@@ -164,6 +167,7 @@ var en = {
   ].join("\n"),
   // swarm
   "swarm.noAgents": "No agents configured. Run `polypus setup` or `polypus add-agent` first.",
+  "swarm.needsAgents": "Swarm mode needs at least {min} configured agents (you have {have}). Add more with `polypus add-agent`, or use `polypus run` for a single agent.",
   "swarm.status": "swarm agents=[{agents}] workspace={workspace}",
   "swarm.bypassNote": "Workers run in bypass mode inside isolated git worktrees; branches are merged at the end.",
   "swarm.decomposed": "Decomposed into {n} subtask(s):",
@@ -189,6 +193,12 @@ var en = {
   "swarm.conflictsHeader": "\u26A0 {n} branch(es) had merge conflicts (kept for inspection):",
   "swarm.statusDone": "done",
   "swarm.statusIncomplete": "incomplete",
+  // init
+  "init.created": "\u2713 .poly scaffolded:",
+  "init.skipped": "Kept (already existed):",
+  "init.allExist": "Nothing to do \u2014 .poly already has these files:",
+  "init.forceHint": "Run `polypus init --force` to overwrite them.",
+  "init.tip": "Tip: edit .poly/agents.md \u2014 Polypus loads it into the agent's context automatically.",
   // wizard
   "wizard.title": " polypus setup ",
   "wizard.intro": [
@@ -274,7 +284,8 @@ var en = {
   "welcome.hints": "Type your task and press Enter  \xB7  ESC cancels  \xB7  /help  \xB7  /exit",
   "welcome.firstRun": "No agents configured yet \u2014 let's set you up.",
   // agent system prompt
-  "prompt.language": "Communicate with the user in {language}."
+  "prompt.language": "Communicate with the user in {language}.",
+  "prompt.projectInstructions": "Project-specific operating instructions follow, loaded from `.poly/agents.md`. Treat them as authoritative for how to work in THIS repo. Paths they reference (e.g. skills/*.md, ../context.md, ../rules.md) are relative to the `.poly/` directory \u2014 read those files when relevant before acting:"
 };
 var ptBR = {
   "common.default": "padr\xE3o",
@@ -283,11 +294,13 @@ var ptBR = {
   "cli.description": "Harness ag\xEAntico que faz qualquer API de IA gerar e aplicar c\xF3digo \u2014 OpenRouter, Ollama e qualquer endpoint compat\xEDvel com OpenAI.",
   "cli.opt.lang": "idioma da interface: pt-BR | en",
   "cli.cmd.setup": "Assistente de configura\xE7\xE3o interativo (agentes, chaves, permiss\xF5es)",
+  "cli.cmd.init": "Cria um workspace .poly/ (agents.md, skills, template de spec SDD, README)",
+  "cli.opt.force": "sobrescreve arquivos que j\xE1 existem",
   "cli.cmd.addAgent": "Cadastra um novo agente (chave de API + modelo)",
   "cli.cmd.removeAgent": "Remove um agente configurado",
   "cli.cmd.listAgents": "Lista os agentes configurados",
   "cli.cmd.run": "Executa uma tarefa de c\xF3digo com um agente",
-  "cli.cmd.swarm": "Divide uma tarefa entre v\xE1rios agentes trabalhando em paralelo em git worktrees",
+  "cli.cmd.swarm": "Divide uma tarefa entre v\xE1rios agentes em git worktrees paralelas (requer 3+ agentes configurados)",
   "cli.cmd.models": "Explora os modelos do OpenRouter (pre\xE7o, contexto, suporte a tools)",
   "cli.cmd.prd": "Gera um PRD a partir de uma issue do GitHub (usa um modelo gratuito do OpenRouter)",
   "cli.arg.prdIssue": "n\xFAmero da issue para transformar em PRD",
@@ -348,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.",
@@ -361,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",
@@ -369,6 +384,7 @@ var ptBR = {
     "Qualquer outra coisa \xE9 enviada ao agente como tarefa."
   ].join("\n"),
   "swarm.noAgents": "Nenhum agente configurado. Rode `polypus setup` ou `polypus add-agent` primeiro.",
+  "swarm.needsAgents": "O modo swarm precisa de pelo menos {min} agentes configurados (voc\xEA tem {have}). Adicione mais com `polypus add-agent`, ou use `polypus run` para um agente s\xF3.",
   "swarm.status": "swarm agentes=[{agents}] workspace={workspace}",
   "swarm.bypassNote": "Os workers rodam em modo bypass dentro de git worktrees isoladas; os branches s\xE3o mesclados no final.",
   "swarm.decomposed": "Dividido em {n} subtarefa(s):",
@@ -394,6 +410,12 @@ var ptBR = {
   "swarm.conflictsHeader": "\u26A0 {n} branch(es) tiveram conflitos de merge (mantidos para inspe\xE7\xE3o):",
   "swarm.statusDone": "ok",
   "swarm.statusIncomplete": "incompleta",
+  // init
+  "init.created": "\u2713 .poly criado:",
+  "init.skipped": "Mantidos (j\xE1 existiam):",
+  "init.allExist": "Nada a fazer \u2014 o .poly j\xE1 tem estes arquivos:",
+  "init.forceHint": "Rode `polypus init --force` para sobrescrev\xEA-los.",
+  "init.tip": "Dica: edite o .poly/agents.md \u2014 o Polypus carrega ele no contexto do agente automaticamente.",
   "wizard.title": " configura\xE7\xE3o do polypus ",
   "wizard.intro": [
     "O Polypus comanda qualquer API de IA para ler e escrever c\xF3digo neste tipo de projeto.",
@@ -455,6 +477,7 @@ var ptBR = {
   "wizard.envInvalid": "Use letras, d\xEDgitos e sublinhados",
   "wizard.keyPrompt": "Chave de API (armazenada em texto puro no arquivo de config)",
   "prompt.language": "Comunique-se com o usu\xE1rio em {language}.",
+  "prompt.projectInstructions": "Seguem instru\xE7\xF5es operacionais espec\xEDficas do projeto, carregadas de `.poly/agents.md`. Trate-as como autoritativas para trabalhar NESTE reposit\xF3rio. Os caminhos que elas citam (ex.: skills/*.md, ../context.md, ../rules.md) s\xE3o relativos \xE0 pasta `.poly/` \u2014 leia esses arquivos quando relevante antes de agir:",
   "models.fetching": "Buscando modelos do OpenRouter\u2026",
   "models.fetchError": "N\xE3o foi poss\xEDvel buscar modelos: {msg}",
   "models.none": "Nenhum modelo corresponde aos filtros.",
@@ -669,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
@@ -1025,6 +1048,10 @@ function basePreamble(ctx) {
     "- Do not ask for permission and do not say you cannot edit files \u2014 you can. Just emit the tool calls.",
     "- Make the changes directly. When the task is fully done, call the `finish` tool with a short summary.",
     t("prompt.language", { language: LOCALE_NAMES[getLocale()] }),
+    ctx.projectInstructions ? `
+${t("prompt.projectInstructions")}
+
+${ctx.projectInstructions}` : "",
     ctx.briefing ? `
 Your assigned task:
 ${ctx.briefing}` : ""
@@ -1668,6 +1695,23 @@ function formatSchema(spec) {
   return lines.join("\n") || "  (no parameters)";
 }
 
+// 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"];
+var MAX_CHARS2 = 8e3;
+async function loadProjectInstructions(workspace) {
+  for (const rel of INSTRUCTION_FILES) {
+    try {
+      const raw = (await readFile5(join2(workspace, rel), "utf8")).trim();
+      if (!raw) continue;
+      return raw.length > MAX_CHARS2 ? raw.slice(0, MAX_CHARS2) + "\n\u2026(truncated)" : raw;
+    } catch {
+    }
+  }
+  return void 0;
+}
+
 // src/core/agent/loop.ts
 function looksLikeStall(text2) {
   const lc = text2.toLowerCase();
@@ -1710,10 +1754,12 @@ async function runAgent(opts) {
   const maxReprompts = opts.maxReprompts ?? 3;
   const driver = makeDriver(agent.toolMode, toolSpecs());
   const ctx = { workspace: opts.workspace, permissions };
-  const messages = opts.history && opts.history.length > 0 ? [...opts.history, { role: "user", content: opts.task }] : [
-    { role: "system", content: driver.systemPrompt(opts.promptContext) },
+  const seeding = !(opts.history && opts.history.length > 0);
+  const promptContext = seeding && opts.promptContext.projectInstructions === void 0 ? { ...opts.promptContext, projectInstructions: await loadProjectInstructions(opts.workspace) } : opts.promptContext;
+  const messages = seeding ? [
+    { role: "system", content: driver.systemPrompt(promptContext) },
     { role: "user", content: opts.task }
-  ];
+  ] : [...opts.history, { role: "user", content: opts.task }];
   let consecutiveNoTool = 0;
   let lastFailSig = "";
   let failStreak = 0;
@@ -1818,8 +1864,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
@@ -2182,6 +2226,23 @@ async function promptApiKey(provider) {
 
 // src/ui/banner.ts
 import pc5 from "picocolors";
+
+// src/core/version.ts
+import { createRequire } from "module";
+function resolveVersion() {
+  const require2 = createRequire(import.meta.url);
+  for (const rel of ["../package.json", "../../package.json"]) {
+    try {
+      const version = require2(rel).version;
+      if (typeof version === "string" && version.length > 0) return version;
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
+var VERSION = resolveVersion();
+
+// src/ui/banner.ts
 var RESET = "\x1B[0m";
 var useColor = (Boolean(process.stdout.isTTY) || Boolean(process.env.FORCE_COLOR)) && !process.env.NO_COLOR;
 var animated = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR && !process.env.POLYPUS_NO_ANIM;
@@ -2255,7 +2316,7 @@ function colorChar(rowIdx, ch) {
 function renderArtRow(rowIdx, line) {
   return [...center(line)].map((ch) => colorChar(rowIdx, ch)).join("");
 }
-var tagline = () => c1(t("welcome.tagline")) + pc5.dim("   v0.1.0");
+var tagline = () => c1(t("welcome.tagline")) + pc5.dim(`   v${VERSION}`);
 function authorLine() {
   return pc5.dim("by ") + c2(AUTHOR.name) + pc5.dim("  \xB7  ") + c1(AUTHOR.github) + pc5.dim("  \xB7  ") + c1(AUTHOR.linkedin);
 }
@@ -2324,6 +2385,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((resolve8) => {
+      rl.question(prompt).then(resolve8, () => resolve8(null));
+      rl.on("SIGINT", () => resolve8(null));
+      rl.on("close", () => resolve8(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 (; ; ) {
@@ -2353,16 +2544,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) {
@@ -2387,6 +2568,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;
@@ -2450,125 +2643,537 @@ 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 join3 } 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(join3(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();
-      cancel2.pause();
-      const ok = await confirmAction(req);
-      cancel2.resume();
-      return ok;
-    }
-  });
-  spinner3.start(t("ui.thinking"));
-  let result;
-  try {
-    result = await runAgent({
-      task,
-      workspace,
+
+// 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();
+      return ok;
+    }
+  });
+  spinner3.start(t("ui.thinking"));
+  let result;
+  try {
+    result = await runAgent({
+      task,
+      workspace,
       agent: resolved,
       permissions,
       promptContext: { workspace, mode: session.mode, allow: session.allow },
@@ -2583,16 +3188,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),
@@ -2633,7 +3238,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;
@@ -2649,26 +3254,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")));
     }
   };
 }
@@ -2678,405 +3283,297 @@ async function setup() {
   await runWizard();
 }
 
-// src/cli/commands/swarm.ts
-import pc8 from "picocolors";
+// src/cli/commands/init.ts
+import pc9 from "picocolors";
 
-// src/core/git/worktree.ts
-import { mkdtemp } from "fs/promises";
-import { tmpdir } from "os";
-import { join as join2 } 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(join2(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/scaffold/init.ts
+import { mkdir as mkdir3, writeFile as writeFile4, access } from "fs/promises";
+import { dirname as dirname3, join as join4 } from "path";
 
-// 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/scaffold/templates.ts
+function polyTemplates(locale) {
+  return locale === "pt-BR" ? PT : EN;
 }
+var EN = {
+  "agents.md": `# agents.md \u2014 how an AI agent operates this repo
 
-// 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}
+> Local workspace under \`.poly/\`. Conditions any AI agent (Polypus, Claude, \u2026)
+> to work the way this project expects. **Polypus loads this file automatically**
+> into the agent's system prompt on every run, so keep it accurate and lean.
+
+## Role
+
+You implement changes end to end \u2014 from understanding the task to a reviewable
+result \u2014 respecting the rules below.
+
+## Golden rules
+
+1. Green before a PR: the project builds, type-checks and tests pass.
+2. Keep docs/changelog in sync with behavior changes.
+3. Confirm before irreversible actions (publishing, deleting, force-pushing).
+4. Small, targeted changes over broad rewrites.
+
+## Skills index
+
+| Skill | When to use |
+|-------|-------------|
+| [skills/coding.md](skills/coding.md) | Technical standards for any code change |
+| [skills/spec-driven.md](skills/spec-driven.md) | Write a spec before non-trivial work |
+
+## Environment
+
+- Describe the OS, shell, package manager and any tooling the agent needs.
+- Note where credentials/CLIs live and how commands are run.
+`,
+  "README.md": `# .poly \u2014 your project's AI operating manual
+
+\`.poly/\` is a small, local workspace that teaches AI agents how to work in THIS
+repository. Gitignore it to keep it personal, or commit it to standardize the
+workflow across your team.
+
+## What's inside
+
+- **\`agents.md\`** \u2014 the entry point: role, golden rules and an index of skills.
+  Polypus loads it automatically into the agent's system prompt on every run.
+- **\`skills/\`** \u2014 focused how-to guides the agent reads when relevant.
+- **\`templates/spec.md\`** \u2014 a lean Spec-Driven Development (SDD) template.
+
+## How it works
+
+1. You describe a task to the agent.
+2. The agent reads \`agents.md\`, follows the golden rules and opens the skills it needs.
+3. For non-trivial work, it writes a spec first from \`templates/spec.md\`.
+
+## Extend it
+
+- Edit \`agents.md\` to encode your conventions.
+- Add one skill file per recurring workflow (releases, reviews, migrations\u2026).
+- Reference new skills from \`agents.md\` so the agent can discover them.
+
+Regenerate any missing files with \`polypus init\` (existing files are preserved;
+use \`--force\` to overwrite).
+`,
+  "skills/coding.md": `# skill: coding
+
+Technical standards for changes in this repo.
+
+## Principles
+
+- Match the style, naming and structure of the surrounding code.
+- Prefer small, targeted edits over broad rewrites.
+- Add or update tests with every behavior change.
+
+## Checklist before opening a PR
+
+- [ ] Builds and type-checks
+- [ ] Tests pass
+- [ ] Docs / changelog updated when behavior changed
+`,
+  "skills/spec-driven.md": `# skill: spec-driven development
+
+For anything non-trivial, write a short spec BEFORE coding.
+
+## Flow
+
+1. Copy \`templates/spec.md\` into your issue (or \`specs/<slug>.md\`).
+2. Fill **Why / What / Acceptance criteria / Out of scope**.
+3. Get a thumbs-up, then implement to the acceptance criteria.
+4. Keep the spec updated if scope changes.
+
+Lean by design: if a section is empty, delete it.
+`,
+  "templates/spec.md": `# Spec: <title>
+
+> Status: draft \xB7 Owner: <name> \xB7 Updated: <yyyy-mm-dd>
+
+## Why
+
+What problem are we solving, and for whom? Why now?
+
+## What
+
+The change in plain terms \u2014 the behavior a user will actually see.
+
+## Acceptance criteria
+
+- [ ] Observable outcome 1
+- [ ] Observable outcome 2
+
+## Out of scope
+
+- Things we are explicitly NOT doing here.
+
+## Notes / open questions
+
+- \u2026
+`
+};
+var PT = {
+  "agents.md": `# agents.md \u2014 como um agente de IA opera este reposit\xF3rio
+
+> Workspace local em \`.poly/\`. Condiciona qualquer agente de IA (Polypus, Claude\u2026)
+> a trabalhar do jeito que este projeto espera. **O Polypus carrega este arquivo
+> automaticamente** no system prompt do agente a cada execu\xE7\xE3o \u2014 mantenha-o
+> preciso e enxuto.
+
+## Papel
+
+Voc\xEA implementa mudan\xE7as de ponta a ponta \u2014 do entendimento da tarefa a um
+resultado revis\xE1vel \u2014 respeitando as regras abaixo.
+
+## Regras de ouro
+
+1. Verde antes do PR: o projeto builda, passa no type-check e nos testes.
+2. Mantenha docs/changelog em sincronia com mudan\xE7as de comportamento.
+3. Confirme antes de a\xE7\xF5es irrevers\xEDveis (publicar, deletar, force-push).
+4. Mudan\xE7as pequenas e focadas em vez de reescritas amplas.
+
+## \xCDndice de skills
+
+| Skill | Quando usar |
+|-------|-------------|
+| [skills/coding.md](skills/coding.md) | Padr\xF5es t\xE9cnicos para qualquer mudan\xE7a de c\xF3digo |
+| [skills/spec-driven.md](skills/spec-driven.md) | Escrever um spec antes de trabalho n\xE3o-trivial |
+
+## Ambiente
+
+- Descreva SO, shell, gerenciador de pacotes e ferramentas que o agente precisa.
+- Anote onde ficam credenciais/CLIs e como os comandos s\xE3o executados.
+`,
+  "README.md": `# .poly \u2014 o manual de opera\xE7\xE3o de IA do seu projeto
+
+O \`.poly/\` \xE9 um workspace local e pequeno que ensina agentes de IA a trabalhar
+NESTE reposit\xF3rio. Coloque no .gitignore para mant\xEA-lo pessoal, ou commite para
+padronizar o fluxo entre o time.
+
+## O que tem dentro
+
+- **\`agents.md\`** \u2014 o ponto de entrada: papel, regras de ouro e um \xEDndice de skills.
+  O Polypus carrega ele automaticamente no system prompt do agente a cada execu\xE7\xE3o.
+- **\`skills/\`** \u2014 guias pr\xE1ticos e focados que o agente l\xEA quando relevante.
+- **\`templates/spec.md\`** \u2014 um template enxuto de Spec-Driven Development (SDD).
+
+## Como funciona
+
+1. Voc\xEA descreve uma tarefa ao agente.
+2. O agente l\xEA o \`agents.md\`, segue as regras de ouro e abre as skills necess\xE1rias.
+3. Para trabalho n\xE3o-trivial, escreve um spec primeiro a partir de \`templates/spec.md\`.
+
+## Como estender
+
+- Edite o \`agents.md\` para codificar suas conven\xE7\xF5es.
+- Adicione um arquivo de skill por fluxo recorrente (releases, reviews, migra\xE7\xF5es\u2026).
+- Referencie as novas skills no \`agents.md\` para o agente descobri-las.
+
+Regenere arquivos que faltarem com \`polypus init\` (os existentes s\xE3o preservados;
+use \`--force\` para sobrescrever).
+`,
+  "skills/coding.md": `# skill: coding
 
-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)
-      }));
+Padr\xF5es t\xE9cnicos para mudan\xE7as neste reposit\xF3rio.
+
+## Princ\xEDpios
+
+- Siga o estilo, a nomenclatura e a estrutura do c\xF3digo ao redor.
+- Prefira edi\xE7\xF5es pequenas e focadas a reescritas amplas.
+- Adicione ou atualize testes a cada mudan\xE7a de comportamento.
+
+## Checklist antes de abrir um PR
+
+- [ ] Builda e passa no type-check
+- [ ] Testes passam
+- [ ] Docs / changelog atualizados quando o comportamento mudou
+`,
+  "skills/spec-driven.md": `# skill: spec-driven development
+
+Para qualquer coisa n\xE3o-trivial, escreva um spec curto ANTES de codar.
+
+## Fluxo
+
+1. Copie \`templates/spec.md\` para a issue (ou \`specs/<slug>.md\`).
+2. Preencha **Por qu\xEA / O qu\xEA / Crit\xE9rios de aceite / Fora de escopo**.
+3. Valide com um "ok", ent\xE3o implemente at\xE9 os crit\xE9rios de aceite.
+4. Mantenha o spec atualizado se o escopo mudar.
+
+Enxuto por design: se uma se\xE7\xE3o ficar vazia, apague-a.
+`,
+  "templates/spec.md": `# Spec: <t\xEDtulo>
+
+> Status: rascunho \xB7 Dono: <nome> \xB7 Atualizado: <aaaa-mm-dd>
+
+## Por qu\xEA
+
+Que problema estamos resolvendo, e para quem? Por que agora?
+
+## O qu\xEA
+
+A mudan\xE7a em termos simples \u2014 o comportamento que o usu\xE1rio vai realmente ver.
+
+## Crit\xE9rios de aceite
+
+- [ ] Resultado observ\xE1vel 1
+- [ ] Resultado observ\xE1vel 2
+
+## Fora de escopo
+
+- Coisas que explicitamente N\xC3O faremos aqui.
+
+## Notas / d\xFAvidas em aberto
+
+- \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 = join4(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
-async function swarm(task, opts) {
-  const config = await loadConfig();
-  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(
-    pc8.dim(t("swarm.status", { agents: resolved.map((a) => a.config.name).join(", "), workspace: process.cwd() }))
-  );
-  console.log(pc8.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(pc8.bold("\n" + t("swarm.summary")));
-  for (const o of result.outcomes) {
-    const status = o.finished ? pc8.green(t("swarm.statusDone")) : pc8.yellow(t("swarm.statusIncomplete"));
-    const committed = o.committed ? "" : pc8.dim(` (${t("swarm.noChanges")})`);
-    console.log(`  ${pc8.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(pc8.red("\n" + t("swarm.conflictsHeader", { n: conflicts.length })));
-    for (const m of conflicts) {
-      console.log(pc8.red(`  ${m.branch}: ${m.conflicts.join(", ")}`));
-    }
-  } else {
-    console.log(pc8.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
-import pc9 from "picocolors";
+import pc10 from "picocolors";
 import * as p3 from "@clack/prompts";
 async function models(opts) {
   const apiKey = await resolveOpenRouterKey();
@@ -3085,9 +3582,9 @@ async function models(opts) {
   let all;
   try {
     all = await listOpenRouterModels(apiKey);
-    spin.stop(pc9.green("\u2713 OpenRouter"));
+    spin.stop(pc10.green("\u2713 OpenRouter"));
   } catch (err) {
-    spin.stop(pc9.red(t("models.fetchError", { msg: err.message })), 2);
+    spin.stop(pc10.red(t("models.fetchError", { msg: err.message })), 2);
     return;
   }
   const filtered = filterModels(all, {
@@ -3101,26 +3598,26 @@ async function models(opts) {
   printModelsTable(filtered, limit, all.length);
 }
 function printModelsTable(models2, limit, total) {
-  console.log(pc9.dim(t("models.legend")));
+  console.log(pc10.dim(t("models.legend")));
   if (models2.length === 0) {
-    console.log(pc9.yellow(t("models.none")));
+    console.log(pc10.yellow(t("models.none")));
     return;
   }
   const rows = models2.slice(0, limit);
   console.log(
-    "  " + pc9.dim(t("models.colTools").padEnd(6)) + pc9.dim(t("models.colPrice").padEnd(16)) + pc9.dim(t("models.colCtx").padEnd(9)) + pc9.dim(t("models.colModel"))
+    "  " + pc10.dim(t("models.colTools").padEnd(6)) + pc10.dim(t("models.colPrice").padEnd(16)) + pc10.dim(t("models.colCtx").padEnd(9)) + pc10.dim(t("models.colModel"))
   );
   for (const m of rows) {
     console.log("  " + modelRow(m));
   }
-  console.log(pc9.dim("\n" + t("models.shown", { shown: rows.length, total })));
+  console.log(pc10.dim("\n" + t("models.shown", { shown: rows.length, total })));
 }
 function modelRow(m) {
-  const tools = m.supportsTools ? pc9.green("\u{1F6E0}".padEnd(5)) : pc9.dim("\u2014".padEnd(5));
+  const tools = m.supportsTools ? pc10.green("\u{1F6E0}".padEnd(5)) : pc10.dim("\u2014".padEnd(5));
   const price = `${fmtPrice(m.promptPrice)}/${fmtPrice(m.completionPrice)}`;
-  const priceColored = (m.free ? pc9.green : pc9.yellow)(price.padEnd(16));
-  const ctx = pc9.cyan(fmtContext(m.contextLength).padEnd(9));
-  return `${tools} ${priceColored}${ctx}${pc9.bold(m.id)}`;
+  const priceColored = (m.free ? pc10.green : pc10.yellow)(price.padEnd(16));
+  const ctx = pc10.cyan(fmtContext(m.contextLength).padEnd(9));
+  return `${tools} ${priceColored}${ctx}${pc10.bold(m.id)}`;
 }
 async function resolveOpenRouterKey() {
   if (process.env.OPENROUTER_API_KEY) return process.env.OPENROUTER_API_KEY;
@@ -3134,10 +3631,10 @@ async function resolveOpenRouterKey() {
 }
 
 // src/cli/commands/prd.ts
-import { writeFile as writeFile4, readFile as readFile5 } from "fs/promises";
+import { writeFile as writeFile5, readFile as readFile6 } from "fs/promises";
 import { execFile } from "child_process";
 import { promisify as promisify2 } from "util";
-import pc10 from "picocolors";
+import pc11 from "picocolors";
 
 // src/core/agent/prd.ts
 var SYSTEM = [
@@ -3265,15 +3762,15 @@ async function prd(issueRef, opts) {
   const guide = readProjectGuide(["context.md"]);
   const markdown = await withRetry(() => generatePrd(issue, provider, guide));
   if (opts.out) {
-    await writeFile4(opts.out, markdown + "\n", "utf8");
-    console.error(pc10.green(t("prd.wrote", { path: opts.out })));
+    await writeFile5(opts.out, markdown + "\n", "utf8");
+    console.error(pc11.green(t("prd.wrote", { path: opts.out })));
   } else {
     process.stdout.write(markdown + "\n");
   }
 }
 async function loadIssue(issueRef, input) {
   if (input) {
-    const raw = input === "-" ? await readStdin() : await readFile5(input, "utf8");
+    const raw = input === "-" ? await readStdin() : await readFile6(input, "utf8");
     return normalize2(JSON.parse(stripBom(raw)));
   }
   const num = numericRef(issueRef);
@@ -3292,10 +3789,10 @@ function normalize2(raw) {
 }
 
 // src/cli/commands/review.ts
-import { writeFile as writeFile5, readFile as readFile6 } from "fs/promises";
+import { writeFile as writeFile6, readFile as readFile7 } from "fs/promises";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify3 } from "util";
-import pc11 from "picocolors";
+import pc12 from "picocolors";
 
 // src/core/agent/review.ts
 var MAX_DIFF_CHARS = Number(process.env.POLYPUS_MAX_DIFF_CHARS) || 6e4;
@@ -3361,14 +3858,14 @@ async function review(prRef, opts) {
   const guide = readProjectGuide(["rules.md", "context.md"]);
   const markdown = await withRetry(() => reviewDiff(diff, meta, provider, guide));
   if (opts.out) {
-    await writeFile5(opts.out, markdown + "\n", "utf8");
-    console.error(pc11.green(t("review.wrote", { path: opts.out })));
+    await writeFile6(opts.out, markdown + "\n", "utf8");
+    console.error(pc12.green(t("review.wrote", { path: opts.out })));
   } else {
     process.stdout.write(markdown + "\n");
   }
 }
 async function loadDiff(num, input) {
-  if (input) return input === "-" ? readStdin() : readFile6(input, "utf8");
+  if (input) return input === "-" ? readStdin() : readFile7(input, "utf8");
   const { stdout: stdout2 } = await exec3("gh", ["pr", "diff", num]);
   return stdout2;
 }
@@ -3380,7 +3877,7 @@ async function loadMeta(num, input) {
 }
 
 // src/cli/index.ts
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 
 // src/core/config/dotenv.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
@@ -3409,12 +3906,11 @@ function loadDotenv(paths) {
 }
 
 // src/cli/index.ts
-var { version: pkgVersion } = createRequire(import.meta.url)("../package.json");
 async function launchInteractive() {
   const config = await loadConfig();
   if (config.agents.length === 0) {
     console.log(banner());
-    console.log("  " + pc12.yellow(t("welcome.firstRun")) + "\n");
+    console.log("  " + pc13.yellow(t("welcome.firstRun")) + "\n");
     await setup();
   }
   await run(void 0, {});
@@ -3435,8 +3931,9 @@ async function resolveLocale() {
 }
 function buildProgram() {
   const program = new Command();
-  program.name("polypus").description(t("cli.description")).version(pkgVersion).option("--lang <locale>", t("cli.opt.lang")).action(() => launchInteractive());
+  program.name("polypus").description(t("cli.description")).version(VERSION).option("--lang <locale>", t("cli.opt.lang")).action(() => launchInteractive());
   program.command("setup").description(t("cli.cmd.setup")).action(() => setup());
+  program.command("init").option("--force", t("cli.opt.force")).description(t("cli.cmd.init")).action((opts) => init(opts));
   program.command("add-agent").argument("<name>", t("cli.arg.addAgentName")).requiredOption("--provider <provider>", t("cli.opt.provider")).requiredOption("--model <model>", t("cli.opt.model")).option("--api-key <key>", t("cli.opt.apiKey")).option("--base-url <url>", t("cli.opt.baseUrl")).option("--tool-mode <mode>", t("cli.opt.toolMode"), "auto").option("--set-default", t("cli.opt.setDefault")).description(t("cli.cmd.addAgent")).action((name, opts) => addAgent(name, opts));
   program.command("remove-agent").argument("<name>", t("cli.arg.removeAgentName")).description(t("cli.cmd.removeAgent")).action((name) => removeAgent(name));
   program.command("list-agents").alias("agents").description(t("cli.cmd.listAgents")).action(() => listAgents());
@@ -3449,11 +3946,11 @@ function buildProgram() {
 }
 async function main() {
   try {
-    loadDotenv([join3(configDir(), ".env"), join3(process.cwd(), ".env")]);
+    loadDotenv([join5(configDir(), ".env"), join5(process.cwd(), ".env")]);
     await resolveLocale();
     await buildProgram().parseAsync(process.argv);
   } catch (err) {
-    console.error(pc12.red(`\u2717 ${err.message}`));
+    console.error(pc13.red(`\u2717 ${err.message}`));
     process.exitCode = 1;
   }
 }