@gaberrb/polypus 0.4.10 → 0.4.12

package/dist/index.js

@@ -143,6 +143,7 @@ var en = {
   "run.autocorrect": "\u21BB tool failed \u2014 auto-correcting with extra context",
   "run.cancelled": "\u25A0 cancelled",
   "compaction.done": "context compacted: ~{before} \u2192 ~{after} tokens",
+  "tools.customLoaded": "loaded custom tool(s): {names}",
   "run.jsonNeedsTask": "--json requires a task argument (headless mode has no interactive REPL).",
   "review.approveAll": "approve all",
   "review.reject": "reject",
@@ -204,6 +205,7 @@ var en = {
   "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.cancelling": "cancelling swarm \u2014 finishing in-flight workers, then merging what committed\u2026",
   "swarm.decomposed": "Decomposed into {n} subtask(s):",
   "swarm.workerStart": "\u25B6 {id} started by {agent}",
   "swarm.workerDone": "\u2713 {id} done",
@@ -403,6 +405,7 @@ var ptBR = {
   "run.autocorrect": "\u21BB tool falhou \u2014 autocorrigindo com contexto extra",
   "run.cancelled": "\u25A0 cancelado",
   "compaction.done": "contexto compactado: ~{before} \u2192 ~{after} tokens",
+  "tools.customLoaded": "tool(s) customizada(s) carregada(s): {names}",
   "run.jsonNeedsTask": "--json exige um argumento de tarefa (o modo headless n\xE3o tem REPL interativo).",
   "review.approveAll": "aprovar tudo",
   "review.reject": "rejeitar",
@@ -462,6 +465,7 @@ var ptBR = {
   "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.cancelling": "cancelando o swarm \u2014 encerrando os workers em andamento e mesclando o que commitou\u2026",
   "swarm.decomposed": "Dividido em {n} subtarefa(s):",
   "swarm.workerStart": "\u25B6 {id} iniciada por {agent}",
   "swarm.workerDone": "\u2713 {id} conclu\xEDda",
@@ -2144,6 +2148,66 @@ ${summary.content.trim()}`
   return system ? [system, summaryMessage, ...tail] : [summaryMessage, ...tail];
 }
 
+// src/core/agent/hooks.ts
+import { exec as exec2 } from "child_process";
+import { readFile as readFile8 } from "fs/promises";
+import { join as join4 } from "path";
+import { promisify as promisify2 } from "util";
+import { z as z8 } from "zod";
+var execAsync2 = promisify2(exec2);
+var HOOK_TIMEOUT = 12e4;
+var HooksSchema = z8.object({
+  /** Shell command run after a successful write_file. `{path}` is substituted. */
+  afterWrite: z8.string().optional(),
+  /** Shell command run after a successful edit_file. `{path}` is substituted. */
+  afterEdit: z8.string().optional(),
+  /** Shell command run after any successful mutating tool. `{tool}`/`{path}` substituted. */
+  afterTool: z8.string().optional(),
+  /** Block run_command when the command contains any of these substrings. */
+  beforeCommand: z8.object({ deny: z8.array(z8.string()).default([]) }).optional()
+});
+async function loadHooks(workspace) {
+  try {
+    const raw = await readFile8(join4(workspace, ".poly", "hooks.json"), "utf8");
+    const parsed = HooksSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function screenCommandHook(hooks, command) {
+  const deny = hooks?.beforeCommand?.deny ?? [];
+  for (const needle of deny) {
+    if (needle && command.includes(needle)) {
+      return { blocked: true, reason: `matches deny rule "${needle}"` };
+    }
+  }
+  return { blocked: false };
+}
+function substitute(template, call) {
+  const path = typeof call.arguments.path === "string" ? call.arguments.path : "";
+  return template.replace(/\{path\}/g, path).replace(/\{tool\}/g, call.name);
+}
+async function runAfterHook(hooks, call, workspace) {
+  if (!hooks) return void 0;
+  const commands = [];
+  if (call.name === "write_file" && hooks.afterWrite) commands.push({ label: "afterWrite", cmd: hooks.afterWrite });
+  if (call.name === "edit_file" && hooks.afterEdit) commands.push({ label: "afterEdit", cmd: hooks.afterEdit });
+  if (hooks.afterTool) commands.push({ label: "afterTool", cmd: hooks.afterTool });
+  if (commands.length === 0) return void 0;
+  const notes = [];
+  for (const { label, cmd } of commands) {
+    const resolved = substitute(cmd, call);
+    try {
+      await execAsync2(resolved, { cwd: workspace, timeout: HOOK_TIMEOUT, windowsHide: true });
+      notes.push(`\u21AA hook ${label} ok`);
+    } catch (err) {
+      notes.push(`\u21AA hook ${label} failed: ${err.message.split("\n")[0]}`);
+    }
+  }
+  return notes.join("\n");
+}
+
 // src/core/agent/loop.ts
 function looksLikeStall(text2) {
   const lc = text2.toLowerCase();
@@ -2184,7 +2248,13 @@ async function runAgent(opts) {
   const { agent, permissions, events } = opts;
   const maxSteps = opts.maxSteps ?? 30;
   const maxReprompts = opts.maxReprompts ?? 3;
-  const driver = makeDriver(agent.toolMode, toolSpecs());
+  const extra = opts.extraTools ?? [];
+  const extraByName = new Map(extra.map((tl) => [tl.spec.name, tl]));
+  const baseSpecs = toolSpecs();
+  const finishSpec = baseSpecs[baseSpecs.length - 1];
+  const allSpecs = [...baseSpecs.slice(0, -1), ...extra.map((tl) => tl.spec), finishSpec];
+  const resolveTool = (name) => extraByName.get(name) ?? getTool(name);
+  const driver = makeDriver(agent.toolMode, allSpecs);
   const ctx = { workspace: opts.workspace, permissions };
   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;
@@ -2265,8 +2335,21 @@ async function runAgent(opts) {
         const summary = String(call.arguments.summary ?? "").trim();
         return { finished: true, reason: "finished", summary, steps: step, messages, usage: usage2 };
       }
-      const tool = getTool(call.name);
-      const result = tool ? await tool.run(call.arguments, ctx) : { ok: false, output: `Unknown tool "${call.name}". Available: ${toolSpecs().map((t2) => t2.name).join(", ")}` };
+      const tool = resolveTool(call.name);
+      const hookScreen = call.name === "run_command" ? screenCommandHook(opts.hooks, String(call.arguments.command ?? "")) : { blocked: false };
+      let result;
+      if (hookScreen.blocked) {
+        result = { ok: false, output: `Command blocked by hook: ${hookScreen.reason}` };
+      } else if (tool) {
+        result = await tool.run(call.arguments, ctx);
+        if (result.ok) {
+          const note2 = await runAfterHook(opts.hooks, call, opts.workspace);
+          if (note2) result = { ...result, output: `${result.output}
+${note2}` };
+        }
+      } else {
+        result = { ok: false, output: `Unknown tool "${call.name}". Available: ${allSpecs.map((t2) => t2.name).join(", ")}` };
+      }
       events?.onToolResult?.(call, result);
       const sig = `${call.name}:${JSON.stringify(call.arguments)}`;
       let resultText = result.output;
@@ -2310,7 +2393,7 @@ ${guidance}`;
 }
 
 // src/core/context/mentions.ts
-import { readdir as readdir4, readFile as readFile8, stat as stat2 } from "fs/promises";
+import { readdir as readdir4, readFile as readFile9, stat as stat2 } from "fs/promises";
 import { resolve as resolve9 } from "path";
 var MAX_FILE_CHARS = 1e4;
 var MENTION_RE = /(?:^|\s)@([\w./-]+)/g;
@@ -2337,7 +2420,7 @@ ${t("mentions.notFound", { path: token })}`);
 ${listing || "(empty)"}`);
         injected.push(decision.rel);
       } else {
-        const raw = await readFile8(abs, "utf8");
+        const raw = await readFile9(abs, "utf8");
         const content = raw.length > MAX_FILE_CHARS ? raw.slice(0, MAX_FILE_CHARS) + "\n\u2026[truncated]" : raw;
         blocks.push(`## @${decision.rel}
 \`\`\`
@@ -2360,16 +2443,16 @@ ${blocks.join("\n\n")}`;
 }
 
 // src/core/agent/verify.ts
-import { exec as exec2 } from "child_process";
-import { readFile as readFile9 } from "fs/promises";
+import { exec as exec3 } from "child_process";
+import { readFile as readFile10 } from "fs/promises";
 import { resolve as resolve10 } from "path";
-import { promisify as promisify2 } from "util";
-var execAsync2 = promisify2(exec2);
+import { promisify as promisify3 } from "util";
+var execAsync3 = promisify3(exec3);
 var MAX_OUTPUT3 = 8e3;
 var CHECK_SCRIPTS = ["typecheck", "build", "test"];
 async function detectChecks(workspace) {
   try {
-    const raw = await readFile9(resolve10(workspace, "package.json"), "utf8");
+    const raw = await readFile10(resolve10(workspace, "package.json"), "utf8");
     const scripts = JSON.parse(raw).scripts ?? {};
     return CHECK_SCRIPTS.filter((s) => typeof scripts[s] === "string").map((s) => `npm run ${s}`);
   } catch {
@@ -2380,7 +2463,7 @@ async function runChecks(workspace, commands) {
   const results = [];
   for (const command of commands) {
     try {
-      const { stdout: stdout2, stderr } = await execAsync2(command, {
+      const { stdout: stdout2, stderr } = await execAsync3(command, {
         cwd: workspace,
         timeout: 3e5,
         maxBuffer: 10 * 1024 * 1024,
@@ -2412,8 +2495,8 @@ function clamp2(s) {
 }
 
 // src/core/agent/usage.ts
-import { appendFile, mkdir as mkdir3, readFile as readFile10 } from "fs/promises";
-import { join as join4 } from "path";
+import { appendFile, mkdir as mkdir3, readFile as readFile11 } from "fs/promises";
+import { join as join5 } from "path";
 
 // src/core/providers/openrouter.ts
 var MODELS_URL = "https://openrouter.ai/api/v1/models";
@@ -2513,7 +2596,7 @@ function fmtUsd(n) {
   return `US$${n.toFixed(2)}`;
 }
 function usagePath() {
-  return join4(configDir(), "usage.jsonl");
+  return join5(configDir(), "usage.jsonl");
 }
 async function recordUsage(entry) {
   try {
@@ -2525,7 +2608,7 @@ async function recordUsage(entry) {
 async function aggregateUsage() {
   let text2 = "";
   try {
-    text2 = await readFile10(usagePath(), "utf8");
+    text2 = await readFile11(usagePath(), "utf8");
   } catch {
     return { days: [], total: emptyBucket("total") };
   }
@@ -2559,10 +2642,10 @@ function accumulate(bucket, e) {
 }
 
 // src/core/agent/session-store.ts
-import { mkdir as mkdir4, readFile as readFile11, readdir as readdir5, writeFile as writeFile4 } from "fs/promises";
-import { join as join5 } from "path";
+import { mkdir as mkdir4, readFile as readFile12, readdir as readdir5, writeFile as writeFile4 } from "fs/promises";
+import { join as join6 } from "path";
 function sessionsDir() {
-  return join5(configDir(), "sessions");
+  return join6(configDir(), "sessions");
 }
 function newSessionId() {
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -2570,7 +2653,7 @@ function newSessionId() {
   return `${stamp}-${rand}`;
 }
 function sessionPath(id) {
-  return join5(sessionsDir(), `${id}.json`);
+  return join6(sessionsDir(), `${id}.json`);
 }
 async function saveSession(record) {
   await mkdir4(sessionsDir(), { recursive: true });
@@ -2582,7 +2665,7 @@ async function saveSession(record) {
 }
 async function loadSession(id) {
   try {
-    return JSON.parse(await readFile11(sessionPath(id), "utf8"));
+    return JSON.parse(await readFile12(sessionPath(id), "utf8"));
   } catch {
     return void 0;
   }
@@ -2597,7 +2680,7 @@ async function listSessions() {
   const summaries = [];
   for (const f of files) {
     try {
-      const r = JSON.parse(await readFile11(join5(sessionsDir(), f), "utf8"));
+      const r = JSON.parse(await readFile12(join6(sessionsDir(), f), "utf8"));
       summaries.push({
         id: r.id,
         updatedAt: r.updatedAt,
@@ -2621,6 +2704,83 @@ function deriveTitle(messages) {
   return text2.length > 60 ? text2.slice(0, 60) + "\u2026" : text2 || "(untitled)";
 }
 
+// src/core/tools/custom.ts
+import { exec as exec4 } from "child_process";
+import { readFile as readFile13, readdir as readdir6 } from "fs/promises";
+import { join as join7 } from "path";
+import { promisify as promisify4 } from "util";
+import { z as z9 } from "zod";
+var execAsync4 = promisify4(exec4);
+var MAX_OUTPUT4 = 2e4;
+var CustomToolSchema = z9.object({
+  name: z9.string().min(1).regex(/^[a-z][a-z0-9_]*$/i, "tool name must be alphanumeric/underscore"),
+  description: z9.string().min(1),
+  /** JSON-schema object for the tool parameters (advertised to the model). */
+  parameters: z9.record(z9.unknown()).optional(),
+  /** Shell command template; `{argName}` placeholders are filled from the call arguments. */
+  command: z9.string().min(1)
+});
+function makeCommandTool(def) {
+  return {
+    mutating: true,
+    spec: {
+      name: def.name,
+      description: def.description,
+      parameters: def.parameters ?? { type: "object", properties: {} }
+    },
+    async run(rawArgs, ctx) {
+      const command = fillTemplate(def.command, rawArgs);
+      const decision = await ctx.permissions.authorizeCommand(command);
+      if (!decision.allowed) return { ok: false, output: `Command denied: ${decision.reason}` };
+      try {
+        const { stdout: stdout2, stderr } = await execAsync4(command, {
+          cwd: ctx.workspace,
+          timeout: 12e4,
+          maxBuffer: 10 * 1024 * 1024,
+          windowsHide: true
+        });
+        return { ok: true, output: clamp3(`${stdout2}${stderr ? `
+[stderr]
+${stderr}` : ""}`.trim() || "(no output)") };
+      } catch (err) {
+        const e = err;
+        return {
+          ok: false,
+          output: clamp3(`Command failed (exit ${e.code ?? "?"}): ${e.message}
+${e.stdout ?? ""}${e.stderr ?? ""}`)
+        };
+      }
+    }
+  };
+}
+async function loadCustomTools(workspace) {
+  let files;
+  try {
+    files = (await readdir6(join7(workspace, ".poly", "tools"))).filter((f) => f.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const tools = [];
+  for (const f of files) {
+    try {
+      const raw = await readFile13(join7(workspace, ".poly", "tools", f), "utf8");
+      const parsed = CustomToolSchema.safeParse(JSON.parse(raw));
+      if (parsed.success) tools.push(makeCommandTool(parsed.data));
+    } catch {
+    }
+  }
+  return tools;
+}
+function fillTemplate(template, args) {
+  return template.replace(/\{(\w+)\}/g, (_, key) => {
+    const v = args[key];
+    return v === void 0 || v === null ? "" : String(v);
+  });
+}
+function clamp3(s) {
+  return s.length > MAX_OUTPUT4 ? s.slice(0, MAX_OUTPUT4) + "\n\u2026[truncated]" : s;
+}
+
 // src/cli/commands/json-output.ts
 var OUTPUT_PREVIEW = 500;
 function createJsonCollector() {
@@ -3419,7 +3579,7 @@ import pc7 from "picocolors";
 // src/core/git/worktree.ts
 import { mkdtemp } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 import { simpleGit } from "simple-git";
 async function ensureRepo(workspace) {
   const git = simpleGit(workspace);
@@ -3440,7 +3600,7 @@ async function identityArgs(git) {
 }
 async function createWorktree(git, label) {
   const branch = `polypus/${label}-${Date.now().toString(36)}`;
-  const path = await mkdtemp(join6(tmpdir(), "polypus-wt-"));
+  const path = await mkdtemp(join8(tmpdir(), "polypus-wt-"));
   await git.raw(["worktree", "add", "-b", branch, path, "HEAD"]);
   return { path, branch };
 }
@@ -3474,7 +3634,7 @@ async function removeWorktree(git, wt) {
 }
 
 // src/core/agent/worker.ts
-async function runWorker(subtask, agent, wt, allow, deny, events) {
+async function runWorker(subtask, agent, wt, allow, deny, events, signal) {
   const permissions = new PermissionEngine({
     mode: "bypass",
     policy: { workspace: wt.path, allow, deny },
@@ -3486,9 +3646,10 @@ async function runWorker(subtask, agent, wt, allow, deny, events) {
     agent,
     permissions,
     promptContext: { workspace: wt.path, mode: "bypass", allow, briefing: subtask.brief },
-    events
+    events,
+    signal
   });
-  const committed = await commitWorktree(wt, `polypus(${subtask.id}): ${subtask.title}`);
+  const committed = result.reason === "cancelled" ? false : await commitWorktree(wt, `polypus(${subtask.id}): ${subtask.title}`);
   return {
     subtask,
     agentName: agent.config.name,
@@ -3505,30 +3666,23 @@ 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 concurrency = Math.max(1, opts.concurrency ?? opts.agents.length);
+  const idleTimeoutMs2 = opts.idleTimeoutMs ?? 0;
   const git = await ensureRepo(opts.workspace);
-  const subtasks = await decompose(lead, opts.task, maxSubtasks);
+  const subtasks = await decompose(lead, opts.task, maxSubtasks, opts.signal);
   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 runOne = (subtask, i) => guardedWorker(subtask, opts.agents[i % opts.agents.length], worktrees[i], {
+    allow: opts.allow,
+    deny: opts.deny,
+    idleTimeoutMs: idleTimeoutMs2,
+    signal: opts.signal,
+    events: opts.events
+  });
+  const outcomes = await runPool(subtasks, concurrency, runOne);
   const merges = [];
   for (const outcome of outcomes) {
     if (!outcome.committed) continue;
@@ -3546,13 +3700,69 @@ async function runSwarm(opts) {
   }
   return { subtasks, outcomes, merges };
 }
+async function guardedWorker(subtask, agent, wt, opts) {
+  const ac = new AbortController();
+  const onAbort = () => ac.abort();
+  if (opts.signal) {
+    if (opts.signal.aborted) ac.abort();
+    else opts.signal.addEventListener("abort", onAbort, { once: true });
+  }
+  let idleTimer;
+  const resetIdle = () => {
+    if (opts.idleTimeoutMs <= 0) return;
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => ac.abort(), opts.idleTimeoutMs);
+    idleTimer.unref?.();
+  };
+  const base = opts.events?.workerEvents?.(subtask);
+  const events = {
+    ...base,
+    onStep: (n) => {
+      resetIdle();
+      base?.onStep?.(n);
+    }
+  };
+  opts.events?.onWorkerStart?.(subtask, agent.config.name);
+  resetIdle();
+  let outcome;
+  try {
+    outcome = await runWorker(subtask, agent, wt, opts.allow, opts.deny, events, ac.signal);
+  } catch {
+    outcome = {
+      subtask,
+      agentName: agent.config.name,
+      branch: wt.branch,
+      finished: false,
+      committed: false,
+      steps: 0
+    };
+  } finally {
+    if (idleTimer) clearTimeout(idleTimer);
+    opts.signal?.removeEventListener("abort", onAbort);
+  }
+  opts.events?.onWorkerDone?.(outcome);
+  return outcome;
+}
+async function runPool(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const i = next++;
+      if (i >= items.length) return;
+      results[i] = await fn(items[i], i);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+  return results;
+}
 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) {
+async function decompose(lead, task, maxSubtasks, signal) {
   try {
     const res = await lead.provider.chat({
       messages: [
@@ -3562,7 +3772,8 @@ ${task}
 
 Return at most ${maxSubtasks} subtasks as a JSON array.` }
       ],
-      params: { temperature: 0 }
+      params: { temperature: 0 },
+      signal
     });
     const parsed = extractJsonArray(res.content);
     if (parsed && parsed.length > 0) {
@@ -3588,6 +3799,28 @@ function extractJsonArray(text2) {
   }
 }
 
+// src/core/agent/concurrency.ts
+var OLLAMA_ENDPOINT_CONCURRENCY = 2;
+var DEFAULT_IDLE_TIMEOUT_MS = 3e5;
+function endpointKey(agent) {
+  return `${agent.config.provider}:${agent.config.baseUrl ?? "default"}`;
+}
+function recommendConcurrency(agents) {
+  const perEndpoint = /* @__PURE__ */ new Map();
+  for (const a of agents) {
+    perEndpoint.set(endpointKey(a), (perEndpoint.get(endpointKey(a)) ?? 0) + 1);
+  }
+  let total = 0;
+  for (const [key, count] of perEndpoint) {
+    total += key.startsWith("ollama:") ? Math.min(count, OLLAMA_ENDPOINT_CONCURRENCY) : count;
+  }
+  return Math.max(1, total);
+}
+function idleTimeoutMs() {
+  const raw = Number(process.env.POLYPUS_SWARM_IDLE_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_IDLE_TIMEOUT_MS;
+}
+
 // src/ui/swarm-view.ts
 var RESET2 = "\x1B[0m";
 var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -3751,6 +3984,35 @@ function pad(s, n) {
   return s.length >= n ? s : s + " ".repeat(n - s.length);
 }
 
+// src/ui/cancel.ts
+function listenForCancel(controller) {
+  const stdin2 = process.stdin;
+  if (!stdin2.isTTY) return { pause() {
+  }, resume() {
+  }, dispose() {
+  } };
+  const onData = (buf) => {
+    if (buf.length === 1 && (buf[0] === 27 || buf[0] === 3)) controller.abort();
+  };
+  let active = false;
+  const attach = () => {
+    if (active) return;
+    stdin2.setRawMode(true);
+    stdin2.resume();
+    stdin2.on("data", onData);
+    active = true;
+  };
+  const detach = () => {
+    if (!active) return;
+    stdin2.off("data", onData);
+    stdin2.setRawMode(false);
+    stdin2.pause();
+    active = false;
+  };
+  attach();
+  return { pause: detach, resume: attach, dispose: detach };
+}
+
 // src/cli/commands/swarm.ts
 var MIN_SWARM_AGENTS = 3;
 function canSwarm(agentCount) {
@@ -3774,6 +4036,11 @@ async function runSwarmSession(task, config, opts = {}) {
     pc7.dim(t("swarm.status", { agents: resolved.map((a) => a.config.name).join(", "), workspace }))
   );
   console.log(pc7.yellow(t("swarm.bypassNote") + "\n"));
+  const controller = new AbortController();
+  const cancel2 = listenForCancel(controller);
+  controller.signal.addEventListener("abort", () => console.log(pc7.dim("\n" + t("swarm.cancelling"))), {
+    once: true
+  });
   const view = new SwarmView(resolved[0].config.name);
   view.start();
   let result;
@@ -3785,6 +4052,9 @@ async function runSwarmSession(task, config, opts = {}) {
       allow: config.permissions.allow,
       deny: config.permissions.deny,
       maxSubtasks: opts.maxSubtasks,
+      concurrency: recommendConcurrency(resolved),
+      idleTimeoutMs: idleTimeoutMs(),
+      signal: controller.signal,
       events: {
         onDecomposed: (subtasks) => view.setSubtasks(subtasks),
         onWorkerStart: (subtask, agentName) => view.workerStart(subtask.id, agentName),
@@ -3798,6 +4068,7 @@ async function runSwarmSession(task, config, opts = {}) {
     });
   } finally {
     view.stop();
+    cancel2.dispose();
   }
   console.log("");
   console.log(pc7.bold("\n" + t("swarm.summary")));
@@ -3991,6 +4262,10 @@ async function executeTask(task, resolved, workspace, session, json = false, ver
       return ok;
     }
   });
+  const [extraTools, hooks] = await Promise.all([loadCustomTools(workspace), loadHooks(workspace)]);
+  if (!json && extraTools.length > 0) {
+    console.log(pc8.dim(t("tools.customLoaded", { names: extraTools.map((tl) => tl.spec.name).join(", ") })));
+  }
   const runOnce = (taskText) => runAgent({
     task: taskText,
     workspace,
@@ -4000,6 +4275,8 @@ async function executeTask(task, resolved, workspace, session, json = false, ver
     history: session.history,
     maxSteps: session.maxSteps,
     compactThresholdTokens: compactionThreshold(),
+    extraTools,
+    hooks,
     signal: controller.signal,
     events
   });
@@ -4064,33 +4341,6 @@ async function executeTask(task, resolved, workspace, session, json = false, ver
 function fmtTokens(n) {
   return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
 }
-function listenForCancel(controller) {
-  const stdin2 = process.stdin;
-  if (!stdin2.isTTY) return { pause() {
-  }, resume() {
-  }, dispose() {
-  } };
-  const onData = (buf) => {
-    if (buf.length === 1 && (buf[0] === 27 || buf[0] === 3)) controller.abort();
-  };
-  let active = false;
-  const attach = () => {
-    if (active) return;
-    stdin2.setRawMode(true);
-    stdin2.resume();
-    stdin2.on("data", onData);
-    active = true;
-  };
-  const detach = () => {
-    if (!active) return;
-    stdin2.off("data", onData);
-    stdin2.setRawMode(false);
-    stdin2.pause();
-    active = false;
-  };
-  attach();
-  return { pause: detach, resume: attach, dispose: detach };
-}
 async function confirmAction(req) {
   if (req.kind === "write" && req.hunks && req.hunks.length > 0) {
     renderDiff(req.hunks);
@@ -4204,7 +4454,7 @@ import pc9 from "picocolors";
 
 // src/core/scaffold/init.ts
 import { mkdir as mkdir5, writeFile as writeFile5, access } from "fs/promises";
-import { dirname as dirname3, join as join7 } from "path";
+import { dirname as dirname3, join as join9 } from "path";
 
 // src/core/scaffold/templates.ts
 function polyTemplates(locale) {
@@ -4447,7 +4697,7 @@ async function scaffoldPoly(workspace, opts) {
   const skipped = [];
   for (const [rel, content] of Object.entries(templates)) {
     const display = `.poly/${rel}`;
-    const abs = join7(workspace, ".poly", ...rel.split("/"));
+    const abs = join9(workspace, ".poly", ...rel.split("/"));
     if (!opts.force && await exists(abs)) {
       skipped.push(display);
       continue;
@@ -4587,9 +4837,9 @@ async function sessions() {
 }
 
 // src/cli/commands/prd.ts
-import { writeFile as writeFile6, readFile as readFile12 } from "fs/promises";
+import { writeFile as writeFile6, readFile as readFile14 } from "fs/promises";
 import { execFile } from "child_process";
-import { promisify as promisify3 } from "util";
+import { promisify as promisify5 } from "util";
 import pc13 from "picocolors";
 
 // src/core/agent/prd.ts
@@ -4711,7 +4961,7 @@ function stripBom(s) {
 }
 
 // src/cli/commands/prd.ts
-var exec3 = promisify3(execFile);
+var exec5 = promisify5(execFile);
 async function prd(issueRef, opts) {
   const issue = await loadIssue(issueRef, opts.input);
   const { provider } = resolveFreeProvider(opts.model ?? DEFAULT_PRD_MODEL);
@@ -4726,11 +4976,11 @@ async function prd(issueRef, opts) {
 }
 async function loadIssue(issueRef, input) {
   if (input) {
-    const raw = input === "-" ? await readStdin() : await readFile12(input, "utf8");
+    const raw = input === "-" ? await readStdin() : await readFile14(input, "utf8");
     return normalize2(JSON.parse(stripBom(raw)));
   }
   const num = numericRef(issueRef);
-  const { stdout: stdout2 } = await exec3("gh", ["issue", "view", num, "--json", "number,title,body,comments"]);
+  const { stdout: stdout2 } = await exec5("gh", ["issue", "view", num, "--json", "number,title,body,comments"]);
   const data = normalize2(JSON.parse(stdout2));
   data.number ??= Number(num);
   return data;
@@ -4745,9 +4995,9 @@ function normalize2(raw) {
 }
 
 // src/cli/commands/review.ts
-import { writeFile as writeFile7, readFile as readFile13 } from "fs/promises";
+import { writeFile as writeFile7, readFile as readFile15 } from "fs/promises";
 import { execFile as execFile2 } from "child_process";
-import { promisify as promisify4 } from "util";
+import { promisify as promisify6 } from "util";
 import pc14 from "picocolors";
 
 // src/core/agent/review.ts
@@ -4805,7 +5055,7 @@ ${projectGuide}`
 }
 
 // src/cli/commands/review.ts
-var exec4 = promisify4(execFile2);
+var exec6 = promisify6(execFile2);
 async function review(prRef, opts) {
   const num = opts.input ? prRef.replace(/^#/, "") : numericRef(prRef);
   const diff = await loadDiff(num, opts.input);
@@ -4821,19 +5071,19 @@ async function review(prRef, opts) {
   }
 }
 async function loadDiff(num, input) {
-  if (input) return input === "-" ? readStdin() : readFile13(input, "utf8");
-  const { stdout: stdout2 } = await exec4("gh", ["pr", "diff", num]);
+  if (input) return input === "-" ? readStdin() : readFile15(input, "utf8");
+  const { stdout: stdout2 } = await exec6("gh", ["pr", "diff", num]);
   return stdout2;
 }
 async function loadMeta(num, input) {
   if (input) return { number: Number(num) || void 0, title: `PR ${num}`, body: "" };
-  const { stdout: stdout2 } = await exec4("gh", ["pr", "view", num, "--json", "number,title,body"]);
+  const { stdout: stdout2 } = await exec6("gh", ["pr", "view", num, "--json", "number,title,body"]);
   const raw = JSON.parse(stdout2);
   return { number: raw.number, title: raw.title ?? "", body: raw.body ?? "" };
 }
 
 // src/cli/index.ts
-import { join as join8 } from "path";
+import { join as join10 } from "path";
 
 // src/core/config/dotenv.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
@@ -4904,7 +5154,7 @@ function buildProgram() {
 }
 async function main() {
   try {
-    loadDotenv([join8(configDir(), ".env"), join8(process.cwd(), ".env")]);
+    loadDotenv([join10(configDir(), ".env"), join10(process.cwd(), ".env")]);
     await resolveLocale();
     await buildProgram().parseAsync(process.argv);
   } catch (err) {