huddle-cli 0.1.3 → 0.1.5

package/dist/connectors/hub.js

@@ -0,0 +1,234 @@
+// Connectors: the outside tools a team works with — GitHub, Jira, Confluence,
+// Linear, Notion, Miro… — given once to every agent in a run, whichever CLI it is.
+//
+// The Room runs them, not each agent: one process per connector per run, one
+// sign-in, and every call goes through the Plug (huddle plug), so Claude,
+// Codex, Cursor and the rest see the same tools without 14 vendor configs.
+//
+//   ~/.huddle/connectors.json   yours, on this machine (HUDDLE_HOME moves it)
+//   {
+//     "github": { "off": false, "write": false },
+//     "connectors": {
+//       "atlassian": { "command": ["npx", "-y", "mcp-remote", "https://mcp.atlassian.com/v1/mcp"] },
+//       "mine":      { "command": ["node", "/path/server.js"], "write": true, "env": { "X": "1" } }
+//     }
+//   }
+//
+// Any MCP server over stdio is a connector. Remote ones (an https URL) run
+// through mcp-remote, which does the service's OAuth itself and keeps the
+// token: Huddle holds none. Until you allow writes (`write: true`), agents
+// see only the tools that read.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { githubTools, runAsync } from "./github.js";
+/** Known services: `huddle connectors add atlassian`. Each is its vendor's own remote MCP server. */
+export const PRESETS = {
+    atlassian: { url: "https://mcp.atlassian.com/v1/mcp", what: "Jira and Confluence" },
+    linear: { url: "https://mcp.linear.app/mcp", what: "Linear issues and projects" },
+    notion: { url: "https://mcp.notion.com/mcp", what: "Notion pages and databases" },
+    miro: { url: "https://mcp.miro.com/", what: "Miro boards" },
+    sentry: { url: "https://mcp.sentry.dev/mcp", what: "Sentry errors" },
+};
+const ALIASES = { jira: "atlassian", confluence: "atlassian" };
+export const presetName = (n) => ALIASES[n.toLowerCase()] ?? n.toLowerCase();
+export const remoteCommand = (url) => ["npx", "-y", "mcp-remote", url];
+const home = () => process.env.HUDDLE_HOME ?? path.join(os.homedir(), ".huddle");
+export const configFile = () => path.join(home(), "connectors.json");
+export function readConfig() {
+    try {
+        const c = JSON.parse(fs.readFileSync(configFile(), "utf8"));
+        return c && typeof c === "object" ? c : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function writeConfig(c) {
+    fs.mkdirSync(path.dirname(configFile()), { recursive: true });
+    fs.writeFileSync(configFile(), JSON.stringify(c, null, 2) + "\n");
+}
+/** A connector's tool names start with its name: [a-z0-9_-], at most 64 characters (what every CLI accepts). */
+export const toolName = (connector, tool) => `${connector}_${tool}`.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 64);
+const READ_VERB = /^(get|list|search|read|fetch|view|find|query|lookup|describe|show|retrieve|count|whoami|atlassianUserInfo|getAccessible)/i;
+/**
+ * Whether a tool only reads. The server's own annotations decide when it
+ * gives them; otherwise its name does (getJiraIssue, search_issues, list_…).
+ */
+export function readsOnly(t) {
+    if (t.annotations?.readOnlyHint === true)
+        return true;
+    if (t.annotations?.readOnlyHint === false || t.annotations?.destructiveHint === true)
+        return false;
+    return READ_VERB.test(t.name.replace(/^[a-z]+_/, "")) || READ_VERB.test(t.name);
+}
+const MAX_RESULT = 60_000;
+/** An MCP tool result as plain text an agent can read (images and the like become a note). */
+function flatten(r) {
+    const parts = Array.isArray(r?.content) ? r.content : [];
+    const text = parts
+        .map((p) => (p?.type === "text" ? String(p.text ?? "") : p?.type === "resource" ? String(p.resource?.text ?? p.resource?.uri ?? "") : `(${p?.type ?? "item"} not shown)`))
+        .join("\n");
+    const out = text.length > MAX_RESULT ? text.slice(0, MAX_RESULT) + `\n… (cut at ${MAX_RESULT} characters)` : text;
+    return r?.isError ? { error: out || "the connector reported an error" } : out || r?.structuredContent || "(empty result)";
+}
+function withTimeout(p, ms, what) {
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(() => reject(new Error(`${what}: no answer in ${Math.round(ms / 1000)}s`)), ms);
+        p.then((v) => (clearTimeout(t), resolve(v)), (e) => (clearTimeout(t), reject(e)));
+    });
+}
+export async function githubReady(root) {
+    const r = await runAsync(["gh", "repo", "view", "--json", "nameWithOwner"], { cwd: root, timeoutMs: 15_000 });
+    if (r.code === 127)
+        return { ok: false, note: "the GitHub CLI isn't installed (https://cli.github.com)" };
+    if (r.code !== 0) {
+        const e = (r.stderr || r.stdout).toLowerCase();
+        if (/auth|log ?in|token/.test(e))
+            return { ok: false, note: "gh isn't signed in: gh auth login" };
+        if (/no git remote|not a git|none of the git remotes|could not determine/.test(e))
+            return { ok: false, note: "this repo has no GitHub remote" };
+        return { ok: false, note: (r.stderr || r.stdout).trim().split("\n")[0].slice(0, 160) || "gh failed" };
+    }
+    try {
+        return { ok: true, note: JSON.parse(r.stdout).nameWithOwner };
+    }
+    catch {
+        return { ok: true, note: "" };
+    }
+}
+/** Starts this machine's connectors for a run in `root`. Never throws: a connector that fails is left out, with a note. */
+export function startHub(opts) {
+    const cfg = opts.config ?? readConfig();
+    const tools = [];
+    const statuses = [];
+    const open = [];
+    let closed = false;
+    const sig = opts.signature ?? ((agent) => `<sub>— ${agent}, via Huddle</sub>`);
+    const github = async () => {
+        if (cfg.github?.off)
+            return;
+        const g = await (opts.githubReady ?? (() => githubReady(opts.root)))();
+        if (!g.ok)
+            return void statuses.push({ name: "github", ok: false, tools: 0, hidden: 0, note: g.note });
+        const gh = (args, input) => runAsync(["gh", ...args], { cwd: opts.root, input, timeoutMs: 45_000 });
+        const all = githubTools(gh, { write: true, signature: sig });
+        const mine = githubTools(gh, { write: !!cfg.github?.write, signature: sig });
+        tools.push(...mine);
+        statuses.push({ name: "github", ok: true, tools: mine.length, hidden: all.length - mine.length, note: g.note });
+    };
+    const mcp = async (name, c) => {
+        if (c.off)
+            return;
+        if (!Array.isArray(c.command) || !c.command.length)
+            return void statuses.push({ name, ok: false, tools: 0, hidden: 0, note: "no command" });
+        const transport = new StdioClientTransport({
+            command: c.command[0],
+            args: c.command.slice(1),
+            env: { ...process.env, ...(c.env ?? {}) },
+            cwd: opts.root,
+            stderr: "pipe",
+        });
+        const client = new Client({ name: "huddle", version: "1" });
+        try {
+            await withTimeout(client.connect(transport), opts.connectMs ?? 60_000, name);
+            const listed = await withTimeout(client.listTools(), opts.connectMs ?? 60_000, name);
+            if (closed)
+                return void client.close().catch(() => { });
+            open.push({ name, client, transport });
+            let hidden = 0;
+            for (const t of listed.tools) {
+                const write = !readsOnly(t);
+                if (write && !c.write) {
+                    hidden++;
+                    continue;
+                }
+                tools.push({
+                    name: toolName(name, t.name),
+                    description: `[${name}] ${t.description ?? t.name}`.slice(0, 1500),
+                    inputSchema: t.inputSchema ?? { type: "object", properties: {} },
+                    write,
+                    call: async (args) => flatten(await client.callTool({ name: t.name, arguments: args }, undefined, { timeout: 120_000 })),
+                });
+            }
+            statuses.push({ name, ok: true, tools: listed.tools.length - hidden, hidden, note: "" });
+        }
+        catch (e) {
+            client.close().catch(() => { });
+            statuses.push({ name, ok: false, tools: 0, hidden: 0, note: String(e?.message ?? e).split("\n")[0].slice(0, 200) });
+        }
+    };
+    const ready = Promise.all([github(), ...Object.entries(cfg.connectors ?? {}).map(([n, c]) => mcp(n, c))]).then(() => {
+        // Same name twice (two connectors exposing one tool): the first one wins.
+        const seen = new Set();
+        for (let i = 0; i < tools.length; i++) {
+            if (seen.has(tools[i].name))
+                tools.splice(i--, 1);
+            else
+                seen.add(tools[i].name);
+        }
+    });
+    return {
+        ready,
+        tools: () => tools,
+        status: () => statuses,
+        async call(name, args, agent) {
+            const t = tools.find((x) => x.name === name);
+            if (!t)
+                return { error: `no connector tool "${name}"` };
+            try {
+                return await t.call(args ?? {}, agent);
+            }
+            catch (e) {
+                return { error: String(e?.message ?? e) };
+            }
+        },
+        close() {
+            closed = true;
+            for (const o of open.splice(0))
+                o.client.close().catch(() => { });
+        },
+    };
+}
+/** One line per connector, for the run's opening and `huddle connectors`. */
+export function statusLine(s) {
+    if (!s.ok)
+        return `${s.name}: off — ${s.note}`;
+    return `${s.name}: ${s.tools} tool(s)${s.note ? ` · ${s.note}` : ""}${s.hidden ? ` · ${s.hidden} that write hidden` : ""}`;
+}
+const PHRASES = {
+    github_issues: (a) => `listed ${a.state && a.state !== "open" ? a.state + " " : ""}issues${a.search ? ` matching "${a.search}"` : ""}${a.label ? ` labelled ${a.label}` : ""}`,
+    github_issue: (a) => `read issue #${a.number}`,
+    github_prs: () => "listed pull requests",
+    github_pr: (a) => `read PR #${a.number}${a.diff ? " and its diff" : ""}`,
+    github_ci: (a) => `checked CI${a.branch ? ` on ${a.branch}` : ""}`,
+    github_comment: (a) => `commented on #${a.number}`,
+    github_new_issue: (a) => `opened an issue: ${String(a.title ?? "").slice(0, 80)}`,
+};
+/** A connector call in words, for the live run: { head: "github:", body: "read issue #12" }. */
+export function connectorLine(p) {
+    const tool = String(p.tool ?? "");
+    const [conn, ...rest] = tool.split("_");
+    const phrase = PHRASES[tool]?.(p.args ?? {}) ?? rest.join("_").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+    return { head: `${conn}:`, body: phrase + (p.ok === false ? " (failed)" : "") };
+}
+/**
+ * For the planner and the council, who plan without tools: what the agents
+ * will be able to read while they work, so a goal naming a ticket gets tasks
+ * that read it first instead of guessing what it says.
+ */
+export function toolsNote(hub) {
+    const by = new Map();
+    for (const t of hub.tools()) {
+        const conn = t.name.split("_")[0];
+        by.set(conn, [...(by.get(conn) ?? []), t.name]);
+    }
+    if (!by.size)
+        return "";
+    return `OUTSIDE TOOLS: every agent can call these while it works (you can't, in this step):
+${[...by].map(([c, names]) => `- ${c}: ${names.join(", ")}`).join("\n")}
+When the goal names something only these tools can show (a ticket, issue, PR, page, board), don't guess what it says: the spec of every task that needs it says to read it first, naming the tool and the item (e.g. "read WEB-7 with jira_getJiraIssue").`;
+}
+//# sourceMappingURL=hub.js.map

package/dist/connectors/types.js

@@ -0,0 +1,3 @@
+// What a connector gives agents: tools, each one callable through the Plug.
+export {};
+//# sourceMappingURL=types.js.map

package/dist/mcp/context-tools.js

@@ -54,6 +54,8 @@ export function contextTools(room) {
  * machines (a teammate's agent) are saved here and replaced by a local path.
  */
 export function toContent(result) {
+    if (typeof result === "string")
+        return [{ type: "text", text: result }];
     if (!result || typeof result !== "object" || Array.isArray(result))
         return [{ type: "text", text: JSON.stringify(result, null, 2) }];
     const { image, file, ...rest } = result;

package/dist/mcp/server.js

@@ -262,6 +262,7 @@ export const PLUG_INSTRUCTIONS = `Huddle: you are one of several AI coding agent
 - Sharing work: when huddle_offer_help reaches you, huddle_split hands part of your task to a free agent; huddle_take_backlog picks up the next task; huddle_claim takes a specific one.
 - QA rounds: huddle_report_bug files one reproducible bug in the merged build; it becomes a fix task for the file's author.
 - The shared screen (what the user pasted, dropped or uploaded — logs, docs, screenshots): huddle_context lists it, huddle_context_read opens one item in chunks (images/PDFs as a file path), huddle_context_search finds text in it, huddle_context_note pins a comment on an item for everyone.
+- Connectors: tools named github_*, atlassian_*, linear_*… (when listed) reach the team's outside tools — issues, tickets, docs, CI. When the goal names an issue or ticket, read it (and its comments) before you start. Post or change things there only when your task asks for it.
 - Finish: huddle_done with a short summary. Huddle tests and merges it.`;
 /** The Plug's verb names, in the order listed to agents. */
 export const PLUG_VERBS = TOOLS.map((t) => t.name);
@@ -270,13 +271,32 @@ export async function runPlug() {
     if (process.env.HUDDLE_LIVE)
         return (await import("../attach/plug.js")).runLivePlug();
     const server = new Server({ name: "huddle", version: packageInfo().version }, { capabilities: { tools: {} }, instructions: PLUG_INSTRUCTIONS });
+    // Connectors (GitHub, Jira, …) the Room runs for this session, after Huddle's own verbs.
+    let extra = null;
+    const connectorTools = async () => {
+        if (extra)
+            return extra;
+        try {
+            const r = await room("/tools", "GET");
+            extra = Array.isArray(r?.tools) ? r.tools : [];
+        }
+        catch {
+            extra = [];
+        }
+        return extra;
+    };
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: TOOLS.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })),
+        tools: [...TOOLS.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })), ...(await connectorTools())],
     }));
     server.setRequestHandler(CallToolRequestSchema, async (req) => {
         const tool = TOOLS.find((t) => t.name === req.params.name);
-        if (!tool)
-            throw new Error(`unknown tool: ${req.params.name}`);
+        if (!tool) {
+            if (!(await connectorTools()).some((t) => t.name === req.params.name))
+                throw new Error(`unknown tool: ${req.params.name}`);
+            const r = await room("/tool", "POST", { name: req.params.name, arguments: req.params.arguments ?? {} });
+            const result = r?.result ?? r;
+            return { content: toContent(result), isError: !!(result && typeof result === "object" && "error" in result) };
+        }
         const result = await tool.handler((req.params.arguments ?? {}));
         return { content: toContent(result) };
     });

package/dist/orchestrator/council.js

@@ -372,7 +372,7 @@ export async function runCouncil(goal, crew, members, repoRoot, opts) {
     // (0.1.2): the whole team waited 2 minutes on one agent's ratify that then timed out.
     const ratifyMs = Math.min(timeoutMs, (Number(process.env.HUDDLE_RATIFY_TIMEOUT_S) || 75) * 1000);
     const ro = { ask: opts.ask ?? defaultAsk, cwd: repoRoot, timeoutMs, signal: opts.signal, onEvent: opts.onEvent };
-    const context = repoContext(repoRoot, 150);
+    const context = repoContext(repoRoot, 150) + (opts.outside ? `\n\n${opts.outside}` : "");
     const ids = members.map((m) => m.id);
     const result = (extra) => ({
         members: ids,

package/dist/orchestrator/planner.js

@@ -147,7 +147,7 @@ export async function planGoal(goal, crew, repoRoot, opts = {}) {
     const brain = opts.brain ?? brainFrom("claude");
     if (!brain)
         return { tasks: templatePlan(goal), by: "template", note: "no brain available" };
-    const prompt = plannerPrompt(goal, crew, repoContext(repoRoot), undefined, { project: opts.project });
+    const prompt = plannerPrompt(goal, crew, repoContext(repoRoot) + (opts.outside ? `\n\n${opts.outside}` : ""), undefined, { project: opts.project });
     let ms = 0;
     for (let attempt = 0; attempt < 2 && !opts.signal?.aborted; attempt++) {
         const res = await brain.think(prompt, repoRoot, {

package/dist/orchestrator/scheduler.js

@@ -53,12 +53,32 @@ HOW:
    resolution and re-runs the tests before anything lands.
 4. huddle_remember(kind="decision", body=<how you combined them>, why=...), then huddle_done(task_id, summary).`;
 }
-function reviewPrompt(title, spec, diff, contract = "") {
+/** What a task's author read through connectors (a ticket, an issue), for a reviewer who has no tools. */
+export function outsideReads(db, taskId, max = 8000) {
+    const seen = new Set();
+    const parts = [];
+    for (const e of db.eventsOfType(["connector.call"], 0, 500)) {
+        if (e.task_id !== taskId)
+            continue;
+        const p = JSON.parse(e.payload || "{}");
+        if (p.ok === false || !p.result)
+            continue;
+        const key = `${p.tool} ${JSON.stringify(p.args ?? {})}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        parts.push(`- ${key}:\n${p.result}`);
+    }
+    if (!parts.length)
+        return "";
+    return cap(`WHAT THE AUTHOR READ FROM OUTSIDE TOOLS (verbatim — the ticket/issue the task refers to):\n${parts.join("\n")}`, max);
+}
+function reviewPrompt(title, spec, diff, contract = "", outside = "") {
     return `You are reviewing a teammate's change before Huddle merges it. Another AI agent wrote it.
 
 TASK: ${title}
 ${spec}
-${contract ? `\n${cap(contract, 2500)}\n` : ""}
+${contract ? `\n${cap(contract, 2500)}\n` : ""}${outside ? `\n${outside}\n` : ""}
 DIFF (against main):
 ${diff || "(empty diff)"}
 
@@ -985,7 +1005,7 @@ export async function runBoard(opts) {
                 onEvent({ type: "review", agent: reviewer.id, author: w.id, task: task.id, title: task.title });
                 fill(); // everyone else keeps going
                 const t0 = Date.now();
-                const res = await askAgent(reviewer.adapter, reviewPrompt(task.title, task.spec, branchDiff(repoRoot, wt), contract()), wt.path, {
+                const res = await askAgent(reviewer.adapter, reviewPrompt(task.title, task.spec, branchDiff(repoRoot, wt), contract(), outsideReads(db, task.id)), wt.path, {
                     signal,
                     timeoutMs: 90_000,
                     noTools: true, // the diff is in the prompt — no need to explore

package/dist/room/server.js

@@ -674,6 +674,33 @@ export async function startRoom(db, port = 0, info = {}) {
         "POST /context_search": "context_search",
         "POST /context_note": "context_note",
     };
+    /** GET /tools: the connectors' tools (once they've started, bounded); POST /tool: call one. */
+    const connectorVerb = async (p, req, agentId) => {
+        const hub = room.connectors;
+        if (p === "/tools") {
+            if (!hub)
+                return { status: 200, body: { tools: [] } };
+            await Promise.race([hub.ready, new Promise((r) => setTimeout(r, 20_000))]);
+            return { status: 200, body: { tools: hub.tools().map(({ name, description, inputSchema }) => ({ name, description, inputSchema })) } };
+        }
+        const body = await readJson(req);
+        const name = String(body.name ?? "");
+        if (!hub)
+            return { status: 200, body: { error: "no connectors in this run" } };
+        const t0 = Date.now();
+        const result = await hub.call(name, body.arguments && typeof body.arguments === "object" ? body.arguments : {}, agentId);
+        const failed = !!result && typeof result === "object" && "error" in result;
+        // What it read is kept (cut short) on the agent's task: a reviewer has no tools, and needs
+        // the ticket the author built from (found live, 0.1.4: codex sent back WEB-7 for "the ticket's missing").
+        const task = db.listTasks().find((t) => t.claimed_by === agentId && !["merged", "backlog"].includes(t.status));
+        const text = typeof result === "string" ? result : JSON.stringify(result);
+        db.publish("connector.call", {
+            agent_id: agentId,
+            task_id: task?.id ?? null,
+            payload: { tool: name, args: body.arguments ?? {}, ms: Date.now() - t0, ok: !failed, result: text.length > 6000 ? text.slice(0, 6000) + " …(cut)" : text },
+        });
+        return { status: 200, body: { result } };
+    };
     const localServer = http.createServer(async (req, res) => {
         const url = new URL(req.url ?? "/", "http://local");
         const reply = (r) => {
@@ -688,6 +715,8 @@ export async function startRoom(db, port = 0, info = {}) {
                 const body = req.method === "POST" ? await readJson(req) : Object.fromEntries(url.searchParams);
                 return reply(await room.live.handle(live[1], body, String(req.headers["x-huddle-agent"] ?? "")));
             }
+            if (url.pathname === "/tools" || url.pathname === "/tool")
+                return reply(await connectorVerb(url.pathname, req, String(req.headers["x-huddle-agent"] ?? "agent")));
             const verb = LOCAL_VERBS[`${req.method} ${url.pathname}`];
             if (!verb)
                 return reply({ status: 404, body: { error: "not found" } });

package/dist/ui/app.js

@@ -10,6 +10,8 @@
 //
 // Everything happens here. Claude, Codex, Gemini and Cursor run in the
 // background as Huddle's workers; you watch the board, never their terminals.
+import { issueGoal, issueMentions, issueRef, runAsync } from "../connectors/github.js";
+import { connectorLine, startHub, statusLine, toolsNote } from "../connectors/hub.js";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -614,6 +616,7 @@ async function withSpinner(label, p) {
 /** A run, and the brief's pointers put back however it ended (plan mode, a stop, a crash). */
 /** The current run's typing line and open questions, closed however the run ends (a throw included). */
 let endTalkNow = null;
+let hubNow = null;
 export async function runGoal(goal, opts) {
     try {
         await runGoalOnce(goal, opts);
@@ -621,6 +624,8 @@ export async function runGoal(goal, opts) {
     finally {
         endTalkNow?.();
         endTalkNow = null;
+        hubNow?.close();
+        hubNow = null;
         if (isGitRepo(process.cwd()))
             placePointers(repoRoot(), { enabled: readPrefs().brief !== false });
     }
@@ -659,6 +664,48 @@ async function runGoalOnce(goal, opts) {
     }
     const root = repoRoot();
     const rl = opts.rl;
+    // `huddle build #12`: the GitHub issue, verbatim, is the goal (connectors/github.ts).
+    const issueNo = issueRef(goal);
+    if (issueNo !== null) {
+        const r = await runAsync(["gh", "issue", "view", String(issueNo), "--json", "number,title,body,url,comments"], { cwd: root, timeoutMs: 30_000 });
+        if (r.code !== 0) {
+            print(C.red(`✗ couldn't read GitHub issue #${issueNo}: `) + ((r.stderr || r.stdout).trim().split("\n")[0] || "gh failed") + C.faint(r.code === 127 ? "  (install the GitHub CLI: https://cli.github.com)" : ""));
+            if (!opts.rl)
+                process.exitCode = 1;
+            return;
+        }
+        const issue = JSON.parse(r.stdout);
+        goal = issueGoal(issue);
+        print(`  ${C.violet("◆")} ${C.faint("goal from GitHub issue")} #${issue.number}: ${issue.title}`);
+    }
+    else {
+        // "fix #12 and add a test": the goal stays yours, the issue comes along (when gh can read it).
+        for (const n of issueMentions(goal)) {
+            const r = await runAsync(["gh", "issue", "view", String(n), "--json", "number,title,body,url,comments"], { cwd: root, timeoutMs: 20_000 });
+            if (r.code !== 0)
+                continue;
+            try {
+                const issue = JSON.parse(r.stdout);
+                goal += `\n\n--- ${issueGoal(issue).replace(/^Resolve /, "")}`;
+                print(`  ${C.violet("◆")} ${C.faint("with GitHub issue")} #${issue.number}: ${issue.title}`);
+            }
+            catch {
+                /* not an issue: leave the goal as typed */
+            }
+        }
+    }
+    // GitHub, Jira, … for every agent this run, through the Plug (connectors/hub.ts).
+    // Started now, so they connect while the plan is made, and the planner knows what agents can read.
+    const hub = startHub({ root });
+    hubNow = hub;
+    let saidTools = false;
+    const outside = async () => {
+        await Promise.race([hub.ready, new Promise((r) => setTimeout(r, 30_000))]);
+        if (!saidTools && hub.status().length)
+            print(C.faint(`  connectors: ${hub.status().map(statusLine).join("  ·  ")}`));
+        saidTools = true;
+        return toolsNote(hub);
+    };
     // Teammates' agents (from `huddle join` on their machines) work alongside yours.
     const bridge = opts.room?.server.remote;
     const remoteNow = () => (bridge?.workers() ?? []).map((r) => ({ id: r.id, remote: r }));
@@ -943,7 +990,7 @@ async function runGoalOnce(goal, opts) {
             /* no history: roster order */
         }
         try {
-            plan = await runCouncil(goal, crew, members, root, { brain, signal: life.signal, onEvent: onCouncil, pastSyntheses: past });
+            plan = await runCouncil(goal, crew, members, root, { brain, signal: life.signal, onEvent: onCouncil, pastSyntheses: past, outside: await outside() });
         }
         finally {
             stopDock(); // the plan prints in full; the dock comes back for the build
@@ -954,7 +1001,7 @@ async function runGoalOnce(goal, opts) {
         opts.onStats?.(stats);
         // A big goal without a council (--no-council, or one agent) still gets a project-sized plan.
         const project = !listsOwnTasks(goal) && isBigGoal(goal, { repoFiles });
-        plan = await withSpinner(`planning with ${brain?.label ?? "template"}…`, planGoal(goal, crew, root, { brain, signal: life.signal, project }));
+        plan = await withSpinner(`planning with ${brain?.label ?? "template"}…`, planGoal(goal, crew, root, { brain, signal: life.signal, project, outside: await outside() }));
     }
     if (life.signal.aborted)
         return endTalk();
@@ -1009,6 +1056,7 @@ async function runGoalOnce(goal, opts) {
     const seen = [];
     db.clearBoard();
     const room = opts.room?.server ?? (await startRoom(db, ROOM_PORT));
+    room.connectors = hub;
     const taskIds = seedBoard(db, goal, plan.tasks);
     // Who planned it, for `huddle story` (the tasks themselves are task.added events).
     db.publish("plan.made", { payload: { by: plan.by, note: plan.note ?? null, ms: plan.ms ?? null, tokens: plan.tokens ?? null, tasks: plan.tasks.length, plain: plan.plain ?? null } });
@@ -1079,6 +1127,12 @@ async function runGoalOnce(goal, opts) {
             const head = `  ${C.violet("◆")} ${pad(String(p.author ?? "memory"), 12)} ${C.faint("noted:")} `;
             print(`${head}${oneLine(p.body, space(head))}`);
         }
+        else if (e.type === "connector.call" && e.agent_id) {
+            // "codex  github: read issue #12"
+            const line = connectorLine(p);
+            sayOne(e.agent_id, C.faint(line.head), line.body);
+            act(e.agent_id, `${C.faint(line.head)} ${line.body}`);
+        }
         else if (e.type === "plan.announced" && e.agent_id) {
             sayOne(e.agent_id, C.faint("plans:"), p.intent ?? "");
             act(e.agent_id, `${C.faint("plans:")} ${p.intent ?? ""}`);
@@ -1320,6 +1374,9 @@ async function runGoalOnce(goal, opts) {
     unsub();
     unwatchBudget();
     room.askUser = undefined;
+    room.connectors = undefined;
+    hub.close();
+    hubNow = null;
     endTalk();
     const undone = budget.level === "ok" ? [] : db.listTasks().filter((t) => t.status === "backlog").map((t) => t.title);
     const doneNotes = db.recall().filter((m) => /^Task \S+ done:/.test(m.body)).map((m) => `- (${m.author}) ${m.body}`);
@@ -1330,6 +1387,8 @@ async function runGoalOnce(goal, opts) {
         if (ev.task_id && p.kind === "rescue" && p.branch)
             takeovers.set(ev.task_id, String(p.branch));
     }
+    // What `huddle undo` takes back: every commit this run put on the branch.
+    db.publish("git.range", { payload: { start: startHead, end: git(["rev-parse", "HEAD"], root).out, branch: git(["symbolic-ref", "--short", "HEAD"], root).out } });
     const learned = learnFromRun({ db, root, since: runStart, events: seen });
     progress({ phase: "DONE" });
     board = null;

package/dist/ui/catalog.js

@@ -93,7 +93,7 @@ export function printAgents() {
     }
     console.log(`\n  ${C.faint("choose:")}          huddle agents use claude,codex  ${C.faint("·")}  huddle agents skip cursor`);
     console.log(`  ${C.faint("set up the rest:")} huddle setup`);
-    console.log(`  ${C.faint("every connector:")} huddle agents --all\n`);
+    console.log(`  ${C.faint("every agent:    ")} huddle agents --all\n`);
 }
 /** `huddle agents use|skip <ids>`: remembered in ~/.huddle/prefs.json. */
 export function chooseAgents(verb, list) {