jarvis-hq 0.0.3

package/dist/client-vendor.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vendorScripts = vendorScripts;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/** marked (GFM markdown) + DOMPurify (sanitiser), inlined into the page.
+ *  The hub is usually reached over a LAN or a tunnel, often with no internet,
+ *  so a CDN tag would leave the transcript unformatted. Read once, cached. */
+let cached;
+/** Reads a file sitting next to a package entry point. Resolving through an
+ *  entry rather than a bare path keeps this working from anywhere npm chose to
+ *  hoist the dependency; dompurify doesn't export its package.json, so its
+ *  main entry is the anchor. */
+function readVendor(entry, file) {
+    return (0, fs_1.readFileSync)((0, path_1.join)((0, path_1.dirname)(require.resolve(entry)), file), "utf8");
+}
+function vendorScripts() {
+    if (cached !== undefined)
+        return cached;
+    try {
+        const marked = readVendor("marked/package.json", "lib/marked.umd.js");
+        const purify = readVendor("dompurify", "purify.min.js");
+        cached = `<script>${marked}</script>\n<script>${purify}</script>`;
+    }
+    catch (err) {
+        // Missing deps shouldn't take the hub down — the client falls back to
+        // plain text when marked/DOMPurify aren't on the page.
+        console.warn(`  Markdown renderer unavailable (${err?.message ?? err}); showing plain text.`);
+        cached = "";
+    }
+    return cached;
+}

package/dist/client.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.client = client;
+const node_http_1 = __importDefault(require("node:http"));
+const node_os_1 = require("node:os");
+const node_child_process_1 = require("node:child_process");
+const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
+const client_html_1 = require("./client-html");
+const PORT = 3001;
+function getLocalIP() {
+    const nets = (0, node_os_1.networkInterfaces)();
+    for (const name of Object.keys(nets)) {
+        for (const net of nets[name]) {
+            if (net.family === "IPv4" && !net.internal) {
+                return net.address;
+            }
+        }
+    }
+    return "localhost";
+}
+function getTailscaleIP() {
+    return new Promise((resolve) => {
+        (0, node_child_process_1.execFile)("tailscale", ["ip", "-4"], { timeout: 2000 }, (err, stdout) => {
+            if (err)
+                return resolve(null);
+            const ip = stdout.trim().split("\n")[0];
+            resolve(ip || null);
+        });
+    });
+}
+async function client() {
+    const server = node_http_1.default.createServer((_req, res) => {
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(client_html_1.html);
+    });
+    server.listen(PORT, async () => {
+        const ip = getLocalIP();
+        const tsIP = await getTailscaleIP();
+        const urls = [
+            { label: "My Local Network", url: `http://${ip}:${PORT}` },
+        ];
+        if (tsIP) {
+            urls.push({ label: "Tailscale", url: `http://${tsIP}:${PORT}` });
+        }
+        // Pre-generate all QR codes
+        const qrCodes = await Promise.all(urls.map((u) => new Promise((resolve) => {
+            qrcode_terminal_1.default.generate(u.url, { small: true }, (code) => {
+                resolve(code.trimEnd());
+            });
+        })));
+        // Print header
+        const headerLines = [
+            "",
+            "  \x1b[1mgrass client\x1b[0m",
+            "",
+            ...urls.map((u) => `  ${u.label.padEnd(9)}  ${u.url}`),
+            "",
+        ];
+        for (const line of headerLines)
+            console.log(line);
+        // QR cycling state
+        let qrIdx = urls.length > 1 ? 1 : 0;
+        let qrLineCount = 0;
+        function renderQR() {
+            const hint = urls.length > 1 ? " (\u2191\u2193 to switch)" : "";
+            const label = `  QR: ${urls[qrIdx].label}${hint}`;
+            const block = `${label}\n${qrCodes[qrIdx]}`;
+            const lines = block.split("\n");
+            // Move cursor up to overwrite previous QR block
+            if (qrLineCount > 0) {
+                process.stdout.write(`\x1b[${qrLineCount}A`);
+            }
+            for (const line of lines) {
+                process.stdout.write(`\r${line}\x1b[K\n`);
+            }
+            // Clear leftover lines if previous block was taller
+            for (let i = lines.length; i < qrLineCount; i++) {
+                process.stdout.write(`\r\x1b[K\n`);
+            }
+            qrLineCount = Math.max(lines.length, qrLineCount);
+        }
+        renderQR();
+        // Listen for arrow keys
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.on("data", (key) => {
+                const s = key.toString();
+                if (s === "\x03") {
+                    shutdown();
+                    return;
+                }
+                if (s === "\x1b[A") {
+                    qrIdx = (qrIdx - 1 + urls.length) % urls.length;
+                    renderQR();
+                }
+                else if (s === "\x1b[B") {
+                    qrIdx = (qrIdx + 1) % urls.length;
+                    renderQR();
+                }
+            });
+        }
+    });
+    const shutdown = () => {
+        console.log("\nShutting down client...");
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        server.close(() => {
+            process.exit(0);
+        });
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}

package/dist/dictation.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dictationConfigured = dictationConfigured;
+exports.handleDictationRoutes = handleDictationRoutes;
+const server_common_1 = require("./server-common");
+/**
+ * Tap-to-talk dictation for the composer boxes.
+ *
+ * The browser records a clip and POSTs it here; the clip goes to Deepgram for
+ * the raw transcript, and the transcript goes to gpt-4o-mini to strip filler
+ * words and resolve self-corrections. Only the polished text goes back — the
+ * raw dictation is never shown.
+ *
+ * Audio rides in as base64 inside a JSON body rather than a binary upload
+ * because relay mode carries request bodies as strings.
+ *
+ * Needs DEEPGRAM_API_KEY and OPENAI_API_KEY in the environment.
+ */
+const DEEPGRAM_URL = "https://api.deepgram.com/v1/listen?model=nova-2-general&smart_format=true";
+const OPENAI_URL = "https://api.openai.com/v1/chat/completions";
+const CLEANUP_MODEL = "gpt-4o-mini";
+// Roughly two minutes of opus; anything longer is a mistake, not a message.
+const MAX_AUDIO_BYTES = 8 * 1024 * 1024;
+const CLEANUP_PROMPT = `You are an intent extraction engine for a voice assistant.
+The user will provide a messy, unedited voice transcript containing filler words, pauses, and self-corrections.
+
+Your task:
+1. Analyze the spoken words to find the user's ultimate intent.
+2. Completely remove filler words ("uh", "um", "like") and resolve self-corrections (e.g., "set a meeting for 5, no, make it 6 PM" becomes "6 PM").
+3. Output ONLY the final, polished instructions. Do not include introductory text, explanations, or quotes.
+
+Keep the user's wording and voice where it is already clear; do not summarize, expand, or answer the request.`;
+function dictationConfigured() {
+    return {
+        deepgram: Boolean(process.env.DEEPGRAM_API_KEY),
+        openai: Boolean(process.env.OPENAI_API_KEY),
+    };
+}
+async function transcribe(audio, mimeType) {
+    const res = await fetch(DEEPGRAM_URL, {
+        method: "POST",
+        headers: {
+            Authorization: `Token ${process.env.DEEPGRAM_API_KEY}`,
+            "Content-Type": mimeType,
+        },
+        body: new Uint8Array(audio),
+    });
+    if (!res.ok) {
+        const detail = await res.text().catch(() => "");
+        throw new Error(`Deepgram ${res.status}: ${detail.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    return data?.results?.channels?.[0]?.alternatives?.[0]?.transcript ?? "";
+}
+async function cleanUp(transcript) {
+    const res = await fetch(OPENAI_URL, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            model: CLEANUP_MODEL,
+            temperature: 0,
+            messages: [
+                { role: "system", content: CLEANUP_PROMPT },
+                { role: "user", content: transcript },
+            ],
+        }),
+    });
+    if (!res.ok) {
+        const detail = await res.text().catch(() => "");
+        throw new Error(`OpenAI ${res.status}: ${detail.slice(0, 200)}`);
+    }
+    const data = await res.json();
+    return (data?.choices?.[0]?.message?.content ?? "").trim();
+}
+/** Returns true when the request was handled. */
+async function handleDictationRoutes(req, res) {
+    const path = (req.url ?? "/").split("?")[0];
+    const method = req.method ?? "GET";
+    if (method === "GET" && path === "/dictate/status") {
+        (0, server_common_1.jsonOk)(res, dictationConfigured());
+        return true;
+    }
+    if (method === "POST" && path === "/dictate") {
+        const keys = dictationConfigured();
+        if (!keys.deepgram || !keys.openai) {
+            const missing = [!keys.deepgram && "DEEPGRAM_API_KEY", !keys.openai && "OPENAI_API_KEY"].filter(Boolean);
+            (0, server_common_1.jsonError)(res, 503, `Dictation is not configured: set ${missing.join(" and ")}`);
+            return true;
+        }
+        const body = await (0, server_common_1.readBody)(req);
+        const { audio, mimeType } = body ?? {};
+        if (typeof audio !== "string" || !audio) {
+            (0, server_common_1.jsonError)(res, 400, "audio is required");
+            return true;
+        }
+        if (typeof mimeType !== "string" || !mimeType.startsWith("audio/")) {
+            (0, server_common_1.jsonError)(res, 400, "mimeType must be an audio type");
+            return true;
+        }
+        const bytes = Buffer.from(audio, "base64");
+        if (bytes.length === 0) {
+            (0, server_common_1.jsonError)(res, 400, "audio is empty");
+            return true;
+        }
+        if (bytes.length > MAX_AUDIO_BYTES) {
+            (0, server_common_1.jsonError)(res, 413, "recording is too long");
+            return true;
+        }
+        try {
+            const transcript = await transcribe(bytes, mimeType);
+            if (!transcript.trim()) {
+                (0, server_common_1.jsonOk)(res, { text: "" });
+                return true;
+            }
+            const text = await cleanUp(transcript);
+            (0, server_common_1.jsonOk)(res, { text });
+        }
+        catch (err) {
+            console.error(`[dictate] ${err?.message ?? err}`);
+            (0, server_common_1.jsonError)(res, 502, err?.message ?? "Dictation failed");
+        }
+        return true;
+    }
+    return false;
+}

package/dist/env-file.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envFileCandidates = envFileCandidates;
+exports.loadEnvFiles = loadEnvFiles;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+/**
+ * Loads API keys from an env file so they don't have to be exported by hand on
+ * every run. Keys already present in the real environment always win, so an
+ * explicit `FOO=bar jarvis start` still overrides the file.
+ *
+ * Files are read in order, first definition of a name winning:
+ *
+ *   $JARVIS_ENV_FILE        explicit override
+ *   ./.env                  the directory jarvis was started in
+ *   ~/.config/jarvis/env    machine-wide, written by scripts/sandbox-setup.sh
+ *
+ * Format is the usual one: KEY=value per line, # comments, blank lines, and
+ * optional matching quotes around the value. No interpolation, no `export`
+ * expansion beyond stripping the keyword.
+ */
+function envFileCandidates() {
+    const paths = [];
+    if (process.env.JARVIS_ENV_FILE)
+        paths.push(process.env.JARVIS_ENV_FILE);
+    paths.push((0, path_1.join)(process.cwd(), ".env"));
+    paths.push((0, path_1.join)((0, os_1.homedir)(), ".config", "jarvis", "env"));
+    return paths;
+}
+function parse(text) {
+    const out = {};
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const eq = line.indexOf("=");
+        if (eq <= 0)
+            continue;
+        const key = line.slice(0, eq).trim().replace(/^export\s+/, "");
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+            continue;
+        let value = line.slice(eq + 1).trim();
+        const quote = value[0];
+        if ((quote === '"' || quote === "'") && value.endsWith(quote) && value.length > 1) {
+            value = value.slice(1, -1);
+        }
+        if (!(key in out))
+            out[key] = value;
+    }
+    return out;
+}
+/** Returns the files that were actually read, for the startup banner. */
+function loadEnvFiles() {
+    const loaded = [];
+    for (const path of envFileCandidates()) {
+        if (!(0, fs_1.existsSync)(path))
+            continue;
+        let text;
+        try {
+            text = (0, fs_1.readFileSync)(path, "utf-8");
+        }
+        catch (err) {
+            console.error(`[env] could not read ${path}: ${err.message}`);
+            continue;
+        }
+        const vars = parse(text);
+        let used = false;
+        for (const [key, value] of Object.entries(vars)) {
+            if (process.env[key] === undefined) {
+                process.env[key] = value;
+                used = true;
+            }
+        }
+        if (used)
+            loaded.push(path);
+    }
+    return loaded;
+}

package/dist/index.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+process.on("SIGINT", () => {
+    console.log();
+    process.exit(0);
+});
+const commander_1 = require("commander");
+const env_file_1 = require("./env-file");
+const server_1 = require("./server");
+// Before anything reads process.env: .env in the working directory and
+// ~/.config/jarvis/env supply API keys (Deepgram, OpenAI) without exporting
+// them by hand. A real environment variable always wins over the file.
+const envFiles = (0, env_file_1.loadEnvFiles)();
+const program = new commander_1.Command();
+program
+    .name("jarvis")
+    .description("Jarvis — a persistent AI engineering partner on top of Claude Code and other coding agents")
+    .version(require("../package.json").version);
+program
+    .command("start")
+    .description("Start Jarvis — the hub you talk to from any device")
+    .option("-c, --caffeinate", "run caffeinate for 8 hours to prevent sleep")
+    .option("-p, --port <port>", "bind this local port and serve the UI at http://localhost:<port> (implies --local)", "3000")
+    .option("-l, --local", "bind a local port instead of connecting to the relay")
+    .option("-r, --relay <url>", "connect to a relay server instead of binding a local port (e.g. wss://relay.example.com)", "wss://relay.codeongrass.com")
+    .action(async (opts, command) => {
+    // -p defaults to 3000; an explicit --relay still wins over that default.
+    const portFromUser = command.getOptionValueSource("port") !== "default";
+    const relayFromUser = command.getOptionValueSource("relay") !== "default";
+    const port = opts.port && !(relayFromUser && !portFromUser) ? Number(opts.port) : undefined;
+    if (port !== undefined && !Number.isInteger(port)) {
+        console.error("  --port must be a number");
+        process.exit(1);
+    }
+    for (const file of envFiles)
+        console.log(`  env:  ${file}`);
+    const local = opts.local || port !== undefined;
+    await (0, server_1.start)("local", port, opts.caffeinate ?? false, local ? undefined : opts.relay);
+});
+program.parse();

package/dist/jarvis-tools.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JARVIS_TOOL_NAMES = exports.JARVIS_MCP_NAME = void 0;
+exports.buildJarvisTools = buildJarvisTools;
+const claude_agent_sdk_1 = require("@anthropic-ai/claude-agent-sdk");
+const zod_1 = require("zod");
+const server_common_1 = require("./server-common");
+const bot_store_1 = require("./bot-store");
+const jarvis_1 = require("./jarvis");
+const turns_1 = require("./turns");
+/**
+ * The tools that make Jarvis more than a chat: it sees the projects, can add
+ * one, and can put a project agent to work — either waiting for a report
+ * (delegate) or handing the conversation over (handoff). They run in-process
+ * via the SDK's MCP bridge, so a tool call is a plain function call here.
+ *
+ * Both dispatch tools start a real turn on a real hub thread under the
+ * project's bot, so what Jarvis dispatches shows up in the UI like any other
+ * work and can be rejoined, continued or read back later.
+ */
+exports.JARVIS_MCP_NAME = "jarvis";
+function buildJarvisTools(store, workspaceCwd) {
+    const text = (s) => ({ content: [{ type: "text", text: s }] });
+    const fail = (s) => ({ content: [{ type: "text", text: s }], isError: true });
+    return (0, claude_agent_sdk_1.createSdkMcpServer)({
+        name: exports.JARVIS_MCP_NAME,
+        version: "1.0.0",
+        tools: [
+            (0, claude_agent_sdk_1.tool)("list_projects", "Every project Jarvis knows (name, slug, checkout path, remote, first line of notes), plus folders in the workspace that no project has claimed yet.", {}, async () => text(JSON.stringify({
+                projects: (0, jarvis_1.listProjects)().map(summary),
+                unclaimed_folders: (0, jarvis_1.unregisteredFolders)(workspaceCwd),
+                workspace: workspaceCwd,
+            }, null, 2))),
+            (0, claude_agent_sdk_1.tool)("read_project", "The full notes of one project, by name or slug.", { project: zod_1.z.string().describe("Project name or slug, as the user refers to it") }, async ({ project }) => {
+                const p = (0, jarvis_1.findProject)(project);
+                if (!p)
+                    return fail(`No project matches "${project}". Call list_projects to see what exists.`);
+                return text(JSON.stringify({ ...summary(p), notes: p.notes }, null, 2));
+            }),
+            (0, claude_agent_sdk_1.tool)("create_project", "Register a new project. Give a repo URL to clone it into the workspace, or the path of a folder that already exists. Creates the project file and the project's agent.", {
+                name: zod_1.z.string().describe("The name the user uses for the project"),
+                repo: zod_1.z.string().optional().describe("Git URL to clone, e.g. https://github.com/org/repo"),
+                path: zod_1.z.string().optional().describe("Absolute path of an existing checkout to adopt instead of cloning"),
+                notes: zod_1.z.string().optional().describe("Initial Markdown notes: what the project is, people, commands"),
+            }, async ({ name, repo, path, notes }) => {
+                try {
+                    const p = (0, jarvis_1.createProject)({ name, repo, path, notes }, workspaceCwd);
+                    (0, server_common_1.emitEvent)(store, "project_created", { project: summary(p) });
+                    return text(`Created project "${p.name}" (slug ${p.slug}) at ${p.path}.`);
+                }
+                catch (err) {
+                    return fail(err?.message ?? "Could not create the project");
+                }
+            }),
+            (0, claude_agent_sdk_1.tool)("update_project", "Rewrite a project's notes (the Markdown under its front matter). Read them first and pass the whole new text; use this to record what you learn.", {
+                project: zod_1.z.string().describe("Project name or slug"),
+                notes: zod_1.z.string().describe("The complete new notes in Markdown"),
+            }, async ({ project, notes }) => {
+                const p = (0, jarvis_1.findProject)(project);
+                if (!p)
+                    return fail(`No project matches "${project}".`);
+                try {
+                    (0, jarvis_1.updateProjectNotes)(p.slug, notes);
+                    return text(`Updated notes for ${p.name}.`);
+                }
+                catch (err) {
+                    return fail(err?.message ?? "Could not update the project");
+                }
+            }),
+            (0, claude_agent_sdk_1.tool)("delegate", "Give a project's agent a bounded task and wait for its report, so you can combine it with other things. Blocks until the agent finishes (seconds to many minutes); call it for several projects in parallel when a request spans projects. Not for a request about a single project, however small — that is a handoff, so the user's follow-ups land in the project.", {
+                project: zod_1.z.string().describe("Project name or slug"),
+                task: zod_1.z.string().describe("The task, self-contained: what to do, what to report back, and any constraints such as 'do not merge'"),
+            }, async ({ project, task }) => {
+                const p = (0, jarvis_1.findProject)(project);
+                if (!p)
+                    return fail(`No project matches "${project}". Ask the user which repository it is, then create_project.`);
+                if (p.pathMissing)
+                    return fail(`The checkout for "${p.name}" no longer exists at ${p.path}. The folder may have been renamed or moved. Ask the user for the new path, then update the project file at ${(0, jarvis_1.projectFile)(p.slug)}.`);
+                try {
+                    const bot = (0, jarvis_1.ensureProjectBot)(p);
+                    const thread = (0, bot_store_1.createThread)(bot.id, p.path, titleFor(task));
+                    const { store: child, done } = (0, turns_1.beginThreadTurn)(thread, bot, { prompt: delegatedPrompt(task), silent: true });
+                    (0, server_common_1.emitEvent)(store, "delegation", { project: summary(p), botId: bot.id, threadId: thread.id, sessionId: child.gitbotId, title: thread.title, status: "running" });
+                    const report = await done;
+                    (0, server_common_1.emitEvent)(store, "delegation", { project: summary(p), botId: bot.id, threadId: thread.id, sessionId: child.gitbotId, title: thread.title, status: child.status === "done" ? "done" : "error" });
+                    return text(`Report from ${p.name} (thread ${thread.id}):\n\n${report || "(the agent produced no final message)"}`);
+                }
+                catch (err) {
+                    return fail(err?.message ?? "Delegation failed");
+                }
+            }),
+            (0, claude_agent_sdk_1.tool)("handoff", "Move this conversation into a project. The default for any request about one project, including quick questions: the project's agent receives the message, answers the user directly, and keeps the context for their follow-ups. End your turn immediately after calling this, with at most one short line. Pass the user's request in full, with any context you gathered.", {
+                project: zod_1.z.string().describe("Project name or slug"),
+                message: zod_1.z.string().describe("The message for the project agent: the user's request as they put it, plus context and constraints"),
+                continue_thread: zod_1.z.boolean().optional().describe("Continue the project's most recent thread instead of opening a new one; use when the user is clearly following up on earlier work there"),
+            }, async ({ project, message, continue_thread }) => {
+                const p = (0, jarvis_1.findProject)(project);
+                if (!p)
+                    return fail(`No project matches "${project}". Ask the user which repository it is, then create_project.`);
+                if (p.pathMissing)
+                    return fail(`The checkout for "${p.name}" no longer exists at ${p.path}. The folder may have been renamed or moved. Ask the user for the new path, then update the project file at ${(0, jarvis_1.projectFile)(p.slug)}.`);
+                const bot = (0, jarvis_1.ensureProjectBot)(p);
+                let thread;
+                if (continue_thread)
+                    thread = (0, bot_store_1.listThreads)(bot.id).find((t) => t.kind !== "setup");
+                if (!thread)
+                    thread = (0, bot_store_1.createThread)(bot.id, p.path, titleFor(message));
+                try {
+                    const { store: child } = (0, turns_1.beginThreadTurn)(thread, bot, { prompt: message });
+                    (0, server_common_1.emitEvent)(store, "handoff", { project: summary(p), botId: bot.id, threadId: thread.id, sessionId: child.gitbotId, title: thread.title });
+                    return text(`Handed off to ${p.name}. The project agent is now answering the user in thread ${thread.id}; end your turn.`);
+                }
+                catch (err) {
+                    if (err instanceof turns_1.TurnBusyError) {
+                        return fail(`${p.name}'s latest thread is still busy. Call handoff again without continue_thread to open a new one.`);
+                    }
+                    return fail(err?.message ?? "Handoff failed");
+                }
+            }),
+        ],
+    });
+}
+/** Tool names as Claude Code sees them, for the allowed-tools list. */
+exports.JARVIS_TOOL_NAMES = ["list_projects", "read_project", "create_project", "update_project", "delegate", "handoff"]
+    .map((t) => `mcp__${exports.JARVIS_MCP_NAME}__${t}`);
+function summary(p) {
+    return {
+        name: p.name,
+        slug: p.slug,
+        path: p.path,
+        repo: p.repo ?? null,
+        summary: p.notes.split("\n").map((l) => l.replace(/^#+\s*/, "").trim()).find(Boolean) ?? "",
+    };
+}
+function delegatedPrompt(task) {
+    return `Task delegated by Jarvis. Do it, then end with a report Jarvis can pass on: the answer or outcome first, then what you checked or changed and anything the user should know.\n\n${task}`;
+}
+function titleFor(text) {
+    const line = text.split("\n").map((l) => l.trim()).find((l) => l && !/^task delegated/i.test(l));
+    if (!line)
+        return undefined;
+    return line.length > 60 ? line.slice(0, 57).replace(/\s+\S*$/, "") + "…" : line;
+}