@ra3orblade/swarm 0.5.0 → 0.7.0

package/dist/swarm.js

@@ -144,9 +144,13 @@ var HOOK_EVENTS = [
   "Notification",
   "PreCompact"
 ];
+// packages/core/src/budget.ts
+var BUDGET_ASK_TOOLS = new Set(["Bash", "Edit", "Write", "MultiEdit", "NotebookEdit"]);
 // packages/core/src/rules.ts
 var LIVE_WINDOW_MS = 10 * 60000;
 var WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+// packages/core/src/ledger.ts
+var EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
 // packages/cli/src/install.ts
 var MARK = "swarm-hook";
 var isOurs = (h) => h.command.includes(MARK) || h.command.includes("/packages/hook/src/bin.ts");
@@ -190,6 +194,95 @@ function mcpRegistered() {
   const c = loadClaudeJson();
   return Boolean(c.mcpServers?.swarm);
 }
+var codexConfigPath = () => process.env.CODEX_CONFIG ?? join2(homedir2(), ".codex", "config.toml");
+var geminiSettingsPath = () => process.env.GEMINI_SETTINGS ?? join2(homedir2(), ".gemini", "settings.json");
+function codexBlock() {
+  const { command, args } = mcpServerConfig();
+  return `[mcp_servers.swarm]
+command = ${JSON.stringify(command)}
+args = ${JSON.stringify(args)}
+`;
+}
+var CODEX_BLOCK_RE = /\[mcp_servers\.swarm\]\n(?:(?!\[)[^\n]*\n?)*/;
+function registerCodex() {
+  const p = codexConfigPath();
+  if (!existsSync3(join2(p, "..")))
+    return false;
+  const cur = existsSync3(p) ? readFileSync2(p, "utf8") : "";
+  const next = CODEX_BLOCK_RE.test(cur) ? cur.replace(CODEX_BLOCK_RE, codexBlock()) : `${cur.trimEnd()}${cur.trim() ? `
+
+` : ""}${codexBlock()}`;
+  if (next !== cur)
+    writeFileSync2(p, next);
+  return true;
+}
+function unregisterCodex() {
+  const p = codexConfigPath();
+  if (!existsSync3(p))
+    return false;
+  const cur = readFileSync2(p, "utf8");
+  if (!CODEX_BLOCK_RE.test(cur))
+    return false;
+  writeFileSync2(p, cur.replace(CODEX_BLOCK_RE, "").replace(/\n{3,}/g, `
+
+`).trimEnd().concat(`
+`));
+  return true;
+}
+function registerGemini() {
+  const p = geminiSettingsPath();
+  if (!existsSync3(join2(p, "..")))
+    return false;
+  let c = {};
+  try {
+    c = existsSync3(p) ? JSON.parse(readFileSync2(p, "utf8")) : {};
+  } catch {
+    return false;
+  }
+  const mcp = c.mcpServers ?? {};
+  mcp.swarm = mcpServerConfig();
+  c.mcpServers = mcp;
+  writeFileSync2(p, `${JSON.stringify(c, null, 2)}
+`);
+  return true;
+}
+function unregisterGemini() {
+  const p = geminiSettingsPath();
+  if (!existsSync3(p))
+    return false;
+  try {
+    const c = JSON.parse(readFileSync2(p, "utf8"));
+    const mcp = c.mcpServers ?? {};
+    if (!mcp.swarm)
+      return false;
+    delete mcp.swarm;
+    if (Object.keys(mcp).length)
+      c.mcpServers = mcp;
+    else
+      delete c.mcpServers;
+    writeFileSync2(p, `${JSON.stringify(c, null, 2)}
+`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function registerOtherAgents() {
+  const out = [];
+  if (registerCodex())
+    out.push("codex");
+  if (registerGemini())
+    out.push("gemini");
+  return out;
+}
+function unregisterOtherAgents() {
+  const out = [];
+  if (unregisterCodex())
+    out.push("codex");
+  if (unregisterGemini())
+    out.push("gemini");
+  return out;
+}
 var hookCommand = (event) => `${binCommand("swarm-hook")} ${event}`;
 var shimPath = () => resolveBin("swarm-hook").at(-1);
 function mcpServerConfig() {
@@ -228,6 +321,7 @@ function install() {
   }
   save(s);
   registerMcp();
+  registerOtherAgents();
   return added;
 }
 function uninstall() {
@@ -265,13 +359,23 @@ function uninstall() {
   save(s);
   if (unregisterMcp())
     removed++;
+  removed += unregisterOtherAgents().length;
   return removed;
 }
 function status() {
   const s = load();
   const hooks2 = s.hooks ?? {};
   const installed = Object.values(hooks2).some((l) => l.some((g) => g.hooks.some(isOurs)));
-  return { installed, mcp: mcpRegistered(), path: settingsPath(), shim: shimPath() };
+  const otherAgents = [];
+  const cp = codexConfigPath();
+  if (existsSync3(cp) && CODEX_BLOCK_RE.test(readFileSync2(cp, "utf8")))
+    otherAgents.push("codex");
+  const gp = geminiSettingsPath();
+  try {
+    if (existsSync3(gp) && JSON.parse(readFileSync2(gp, "utf8")).mcpServers?.swarm)
+      otherAgents.push("gemini");
+  } catch {}
+  return { installed, mcp: mcpRegistered(), path: settingsPath(), shim: shimPath(), otherAgents };
 }
 
 // packages/cli/src/procs.ts
@@ -389,14 +493,20 @@ var help = `swarm \u2014 control plane for AI-agent development
   tail [--project p] [--session id]   follow the live event stream
 
   claim <task> [--owner n]   claim a task in a fresh isolated git worktree (fail-closed)
+  gate run <task> [gate\u2026]    execute the repo's [gates.<name>] cmd gates in the task's worktree and record them
+  wt [ls|create|open|diff|rm|gc]  first-class worktrees: create task-less ones, open, diff, remove, collect stale
+  pr open <task|worktree>    push the branch and open a PR/MR prefilled from the task, handoff, gates and files
+  questions [--all]          questions agents are waiting on a human for (this repo); answer <id> <text\u2026>
+  dispatch --ready | <task\u2026> claim + spawn a run per task, [dispatch] max_parallel at a time; status | clear
   renew <task>            extend the lease;  release <task> [--force]   release + remove worktree
   claims                  list claims;  reap   release abandoned claims (keeps ones holding work)
   tasks [--ready] [--json] the repo's task source (.swarm.toml [tasks] source); --ready = claimable now
   gate record <task> <gate> pass|fail --rubric "\u2026" [--evidence "\u2026"]   record a verification run (rubric required)
   gate ls [task]          latest verdict per gate (and the run history for one task)
-  run --task <id> (--prompt "\u2026" | --prompt-file f) [--model m] [--permission-mode m] [--allowed-tools a,b] [--max-turns n]
+  run --task <id> (--prompt "\u2026" | --prompt-file f) [--model m] [--permission-mode m] [--profile full|no-edits|read-only] [--allowed-tools a,b] [--max-turns n]
                           claim the task and spawn claude -p in its worktree; the session shows in Fleet
   run ls | send <task|id> "text" | stop <task|id>   steer (stdin) or stop a spawned run, by pid never pattern
+  run resume <session-id> [--model m] [--permission-mode m]   spawn a run that picks up where a dead session stopped (its handoff + tail)
   handoff <task> --done "\u2026" --remaining "\u2026" [--files a,b] [--verify "\u2026"]   leave notes for the next holder
   resume <task>           print the latest handoff (the next session gets it automatically on start)
   res ls | acquire <name> [--owner n] [--pid n] [--port n] | release <name> [--force]
@@ -406,6 +516,8 @@ var help = `swarm \u2014 control plane for AI-agent development
   serve ls | stop [name]  list / stop servers this project started (by pid, never by pattern)
   proc start [--name n] -- <cmd> | ls | stop <name|pid>   same, for workers without a port
   stats [-p] [--json]     all-time totals, streak, records (the dashboard's Stats view)
+  search <query\u2026> [-p] [--kind handoff|incident|gate|session] [--json]   memory over Swarm's own data (handoffs, incidents, gates, what sessions said)
+  rules dryrun [--set rule=mode,\u2026] [--limit n] [--json]   replay this repo's history under rule modes; shows what would fire + flaky signals
 
   install | uninstall     add/remove Swarm hooks in ~/.claude/settings.json
 
@@ -442,7 +554,7 @@ try {
       const base = await ensureDaemon();
       const evs = install();
       console.log(`\u2713 daemon running at ${base}`);
-      console.log(`\u2713 installed hooks for ${evs.length} events + MCP server (${status().path})`);
+      console.log(`\u2713 installed hooks for ${evs.length} events + MCP server (${status().path})${status().otherAgents.length ? ` \xB7 MCP also for ${status().otherAgents.join(", ")}` : ""}`);
       console.log("\u2713 any Claude session you start now will appear in Swarm");
       Bun.spawn(["open", base]).unref?.();
       console.log(`
@@ -487,6 +599,8 @@ Open the dashboard: ${base}`);
       line(running, `daemon ${info ? `(pid ${info.pid}, ${info.url})` : ""}`, "run: swarm start");
       line(st.installed, "hooks installed", "run: swarm install");
       line(st.mcp, "MCP server registered", "run: swarm install");
+      if (st.otherAgents.length)
+        console.log(`\u2713 MCP server also registered for ${st.otherAgents.join(", ")} (swarm_* tools in those CLIs too)`);
       const forge2 = (bin, auth) => {
         const path = Bun.which(bin);
         if (!path)
@@ -540,7 +654,8 @@ url: ${resolveBaseUrl()}`);
         console.log(JSON.stringify(r));
       else if (r.ok)
         console.log(`claimed ${task} \u2192 ${r.worktree}
-  cd ${r.worktree}`);
+  cd ${r.worktree}${r.bootstrap ? `
+  bootstrapping in the background (setup log: ${r.bootstrap})` : ""}`);
       else {
         console.error(`REFUSED: ${r.error}`);
         process.exit(1);
@@ -573,6 +688,317 @@ url: ${resolveBaseUrl()}`);
       }
       break;
     }
+    case "wt": {
+      await ensureDaemon({ quiet: true });
+      const sub = arg();
+      const proj = await api("/v1/projects", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ path: resolve3(".") })
+      });
+      const post2 = (path, body) => fetch(`${new SwarmClient().baseUrl}${path}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ projectId: proj.id, ...body })
+      }).then((x) => x.json());
+      const refuse = (r) => {
+        if (json)
+          console.log(JSON.stringify(r));
+        else if (!r.ok) {
+          console.error(`REFUSED: ${r.error}`);
+          process.exit(1);
+        }
+        return !r.ok;
+      };
+      const flag = (n) => {
+        const i = rest.indexOf(n);
+        return i >= 0 ? rest[i + 1] : undefined;
+      };
+      const VALUE_FLAGS = ["--base", "--branch"];
+      const positional = rest.filter((a, i) => !a.startsWith("--") && !VALUE_FLAGS.includes(rest[i - 1] ?? ""));
+      const target = positional[1];
+      switch (sub) {
+        case "create": {
+          if (!target)
+            throw new Error("usage: swarm wt create <name> [--base ref] [--branch name]");
+          const r = await post2("/v1/worktrees", {
+            name: target,
+            baseRef: flag("--base"),
+            branch: flag("--branch")
+          });
+          if (refuse(r) || json)
+            break;
+          console.log(`created ${r.name} \u2192 ${r.worktree} (branch ${r.branch})
+  cd ${r.worktree}${r.bootstrap ? `
+  bootstrapping in the background (setup log: ${r.bootstrap})` : ""}`);
+          break;
+        }
+        case "ls":
+        case undefined: {
+          const wts = await api(`/v1/worktrees?project=${proj.id}`);
+          if (json)
+            console.log(JSON.stringify(wts));
+          else {
+            for (const w of wts) {
+              const st = w.main ? "main" : [
+                w.dirty > 0 ? `${w.dirty} dirty` : "",
+                w.ahead > 0 ? `${w.ahead} unpushed` : "",
+                w.behind > 0 ? `${w.behind} behind` : "",
+                w.merged ? "merged" : ""
+              ].filter(Boolean).join(", ") || "clean";
+              console.log(`${(w.branch ?? "(detached)").padEnd(32)} ${w.head}  ${st.padEnd(24)} ${w.path}`);
+            }
+            if (!wts.length)
+              console.log("no worktrees");
+          }
+          break;
+        }
+        case "open": {
+          if (!target)
+            throw new Error("usage: swarm wt open <name|path>");
+          const r = await post2("/v1/worktrees/open", { worktree: target });
+          if (refuse(r) || json)
+            break;
+          console.log(`opened ${r.worktree}`);
+          break;
+        }
+        case "rm": {
+          if (!target)
+            throw new Error("usage: swarm wt rm <name|path> [--force]");
+          const r = await post2("/v1/worktrees/remove", {
+            worktree: target,
+            force: rest.includes("--force")
+          });
+          if (refuse(r) || json)
+            break;
+          console.log(`removed ${r.worktree}`);
+          break;
+        }
+        case "diff": {
+          if (!target)
+            throw new Error("usage: swarm wt diff <name|path|task> [--file f] [--patch]");
+          const q = new URLSearchParams({ project: proj.id, worktree: target });
+          const file = flag("--file");
+          if (file)
+            q.set("file", file);
+          if (rest.includes("--patch"))
+            q.set("patch", "1");
+          const d = await api(`/v1/worktrees/diff?${q}`);
+          if (d.error) {
+            console.error(`REFUSED: ${d.error}`);
+            process.exit(1);
+          }
+          if (json)
+            console.log(JSON.stringify(d));
+          else if (d.patch !== undefined)
+            console.log(d.patch);
+          else {
+            console.log(`vs ${d.baseRef ?? "HEAD"} \xB7 ${d.commits.length} commit${d.commits.length === 1 ? "" : "s"} \xB7 ${d.files.length} file${d.files.length === 1 ? "" : "s"}${d.dirty ? " \xB7 dirty" : ""}`);
+            for (const c of d.commits)
+              console.log(`  ${c}`);
+            for (const f of d.files)
+              console.log(`${f.status} ${f.added >= 0 ? `+${f.added}`.padStart(6) : "   bin"} ${f.deleted >= 0 ? `-${f.deleted}`.padStart(6) : "      "}  ${f.path}`);
+          }
+          break;
+        }
+        case "gc": {
+          const r = await post2("/v1/worktrees/gc", { apply: rest.includes("--apply") });
+          if (json)
+            console.log(JSON.stringify(r));
+          else if (!r.candidates.length)
+            console.log("nothing to collect");
+          else {
+            for (const x of r.candidates)
+              console.log(`${r.removed.includes(x.path) ? "removed " : x.removable ? "removable" : `blocked (${x.blocker})`}  ${x.why.padEnd(15)} ${x.branch ?? "(detached)"}  ${x.path}`);
+            if (!rest.includes("--apply") && r.candidates.some((x) => x.removable))
+              console.log("\nrun `swarm wt gc --apply` to remove the removable ones");
+          }
+          break;
+        }
+        default:
+          throw new Error("usage: swarm wt [ls] | create <name> | open <ref> | rm <ref> [--force] | gc [--apply]");
+      }
+      break;
+    }
+    case "questions":
+    case "answer": {
+      await ensureDaemon({ quiet: true });
+      if (cmd === "questions") {
+        const q = new URLSearchParams;
+        if (!rest.includes("--all"))
+          q.set("open", "1");
+        if (!rest.includes("--everywhere")) {
+          const proj = await api("/v1/projects", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ path: resolve3(".") })
+          });
+          q.set("project", proj.id);
+        }
+        const qs = await api(`/v1/questions?${q}`);
+        if (json)
+          console.log(JSON.stringify(qs));
+        else if (!qs.length)
+          console.log("no open questions");
+        else
+          for (const x of qs)
+            console.log(`#${x.id}  ${x.createdAt.slice(0, 16).replace("T", " ")}  ${x.task ? `[${x.task}] ` : ""}${x.text}${x.options.length ? `
+      options: ${x.options.join(" | ")}` : ""}${x.answer ? `
+      answered by ${x.answeredBy}: ${x.answer}` : ""}`);
+        break;
+      }
+      const [idRaw, ...words] = rest.filter((a) => !a.startsWith("--"));
+      const id = Number(idRaw);
+      const text = words.join(" ");
+      if (!id || !text)
+        throw new Error("usage: swarm answer <id> <text\u2026>");
+      const r = await fetch(`${new SwarmClient().baseUrl}/v1/questions/${id}/answer`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ text, by: process.env.USER ?? "cli" })
+      }).then((x) => x.json());
+      if (json)
+        console.log(JSON.stringify(r));
+      else if (r.ok)
+        console.log(`answered #${id}`);
+      else {
+        console.error(`REFUSED: ${r.error}`);
+        process.exit(1);
+      }
+      break;
+    }
+    case "dispatch": {
+      await ensureDaemon({ quiet: true });
+      const proj = await api("/v1/projects", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ path: resolve3(".") })
+      });
+      const VALUE_FLAGS = [
+        "--max",
+        "--parallel",
+        "--model",
+        "--permission-mode",
+        "--max-turns",
+        "--profile"
+      ];
+      const positional = rest.filter((a, i) => !a.startsWith("--") && !VALUE_FLAGS.includes(rest[i - 1] ?? ""));
+      const flag = (n) => {
+        const i = rest.indexOf(n);
+        return i >= 0 ? rest[i + 1] : undefined;
+      };
+      const num = (n) => {
+        const v = flag(n);
+        return v ? Number(v) : undefined;
+      };
+      const sub = positional[0];
+      if (sub === "status" || !sub && !rest.includes("--ready")) {
+        const d = await api(`/v1/dispatch?project=${proj.id}`);
+        if (json)
+          console.log(JSON.stringify(d));
+        else if (!d.entries.length)
+          console.log(`nothing dispatched (max_parallel ${d.config.max_parallel}); swarm dispatch --ready | <task\u2026>`);
+        else
+          for (const e of d.entries)
+            console.log(`${(e.state === "finished" ? e.outcome ?? "?" : e.state).padEnd(13)} ${e.task.padEnd(10)} ${e.runId ? `run ${e.runId} ` : ""}${e.costUsd != null ? `$${e.costUsd.toFixed(2)} ` : ""}${e.detail ?? ""}`);
+        break;
+      }
+      if (sub === "clear") {
+        const r2 = await fetch(`${new SwarmClient().baseUrl}/v1/dispatch`, {
+          method: "DELETE",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ projectId: proj.id, task: positional[1] })
+        }).then((x) => x.json());
+        console.log(json ? JSON.stringify(r2) : `cleared ${r2.cleared}`);
+        break;
+      }
+      const r = await fetch(`${new SwarmClient().baseUrl}/v1/dispatch`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          projectId: proj.id,
+          ready: rest.includes("--ready"),
+          tasks: positional,
+          max: num("--max"),
+          maxParallel: num("--parallel"),
+          model: flag("--model"),
+          permissionMode: flag("--permission-mode"),
+          maxTurns: num("--max-turns"),
+          profile: flag("--profile"),
+          owner: process.env.USER ?? "cli"
+        })
+      }).then((x) => x.json());
+      if (json)
+        console.log(JSON.stringify(r));
+      else if (!r.ok) {
+        console.error(`REFUSED: ${r.error}`);
+        process.exit(1);
+      } else {
+        for (const t of r.started)
+          console.log(`started   ${t}`);
+        for (const t of r.queued)
+          console.log(`queued    ${t}`);
+        for (const x of r.rejected)
+          console.log(`rejected  ${x.id} \u2014 ${x.reason}`);
+        if (!r.started.length && !r.queued.length)
+          console.log("nothing to dispatch");
+        else
+          console.log(`
+watch: swarm dispatch status \xB7 swarm run ls \xB7 the Board`);
+      }
+      break;
+    }
+    case "pr": {
+      await ensureDaemon({ quiet: true });
+      const sub = arg();
+      const VALUE_FLAGS = ["--title", "--body"];
+      const positional = rest.filter((a, i) => !a.startsWith("--") && !VALUE_FLAGS.includes(rest[i - 1] ?? ""));
+      const flag = (n) => {
+        const i = rest.indexOf(n);
+        return i >= 0 ? rest[i + 1] : undefined;
+      };
+      const target = positional[1];
+      if (sub !== "open" || !target)
+        throw new Error("usage: swarm pr open <task|worktree> [--title t] [--body b] [--draft] [--dry-run]");
+      const proj = await api("/v1/projects", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ path: resolve3(".") })
+      });
+      if (rest.includes("--dry-run")) {
+        const d = await api(`/v1/prs/draft?project=${proj.id}&worktree=${encodeURIComponent(target)}`);
+        if (json)
+          console.log(JSON.stringify(d));
+        else if (!d.ok) {
+          console.error(`REFUSED: ${d.error}`);
+          process.exit(1);
+        } else
+          console.log(`${flag("--title") ?? d.title}
+
+${flag("--body") ?? d.body}`);
+        break;
+      }
+      const r = await fetch(`${new SwarmClient().baseUrl}/v1/prs/open`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          projectId: proj.id,
+          worktree: target,
+          title: flag("--title"),
+          body: flag("--body"),
+          draft: rest.includes("--draft")
+        })
+      }).then((x) => x.json());
+      if (json)
+        console.log(JSON.stringify(r));
+      else if (r.ok)
+        console.log(`opened ${r.url}`);
+      else {
+        console.error(`REFUSED: ${r.error}`);
+        process.exit(1);
+      }
+      break;
+    }
     case "reap": {
       await ensureDaemon({ quiet: true });
       const r = await api("/v1/claims/reap", { method: "POST" });
@@ -613,7 +1039,8 @@ url: ${resolveBaseUrl()}`);
         "--permission-mode",
         "--allowed-tools",
         "--max-turns",
-        "--owner"
+        "--owner",
+        "--profile"
       ]);
       const positionals = [];
       for (let i = 0;i < rest.length; i++) {
@@ -659,35 +1086,39 @@ url: ${resolveBaseUrl()}`);
         }
         break;
       }
-      const task = flag("--task") ?? sub;
-      let prompt = flag("--prompt");
+      const resumeFrom = sub === "resume" ? positionals[1] : undefined;
+      if (sub === "resume" && !resumeFrom)
+        throw new Error("usage: swarm run resume <session-id>");
+      const task = resumeFrom ? "(resumed)" : flag("--task") ?? sub;
+      let prompt = resumeFrom ? "(from handoff)" : flag("--prompt");
       const pf = flag("--prompt-file");
       if (!prompt && pf)
         prompt = await Bun.file(resolve3(pf)).text();
       if (!task || !prompt)
-        throw new Error('usage: swarm run --task <id> --prompt "\u2026" | --prompt-file f  [--model] [--permission-mode] [--allowed-tools a,b] [--max-turns n]');
-      const r = await fetch(`${base}/v1/runs`, {
+        throw new Error('usage: swarm run --task <id> --prompt "\u2026" | --prompt-file f  [--model] [--permission-mode] [--profile p] [--allowed-tools a,b] [--max-turns n]');
+      const r = await fetch(resumeFrom ? `${base}/v1/sessions/${encodeURIComponent(resumeFrom)}/resume` : `${base}/v1/runs`, {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify({
           projectId: proj.id,
           task,
           prompt,
-          owner: flag("--owner") ?? process.env.USER ?? "me",
+          owner: flag("--owner") ?? (resumeFrom ? undefined : process.env.USER ?? "me"),
           model: flag("--model"),
           permissionMode: flag("--permission-mode"),
           allowedTools: flag("--allowed-tools")?.split(",").map((t) => t.trim()).filter(Boolean),
-          maxTurns: flag("--max-turns") ? Number(flag("--max-turns")) : undefined
+          maxTurns: flag("--max-turns") ? Number(flag("--max-turns")) : undefined,
+          profile: flag("--profile")
         })
       }).then((x) => x.json());
       if (json)
         console.log(JSON.stringify(r));
       else if (r.ok && r.run)
-        console.log(`run ${r.run.id} on ${task} (pid ${r.run.pid})
+        console.log(`run ${r.run.id} on ${r.run.task} (pid ${r.run.pid})
   worktree: ${r.run.worktree}
   session:  ${r.run.sessionId}
   log:      ${r.run.log}
-  steer:    swarm run send ${task} "\u2026"   stop: swarm run stop ${task}   watch: swarm tail --session ${r.run.sessionId}`);
+  steer:    swarm run send ${r.run.task} "\u2026"   stop: swarm run stop ${r.run.task}   watch: swarm tail --session ${r.run.sessionId}`);
       else {
         console.error(`REFUSED: ${r.error}`);
         process.exit(1);
@@ -790,6 +1221,34 @@ url: ${resolveBaseUrl()}`);
         }
         break;
       }
+      if (sub === "run") {
+        const [, task, ...gates2] = positionals;
+        if (!task)
+          throw new Error("usage: swarm gate run <task> [gate\u2026]   (default: the required gates that have a cmd)");
+        const r = await fetch(`${new SwarmClient().baseUrl}/v1/gates/run`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            projectId: proj.id,
+            task,
+            gates: gates2,
+            sessionId: process.env.CLAUDE_SESSION_ID ?? null
+          })
+        }).then((x) => x.json());
+        if (json)
+          console.log(JSON.stringify(r));
+        else {
+          for (const x of r.runs ?? [])
+            console.log(`${x.verdict === "pass" ? "\u2713" : "\u2717"} ${x.gate.padEnd(12)} ${x.rubric}`);
+          for (const x of r.skipped ?? [])
+            console.log(`\u2013 ${x.gate.padEnd(12)} skipped: ${x.reason}`);
+          if (r.error && !r.started?.length)
+            console.error(`REFUSED: ${r.error}`);
+        }
+        if (!r.ok)
+          process.exit(1);
+        break;
+      }
       if (sub === "ls") {
         const task = positionals[1];
         const q = new URLSearchParams({ project: proj.id });
@@ -817,6 +1276,82 @@ url: ${resolveBaseUrl()}`);
       }
       throw new Error("usage: swarm gate record|ls");
     }
+    case "search": {
+      await ensureDaemon({ quiet: true });
+      const q = new URLSearchParams({ limit: "30" });
+      const words = [];
+      for (let i = 0;i < rest.length; i++) {
+        const a = rest[i];
+        if (a === "--kind")
+          q.set("kind", rest[++i] ?? "");
+        else if (a === "-p") {
+          const proj = await api("/v1/projects", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ path: resolve3(".") })
+          });
+          q.set("project", proj.id);
+        } else if (!a.startsWith("--"))
+          words.push(a);
+      }
+      if (!words.length)
+        throw new Error("usage: swarm search <query\u2026> [-p] [--kind k]");
+      q.set("q", words.join(" "));
+      const r = await api(`/v1/memory?${q}`);
+      if (json)
+        console.log(JSON.stringify(r.hits));
+      else if (!r.hits.length)
+        console.log("nothing in memory matches");
+      else
+        for (const h of r.hits)
+          console.log(`${h.kind.padEnd(8)} ${h.ts.slice(0, 16).replace("T", " ")}  ${h.title}${h.task ? `  [${h.task}]` : ""}
+         ${h.snippet.split("\x01").join("").split("\x02").join("").replace(/\s+/g, " ")}${h.sessionId ? `
+         session ${h.sessionId}` : ""}`);
+      break;
+    }
+    case "rules": {
+      if (rest[0] !== "dryrun")
+        throw new Error("usage: swarm rules dryrun [--set rule=mode,\u2026] [--limit n]");
+      await ensureDaemon({ quiet: true });
+      const proj = await api("/v1/projects", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ path: resolve3(".") })
+      });
+      const q = new URLSearchParams({ project: proj.id });
+      const si = rest.indexOf("--set");
+      if (si >= 0)
+        for (const kv of (rest[si + 1] ?? "").split(",")) {
+          const [k, v] = kv.split("=");
+          if (k && v)
+            q.set(k.trim(), v.trim());
+        }
+      const li = rest.indexOf("--limit");
+      if (li >= 0)
+        q.set("limit", rest[li + 1] ?? "");
+      const r = await api(`/v1/rules/dryrun?${q}`);
+      if (json) {
+        console.log(JSON.stringify(r));
+        break;
+      }
+      console.log(`dry-run over ${r.evaluated} of ${r.calls} recorded calls (nothing recorded)`);
+      for (const [rule, n] of Object.entries(r.byRule))
+        console.log(`  ${rule.padEnd(26)} ${String(r.modes[rule]).padEnd(5)} ask ${String(n.ask).padStart(4)}  deny ${String(n.deny).padStart(4)}`);
+      if (r.flaky.length) {
+        console.log(`
+flaky signals:`);
+        for (const f of r.flaky)
+          console.log(`  ${f.display}
+    ${f.suggestion}`);
+      }
+      if (r.hits.length) {
+        console.log(`
+would have fired (newest last):`);
+        for (const h of r.hits.slice(-20))
+          console.log(`  ${h.ts.slice(11, 19)} ${h.action.padEnd(4)} ${h.rule.padEnd(20)} ${h.display}${h.completed ? "  (ran)" : ""}`);
+      }
+      break;
+    }
     case "tasks": {
       await ensureDaemon({ quiet: true });
       const proj = await api("/v1/projects", {
@@ -830,7 +1365,9 @@ url: ${resolveBaseUrl()}`);
       if (json)
         console.log(JSON.stringify(rows));
       else if (!t.source)
-        console.log('no task source \u2014 add `[tasks] source = "path/to/plan.md"` to .swarm.toml');
+        console.log('no task source \u2014 add `[tasks] source = "path/to/plan.md"` (or "github" / "linear") to .swarm.toml');
+      else if (t.error && !t.tasks.length)
+        console.log(`${t.source}: ${t.error}`);
       else if (!rows.length)
         console.log(ready ? "nothing ready to claim" : `no tasks in ${t.source}`);
       else