huddle-cli 0.0.0-stage → 0.1.1

package/dist/mcp/server.js

@@ -0,0 +1,267 @@
+// The Plug: one MCP server, spoken identically by every agent (Claude, Codex,
+// Gemini, Cursor). It is launched per-agent as `huddle plug` and talks to the
+// Room over HTTP, so the agent process stays stateless — the Room owns truth.
+//
+// The agent's identity is passed in via HUDDLE_AGENT_ID (set by the launcher),
+// so each agent's calls are attributed correctly without the model having to
+// remember who it is.
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { contextTools, toContent } from "./context-tools.js";
+import { packageInfo } from "../preflight.js";
+const ROOM = process.env.HUDDLE_ROOM_URL ?? "http://localhost:4737";
+const AGENT = process.env.HUDDLE_AGENT_ID ?? "unknown-agent";
+// Proves to the Room that this call comes from one of this session's own agents.
+const SECRET = process.env.HUDDLE_SECRET ?? "";
+async function room(path, method, body) {
+    const res = await fetch(`${ROOM}${path}`, {
+        method,
+        headers: { "content-type": "application/json", "x-huddle-secret": SECRET, "x-huddle-agent": AGENT },
+        body: method === "POST" ? JSON.stringify({ agent_id: AGENT, ...body }) : undefined,
+    });
+    return res.json();
+}
+const TOOLS = [
+    {
+        name: "huddle_board",
+        description: "See the whole shared task board: the goal, every agent, who claimed what, and live progress. Call this BEFORE you start work and whenever you finish a step.",
+        inputSchema: { type: "object", properties: {} },
+        handler: () => room("/board", "GET"),
+    },
+    {
+        name: "huddle_peers",
+        description: "See what every other agent is doing RIGHT NOW (status + current task). Use this to avoid duplicating work and to know if a teammate is close to done.",
+        inputSchema: { type: "object", properties: {} },
+        handler: () => room("/peers", "GET"),
+    },
+    {
+        name: "huddle_claim",
+        description: "Atomically claim a backlog task so it's yours. Fails if someone already took it or its dependencies aren't merged yet. Always claim before coding.",
+        inputSchema: {
+            type: "object",
+            properties: { task_id: { type: "string" } },
+            required: ["task_id"],
+        },
+        handler: (a) => room("/claim", "POST", { task_id: a.task_id }),
+    },
+    {
+        name: "huddle_check_overlap",
+        description: "Before you edit files/symbols, check whether any teammate has already claimed them. Pass entries as 'path' or 'path::symbol'. Returns anyone you'd collide with.",
+        inputSchema: {
+            type: "object",
+            properties: { touches: { type: "array", items: { type: "string" } } },
+            required: ["touches"],
+        },
+        handler: (a) => room("/check_overlap", "POST", { touches: a.touches }),
+    },
+    {
+        name: "huddle_announce_plan",
+        description: "Announce what you're about to change BEFORE writing code: your intent + the files/symbols you'll touch ('path' or 'path::symbol'). Takes soft leases and flags collisions early.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task_id: { type: "string" },
+                intent: { type: "string" },
+                touches: { type: "array", items: { type: "string" } },
+            },
+            required: ["task_id", "intent", "touches"],
+        },
+        handler: (a) => room("/announce_plan", "POST", { task_id: a.task_id, intent: a.intent, touches: a.touches }),
+    },
+    {
+        name: "huddle_progress",
+        description: "Post live progress on your task (0-100) with a short note. Fans out instantly to the dashboard and to any teammate waiting on you.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task_id: { type: "string" },
+                pct: { type: "number" },
+                note: { type: "string" },
+            },
+            required: ["task_id", "pct"],
+        },
+        handler: (a) => room("/progress", "POST", { task_id: a.task_id, pct: a.pct, note: a.note ?? "" }),
+    },
+    {
+        name: "huddle_split",
+        description: "Your task is big and a teammate is free (you'll see a help offer in huddle_inbox)? Hand a separable PART of it to the room as a new task — ideally one in files you won't keep editing. Huddle gives it to a free agent and merges it separately; you keep the rest and must not do that part yourself. after_mine=true makes the part wait until your task merges.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                task_id: { type: "string", description: "your task" },
+                title: { type: "string", description: "short title of the part you hand off" },
+                spec: { type: "string", description: "exactly what the part must do, incl. names/contracts it must match" },
+                files: { type: "array", items: { type: "string" }, description: "files the part owns" },
+                after_mine: { type: "boolean" },
+            },
+            required: ["task_id", "title", "spec"],
+        },
+        handler: (a) => room("/split", "POST", { task_id: a.task_id, title: a.title, spec: a.spec, files: a.files ?? [], after_mine: !!a.after_mine }),
+    },
+    {
+        name: "huddle_offer_help",
+        description: "You're done (or nearly) and could take more: tell every teammate who is mid-task that you can take part of their work. Returns what's in flight (owner, status, progress, last note, age). They decide whether to huddle_split.",
+        inputSchema: { type: "object", properties: {} },
+        handler: () => room("/offer_help", "POST", {}),
+    },
+    {
+        name: "huddle_remember",
+        description: "Write to SHARED MEMORY so other agents learn from you. kind = decision | fact | gotcha | lesson. Always include 'why' — teammates need the reasoning, not just the what. kind=lesson is also kept for FUTURE runs in this repo: one short, general rule you'd want next time (e.g. 'run npm run typecheck too: npm test doesn't type-check').",
+        inputSchema: {
+            type: "object",
+            properties: {
+                kind: { type: "string", enum: ["decision", "fact", "gotcha", "lesson"] },
+                body: { type: "string" },
+                why: { type: "string" },
+            },
+            required: ["kind", "body"],
+        },
+        handler: (a) => room("/remember", "POST", { kind: a.kind, body: a.body, why: a.why ?? "" }),
+    },
+    {
+        name: "huddle_recall",
+        description: "Read shared memory — the decisions, facts, and gotchas other agents have recorded. Call this at the start of any task to inherit context instead of re-deriving it.",
+        inputSchema: {
+            type: "object",
+            properties: { query: { type: "string" } },
+        },
+        handler: (a) => room(`/recall${a.query ? `?q=${encodeURIComponent(a.query)}` : ""}`, "GET"),
+    },
+    {
+        name: "huddle_ask",
+        description: "Ask a question another agent (on any teammate's machine) may know — e.g. 'what shape is the Order type?'. With `to` = a teammate agent that's working right now, it goes to THEIR inbox and waits a short while for their reply; otherwise (or if they're slow) it's answered from shared memory, and their late reply arrives in your huddle_inbox. Use it before guessing at a contract someone else owns.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                question: { type: "string" },
+                to: { type: "string", description: "optional: the agent who owns it, e.g. 'codex' or 'harsh/codex' (see huddle_peers)" },
+            },
+            required: ["question"],
+        },
+        handler: (a) => room("/ask", "POST", { question: a.question, to: a.to }),
+    },
+    {
+        name: "huddle_send",
+        description: "Message a teammate agent directly: a heads-up ('I renamed X to Y'), an interface you're exposing, or an answer to their question (pass reply_to = the question's id). `to` = an agent id from huddle_peers, a task id, \"all\" for everyone working now, or \"huddle\" to answer Huddle itself. They see it the next time they call any huddle tool.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                to: { type: "string", description: "agent id (e.g. 'codex', 'claude#2', 'harsh/codex'), a task id, or 'all'" },
+                message: { type: "string" },
+                reply_to: { type: "string", description: "optional: id of the message/question you're answering" },
+            },
+            required: ["message"],
+        },
+        handler: (a) => room("/send", "POST", { to: a.to, message: a.message, reply_to: a.reply_to }),
+    },
+    {
+        name: "huddle_contract",
+        description: "Read the team's CONTRACT: the exact cross-task names everyone codes to (files and owners, function signatures, data fields, CLI flags, routes, error strings), its version, and every amendment since. Check it before you name anything another task uses.",
+        inputSchema: { type: "object", properties: {} },
+        handler: () => room("/contract", "GET"),
+    },
+    {
+        name: "huddle_amend_contract",
+        description: "Change or add a name in the CONTRACT (a signature, a field, a file owner, an error string) when your task needs one that isn't there or is wrong. Bumps the version and messages every teammate working now. Never invent a name another task depends on without this.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                section: { type: "string", description: "what part it changes, e.g. 'store.js exports' or 'error strings'" },
+                change: { type: "string", description: "the exact new name/signature/shape" },
+                why: { type: "string" },
+            },
+            required: ["section", "change", "why"],
+        },
+        handler: (a) => room("/amend_contract", "POST", { section: a.section, change: a.change, why: a.why }),
+    },
+    {
+        name: "huddle_inbox",
+        description: "Read messages and questions teammates sent you (marks them read). Huddle tool results already carry new ones (new_messages); call this for more, or with id for a message shown cut short. Answer questions with huddle_send(reply_to=…).",
+        inputSchema: { type: "object", properties: { id: { type: "string", description: "optional: one message's id" } } },
+        handler: (a) => room(a?.id ? `/inbox?id=${encodeURIComponent(String(a.id))}` : "/inbox", "GET"),
+    },
+    {
+        name: "huddle_report_bug",
+        description: "QA: file ONE concrete, reproducible bug you found in the team's merged work. It becomes a fix task on the board, routed to the agent that wrote those files. Exact steps or a command in `repro`; `files` = where the defect is. When sensible, add a regression test that fails today: write it in your worktree and pass its path as `test_file` (or its content as `test_code`). Duplicates are merged automatically. Not for style nits.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                title: { type: "string", description: "short: what is broken" },
+                repro: { type: "string", description: "exact command(s) or steps that show it" },
+                expected: { type: "string" },
+                actual: { type: "string" },
+                files: { type: "array", items: { type: "string" }, description: "files the defect is in" },
+                test_file: { type: "string", description: "optional: path of a regression test you wrote (fails now, passes once fixed)" },
+                test_code: { type: "string", description: "optional: that test's full content, if you didn't write the file" },
+            },
+            required: ["title", "repro", "expected", "actual"],
+        },
+        handler: (a) => room("/report_bug", "POST", {
+            title: a.title,
+            repro: a.repro,
+            expected: a.expected,
+            actual: a.actual,
+            files: a.files ?? [],
+            test_file: a.test_file,
+            test_code: a.test_code,
+        }),
+    },
+    {
+        name: "huddle_take_backlog",
+        description: "You're free. Ask the Room for the highest-value unblocked backlog task that fits your strengths, and claim it automatically. This is how idle agents remove bottlenecks.",
+        inputSchema: {
+            type: "object",
+            properties: { prefers: { type: "array", items: { type: "string" } } },
+        },
+        handler: (a) => room("/take_backlog", "POST", { prefers: a.prefers ?? [] }),
+    },
+    {
+        name: "huddle_done",
+        description: "Mark your task ready. This triggers the test-gate and, if green, the merge into main. Include a short summary of what you did. " +
+            "If a teammate's buddy note or a radar finding on your task has no answer yet, it is refused once with the list: fix each one, or reply " +
+            "huddle_send(to=<who sent it>, reply_to=<its id>, message=\"won't fix: <why>\"), then call huddle_done again.",
+        inputSchema: {
+            type: "object",
+            properties: { task_id: { type: "string" }, summary: { type: "string" } },
+            required: ["task_id", "summary"],
+        },
+        handler: (a) => room("/done", "POST", { task_id: a.task_id, summary: a.summary }),
+    },
+    ...contextTools(room),
+];
+/**
+ * What an MCP host shows the model about the Plug as a whole: the verbs by
+ * phase of a task, so every vendor's agent learns the same team habits. Every
+ * tool in TOOLS is named here (test/team-run.test.ts checks).
+ */
+export const PLUG_INSTRUCTIONS = `Huddle: you are one of several AI coding agents working on one repo at once, each in its own git worktree. These tools are how the team talks.
+- Start: huddle_board (the plan and who is doing what), huddle_recall (shared memory: decisions, contracts, the design council's notes: huddle_recall "council"), huddle_peers, huddle_inbox.
+- Before editing: huddle_announce_plan (what you will touch), huddle_check_overlap (is someone else in that file), huddle_contract (the exact names tasks share).
+- Names other tasks use: code to the contract verbatim. Never invent one that isn't in it — huddle_amend_contract(section, change, why) first; it tells every teammate.
+- While working: huddle_progress (a short note; the reply shows the team's in-flight work), huddle_remember (a decision or contract others need; kind "lesson" is kept for future runs), huddle_send (message one teammate), huddle_ask (ask a teammate or the brain a question), huddle_inbox (read replies).
+- 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.
+- 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);
+export async function runPlug() {
+    // Attach mode (`huddle connect`): a session you started yourself, no scheduler.
+    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 });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: TOOLS.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema })),
+    }));
+    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}`);
+        const result = await tool.handler((req.params.arguments ?? {}));
+        return { content: toContent(result) };
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+//# sourceMappingURL=server.js.map

package/dist/orchestrator/ask.js

@@ -0,0 +1,54 @@
+// One-shot, read-only questions to an agent: answering "where are we with
+// this project?" and planning a goal. Runs in the repo itself (no worktree),
+// with each vendor's read-only / plan mode, so nothing can be edited.
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { stopChild } from "./launcher.js";
+import { onFinished, spawnTool } from "../platform.js";
+/** Preference order for who answers questions and plans. */
+const ASK_ORDER = ["claude", "codex", "antigravity", "cursor", "gemini"];
+export function pickAsker(ready) {
+    return [...ready].filter((a) => a.ask).sort((a, b) => ASK_ORDER.indexOf(a.id) - ASK_ORDER.indexOf(b.id))[0];
+}
+export function askAgent(adapter, prompt, cwd, opts = {}) {
+    // Unique per call: the design council asks several agents in the same millisecond.
+    const outFile = path.join(os.tmpdir(), `huddle-ask-${process.pid}-${Date.now()}-${randomUUID().slice(0, 8)}.txt`);
+    const spec = adapter.ask({ prompt, cwd, outFile, model: opts.model, noTools: opts.noTools, quick: opts.quick });
+    return new Promise((resolve) => {
+        const child = spawnTool(spec.cmd, { cwd: spec.cwd, stdio: ["ignore", "pipe", "pipe"] }, { prompt, stdinPrompt: adapter.stdinPrompt });
+        let out = "";
+        let err = "";
+        child.stdout.on("data", (d) => (out += d));
+        child.stderr.on("data", (d) => (err += d));
+        // SIGKILL after a grace period: a stalled CLI can ignore SIGTERM (seen live with cursor-agent).
+        const stop = () => stopChild(child);
+        const timer = setTimeout(stop, opts.timeoutMs ?? 5 * 60_000);
+        opts.signal?.addEventListener("abort", stop);
+        let over = false;
+        const finish = (code) => {
+            if (over)
+                return;
+            over = true;
+            clearTimeout(timer);
+            let text = out;
+            if (spec.usesOutFile) {
+                try {
+                    text = fs.readFileSync(outFile, "utf8");
+                    fs.unlinkSync(outFile);
+                }
+                catch {
+                    /* fall back to stdout */
+                }
+            }
+            resolve({ ok: code === 0 && text.trim().length > 0, text: text.trim() || err.trim() });
+        };
+        // "exit" can arrive before the last of stdout has been read — when our event
+        // loop was busy (a merge's test run blocks it) the answer was lost and the
+        // review counted as timed out (found on CI). onFinished waits for the pipes
+        // to drain, but not forever: a CLI's leftover child can hold them open.
+        onFinished(child, finish);
+    });
+}
+//# sourceMappingURL=ask.js.map

package/dist/orchestrator/brain.js

@@ -0,0 +1,174 @@
+// The brain: the model Huddle itself thinks with — planning goals, reviewing
+// diffs, writing the "what you got" report. It's separate from the agents that
+// write code, so it can be something small and cheap:
+//
+//   ollama:<model>   a local model (e.g. Qwen2.5-Coder) — free, private, offline
+//   cursor:<model>   a cheap hosted model through Cursor (e.g. grok-4.7-low-fast)
+//   claude:<model>   Claude at a given size (claude:haiku, claude:opus)
+//   codex / antigravity[:model]
+//
+// Agent-backed brains can read the repo themselves. A local model can't, so
+// every prompt carries a compact repo snapshot (see repoContext) — which also
+// makes agent brains faster, since they don't have to explore first.
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { ADAPTERS } from "../adapters/index.js";
+import { askAgent } from "./ask.js";
+import { lessonsBrief } from "../room/lessons.js";
+import { screenForPlanner } from "../room/context.js";
+const OLLAMA = process.env.OLLAMA_HOST?.replace(/\/$/, "") || "http://127.0.0.1:11434";
+/** Models a local Ollama has pulled, or [] if Ollama isn't running. */
+export async function ollamaModels() {
+    try {
+        const r = await fetch(`${OLLAMA}/api/tags`, { signal: AbortSignal.timeout(1500) });
+        const j = await r.json();
+        return (j.models ?? []).map((m) => String(m.name).replace(/:latest$/, ""));
+    }
+    catch {
+        return [];
+    }
+}
+function ollamaBrain(model) {
+    return {
+        spec: `ollama:${model}`,
+        label: `${model} (local, free)`,
+        readsRepo: false,
+        async think(prompt, _cwd, opts = {}) {
+            const t0 = Date.now();
+            try {
+                const signals = [AbortSignal.timeout(opts.timeoutMs ?? 5 * 60_000), ...(opts.signal ? [opts.signal] : [])];
+                const r = await fetch(`${OLLAMA}/api/chat`, {
+                    method: "POST",
+                    headers: { "content-type": "application/json" },
+                    signal: AbortSignal.any(signals),
+                    body: JSON.stringify({
+                        model,
+                        stream: false,
+                        ...(opts.json ? { format: "json" } : {}),
+                        options: { temperature: 0.2, num_ctx: 16384 },
+                        messages: [{ role: "user", content: prompt }],
+                    }),
+                });
+                const j = await r.json();
+                const text = String(j?.message?.content ?? "").trim();
+                return { ok: r.ok && !!text, text: text || String(j?.error ?? ""), tokens: (j.prompt_eval_count ?? 0) + (j.eval_count ?? 0), ms: Date.now() - t0 };
+            }
+            catch (e) {
+                return { ok: false, text: String(e?.message ?? e), ms: Date.now() - t0 };
+            }
+        },
+    };
+}
+function agentBrain(adapterId, model) {
+    const adapter = ADAPTERS.find((a) => a.id === adapterId);
+    if (!adapter?.ask)
+        return null;
+    return {
+        spec: model ? `${adapterId}:${model}` : adapterId,
+        label: model ? `${adapterId} · ${model}` : adapterId,
+        readsRepo: true,
+        async think(prompt, cwd, opts = {}) {
+            const t0 = Date.now();
+            const r = await askAgent(adapter, prompt, cwd, {
+                signal: opts.signal,
+                timeoutMs: opts.timeoutMs,
+                model,
+                noTools: opts.selfContained,
+            });
+            return { ...r, ms: Date.now() - t0 };
+        },
+    };
+}
+/** Parse a brain spec like "ollama:qwencoder" or "cursor:grok-4.7-low-fast". */
+export function brainFrom(spec) {
+    const [kind, ...rest] = spec.split(":");
+    const model = rest.join(":") || undefined;
+    if (kind === "ollama")
+        return model ? ollamaBrain(model) : null;
+    return agentBrain(kind, model);
+}
+/** The default when nothing's configured: the strongest agent you have ready. */
+export const DEFAULT_BRAIN = "claude";
+/** Suggestions for the `brain` command, cheapest first. */
+export async function brainOptions(readyAgents) {
+    const out = [];
+    for (const m of await ollamaModels()) {
+        if (/llava|vision|embed/i.test(m))
+            continue; // not text planners
+        out.push({ spec: `ollama:${m}`, note: "local · free · private · speed depends on your RAM" });
+    }
+    if (readyAgents.includes("cursor"))
+        out.push({ spec: "cursor:grok-4.7-low-fast", note: "cheap + fast, via your Cursor plan" });
+    if (readyAgents.includes("claude")) {
+        out.push({ spec: "claude:haiku", note: "smallest Claude — cheapest hosted option" });
+        out.push({ spec: "claude:sonnet", note: "fast — plans in ~15s, a fraction of Opus's tokens" });
+        out.push({ spec: "claude:opus", note: "default — Opus, strongest plans, most tokens" });
+    }
+    if (readyAgents.includes("codex"))
+        out.push({ spec: "codex", note: "your Codex default model" });
+    return out;
+}
+/**
+ * A compact snapshot of the repo for the brain: file list, README head,
+ * manifest. ~a few thousand tokens; lets even a local model plan sensibly.
+ */
+export function repoContext(cwd, maxFiles = 250) {
+    const files = (spawnSync("git", ["ls-files"], { cwd, encoding: "utf8" }).stdout ?? "").split(/\r?\n/).filter(Boolean);
+    const head = (f, lines) => {
+        try {
+            return fs.readFileSync(path.join(cwd, f), "utf8").split("\n").slice(0, lines).join("\n");
+        }
+        catch {
+            return null;
+        }
+    };
+    const parts = [`FILES (${files.length}${files.length > maxFiles ? `, first ${maxFiles}` : ""}):\n${files.slice(0, maxFiles).join("\n") || "(empty repo)"}`];
+    for (const f of ["package.json", "pyproject.toml", "Cargo.toml", "go.mod"]) {
+        const h = head(f, 40);
+        if (h)
+            parts.push(`${f}:\n${h}`);
+    }
+    const readme = files.find((f) => /^readme(\.md)?$/i.test(f));
+    if (readme) {
+        const h = head(readme, 40);
+        if (h)
+            parts.push(`${readme} (first 40 lines):\n${h}`);
+    }
+    // Small repo: show the source itself. A tool-less planner that only sees
+    // file names tries to "cat" them anyway (seen live: Sonnet replied with a
+    // fake bash call instead of a plan, Opus hung) and misses rules that live
+    // in code, like a test requiring every module in an index.
+    if (files.length <= 80) {
+        const rank = (f) => (/(^|\/)(index|main|app|registry|routes?)\.[a-z]+$/i.test(f) ? 0 : /(^|\/)(test|tests|__tests__)\/|\.(test|spec)\./i.test(f) ? 1 : 2);
+        const skip = /(^|\/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|readme(\.md)?|package\.json)$|\.(png|jpe?g|gif|ico|pdf|zip|gz|woff2?|mp[34]|lock)$/i;
+        let budget = 24_000;
+        for (const f of [...files].sort((a, b) => rank(a) - rank(b))) {
+            if (skip.test(f))
+                continue;
+            let body;
+            try {
+                if (fs.statSync(path.join(cwd, f)).size > 4000)
+                    continue;
+                body = fs.readFileSync(path.join(cwd, f), "utf8");
+            }
+            catch {
+                continue;
+            }
+            if (body.includes("\u0000") || body.length > budget)
+                continue;
+            budget -= body.length;
+            parts.push(`${f}:\n${body.trimEnd()}`);
+        }
+    }
+    // The planner and the council plan from this snapshot: what earlier runs taught goes with it.
+    const lessons = lessonsBrief({ repo: cwd }).trim();
+    if (lessons)
+        parts.push(lessons);
+    // What the user pasted / dropped: the index (+ small items), not N full copies.
+    const screen = screenForPlanner(cwd);
+    if (screen)
+        parts.push(screen);
+    return parts.join("\n\n");
+}
+//# sourceMappingURL=brain.js.map