jarvis-hq 0.0.3 → 0.0.5

package/README.md

@@ -368,7 +368,7 @@ Sessions are the core abstraction. A session is created when a `/chat` POST is r
 
 Jarvis detects which harnesses are available at startup by checking for the `claude` CLI, the `@opencode-ai/sdk` package, and the `codex` CLI. It reports the available agents at `/agents`. A bot's `model` and `permissionMode` are applied to whichever harness runs its threads.
 
-**Claude Code** (`claude-code`): Uses the `@anthropic-ai/claude-agent-sdk` `query()` function. Runs the `claude-opus-4-6` model in `default` permission mode. Supports `canUseTool` for per-tool permission prompts. Session transcripts are stored at `~/.claude/projects/<cwd>/<session-id>.jsonl`.
+**Claude Code** (`claude-code`): Uses the `@anthropic-ai/claude-agent-sdk` `query()` function. Runs the `claude-opus-5[1m]` model (Opus 5 with the 1M-token context window) in `default` permission mode. Supports `canUseTool` for per-tool permission prompts. Session transcripts are stored at `~/.claude/projects/<cwd>/<session-id>.jsonl`.
 
 **Opencode** (`opencode`): Uses the `@opencode-ai/sdk`. Jarvis spawns an Opencode server process at startup (or connects to one already running on port 4096). Per-directory clients are maintained so sessions can be scoped to different repos simultaneously. Events are received via a persistent Opencode event stream (`client.event.subscribe()`). If the stream fails, it reconnects automatically after 2 seconds.
 

package/dist/client-html.js

@@ -72,6 +72,16 @@ exports.html = `<!DOCTYPE html>
   .bar-title { flex: 1; min-width: 0; }
   .bar-title h2 { font-size: 17px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
   .bar-title .sub { color: var(--muted); font-size: 12.5px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  /* Context meter: how full the model's window is, in the thread's own header. */
+  .ctx { display: flex; align-items: center; gap: 6px; margin-top: 2px; font-size: 11px; color: var(--muted); }
+  .ctx-model { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; min-width: 0; }
+  .ctx-dots { display: flex; gap: 2px; flex: none; }
+  .ctx-dots i { width: 5px; height: 5px; border-radius: 50%; background: var(--border); }
+  .ctx-dots i.on { background: var(--muted); }
+  .ctx-num { flex: none; font-variant-numeric: tabular-nums; }
+  /* Past three quarters full the meter stops being background detail. */
+  .ctx.full .ctx-dots i.on { background: var(--danger); }
+  .ctx.full .ctx-num { color: var(--danger); }
 
   .back {
     display: inline-flex; align-items: center; gap: 5px; flex: none;
@@ -560,6 +570,11 @@ exports.html = `<!DOCTYPE html>
     <div class="bar-title">
       <h2 id="thread-title"></h2>
       <div class="sub" id="thread-sub"></div>
+      <div class="ctx" id="thread-ctx" hidden>
+        <span class="ctx-model" id="ctx-model"></span>
+        <span class="ctx-dots" id="ctx-dots"></span>
+        <span class="ctx-num" id="ctx-num"></span>
+      </div>
     </div>
   </div></div>
   <div class="messages" id="messages"><div class="wrap narrow" id="messages-inner"></div></div>
@@ -1279,6 +1294,39 @@ exports.html = `<!DOCTYPE html>
     load(startPath);
   }
 
+  // --- Context meter ---
+  // What the model is carrying into its next turn, against what it can hold.
+  // Ten dots read at a glance on a phone; the exact numbers sit beside them and
+  // the full sentence is in the tooltip.
+
+  function fmtTokens(n) {
+    if (!n) return "0";
+    return n < 1000 ? String(n) : Math.round(n / 1000) + "k";
+  }
+
+  function renderContext(ctx) {
+    var box = $("thread-ctx");
+    if (!ctx || !ctx.used || !ctx.window) { box.hidden = true; return; }
+    var pct = Math.min(100, Math.round((ctx.used / ctx.window) * 100));
+    // "/1000k" already says the window is the long one, so the meter drops the
+    // "(1M context)" tail that would otherwise eat the line on a phone. Plain
+    // string work, not a regex: this file is a template literal, and its
+    // backslashes belong to the build, not to the browser.
+    var name = ctx.label || ctx.model || "";
+    var tail = name.indexOf(" (1M");
+    $("ctx-model").textContent = tail === -1 ? name : name.slice(0, tail);
+    $("ctx-num").textContent = fmtTokens(ctx.used) + "/" + fmtTokens(ctx.window) + " (" + pct + "%)";
+    var dots = $("ctx-dots");
+    dots.innerHTML = "";
+    var lit = Math.min(10, Math.max(1, Math.ceil(pct / 10)));
+    for (var i = 0; i < 10; i++) dots.appendChild(el("i", i < lit ? "on" : null));
+    box.className = "ctx" + (pct >= 75 ? " full" : "");
+    box.title = (ctx.label ? ctx.label + " \u2014 " : "")
+      + ctx.used.toLocaleString() + " of " + ctx.window.toLocaleString()
+      + " tokens in context (" + pct + "% used)";
+    box.hidden = false;
+  }
+
   // --- Thread ---
   function openThread(thread) {
     activeThread = thread;
@@ -1286,6 +1334,7 @@ exports.html = `<!DOCTYPE html>
     $("thread-title").textContent = thread.title;
     $("thread-sub").textContent = shortPath(thread.repoPath, 30);
     $("thread-sub").title = thread.repoPath || "";
+    renderContext(thread.context);
     $("to-bot-label").textContent = threadBack === "jarvis" ? "Jarvis" : (activeBot ? activeBot.name : "Back");
     var av = $("thread-avatar");
     av.textContent = activeBot ? (activeBot.emoji || "\\u{1F916}") : "\\u{1F916}";
@@ -1529,7 +1578,7 @@ exports.html = `<!DOCTYPE html>
 
   // Every event type the agent emits on the turn stream.
   var STREAM_EVENTS = ["user_prompt", "assistant", "tool_use", "status", "permission_request", "aborted", "done", "result", "error",
-                       "delegation", "handoff", "project_created"];
+                       "delegation", "handoff", "project_created", "context"];
 
   function attachStream(sid, onEvent) {
     closeStream();
@@ -1563,6 +1612,11 @@ exports.html = `<!DOCTYPE html>
         appendTool(liveBubble, data.tool_name, data.tool_input);
         break;
 
+      case "context":
+        if (activeThread) activeThread.context = data;
+        renderContext(data);
+        break;
+
       case "status":
         if (state === "aborting") break;
         if (data.status === "thinking") setActivity("Thinking\u2026");
@@ -2122,7 +2176,7 @@ exports.html = `<!DOCTYPE html>
 
     var model = field("Model", "optional", el("input"));
     model.value = bot ? (bot.model || "") : "";
-    model.placeholder = "claude-sonnet-4-6";
+    model.placeholder = "claude-opus-5[1m]";
 
     var permissionMode = field("Permissions", null, el("select"));
     [["ask-permissions", "Ask before each tool"], ["auto-approve", "Auto-approve tools"], ["plan", "Plan only (no edits)"]]

package/dist/context-window.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextWindowFor = contextWindowFor;
+exports.tokensInContext = tokensInContext;
+exports.modelLabel = modelLabel;
+exports.contextUsage = contextUsage;
+const MILLION = 1000000;
+/** What Claude Code assumes for any model that does not ask for the long window. */
+const DEFAULT_WINDOW = 200000;
+/** The [1m] suffix is how the SDK is told to budget a 1M window; mirror that rule. */
+function contextWindowFor(model) {
+    return model?.includes("[1m]") ? MILLION : DEFAULT_WINDOW;
+}
+/** Everything the next request resends, from one message's usage block. */
+function tokensInContext(usage) {
+    if (!usage)
+        return 0;
+    const n = (v) => (typeof v === "number" && isFinite(v) && v > 0 ? v : 0);
+    return n(usage.input_tokens)
+        + n(usage.cache_read_input_tokens)
+        + n(usage.cache_creation_input_tokens)
+        + n(usage.output_tokens);
+}
+/**
+ * "claude-opus-5[1m]" -> "Opus 5 (1M context)", "claude-sonnet-4-6" ->
+ * "Sonnet 4.6". Derived rather than looked up, so a model released tomorrow
+ * still reads properly.
+ */
+function modelLabel(model) {
+    if (!model)
+        return "";
+    const long = model.includes("[1m]");
+    const parts = model.replace(/\[1m\]/g, "").replace(/^claude-/, "").split("-").filter(Boolean);
+    const family = parts.shift() ?? "";
+    const name = family.charAt(0).toUpperCase() + family.slice(1);
+    const version = parts.join(".");
+    return `${[name, version].filter(Boolean).join(" ")}${long ? " (1M context)" : ""}`;
+}
+function contextUsage(used, model, window) {
+    return {
+        used,
+        window: window && window > 0 ? window : contextWindowFor(model),
+        model: model ?? "",
+        label: modelLabel(model),
+    };
+}

package/dist/jarvis-tools.js

@@ -3,6 +3,8 @@ 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 child_process_1 = require("child_process");
+const util_1 = require("util");
 const zod_1 = require("zod");
 const server_common_1 = require("./server-common");
 const bot_store_1 = require("./bot-store");
@@ -67,6 +69,32 @@ function buildJarvisTools(store, workspaceCwd) {
                     return fail(err?.message ?? "Could not update the project");
                 }
             }),
+            (0, claude_agent_sdk_1.tool)("find_repos", "Search the user's GitHub for a repository: their own repos and every organisation they belong to. Use it when the user names a project you do not have and no workspace folder matches, before asking them for a URL — then pass the clone URL to create_project.", {
+                query: zod_1.z.string().optional().describe("Words to match against the repo name and description, e.g. 'relay' or 'expo client'. Omit to list everything."),
+                owner: zod_1.z.string().optional().describe("Restrict to one user or organisation login. Omit to search the user's account and all their orgs."),
+                limit: zod_1.z.number().optional().describe("Maximum repos to return (default 30)"),
+            }, async ({ query, owner, limit }) => {
+                try {
+                    const { repos, searched, warnings } = await findRepos({ query, owner, limit: limit ?? 30 });
+                    const note = warnings.length ? { incomplete_results: warnings, tell_the_user: "Say this to the user; it is something only they can fix." } : {};
+                    if (!repos.length) {
+                        return text(JSON.stringify({
+                            repos: [],
+                            searched_owners: searched,
+                            ...note,
+                            next: `Nothing on GitHub matches ${query ? `"${query}"` : "that"}${owner ? ` under ${owner}` : ""}. Report any incomplete_results above, then ask the user for the repo URL.`,
+                        }, null, 2));
+                    }
+                    return text(JSON.stringify({ repos, searched_owners: searched, ...note }, null, 2));
+                }
+                catch (err) {
+                    if (err instanceof GhSetupError) {
+                        (0, server_common_1.emitEvent)(store, "github_unavailable", { kind: err.kind, message: err.message });
+                        return fail(`GITHUB IS NOT SET UP ON THIS MACHINE. Tell the user exactly this, including the command, and do not ask them for a repo URL until you have:\n\n${err.message}`);
+                    }
+                    return fail(`${err?.message ?? "Could not reach GitHub"}. Tell the user the search failed and why.`);
+                }
+            }),
             (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'"),
@@ -121,7 +149,7 @@ function buildJarvisTools(store, workspaceCwd) {
     });
 }
 /** 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"]
+exports.JARVIS_TOOL_NAMES = ["list_projects", "read_project", "create_project", "update_project", "find_repos", "delegate", "handoff"]
     .map((t) => `mcp__${exports.JARVIS_MCP_NAME}__${t}`);
 function summary(p) {
     return {
@@ -141,3 +169,156 @@ function titleFor(text) {
         return undefined;
     return line.length > 60 ? line.slice(0, 57).replace(/\s+\S*$/, "") + "…" : line;
 }
+// --- GitHub ---
+// Jarvis has no shell, so `gh` is exposed as one read-only tool rather than as
+// a command line: fixed subcommands, arguments passed as an argv array (never
+// through a shell), and only what is needed to turn a name the user said into
+// a repository to clone.
+//
+// gh lives on the machine, not in the conversation, so when it is missing,
+// logged out or short a scope only the user can fix it. Those cases are
+// separated from ordinary failures and carry the exact command to run, which
+// find_repos tells Jarvis to pass on verbatim rather than quietly falling back
+// to "what is the repo URL?".
+const run = (0, util_1.promisify)(child_process_1.execFile);
+/** A problem with the machine's gh install that the user has to fix. */
+class GhSetupError extends Error {
+    constructor(kind, message) {
+        super(message);
+        this.kind = kind;
+    }
+}
+const INSTALL_HINT = process.platform === "darwin"
+    ? "install it with `brew install gh`"
+    : process.platform === "win32"
+        ? "install it with `winget install --id GitHub.cli`"
+        : "install it from https://cli.github.com (on Debian/Ubuntu: `sudo apt install gh`)";
+/**
+ * Confirms gh is installed and logged in before any real call, so a setup
+ * problem is reported once, precisely, instead of as a puzzling empty search.
+ * Successful results are cached; a failure is always re-checked, so the user
+ * can fix it and retry immediately.
+ */
+let authCache;
+async function ghAuth() {
+    if (authCache && Date.now() - authCache.at < 10 * 60 * 1000)
+        return authCache;
+    let out;
+    try {
+        const r = await run("gh", ["auth", "status"], { timeout: 20000 });
+        out = r.stdout + r.stderr;
+    }
+    catch (err) {
+        if (err?.code === "ENOENT") {
+            throw new GhSetupError("missing", `The GitHub CLI (gh) is not installed on the machine running Jarvis, so I cannot search GitHub. To fix it, ${INSTALL_HINT}, then run \`gh auth login\`.`);
+        }
+        const detail = String(err?.stderr || err?.stdout || err?.message || "").trim();
+        if (/not logged|no accounts|gh auth login|authentication/i.test(detail) || typeof err?.code === "number") {
+            throw new GhSetupError("auth", "The GitHub CLI is installed but not logged in, so I cannot search GitHub. To fix it, run `gh auth login` on the machine running Jarvis (or set a GH_TOKEN with `repo` and `read:org` scopes) and ask me again.");
+        }
+        throw new GhSetupError("auth", `Could not check the GitHub CLI's login: ${firstLine(detail) || "unknown error"}. Try \`gh auth status\` on the machine running Jarvis.`);
+    }
+    const login = /account (\S+)/.exec(out)?.[1] ?? "";
+    const scopes = Array.from(out.matchAll(/'([^']+)'/g)).map((m) => m[1]);
+    if (!login) {
+        // gh exited 0 but named no account: a token with no user, or an unexpected format.
+        const me = await ghRaw(["api", "user", "--jq", ".login"]).catch(() => "");
+        if (!me.trim())
+            throw new GhSetupError("auth", "The GitHub CLI is not logged in to an account I can use. Run `gh auth login` on the machine running Jarvis and ask me again.");
+        authCache = { at: Date.now(), login: me.trim(), scopes };
+        return authCache;
+    }
+    authCache = { at: Date.now(), login, scopes };
+    return authCache;
+}
+/** The logins to search: the account itself plus every org it belongs to. */
+let ownersCache;
+async function accountOwners() {
+    if (ownersCache && Date.now() - ownersCache.at < 10 * 60 * 1000)
+        return ownersCache;
+    const { login, scopes } = await ghAuth();
+    const warnings = [];
+    let orgs = [];
+    try {
+        orgs = (await ghRaw(["api", "user/orgs", "--jq", ".[].login"])).split("\n").map((l) => l.trim()).filter(Boolean);
+    }
+    catch (err) {
+        warnings.push(`I could not list your GitHub organisations, so I only searched your personal repositories (${firstLine(err?.message) || "unknown error"}). Try \`gh auth status\` on the machine running Jarvis.`);
+    }
+    // Without the read:org scope the orgs endpoint does not fail — it quietly
+    // returns only public memberships, so a private org's repos look like they
+    // do not exist. Say so whenever the scope is absent.
+    if (scopes.length && !scopes.includes("read:org")) {
+        warnings.push(`The GitHub CLI's token has no \`read:org\` scope, so I can only see organisations you are a public member of${orgs.length ? ` (${orgs.join(", ")})` : ""} — private ones are invisible to me. To fix it, run \`gh auth refresh -s read:org\` on the machine running Jarvis.`);
+    }
+    ownersCache = { at: Date.now(), owners: [login, ...orgs], warnings };
+    return ownersCache;
+}
+async function findRepos({ query, owner, limit }) {
+    const warnings = [];
+    let owners;
+    if (owner) {
+        await ghAuth();
+        owners = [owner];
+    }
+    else {
+        const found = await accountOwners();
+        owners = found.owners;
+        warnings.push(...found.warnings);
+    }
+    const perOwner = Math.max(limit, 100);
+    const searched = [];
+    const lists = await Promise.all(owners.map(async (o) => {
+        try {
+            const out = await ghRaw(["repo", "list", o, "--limit", String(perOwner), "--json", "nameWithOwner,description,url,isPrivate,primaryLanguage,updatedAt"]);
+            searched.push(o);
+            return JSON.parse(out);
+        }
+        catch (err) {
+            // One unreadable org should not sink the whole search, but the user
+            // should know their results are incomplete and why.
+            warnings.push(`Could not list repositories for "${o}": ${firstLine(err?.message) || "unknown error"}.`);
+            return [];
+        }
+    }));
+    const terms = (query ?? "").toLowerCase().split(/\s+/).filter(Boolean);
+    const repos = lists
+        .flat()
+        .map((r) => ({
+        nameWithOwner: r.nameWithOwner,
+        description: r.description ?? "",
+        url: r.url,
+        isPrivate: !!r.isPrivate,
+        language: r.primaryLanguage?.name ?? null,
+        updatedAt: r.updatedAt,
+    }))
+        .filter((r) => terms.every((t) => `${r.nameWithOwner} ${r.description}`.toLowerCase().includes(t)))
+        .sort((a, b) => score(b, terms) - score(a, terms) || b.updatedAt.localeCompare(a.updatedAt))
+        .slice(0, limit);
+    return { repos, searched, warnings };
+}
+/** A hit in the repo name beats one that only matched the description. */
+function score(r, terms) {
+    const name = r.nameWithOwner.split("/")[1]?.toLowerCase() ?? "";
+    return terms.filter((t) => name.includes(t)).length;
+}
+/** One gh call. Setup problems are classified; everything else is the caller's to handle. */
+async function ghRaw(args) {
+    try {
+        const { stdout } = await run("gh", args, { maxBuffer: 8 * 1024 * 1024, timeout: 30000 });
+        return stdout;
+    }
+    catch (err) {
+        if (err?.code === "ENOENT")
+            throw new GhSetupError("missing", `The GitHub CLI (gh) is not installed on the machine running Jarvis. To fix it, ${INSTALL_HINT}, then run \`gh auth login\`.`);
+        const detail = firstLine(String(err?.stderr || err?.message || ""));
+        if (/not logged|gh auth login|bad credentials|401/i.test(detail)) {
+            authCache = undefined;
+            throw new GhSetupError("auth", "The GitHub CLI's login has expired or was revoked. To fix it, run `gh auth login` on the machine running Jarvis and ask me again.");
+        }
+        throw new Error(`gh ${args[0]} ${args[1] ?? ""}`.trim() + ` failed: ${detail || "unknown error"}`);
+    }
+}
+function firstLine(s) {
+    return String(s ?? "").trim().split("\n")[0].trim();
+}

package/dist/jarvis.js

@@ -284,6 +284,12 @@ TOOLS
 - create_project: register a project from a repo URL (cloned into the workspace) or an existing
   folder. Use it once you know enough; then continue the original request.
 - update_project: rewrite a project's notes.
+- find_repos: search the user's GitHub for a repository by name or words in its description.
+  It covers their own account and every organisation they belong to, private repos included;
+  the result says which owners it actually searched. Use it to turn a project name into a repo
+  URL. If it reports that the GitHub CLI is missing, logged out or short a scope, tell the user
+  straight away, with the command that fixes it — only they can fix it, and until then any
+  search of theirs is incomplete or impossible.
 - delegate: give a project agent a bounded task and get its report back. It blocks until the
   agent finishes, which may take minutes. You may call it for several projects at once.
 - handoff: move the conversation into a project. The project agent takes over from the next
@@ -304,8 +310,9 @@ UNKNOWN PROJECTS
 - If the user names a project you do not have, do not fail and do not poke at the folder
   yourself. Check list_projects: an unclaimed workspace folder with a matching name is almost
   certainly it, so create_project with that path, say so in a few words, and carry on with the
-  original request through the new project agent. Otherwise ask which repository it is (URL or
-  path), then create_project and continue.
+  original request through the new project agent. If nothing matches, call find_repos: one
+  clear hit on GitHub is it, so create_project with its URL (which clones it) and continue.
+  Only when that is ambiguous or empty, ask the user which repository it is.
 
 RULES
 - Project agents may edit code, run tests and open branches, but nothing is merged, pushed to a

package/dist/server-common.js

@@ -400,7 +400,11 @@ async function createHttpServer(opts) {
     const server = node_http_1.default.createServer();
     // Serve the SPA for GET /
     server.on("request", (req, res) => {
-        if (req.method === "GET" && (req.url === "/" || req.url === "")) {
+        // Match on the path alone: the API listener skips the root, so a root URL
+        // carrying a query string ("/?v=2") would otherwise be answered by nobody
+        // and hang until the client gave up.
+        const path = (req.url ?? "/").split("?")[0];
+        if (req.method === "GET" && (path === "/" || path === "")) {
             res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
             // Function replacement: the vendor bundles contain `$&`-style sequences
             // that a string replacement would interpret.

package/dist/start-claude-code.js

@@ -17,8 +17,20 @@ const crypto_1 = require("crypto");
 const server_common_1 = require("./server-common");
 const bot_store_1 = require("./bot-store");
 const jarvis_tools_1 = require("./jarvis-tools");
+const context_window_1 = require("./context-window");
 // Where Jarvis's project checkouts live; set once by the server at startup.
 let workspaceCwd = process.cwd();
+/**
+ * The model every Claude Code session runs unless a bot names its own. Jarvis
+ * and its project agents both reason about whole repositories, so the default
+ * is the strongest model rather than the cheapest.
+ *
+ * The [1m] suffix is what the agent SDK reads to budget a 1M-token context
+ * instead of 200K; it asks for the long-context beta and is stripped before
+ * the request reaches the API. Long sessions in a large checkout then run
+ * much further before compaction, at the cost of burning rate limits faster.
+ */
+const DEFAULT_MODEL = "claude-opus-5[1m]";
 function setWorkspaceCwd(cwd) { workspaceCwd = cwd; }
 async function initAgent() {
     try {
@@ -82,10 +94,13 @@ async function runAgent(store) {
                 env: { ...process.env, CLAUDE_CODE_STREAM_CLOSE_TIMEOUT: String(6 * 60 * 60 * 1000) },
             }
             : {};
+        // Settle the model before the run rather than at the call, so the context
+        // meter can name it and size its window.
+        store.model = store.model ?? DEFAULT_MODEL;
         const q = (0, claude_agent_sdk_1.query)({
             prompt: promptParam,
             options: {
-                model: store.model ?? "claude-sonnet-4-6",
+                model: store.model,
                 permissionMode: store.mode === "plan" ? "plan" : "default",
                 abortController,
                 includePartialMessages: true,
@@ -143,6 +158,18 @@ async function runAgent(store) {
                 }
                 if (msg.type === "result")
                     receivedResult = true;
+                // The context meter: an assistant message reports what the request
+                // carried and what it wrote, which together are what the next request
+                // will resend. The result message knows the window the CLI budgeted.
+                if (msg.type === "assistant") {
+                    const used = (0, context_window_1.tokensInContext)(msg.message?.usage);
+                    if (used > 0)
+                        reportContext(store, used);
+                }
+                else if (msg.type === "result") {
+                    const window = msg.modelUsage?.[store.model ?? ""]?.contextWindow;
+                    reportContext(store, store.context?.used ?? 0, window, true);
+                }
                 if (!modelLogged && msg.type === "assistant" && msg.message?.model) {
                     modelLogged = true;
                 }
@@ -555,3 +582,19 @@ function formatToolInput(toolName, input) {
             return JSON.stringify(input);
     }
 }
+/**
+ * Publishes how full the window is: live to the open thread, and — once the
+ * turn ends — onto the thread itself, so reopening it days later still shows
+ * where the conversation stands rather than nothing until the next turn.
+ */
+function reportContext(store, used, window, persist = false) {
+    if (!used)
+        return;
+    const next = (0, context_window_1.contextUsage)(used, store.model, window);
+    const changed = JSON.stringify(next) !== JSON.stringify(store.context);
+    store.context = next;
+    if (changed)
+        (0, server_common_1.emitEvent)(store, "context", next);
+    if (persist && store.threadId)
+        (0, bot_store_1.updateThread)(store.threadId, { context: next });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jarvis-hq",
-  "version": "0.0.3",
-  "description": "Jarvis \u2014 a persistent AI engineering partner. One entry point from any device; project-aware handoff and delegation to Claude Code running on your machine.",
+  "version": "0.0.5",
+  "description": "Jarvis — a persistent AI engineering partner. One entry point from any device; project-aware handoff and delegation to Claude Code running on your machine.",
   "main": "dist/index.js",
   "bin": {
     "jarvis": "dist/index.js"
@@ -11,7 +11,7 @@
     "skills"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && chmod +x dist/index.js",
     "dev": "tsx src/index.ts",
     "prepublishOnly": "npm run build"
   },

package/dist/client.js

@@ -1,118 +0,0 @@
-"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);
-}