@ra3orblade/swarm 0.5.0 → 0.7.0

package/dist/swarm-mcp.js

@@ -19765,6 +19765,29 @@ function buildServer() {
       resources
     });
   });
+  server.registerTool("swarm_search", {
+    title: "Search Swarm's memory",
+    description: "Full-text search over what Swarm remembers about this repo: handoffs (what was done / what's left), incidents (commands the rules stopped, and why), gate runs (rubric + evidence) and what previous sessions last said. Not the codebase \u2014 grep that. Words are AND-ed, the last one is a prefix; quote a phrase; `kind:incident` / `task:M1.2` filter. Use it before redoing work someone may have done, or when a rule blocks you and you want to know how it was handled before.",
+    inputSchema: {
+      query: exports_external.string(),
+      kind: exports_external.enum(["handoff", "incident", "gate", "session"]).optional(),
+      all_projects: exports_external.boolean().optional().describe("search every project, not just this repo"),
+      limit: exports_external.number().int().min(1).max(100).optional()
+    }
+  }, async ({ query, kind, all_projects, limit }) => {
+    const q = new URLSearchParams({ q: query, limit: String(limit ?? 20) });
+    if (!all_projects)
+      q.set("project", await projectId());
+    if (kind)
+      q.set("kind", kind);
+    const r = await api2(`/v1/memory?${q}`);
+    if (!r.hits.length)
+      return ok(`nothing in memory matches "${query}"`, { hits: [] });
+    return ok(r.hits.map((h) => `[${h.kind}] ${h.title}${h.task ? ` (${h.task})` : ""} \u2014 ${h.ts.slice(0, 16)}
+${h.text}`).join(`
+
+`), r.hits);
+  });
   server.registerTool("swarm_next_task", {
     title: "Next claimable task",
     description: "The first unclaimed task in this repo's task source whose dependencies are done \u2014 what to pick up next. Needs `[tasks] source` in .swarm.toml. Pass all=true to list every ready task.",
@@ -19815,7 +19838,7 @@ function buildServer() {
   });
   server.registerTool("swarm_resume", {
     title: "Read the latest handoff",
-    description: "The latest handoff on a task: done, remaining, files, verify. Read it before continuing someone else's work.",
+    description: "The latest handoff on a task: done, remaining, files, verify. Read it before continuing someone else's work. Handoffs marked `auto:` were derived by Swarm from what the previous session did (files edited, last verify command) when it stopped without leaving one.",
     inputSchema: { task: exports_external.string() }
   }, async ({ task }) => {
     const pid = await projectId();
@@ -19853,6 +19876,127 @@ function buildServer() {
       return fail(`REFUSED: ${r.error}`);
     return ok(`recorded ${gate} ${verdict} on ${task}`, r.run);
   });
+  server.registerTool("swarm_gate_run", {
+    title: "Run the repo's executable gates",
+    description: "Execute the gates this repo defines as commands (.swarm.toml [gates.<name>] cmd, e.g. tests, lint, typecheck) inside the task's held worktree and record the verdicts \u2014 exit 0 is a pass. Runs the required ones by default. Prefer this over recording a verdict yourself whenever a gate has a command: the record then says exactly what ran.",
+    inputSchema: {
+      task: exports_external.string().describe("task id whose worktree to run in (must be held)"),
+      gates: exports_external.array(exports_external.string()).optional().describe("gate names; default = required gates that have a cmd")
+    }
+  }, async ({ task, gates }) => {
+    const pid = await projectId();
+    const r = await api2("/v1/gates/run", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ projectId: pid, task, gates, sessionId: SESSION })
+    });
+    if (!r.started?.length)
+      return fail(`REFUSED: ${r.error ?? r.skipped?.[0]?.reason ?? "nothing ran"}`);
+    const lines = r.runs.map((x) => `${x.verdict === "pass" ? "\u2713" : "\u2717"} ${x.gate}: ${x.rubric}${x.verdict === "fail" && x.evidence ? `
+${x.evidence.split(`
+`).slice(-15).join(`
+`)}` : ""}`);
+    for (const x of r.skipped)
+      lines.push(`\u2013 ${x.gate}: skipped (${x.reason})`);
+    return ok(`${r.ok ? "all gates passed" : "gate failure"} on ${task}
+${lines.join(`
+`)}`, r);
+  });
+  server.registerTool("swarm_context", {
+    title: "Refresh your Swarm context",
+    description: "What Swarm told you at session start, current as of now: what you hold (task, worktree, lease left), the latest handoff, gate status, held resources, the repo's rule modes \u2014 plus any answers to your questions and questions still open. Call it after a long stretch of work, when resuming, or when you are not sure what you hold.",
+    inputSchema: {}
+  }, async () => {
+    const r = await api2(`/v1/context?cwd=${encodeURIComponent(process.cwd())}&session=${encodeURIComponent(SESSION ?? "")}`);
+    return ok(r.text ?? "[swarm] nothing to report: no claim here, no open questions, default rules.", r);
+  });
+  server.registerTool("swarm_ask", {
+    title: "Ask the human",
+    description: "Park a question only a person can answer (a product decision, credentials, which of two designs). It shows on the dashboard with a notification; the answer comes back to you as context on a later tool call \u2014 or call swarm_inbox to check. Ask once, then either keep working on what doesn't depend on it or stop and say you're waiting. Don't use it for things you can find out yourself.",
+    inputSchema: {
+      question: exports_external.string().describe("the question, with enough context to answer it cold"),
+      options: exports_external.array(exports_external.string()).optional().describe("up to 8 suggested answers")
+    }
+  }, async ({ question, options }) => {
+    const pid = await projectId();
+    const r = await api2("/v1/questions", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        projectId: pid,
+        sessionId: SESSION,
+        text: question,
+        options,
+        askedBy: "agent",
+        cwd: process.cwd()
+      })
+    });
+    if (!r.ok)
+      return fail(`REFUSED: ${r.error}`);
+    return ok(`asked as question #${r.question?.id}. A human will see it on the dashboard; the answer arrives as [swarm] context on a later tool call, or via swarm_inbox. Continue with what doesn't depend on it, or stop and say you're waiting.`, r.question);
+  });
+  server.registerTool("swarm_inbox", {
+    title: "Answers waiting for you",
+    description: "Answers a human has given to your swarm_ask questions that you haven't received yet.",
+    inputSchema: {}
+  }, async () => {
+    const qs = await api2(`/v1/inbox?session=${encodeURIComponent(SESSION ?? "")}`);
+    if (!qs.length)
+      return ok("no new answers", []);
+    return ok(qs.map((q) => `#${q.id} "${q.text}" \u2192 ${q.answeredBy ?? "a human"}: ${q.answer}`).join(`
+`), qs);
+  });
+  server.registerTool("swarm_dispatch", {
+    title: "Dispatch tasks to spawned agents",
+    description: "Hand ready tasks to autonomous runs: each gets its own claim + worktree and a `claude -p` run with a prompt built from the task (work in the worktree, run gates, hand off, open the PR). At most [dispatch] max_parallel run at once per repo; the rest queue. When a run ends Swarm derives the outcome from the ledger (gates satisfied, PR open) \u2014 never from the agent's word \u2014 and opens an incident if it fell short. Use from a lead session to fan work out; check progress with swarm_status or the Board.",
+    inputSchema: {
+      tasks: exports_external.array(exports_external.string()).optional().describe("task ids; omit with ready=true to take every ready task"),
+      ready: exports_external.boolean().optional(),
+      max: exports_external.number().int().positive().optional().describe("cap on tasks accepted this call")
+    }
+  }, async ({ tasks, ready, max }) => {
+    const pid = await projectId();
+    const r = await api2("/v1/dispatch", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        projectId: pid,
+        tasks,
+        ready: ready ?? !tasks?.length,
+        max,
+        owner: "mcp"
+      })
+    });
+    if (!r.ok)
+      return fail(`REFUSED: ${r.error}`);
+    const lines = [
+      ...r.started.map((t) => `started ${t}`),
+      ...r.queued.map((t) => `queued ${t}`),
+      ...r.rejected.map((x) => `rejected ${x.id} \u2014 ${x.reason}`)
+    ];
+    return ok(lines.join(`
+`) || "nothing to dispatch", r);
+  });
+  server.registerTool("swarm_pr_open", {
+    title: "Open a pull request for a task",
+    description: "Push the task's worktree branch and open a PR (GitHub via gh) or MR (GitLab via glab) for it, with the title and body drafted from the task, the latest handoff, the required gates' verdicts and the changed files \u2014 pass title/body to override. Refuses uncommitted changes: commit first. Use it as the last step of a task, after swarm_handoff and the gates.",
+    inputSchema: {
+      task: exports_external.string().describe("task id (held) or worktree name/path"),
+      title: exports_external.string().optional(),
+      body: exports_external.string().optional().describe("markdown; default is drafted from the handoff"),
+      draft: exports_external.boolean().optional().describe("open as a draft PR")
+    }
+  }, async ({ task, title, body, draft }) => {
+    const pid = await projectId();
+    const r = await api2("/v1/prs/open", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ projectId: pid, worktree: task, title, body, draft })
+    });
+    if (!r.ok)
+      return fail(`REFUSED: ${r.error}`);
+    return ok(`opened ${r.url}`, r);
+  });
   server.registerTool("swarm_gates", {
     title: "Gate status",
     description: "The gates this repo requires (.swarm.toml [gates] required) and, for a task, the latest verdict per gate with run history. A task is done only when every required gate's latest run is a pass.",
@@ -19885,7 +20029,7 @@ ${body}`, g);
     });
     if (!r.ok)
       return fail(`REFUSED: ${r.error}`);
-    return ok(`claimed ${task} \u2014 work in ${r.worktree} (branch ${r.branch}). cd there before editing.`, r);
+    return ok(`claimed ${task} \u2014 work in ${r.worktree} (branch ${r.branch}). cd there before editing.${r.bootstrap ? ` Worktree setup is running in the background (log: ${r.bootstrap}); wait for it before installing or running tests.` : ""}`, r);
   });
   server.registerTool("swarm_renew", {
     title: "Renew a claim",