@holdgrenade/cli 1.0.48 → 1.0.50

package/README.md

@@ -29,7 +29,7 @@ grenade setup
 3. It offers the relay, for reaching the computer from any network (`grenade relay off`). Push notifications follow that answer: on with the relay, off without it, and setup says which.
 4. It shows a QR code. Scan it in the Grenade app and the phone is paired, on any network when the relay is on.
 
-Setup touches no agent's settings. Grenade starts Claude Code and Codex with its hooks (`claude --settings …`, `codex -c hooks.…`), so the phone knows when they work and wait. The first Codex session asks once to trust them; the phone shows it as a card, so tap Trust there or pick "Trust all and continue" in the terminal.
+Setup touches no agent's settings. Grenade starts Claude Code and Codex with its hooks (`claude --settings …`, `codex -c hooks.…`), so the phone knows when they work and wait. Claude Code also starts with a status line of Grenade's, which tells grenaded how full the conversation is and how much of your Pro or Max plan is used, and then runs your own status line, if you have one, so your line looks as before (a change to it applies to sessions started after). The first Codex session asks once to trust them; the phone shows it as a card, so tap Trust there or pick "Trust all and continue" in the terminal.
 
 `--yes` takes the suggested answer to every question; `--no-hooks`, `--no-service`, `--no-relay` and `--no-pair` leave a step out.
 

package/dist/cli.js

@@ -2127,7 +2127,7 @@ var require_extension = __commonJS({
       if (dest[name] === void 0) dest[name] = [elem];
       else dest[name].push(elem);
     }
-    function parse7(header) {
+    function parse8(header) {
       const offers = /* @__PURE__ */ Object.create(null);
       let params = /* @__PURE__ */ Object.create(null);
       let mustUnescape = false;
@@ -2267,7 +2267,7 @@ var require_extension = __commonJS({
         }).join(", ");
       }).join(", ");
     }
-    module.exports = { format, parse: parse7 };
+    module.exports = { format, parse: parse8 };
   }
 });
 
@@ -2301,7 +2301,7 @@ var require_websocket = __commonJS({
     var {
       EventTarget: { addEventListener, removeEventListener }
     } = require_event_target();
-    var { format, parse: parse7 } = require_extension();
+    var { format, parse: parse8 } = require_extension();
     var { toBuffer } = require_buffer_util();
     var kAborted = /* @__PURE__ */ Symbol("kAborted");
     var protocolVersions = [8, 13];
@@ -2991,7 +2991,7 @@ var require_websocket = __commonJS({
           }
           let extensions;
           try {
-            extensions = parse7(secWebSocketExtensions);
+            extensions = parse8(secWebSocketExtensions);
           } catch (err) {
             const message = "Invalid Sec-WebSocket-Extensions header";
             abortHandshake(websocket, socket, message);
@@ -3242,7 +3242,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open5() {
+          ws.once("open", function open7() {
             duplex._final(callback);
           });
           return;
@@ -3263,7 +3263,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open5() {
+          ws.once("open", function open7() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -3283,7 +3283,7 @@ var require_subprotocol = __commonJS({
   "node_modules/ws/lib/subprotocol.js"(exports, module) {
     "use strict";
     var { tokenChars } = require_validation();
-    function parse7(header) {
+    function parse8(header) {
       const protocols = /* @__PURE__ */ new Set();
       let start = -1;
       let end = -1;
@@ -3319,7 +3319,7 @@ var require_subprotocol = __commonJS({
       protocols.add(protocol);
       return protocols;
     }
-    module.exports = { parse: parse7 };
+    module.exports = { parse: parse8 };
   }
 });
 
@@ -7024,8 +7024,8 @@ function isKnownAgent(kind) {
 }
 
 // src/cli.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync16, readFileSync as readFileSync17, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname16 } from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync16, readFileSync as readFileSync18, writeFileSync as writeFileSync18 } from "node:fs";
+import { dirname as dirname17 } from "node:path";
 
 // node_modules/commander/lib/error.js
 var CommanderError = class extends Error {
@@ -12240,18 +12240,18 @@ var validateAsync = async (schema, value, _ctx) => {
   return result.issues.length === 0;
 };
 var _encode = (_Err) => {
-  const parse7 = _parse(_Err);
+  const parse8 = _parse(_Err);
   const fn = (schema, value, _ctx, _params) => {
     const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-    return parse7(schema, value, ctx, finalizeParams(fn, _params));
+    return parse8(schema, value, ctx, finalizeParams(fn, _params));
   };
   return fn;
 };
 var encode = /* @__PURE__ */ _encode($ZodRealError);
 var _decode = (_Err) => {
-  const parse7 = _parse(_Err);
+  const parse8 = _parse(_Err);
   const fn = (schema, value, _ctx, _params) => {
-    return parse7(schema, value, _ctx, finalizeParams(fn, _params));
+    return parse8(schema, value, _ctx, finalizeParams(fn, _params));
   };
   return fn;
 };
@@ -13918,7 +13918,7 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     }
     return propValues;
   });
-  const isObject4 = isObject;
+  const isObject5 = isObject;
   const catchall = def.catchall;
   let value;
   const memo2 = globalConfig.memoizer;
@@ -13926,7 +13926,7 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input2 = payload.value;
-    if (!isObject4(input2)) {
+    if (!isObject5(input2)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -14062,7 +14062,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     return doc.compile();
   };
   let fastpass;
-  const isObject4 = isObject;
+  const isObject5 = isObject;
   const jit = !globalConfig.jitless;
   const allowsEval2 = allowsEval;
   const fastEnabled = jit && allowsEval2.value;
@@ -14071,7 +14071,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input2 = payload.value;
-    if (!isObject4(input2)) {
+    if (!isObject5(input2)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -30900,6 +30900,97 @@ var VoiceTokenFrame = external_exports.object({
   once: external_exports.literal(true).optional()
 });
 
+// ../grenade-protocol/dist/usage.js
+var LIMITS_MAX = 16;
+var SessionContext = external_exports.object({
+  used: external_exports.number().int().min(0),
+  size: external_exports.number().int().min(1)
+});
+var PlanLimit = external_exports.object({
+  agent: AgentKind,
+  minutes: external_exports.number().int().min(1),
+  usedPercent: external_exports.number().min(0).max(100),
+  resetsAt: external_exports.string().datetime().optional(),
+  at: external_exports.string().datetime()
+});
+var LimitsRequestFrame = external_exports.object({ type: external_exports.literal("limits") });
+var LimitsFrame = external_exports.object({
+  type: external_exports.literal("limits"),
+  limits: external_exports.array(PlanLimit).max(LIMITS_MAX)
+});
+
+// ../grenade-protocol/dist/canvas.js
+var CANVAS_FOLDER = ".grenade/canvas";
+var CANVAS_BOARDS_MAX = 500;
+var CANVAS_BOARD_MAX_BYTES = 2 * 1024 * 1024;
+var CANVAS_BOARD_FRAME_MAX_BYTES = 3e6;
+var CANVAS_SUBSCRIPTIONS_MAX = 8;
+var CANVAS_DEFAULT_WIDTH = 1280;
+var CANVAS_DEFAULT_HEIGHT = 800;
+var CANVAS_SIZE_MAX = 8e3;
+var CanvasCwd = external_exports.string().min(1).max(1024).refine((p) => p === "~" || p.startsWith("~/") || p.startsWith("/"), "absolute or starting with ~");
+var CanvasFileName = external_exports.string().min(1).max(255).refine((f) => !/[/\\\0]/.test(f) && !f.startsWith(".") && /\.html?$/i.test(f), "a board's file name in the canvas folder");
+var RequestId = external_exports.string().min(1).max(64);
+var CanvasBoard = external_exports.object({
+  /** Its file name, "R3A · Cards.html". */
+  file: CanvasFileName,
+  /** What it is, from its name: "Cards". The file's name without its extension when the name has nothing after the revision. */
+  name: external_exports.string().min(1).max(255),
+  /** The revision its name starts with: 3 for "R3A · Cards.html". Absent for a name without one. */
+  revision: external_exports.number().int().min(0).max(9999).optional(),
+  /** The letters after the revision, as written: "A" for "R3A · Cards.html". Absent when there are none. */
+  letter: external_exports.string().regex(/^[A-Za-z]{1,3}$/).optional(),
+  /** The size it asks for (`<meta name="board" content="1280x800">`), else 1280 × 800. */
+  width: external_exports.number().int().min(1).max(CANVAS_SIZE_MAX),
+  height: external_exports.number().int().min(1).max(CANVAS_SIZE_MAX),
+  /** When it was last saved. */
+  modified: external_exports.string().datetime(),
+  /** Its size on disk. */
+  bytes: external_exports.number().int().min(0)
+});
+var CanvasRequestFrame = external_exports.object({ type: external_exports.literal("canvas"), id: RequestId, cwd: CanvasCwd });
+var CanvasSubscribeFrame = external_exports.object({ type: external_exports.literal("canvas.subscribe"), id: RequestId, cwd: CanvasCwd });
+var CanvasUnsubscribeFrame = external_exports.object({ type: external_exports.literal("canvas.unsubscribe"), cwd: CanvasCwd });
+var CanvasBoardRequestFrame = external_exports.object({ type: external_exports.literal("canvas.board"), id: RequestId, cwd: CanvasCwd, file: CanvasFileName });
+var CanvasFrame = external_exports.object({
+  type: external_exports.literal("canvas"),
+  /** The request's; absent on a frame sent because the canvas changed. */
+  id: RequestId.optional(),
+  /** As the client sent it. */
+  cwd: external_exports.string().min(1),
+  /** The canvas folder, absolute: `<cwd>/.grenade/canvas`. */
+  folder: external_exports.string().min(1),
+  boards: external_exports.array(CanvasBoard).max(CANVAS_BOARDS_MAX),
+  /** The folder is not there (yet): no session has drawn on this canvas. `boards` is empty. */
+  missing: external_exports.literal(true).optional(),
+  truncated: external_exports.literal(true).optional()
+});
+var CanvasBoardFrame = external_exports.object({
+  type: external_exports.literal("canvas.board"),
+  id: RequestId,
+  cwd: external_exports.string().min(1),
+  file: CanvasFileName,
+  /** The whole file, at most `CANVAS_BOARD_MAX_BYTES` bytes on disk. */
+  html: external_exports.string().max(CANVAS_BOARD_MAX_BYTES),
+  modified: external_exports.string().datetime(),
+  bytes: external_exports.number().int().min(0).max(CANVAS_BOARD_MAX_BYTES)
+});
+function boardNameOf(file2) {
+  const stem = file2.replace(/\.html?$/i, "") || file2;
+  const match = /^[Rr](\d{1,4})([A-Za-z]{0,3})(?![A-Za-z0-9])/.exec(stem);
+  if (!match)
+    return { name: stem };
+  const rest = stem.slice(match[0].length).replace(/^[\s·•\-–—_:|.]+/u, "").trim();
+  return { name: rest || stem, revision: Number(match[1]), ...match[2] ? { letter: match[2] } : {} };
+}
+function boardSizeOf(html) {
+  const meta3 = /<meta[^>]*name=["']board["'][^>]*>/i.exec(html);
+  const content = meta3 && /content=["']\s*(\d{2,5})\s*[x×]\s*(\d{2,5})\s*["']/.exec(meta3[0]);
+  if (!content)
+    return { width: CANVAS_DEFAULT_WIDTH, height: CANVAS_DEFAULT_HEIGHT };
+  return { width: Math.min(Number(content[1]), CANVAS_SIZE_MAX), height: Math.min(Number(content[2]), CANVAS_SIZE_MAX) };
+}
+
 // ../grenade-protocol/dist/relay.js
 var RELAY_PROTOCOL_VERSION = 1;
 var RELAY_DAEMON_PATH = "/v1/daemon";
@@ -31089,6 +31180,8 @@ var Session = external_exports.object({
   model: external_exports.string().min(1).max(MODEL_NAME_MAX).optional(),
   /** The effort level the agent last answered with, or was last switched to (PROTOCOL.md "Models"). Absent until the daemon has seen one, and for a model that takes none. */
   effort: EffortLevel.optional(),
+  /** How full the session's context is after the agent's last reply, in tokens (PROTOCOL.md "Usage"). Absent until the daemon has read it, and for shell sessions. */
+  context: SessionContext.optional(),
   createdAt: external_exports.string().datetime(),
   /** Sessions with the same group are shown together. Absent (older daemons) means the session is on its own. */
   group: external_exports.string().min(1).optional(),
@@ -31142,6 +31235,10 @@ var DaemonInfo = external_exports.object({
   groupNames: external_exports.literal(1).optional(),
   /** 1 when the daemon keeps voice providers' keys and answers `voice`, `voice.key` and `voice.token` (PROTOCOL.md "Voice providers"). Absent from older daemons. */
   voice: external_exports.literal(1).optional(),
+  /** 1 when the daemon serves a group's design canvas: `canvas`, `canvas.subscribe`, `canvas.board` (PROTOCOL.md "Canvas"). Absent from older daemons. */
+  canvas: external_exports.literal(1).optional(),
+  /** 1 when the daemon answers `limits` and sends `context` on sessions (PROTOCOL.md "Usage"). Absent from older daemons. */
+  limits: external_exports.literal(1).optional(),
   /** Retired: 1 when the daemon sends `activity` for Codex sessions too. Still sent for apps that read it; new clients read `agents`. */
   codexActivity: external_exports.literal(1).optional(),
   /** Every agent the daemon can start and what it does with each (PROTOCOL.md "Agents"). Absent from older daemons. */
@@ -31282,6 +31379,11 @@ var ClientFrame = external_exports.discriminatedUnion("type", [
   VoiceRequestFrame,
   VoiceKeyFrame,
   VoiceTokenRequestFrame,
+  CanvasRequestFrame,
+  CanvasSubscribeFrame,
+  CanvasUnsubscribeFrame,
+  CanvasBoardRequestFrame,
+  LimitsRequestFrame,
   PingFrame
 ]);
 var ErrorCode = external_exports.enum([
@@ -31307,7 +31409,7 @@ var ErrorFrame = external_exports.object({
   code: ErrorCode,
   message: external_exports.string(),
   ref: external_exports.string().optional(),
-  /** The `id` of the frame this error answers, when it had one (an `input`). */
+  /** The `id` of the frame this error answers, when it had one (an `input`, a `voice.token`, a `canvas` request). */
   id: external_exports.string().min(1).max(64).optional()
 });
 var SessionsFrame = external_exports.object({ type: external_exports.literal("sessions"), sessions: external_exports.array(Session) });
@@ -31378,6 +31480,9 @@ var DaemonFrame = external_exports.discriminatedUnion("type", [
   FoldersFrame,
   VoiceFrame,
   VoiceTokenFrame,
+  CanvasFrame,
+  CanvasBoardFrame,
+  LimitsFrame,
   PongFrame
 ]);
 var PairRequest = external_exports.object({ code: external_exports.string().regex(/^\d{6}$/), client: ClientInfo });
@@ -33323,6 +33428,53 @@ function shellQuote(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 
+// src/usage/claudeStatusLine.ts
+var STATUS_LINE_PATH = "/hooks/claude/status";
+function claudeStatusLine(port, user) {
+  const post = `curl -s -m 2 -X POST "http://127.0.0.1:${port}${STATUS_LINE_PATH}?session=$GRENADE_SESSION" -H 'content-type: application/json' --data-binary @-`;
+  const report = `(printf '%s' "$in" | ${post} >/dev/null 2>&1 &)`;
+  const command = user ? `in=$(cat); ${report}; printf '%s' "$in" | sh -c ${shellQuote(user.command)}` : `in=$(cat); ${report}`;
+  return { type: "command", command, ...user?.padding !== void 0 ? { padding: user.padding } : {} };
+}
+function userStatusLineIn(settings) {
+  const line = settings?.statusLine;
+  if (!line || line.type !== "command" || typeof line.command !== "string" || !line.command.trim()) return void 0;
+  if (line.command.includes(STATUS_LINE_PATH)) return void 0;
+  return { command: line.command, ...typeof line.padding === "number" ? { padding: line.padding } : {} };
+}
+var WINDOWS = { five_hour: 300, seven_day: 10080 };
+function claudeStatusUsage(payload, at) {
+  const p = payload ?? {};
+  const limits = [];
+  if (isObject3(p.rate_limits)) {
+    for (const [name, minutes] of Object.entries(WINDOWS)) {
+      const w = p.rate_limits[name];
+      if (!isObject3(w) || typeof w.used_percentage !== "number") continue;
+      const resetsAt = typeof w.resets_at === "number" ? new Date(w.resets_at * 1e3).toISOString() : void 0;
+      limits.push({ agent: "claude", minutes, usedPercent: clampPercent(w.used_percentage), ...resetsAt ? { resetsAt } : {}, at });
+    }
+  }
+  const context = contextIn(p.context_window);
+  return { ...context ? { context } : {}, limits };
+}
+function contextIn(window) {
+  if (!isObject3(window)) return void 0;
+  const size = window.context_window_size;
+  if (typeof size !== "number" || !(size >= 1)) return void 0;
+  const usage = window.current_usage;
+  if (isObject3(usage)) {
+    const used = tokens(usage.input_tokens) + tokens(usage.cache_creation_input_tokens) + tokens(usage.cache_read_input_tokens);
+    if (used > 0) return { used, size: Math.round(size) };
+  }
+  if (typeof window.used_percentage === "number") return { used: Math.round(clampPercent(window.used_percentage) / 100 * size), size: Math.round(size) };
+  return void 0;
+}
+var tokens = (v) => typeof v === "number" && v > 0 ? Math.round(v) : 0;
+var clampPercent = (v) => Math.max(0, Math.min(100, v));
+function isObject3(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
 // src/hooks/installHooks.ts
 var HOOK_EVENTS = ["UserPromptSubmit", "PreToolUse", "PostToolUse", "PostToolUseFailure", "Notification", "Stop", "StopFailure", "SessionEnd"];
 var PROMPT_EVENT = "PermissionRequest";
@@ -33344,15 +33496,16 @@ function mergeHooks(input2, port) {
   const command = { type: "command", command: hookCommand(port) };
   return mergeEntries(input2, [...HOOK_EVENTS.map((e) => [e, command]), [PROMPT_EVENT, promptHook(port)]], isGrenadeHook);
 }
-function claudeHookFlags(port) {
-  return `--settings ${shellQuote(JSON.stringify(mergeHooks({}, port).settings))}`;
+function claudeHookFlags(port, userStatusLine) {
+  const settings = { ...mergeHooks({}, port).settings, statusLine: claudeStatusLine(port, userStatusLine) };
+  return `--settings ${shellQuote(JSON.stringify(settings))}`;
 }
 function removeHooks(input2) {
   return removeEntries(input2, isGrenadeHook);
 }
 function mergeEntries(input2, wanted, isOurs) {
-  const settings = isObject3(input2) ? structuredClone(input2) : {};
-  const hooks = isObject3(settings.hooks) ? settings.hooks : {};
+  const settings = isObject4(input2) ? structuredClone(input2) : {};
+  const hooks = isObject4(settings.hooks) ? settings.hooks : {};
   settings.hooks = hooks;
   let changed = false;
   for (const [event, entry] of wanted) {
@@ -33373,8 +33526,8 @@ function mergeEntries(input2, wanted, isOurs) {
   return { settings, changed };
 }
 function removeEntries(input2, isOurs) {
-  const settings = isObject3(input2) ? structuredClone(input2) : {};
-  const hooks = isObject3(settings.hooks) ? settings.hooks : {};
+  const settings = isObject4(input2) ? structuredClone(input2) : {};
+  const hooks = isObject4(settings.hooks) ? settings.hooks : {};
   let changed = false;
   for (const [event, matchers] of Object.entries(hooks)) {
     if (!Array.isArray(matchers)) continue;
@@ -33384,7 +33537,7 @@ function removeEntries(input2, isOurs) {
   }
   return { settings, changed };
 }
-function isObject3(v) {
+function isObject4(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v);
 }
 
@@ -34478,12 +34631,12 @@ function terminalFromEnv() {
   const env = process.env["GRENADE_TERMINAL"];
   return env !== void 0 && isTerminalKind(env) ? env : void 0;
 }
-function relayoutSteps(ordered, open5) {
+function relayoutSteps(ordered, open7) {
   const [head, ...rest] = ordered;
   if (head === void 0) return [];
-  const keepHead = open5.has(head);
+  const keepHead = open7.has(head);
   const steps = [];
-  for (const id of keepHead ? rest : ordered) if (open5.has(id)) steps.push({ kind: "close", id });
+  for (const id of keepHead ? rest : ordered) if (open7.has(id)) steps.push({ kind: "close", id });
   if (!keepHead) steps.push({ kind: "tab", id: head });
   rest.forEach((id, i) => steps.push({ kind: "split", id, nextTo: ordered[i] }));
   return steps;
@@ -34637,9 +34790,9 @@ var TerminalMirror = class {
   /** The nearest live member before `s` in group order that has a pane in `a`, else the last one that has. */
   openMemberOf(s, a) {
     if (s.group === void 0) return void 0;
-    const open5 = otherMembers(s.group, this.registry.list(), s.id).filter((m) => this.openIn.get(m.id) === a);
-    const before = open5.filter((m) => byGroupOrder(m, s) < 0);
-    return (before.at(-1) ?? open5.at(-1))?.id;
+    const open7 = otherMembers(s.group, this.registry.list(), s.id).filter((m) => this.openIn.get(m.id) === a);
+    const before = open7.filter((m) => byGroupOrder(m, s) < 0);
+    return (before.at(-1) ?? open7.at(-1))?.id;
   }
   closeTab(id) {
     const a = this.openIn.get(id);
@@ -34738,7 +34891,7 @@ function underService(env = process.env, pid = process.pid) {
 }
 
 // src/daemon/server.ts
-import { dirname as dirname15, join as join17 } from "node:path";
+import { dirname as dirname16, join as join18 } from "node:path";
 import { createServer as createServer2 } from "node:http";
 import { networkInterfaces } from "node:os";
 
@@ -35478,6 +35631,18 @@ var SessionRegistry = class extends EventEmitter2 {
     this.persist();
     this.emit("updated", r.session);
   }
+  /**
+   * How full the session's context is (PROTOCOL.md "Usage"): Claude Code's status line, Codex's rollout. Not saved:
+   * the next status line or hook after a restart brings it back.
+   */
+  setContext(id, context) {
+    const r = this.records.get(id);
+    if (!r) return;
+    const now = r.session.context;
+    if (now && now.used === context.used && now.size === context.size) return;
+    r.session = { ...r.session, context: { used: context.used, size: context.size } };
+    this.emit("updated", r.session);
+  }
   /**
    * A client switched the session to `model` (PROTOCOL.md "Models") and the agent took it: the session says so at
    * once, before the agent's next reply. `effort` undefined is a model that takes none.
@@ -36729,13 +36894,13 @@ function switchModelDialog(below) {
 }
 function paragraphs(rows) {
   const out = [];
-  let open5 = false;
+  let open7 = false;
   for (const row of rows.map((r) => r.trim())) {
-    if (!row) open5 = false;
-    else if (open5) out[out.length - 1] += ` ${row}`;
+    if (!row) open7 = false;
+    else if (open7) out[out.length - 1] += ` ${row}`;
     else {
       out.push(row);
-      open5 = true;
+      open7 = true;
     }
   }
   return out.map((p) => /[.!?:]$/.test(p) ? p : `${p}.`).join(" ");
@@ -36772,25 +36937,25 @@ async function switchClaudeModel(term, model, effort, timing = DEFAULT_TIMING) {
     throw new ModelSwitchError("Claude Code's prompt is not empty. Send or clear what is typed there, then choose again.");
   }
   await term.key("enter");
-  let open5 = await look2(modelPickerIn);
-  if (!open5) throw new ModelSwitchError("Claude Code did not open its model picker.");
-  if (!open5.sessionOnly) await giveUp("This Claude Code cannot switch one session only. Update Claude Code, then choose again.");
-  for (let moves = 0; selectedModel(open5) !== model; moves++) {
+  let open7 = await look2(modelPickerIn);
+  if (!open7) throw new ModelSwitchError("Claude Code did not open its model picker.");
+  if (!open7.sessionOnly) await giveUp("This Claude Code cannot switch one session only. Update Claude Code, then choose again.");
+  for (let moves = 0; selectedModel(open7) !== model; moves++) {
     if (moves >= MOST_MOVES) await giveUp(`Claude Code's picker has no ${model}.`);
-    const down = rowsDownTo(open5, model);
+    const down = rowsDownTo(open7, model);
     await term.key(down !== null && down > 0 ? "down" : "up");
     await timing.wait(LOOK_EVERY_MS);
-    open5 = await picker() ?? await giveUp("Claude Code closed its model picker.");
+    open7 = await picker() ?? await giveUp("Claude Code closed its model picker.");
   }
   if (effort !== void 0) {
-    for (let steps = 0; open5.effort !== effort; steps++) {
+    for (let steps = 0; open7.effort !== effort; steps++) {
       if (steps >= MOST_EFFORT_STEPS) await giveUp(`${model} has no ${effort} effort in Claude Code.`);
       await term.type(RIGHT);
       await timing.wait(LOOK_EVERY_MS);
-      open5 = await picker() ?? await giveUp("Claude Code closed its model picker.");
+      open7 = await picker() ?? await giveUp("Claude Code closed its model picker.");
     }
   }
-  const chosenEffort = open5.effort ?? void 0;
+  const chosenEffort = open7.effort ?? void 0;
   await term.type("s");
   const closed = await look2((lines) => modelPickerIn(lines) ? null : lines);
   if (!closed) await giveUp("Claude Code did not take the choice.");
@@ -38603,6 +38768,271 @@ function switchTimingProblem(session) {
   return null;
 }
 
+// src/canvas/canvasService.ts
+import { homedir as homedir9 } from "node:os";
+
+// src/canvas/canvasAccess.ts
+import { posix } from "node:path";
+function normalizeCwd(cwd, home) {
+  const expanded = expandHome(cwd, home);
+  if (!expanded.startsWith("/")) return null;
+  return posix.resolve(expanded);
+}
+function sharedFolder(paths2) {
+  if (paths2.length === 0) return null;
+  let shared = paths2[0].split("/").filter(Boolean);
+  for (const path2 of paths2.slice(1)) {
+    const parts = path2.split("/").filter(Boolean);
+    let i = 0;
+    while (i < shared.length && i < parts.length && shared[i] === parts[i]) i++;
+    shared = shared.slice(0, i);
+  }
+  return shared.length === 0 ? null : `/${shared.join("/")}`;
+}
+function canvasCwds(sessions, home) {
+  const allowed = /* @__PURE__ */ new Set();
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const cwd = normalizeCwd(s.cwd, home);
+    if (!cwd) continue;
+    allowed.add(cwd);
+    const key = s.group ?? s.id;
+    groups.set(key, [...groups.get(key) ?? [], cwd]);
+  }
+  for (const cwds of groups.values()) {
+    const shared = cwds.length > 1 ? sharedFolder(cwds) : null;
+    if (shared) allowed.add(shared);
+  }
+  return allowed;
+}
+function allowedCanvasCwd(cwd, sessions, home) {
+  const normalized = normalizeCwd(cwd, home);
+  return normalized && canvasCwds(sessions, home).has(normalized) ? normalized : null;
+}
+function canvasFolderOf(cwd) {
+  return posix.join(cwd, CANVAS_FOLDER);
+}
+
+// src/canvas/canvasFolder.ts
+import { constants as constants3 } from "node:fs";
+import { lstat, open as open5, readdir as readdir5 } from "node:fs/promises";
+import { dirname as dirname12, join as join16 } from "node:path";
+
+// src/canvas/boardListing.ts
+var finderOrder2 = new Intl.Collator("en", { numeric: true, sensitivity: "base" });
+function isBoardFile(name) {
+  return CanvasFileName.safeParse(name).success;
+}
+function boardsFrom(files, max = CANVAS_BOARDS_MAX) {
+  const sorted = files.filter((f) => isBoardFile(f.file)).sort((a, b) => finderOrder2.compare(a.file, b.file));
+  const boards = sorted.slice(0, max).map((f) => ({
+    file: f.file,
+    ...boardNameOf(f.file),
+    ...boardSizeOf(f.head),
+    modified: new Date(f.mtimeMs).toISOString(),
+    bytes: f.bytes
+  }));
+  return { boards, truncated: sorted.length > max };
+}
+function listingKey(listing) {
+  if (listing.missing) return "missing";
+  return listing.boards.map((b) => `${b.file}
+${b.modified}
+${b.bytes}`).join("\n\n");
+}
+function megabytes(bytes) {
+  return (bytes / (1024 * 1024)).toFixed(1);
+}
+function boardTooLarge(file2, fileBytes, frameBytes, computer = "Mac") {
+  if (fileBytes <= CANVAS_BOARD_MAX_BYTES && frameBytes <= CANVAS_BOARD_FRAME_MAX_BYTES) return null;
+  const name = file2.replace(/\.html?$/i, "");
+  return `"${name}" is too large to show here (${megabytes(Math.max(fileBytes, frameBytes))} MB; at most ${megabytes(CANVAS_BOARD_MAX_BYTES).replace(/\.0$/, "")} MB). Open it on the ${computer}.`;
+}
+
+// src/canvas/canvasFolder.ts
+var HEAD_BYTES = 8192;
+var CanvasError = class extends Error {
+};
+async function realFolder(path2) {
+  const st = await lstat(path2).catch((e) => {
+    if (e.code === "ENOENT" || e.code === "ENOTDIR") return null;
+    throw e;
+  });
+  if (!st) return false;
+  if (st.isSymbolicLink() || !st.isDirectory()) throw new CanvasError(`${path2} is not a folder of its own, so it is not served as a canvas.`);
+  return true;
+}
+async function canvasThere(folder) {
+  return await realFolder(dirname12(folder)) && await realFolder(folder);
+}
+async function openBoard(path2) {
+  const handle = await open5(path2, constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK).catch(() => null);
+  if (!handle) return null;
+  const st = await handle.stat();
+  if (!st.isFile()) {
+    await handle.close();
+    return null;
+  }
+  return {
+    size: st.size,
+    mtimeMs: st.mtimeMs,
+    async read(max) {
+      const buffer = Buffer.alloc(Math.min(max, st.size));
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+      return buffer.subarray(0, bytesRead);
+    },
+    close: () => handle.close()
+  };
+}
+async function listCanvas(folder, heads = /* @__PURE__ */ new Map()) {
+  if (!await canvasThere(folder)) return { boards: [], missing: true };
+  const entries = await readdir5(folder, { withFileTypes: true });
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (!e.isFile() || !isBoardFile(e.name)) continue;
+    const st = await lstat(join16(folder, e.name)).catch(() => null);
+    if (!st?.isFile()) continue;
+    const key = `${e.name}
+${st.mtimeMs}
+${st.size}`;
+    seen.add(key);
+    let head = heads.get(key);
+    if (head === void 0) {
+      const board = await openBoard(join16(folder, e.name));
+      if (!board) continue;
+      try {
+        head = (await board.read(HEAD_BYTES)).toString("utf8");
+      } finally {
+        await board.close();
+      }
+      heads.set(key, head);
+    }
+    files.push({ file: e.name, mtimeMs: st.mtimeMs, bytes: st.size, head });
+  }
+  for (const key of heads.keys()) if (!seen.has(key)) heads.delete(key);
+  const { boards, truncated } = boardsFrom(files);
+  return { boards, ...truncated ? { truncated: true } : {} };
+}
+async function readBoard(folder, file2, computer = "Mac") {
+  const notHere = new CanvasError(`"${file2}" is not on this canvas.`);
+  if (!isBoardFile(file2) || !await canvasThere(folder)) throw notHere;
+  const board = await openBoard(join16(folder, file2));
+  if (!board) throw notHere;
+  try {
+    const tooLarge = boardTooLarge(file2, board.size, 0, computer);
+    if (tooLarge) throw new CanvasError(tooLarge);
+    const data = await board.read(CANVAS_BOARD_MAX_BYTES);
+    return { html: data.toString("utf8"), modified: new Date(board.mtimeMs).toISOString(), bytes: data.length };
+  } finally {
+    await board.close();
+  }
+}
+
+// src/canvas/canvasWatcher.ts
+var CANVAS_POLL_MS = 400;
+var realEvery = (fn, ms) => {
+  const timer = setInterval(fn, ms);
+  timer.unref?.();
+  return () => clearInterval(timer);
+};
+var CanvasWatcher = class {
+  constructor(every = realEvery, list = listCanvas, onError = () => {
+  }) {
+    this.every = every;
+    this.list = list;
+    this.onError = onError;
+  }
+  every;
+  list;
+  onError;
+  folders = /* @__PURE__ */ new Map();
+  /** Starts telling `onChange` of every change to `folder` after `current`, the listing the subscriber has. Returns how to stop. */
+  watch(folder, current, onChange) {
+    let watched = this.folders.get(folder);
+    if (!watched) {
+      const created = { subscribers: /* @__PURE__ */ new Set(), heads: /* @__PURE__ */ new Map(), busy: false, stop: () => {
+      } };
+      created.stop = this.every(() => void this.look(folder, created), CANVAS_POLL_MS);
+      this.folders.set(folder, created);
+      watched = created;
+    }
+    const subscriber = { lastKey: listingKey(current), onChange };
+    watched.subscribers.add(subscriber);
+    const w = watched;
+    return () => {
+      w.subscribers.delete(subscriber);
+      if (w.subscribers.size === 0 && this.folders.get(folder) === w) {
+        w.stop();
+        this.folders.delete(folder);
+      }
+    };
+  }
+  /** How many folders are being polled. */
+  get size() {
+    return this.folders.size;
+  }
+  /** Looks at one folder now; a look still running makes this one a no-op. */
+  async look(folder, watched = this.folders.get(folder)) {
+    if (!watched || watched.busy) return;
+    watched.busy = true;
+    try {
+      const listing = await this.list(folder, watched.heads);
+      const key = listingKey(listing);
+      for (const s of watched.subscribers) {
+        if (s.lastKey === key) continue;
+        s.lastKey = key;
+        s.onChange(listing);
+      }
+    } catch (e) {
+      this.onError(folder, e);
+    } finally {
+      watched.busy = false;
+    }
+  }
+  /** Stops every poll (the daemon is stopping). */
+  stopAll() {
+    for (const w of this.folders.values()) w.stop();
+    this.folders.clear();
+  }
+};
+
+// src/canvas/canvasService.ts
+var CanvasService = class {
+  constructor(sessions, watcher = new CanvasWatcher(), home = homedir9(), computer = computerWord()) {
+    this.sessions = sessions;
+    this.watcher = watcher;
+    this.home = home;
+    this.computer = computer;
+  }
+  sessions;
+  watcher;
+  home;
+  computer;
+  /** The canvas folder of `cwd`, or `CanvasError` when no session works there. */
+  folderOf(cwd) {
+    const allowed = allowedCanvasCwd(cwd, this.sessions(), this.home);
+    if (!allowed) throw new CanvasError(`No session on this ${this.computer} works in ${cwd}, so it has no canvas to show.`);
+    return canvasFolderOf(allowed);
+  }
+  async list(cwd) {
+    const folder = this.folderOf(cwd);
+    return { folder, ...await listCanvas(folder) };
+  }
+  async board(cwd, file2) {
+    return readBoard(this.folderOf(cwd), file2, this.computer);
+  }
+  /** The canvas now, and `onChange` with each change after it until `stop`. */
+  async watch(cwd, onChange) {
+    const reply2 = await this.list(cwd);
+    const stop2 = this.watcher.watch(reply2.folder, reply2, (listing) => onChange({ folder: reply2.folder, ...listing }));
+    return { reply: reply2, stop: stop2 };
+  }
+  stop() {
+    this.watcher.stopAll();
+  }
+};
+
 // src/daemon/wsHandler.ts
 var HELLO_TIMEOUT_MS = 5e3;
 var NO_PUSH = { type: "push.state", registered: false, delivery: "off", events: [] };
@@ -38629,6 +39059,8 @@ var Connection = class {
   /** Live terminals this client has open, by session. */
   terms = /* @__PURE__ */ new Map();
   stopWatchingPush;
+  /** Canvases this client watches, by `cwd` as it sent it (PROTOCOL.md "Canvas", "Watching"). */
+  canvasWatches = /* @__PURE__ */ new Map();
   helloTimer;
   onUpdated = (s) => this.send({ type: "session.updated", session: s });
   onRemoved = (id) => {
@@ -38676,7 +39108,7 @@ var Connection = class {
     try {
       await this.dispatch(frame);
     } catch (e) {
-      const id = frame.type === "input" ? frame.id : void 0;
+      const id = frame.type === "input" || frame.type === "canvas" || frame.type === "canvas.subscribe" || frame.type === "canvas.board" ? frame.id : void 0;
       if (e instanceof UnknownSessionError) return this.fail("unknown_session", e.message, frame.type, false, id);
       if (e instanceof SessionExistsError) return this.fail("tmux_failed", e.message, frame.type, false, id);
       if (e instanceof BadCwdError || e instanceof UnknownGroupError) return this.fail("bad_frame", e.message, frame.type, false, id);
@@ -38699,6 +39131,8 @@ var Connection = class {
     for (const id of this.subscriptions) this.d.registry.unsubscribe(id);
     this.subscriptions.clear();
     for (const id of [...this.terms.keys()]) this.closeTerm(id);
+    for (const stop2 of this.canvasWatches.values()) stop2();
+    this.canvasWatches.clear();
     if (this.authed) {
       this.d.registry.off("updated", this.onUpdated);
       this.d.registry.off("removed", this.onRemoved);
@@ -38751,7 +39185,7 @@ var Connection = class {
     }
     this.d.prompts?.on("opened", this.onPrompt);
     this.d.prompts?.on("closed", this.onPrompt);
-    for (const open5 of this.d.prompts?.list() ?? []) this.send(open5);
+    for (const open7 of this.d.prompts?.list() ?? []) this.send(open7);
     this.d.activity?.on("activity", this.onActivity);
   }
   async dispatch(frame) {
@@ -38849,6 +39283,8 @@ ${frame.id}`, () => r.sendText(frame.sessionId, frame.text, frame.submit));
         return this.send({ type: "conversations", conversations: await this.d.conversations.list(this.anyAgentConversations) });
       case "folders":
         return this.send(await listFolders(frame.path));
+      case "limits":
+        return this.send({ type: "limits", limits: this.d.limits?.list() ?? [] });
       case "voice":
         if (!this.d.voice) return this.fail("bad_frame", "this daemon keeps no voice keys", frame.type);
         if (!this.watchesVoice) this.d.voice.on("changed", this.onVoice);
@@ -38875,6 +39311,11 @@ ${frame.id}`, () => r.sendText(frame.sessionId, frame.text, frame.submit));
           throw e;
         }
       }
+      case "canvas":
+      case "canvas.subscribe":
+      case "canvas.unsubscribe":
+      case "canvas.board":
+        return this.handleCanvas(frame);
       case "session.group": {
         const before = r.get(frame.sessionId);
         const after = r.setGroup(frame.sessionId, frame.group, frame.index);
@@ -38930,6 +39371,40 @@ ${frame.id}`, () => r.sendText(frame.sessionId, frame.text, frame.submit));
       }
     }
   }
+  /** The canvas frames (PROTOCOL.md "Canvas"): a refused folder, a missing or too large board is `bad_frame` with the request's `id`. */
+  async handleCanvas(frame) {
+    if (frame.type === "canvas.unsubscribe") {
+      this.canvasWatches.get(frame.cwd)?.();
+      this.canvasWatches.delete(frame.cwd);
+      return;
+    }
+    const canvas = this.d.canvas;
+    if (!canvas) return this.fail("bad_frame", "this daemon serves no canvas", frame.type, false, frame.id);
+    const { cwd, id } = frame;
+    const framed = (reply2, withId) => ({ type: "canvas", ...withId ? { id } : {}, cwd, ...reply2 });
+    try {
+      if (frame.type === "canvas") return this.send(framed(await canvas.list(cwd), true));
+      if (frame.type === "canvas.subscribe") {
+        const again = this.canvasWatches.get(cwd);
+        if (!again && this.canvasWatches.size >= CANVAS_SUBSCRIPTIONS_MAX) {
+          return this.fail("bad_frame", `A connection watches at most ${CANVAS_SUBSCRIPTIONS_MAX} canvases; unsubscribe from one first.`, frame.type, false, id);
+        }
+        const { reply: reply3, stop: stop2 } = await canvas.watch(cwd, (changed) => this.send(framed(changed, false)));
+        if (!this.authed) return stop2();
+        again?.();
+        this.canvasWatches.set(cwd, stop2);
+        return this.send(framed(reply3, true));
+      }
+      const board = await canvas.board(cwd, frame.file);
+      const reply2 = { type: "canvas.board", id, cwd, file: frame.file, ...board };
+      const tooLarge = boardTooLarge(frame.file, board.bytes, Buffer.byteLength(JSON.stringify(reply2)), computerWord());
+      if (tooLarge) return this.fail("bad_frame", tooLarge, frame.type, false, id);
+      return this.send(reply2);
+    } catch (e) {
+      if (e instanceof CanvasError) return this.fail("bad_frame", e.message, frame.type, false, id);
+      throw e;
+    }
+  }
   openTerm(sessionId, cols, rows) {
     if (!this.d.openTerm) return this.fail("bad_frame", "this daemon streams no terminal", "term.open");
     this.requireSession(sessionId);
@@ -39016,7 +39491,7 @@ var PairingWatch = class {
 // src/attachments/attachmentStore.ts
 import { mkdir, writeFile } from "node:fs/promises";
 import { existsSync as existsSync19 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 
 // src/attachments/attachmentName.ts
 var EXTENSION_FOR_MIME = {
@@ -39050,7 +39525,7 @@ function stamp(d) {
 function createAttachmentStore(dir, now = () => /* @__PURE__ */ new Date()) {
   return {
     async save(sessionId, name, mime, data) {
-      const folder = join16(dir, sessionId);
+      const folder = join17(dir, sessionId);
       await mkdir(folder, { recursive: true });
       const path2 = unusedPath(folder, attachmentFileName(name, mime, now()));
       await writeFile(path2, data, { flag: "wx" });
@@ -39062,8 +39537,8 @@ function unusedPath(folder, fileName) {
   const dot = fileName.lastIndexOf(".");
   const stem = dot > 0 ? fileName.slice(0, dot) : fileName;
   const ext = dot > 0 ? fileName.slice(dot) : "";
-  let candidate = join16(folder, fileName);
-  for (let n = 2; existsSync19(candidate); n++) candidate = join16(folder, `${stem}-${n}${ext}`);
+  let candidate = join17(folder, fileName);
+  for (let n = 2; existsSync19(candidate); n++) candidate = join17(folder, `${stem}-${n}${ext}`);
   return candidate;
 }
 
@@ -39078,14 +39553,14 @@ function accessHash(token) {
 
 // src/relay/e2eKey.ts
 import { existsSync as existsSync20, mkdirSync as mkdirSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync15 } from "node:fs";
-import { dirname as dirname12 } from "node:path";
+import { dirname as dirname13 } from "node:path";
 function loadOrCreateE2EKey(path2) {
   if (existsSync20(path2)) {
     const raw = Buffer.from(readFileSync14(path2, "utf8").trim(), "base64");
     if (raw.length === 32) return x25519FromRaw(raw);
   }
   const pair2 = generateX25519();
-  mkdirSync13(dirname12(path2), { recursive: true });
+  mkdirSync13(dirname13(path2), { recursive: true });
   writeFileSync15(path2, privateRaw(pair2.privateKey).toString("base64") + "\n", { mode: 384 });
   return pair2;
 }
@@ -39334,7 +39809,7 @@ var RelayLink = class {
 
 // src/push/boardDevices.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync14, readFileSync as readFileSync15, writeFileSync as writeFileSync16 } from "node:fs";
-import { dirname as dirname13 } from "node:path";
+import { dirname as dirname14 } from "node:path";
 var BoardDevices = class {
   constructor(path2) {
     this.path = path2;
@@ -39377,7 +39852,7 @@ var BoardDevices = class {
   }
   save() {
     if (!this.path) return;
-    mkdirSync14(dirname13(this.path), { recursive: true });
+    mkdirSync14(dirname14(this.path), { recursive: true });
     writeFileSync16(this.path, JSON.stringify(this.list(), null, 2) + "\n", { mode: 384 });
   }
 };
@@ -39630,7 +40105,7 @@ var BoardPusher = class {
 
 // src/push/pushDevices.ts
 import { existsSync as existsSync22, mkdirSync as mkdirSync15, readFileSync as readFileSync16, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname14 } from "node:path";
+import { dirname as dirname15 } from "node:path";
 var PushDevices = class {
   constructor(path2) {
     this.path = path2;
@@ -39673,7 +40148,7 @@ var PushDevices = class {
   }
   save() {
     if (!this.path) return;
-    mkdirSync15(dirname14(this.path), { recursive: true });
+    mkdirSync15(dirname15(this.path), { recursive: true });
     writeFileSync17(this.path, JSON.stringify(this.list(), null, 2) + "\n", { mode: 384 });
   }
 };
@@ -40284,6 +40759,87 @@ function promptText2(prompt) {
   }
 }
 
+// src/usage/planLimits.ts
+var PlanLimits = class {
+  byAgent = /* @__PURE__ */ new Map();
+  /** An agent's latest windows replace what it reported before. A report with none changes nothing. */
+  record(agent, limits) {
+    if (limits.length > 0) this.byAgent.set(agent, [...limits]);
+  }
+  /** Every window not yet reset at `now`, shortest first, then by agent. */
+  list(now = Date.now()) {
+    return [...this.byAgent.values()].flat().filter((l) => l.resetsAt === void 0 || Date.parse(l.resetsAt) > now).sort((a, b) => a.minutes - b.minutes || a.agent.localeCompare(b.agent)).slice(0, LIMITS_MAX);
+  }
+};
+
+// src/usage/readUsage.ts
+import { readFileSync as readFileSync17 } from "node:fs";
+import { open as open6 } from "node:fs/promises";
+
+// src/usage/codexUsage.ts
+function codexUsageIn(jsonl) {
+  const lines = jsonl.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line.includes('"token_count"')) continue;
+    const entry = parse7(line);
+    if (entry?.payload?.type !== "token_count") continue;
+    const at = typeof entry.timestamp === "string" && !Number.isNaN(Date.parse(entry.timestamp)) ? new Date(entry.timestamp).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+    const info = entry.payload.info ?? {};
+    const used = info.last_token_usage?.total_tokens;
+    const size = info.model_context_window;
+    const context = typeof used === "number" && typeof size === "number" && size >= 1 ? { used: Math.max(0, Math.round(used)), size: Math.round(size) } : void 0;
+    const limits = [];
+    const rl = entry.payload.rate_limits ?? {};
+    for (const key of ["primary", "secondary"]) {
+      const w = rl[key];
+      if (!w || typeof w.used_percent !== "number" || typeof w.window_minutes !== "number" || w.window_minutes < 1) continue;
+      const resets = typeof w.resets_at === "number" ? w.resets_at * 1e3 : typeof w.resets_in_seconds === "number" ? Date.parse(at) + w.resets_in_seconds * 1e3 : void 0;
+      limits.push({
+        agent: "codex",
+        minutes: Math.round(w.window_minutes),
+        usedPercent: Math.max(0, Math.min(100, w.used_percent)),
+        ...resets !== void 0 ? { resetsAt: new Date(resets).toISOString() } : {},
+        at
+      });
+    }
+    return { ...context ? { context } : {}, limits };
+  }
+  return null;
+}
+function parse7(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+// src/usage/readUsage.ts
+var TAIL_BYTES2 = 256 * 1024;
+async function readTail(path2) {
+  const file2 = await open6(path2, "r");
+  try {
+    const { size } = await file2.stat();
+    const length = Math.min(size, TAIL_BYTES2);
+    const buffer = Buffer.alloc(length);
+    await file2.read(buffer, 0, length, size - length);
+    return buffer.toString("utf8");
+  } finally {
+    await file2.close();
+  }
+}
+async function readCodexUsage(rolloutPath) {
+  return codexUsageIn(await readTail(rolloutPath));
+}
+function readUserStatusLine(settingsPath) {
+  try {
+    return userStatusLineIn(JSON.parse(readFileSync17(settingsPath, "utf8")));
+  } catch {
+    return void 0;
+  }
+}
+
 // src/daemon/server.ts
 async function startDaemon(opts = {}) {
   ensureDir();
@@ -40291,10 +40847,16 @@ async function startDaemon(opts = {}) {
   const controlPort2 = opts.controlPort ?? CONTROL_PORT;
   const log = opts.log ?? createLogger({ file: paths.log, level: process.env["GRENADE_LOG"] ?? "info" });
   const e2eKey = loadOrCreateE2EKey(opts.e2eKeyPath ?? paths.e2eKey);
-  const info = { id: loadDaemonId(), name: opts.name ?? defaultName(), version: VERSION, os: daemonOs(), key: e2eKey.publicKey.toString("base64"), e2e: 1, inputSent: 1, conversations: 1, conversationDelete: 1, term: 1, folders: 1, board: 1, groupNames: 1, voice: 1, codexActivity: 1, agents: [...AGENTS] };
+  const info = { id: loadDaemonId(), name: opts.name ?? defaultName(), version: VERSION, os: daemonOs(), key: e2eKey.publicKey.toString("base64"), e2e: 1, inputSent: 1, conversations: 1, conversationDelete: 1, term: 1, folders: 1, board: 1, groupNames: 1, voice: 1, canvas: 1, limits: 1, codexActivity: 1, agents: [...AGENTS] };
   const allowPlainLan = opts.allowPlainLan === true;
-  const tmux = opts.tmux ?? createTmux({ agentFlags: { claude: claudeHookFlags(port), codex: codexHookFlags(port) }, serverScope: underSystemd() });
-  const tokens = new TokenStore(opts.tokensPath === null ? void 0 : opts.tokensPath ?? paths.tokens);
+  const tmux = opts.tmux ?? createTmux({ agentFlags: {
+    // Read as each session starts, so a status line the user set up since is the one it runs.
+    get claude() {
+      return claudeHookFlags(port, readUserStatusLine(join18(opts.claudeDir ?? paths.claudeDir, "settings.json")));
+    },
+    codex: codexHookFlags(port)
+  }, serverScope: underSystemd() });
+  const tokens2 = new TokenStore(opts.tokensPath === null ? void 0 : opts.tokensPath ?? paths.tokens);
   const codes = new PairingCodes();
   const pairing = new PairingWatch();
   const registry2 = new SessionRegistry({
@@ -40304,13 +40866,14 @@ async function startDaemon(opts = {}) {
   });
   const summarizer = startSummarizer(registry2, log, opts.summaries ?? process.env["GRENADE_SUMMARIES"] !== "off");
   await registry2.adopt();
-  const groupsPath = opts.sessionsPath === null ? void 0 : opts.sessionsPath ? join17(dirname15(opts.sessionsPath), "groups.json") : paths.groups;
+  const groupsPath = opts.sessionsPath === null ? void 0 : opts.sessionsPath ? join18(dirname16(opts.sessionsPath), "groups.json") : paths.groups;
   const groupOrder = new GroupOrderStore(registry2, log, groupsPath);
   const poller = startPoller({ tmux, registry: registry2, log });
   const pinnedTerminal = opts.terminal ?? terminalFromEnv();
   const mirror = new TerminalMirror({ registry: registry2, log, terminal: pinnedTerminal ?? (() => readTerminalSetting()) });
   const terminalStatus = () => ({ ...mirror.status(), pinned: pinnedTerminal !== void 0 });
   mirror.start().catch((e) => log.warn("Could not mirror sessions into a terminal", { error: e }));
+  const planLimits = new PlanLimits();
   const http = createServer2(async (req, res) => {
     const url2 = new URL(req.url ?? "/", "http://localhost");
     try {
@@ -40324,6 +40887,11 @@ async function startDaemon(opts = {}) {
         closePromptsByHook(prompts, session, body);
         return sendJson(res, r.status, r.body);
       }
+      if (req.method === "POST" && url2.pathname === STATUS_LINE_PATH) {
+        if (!isLoopback(req.socket.remoteAddress)) return sendJson(res, 403, { error: "forbidden" });
+        applyStatusLine(url2.searchParams.get("session"), await readBody(req));
+        return sendJson(res, 200, { ok: true });
+      }
       if (req.method === "POST" && url2.pathname === "/hooks/codex") {
         if (!isLoopback(req.socket.remoteAddress)) return sendJson(res, 403, { error: "forbidden" });
         const r = applyCodexHook(url2.searchParams.get("session"), await readBody(req));
@@ -40376,7 +40944,7 @@ async function startDaemon(opts = {}) {
   for (const { id, path: path2 } of registry2.transcripts()) {
     readActivity(id, path2).catch((e) => log.debug("Could not read the activity from a saved transcript", { session: id, path: path2, error: e }));
   }
-  const marksPath = opts.sessionsPath === null ? void 0 : opts.sessionsPath ? join17(dirname15(opts.sessionsPath), "conversations.json") : paths.conversations;
+  const marksPath = opts.sessionsPath === null ? void 0 : opts.sessionsPath ? join18(dirname16(opts.sessionsPath), "conversations.json") : paths.conversations;
   const marks = new ConversationMarks(log, marksPath);
   const held = () => heldConversations(registry2.transcripts(), (id) => (registry2.get(id)?.status ?? "gone") !== "gone");
   const conversationIndex = new AllConversations([
@@ -40390,6 +40958,7 @@ async function startDaemon(opts = {}) {
     log,
     ...opts.voiceFetch ? { fetch: opts.voiceFetch } : {}
   });
+  const canvas = new CanvasService(() => registry2.list(), new CanvasWatcher(void 0, void 0, (folder, error62) => log.debug("Could not look at a canvas", { folder, error: error62 instanceof Error ? error62.message : String(error62) })));
   const models = {
     async switch(session, model, effort) {
       if (switchingModel.has(session.id)) throw new ModelSwitchError("A model switch is already under way in this session.");
@@ -40464,6 +41033,10 @@ async function startDaemon(opts = {}) {
     },
     onTranscript: (id, path2, event) => {
       registry2.setTranscript(id, path2);
+      readCodexUsage(path2).then((usage) => {
+        if (usage?.context) registry2.setContext(id, usage.context);
+        if (usage) planLimits.record("codex", usage.limits);
+      }).catch((e) => log.debug("Could not read the usage from a Codex rollout", { session: id, path: path2, error: e }));
       catchUp.cancel(id);
       codexStopCatchUp.cancel(id);
       readActivity(id, path2).then((entries) => {
@@ -40472,6 +41045,17 @@ async function startDaemon(opts = {}) {
       }).catch((e) => log.debug("Could not read the activity from a Codex rollout", { session: id, path: path2, error: e }));
     }
   });
+  function applyStatusLine(session, body) {
+    let payload;
+    try {
+      payload = JSON.parse(body || "{}");
+    } catch {
+      return;
+    }
+    const usage = claudeStatusUsage(payload, (/* @__PURE__ */ new Date()).toISOString());
+    planLimits.record("claude", usage.limits);
+    if (session && usage.context) registry2.setContext(session, usage.context);
+  }
   function handlePair(raw, res) {
     if (!allowPlainLan) return sendJson(res, 426, { error: "encryption_required" });
     let json2;
@@ -40485,7 +41069,7 @@ async function startDaemon(opts = {}) {
     const verdict = codes.verify(body.data.code);
     if (verdict === "too_many_attempts") return sendJson(res, 429, { error: verdict });
     if (verdict === "invalid_code") return sendJson(res, 400, { error: verdict });
-    const token = tokens.issue(body.data.client);
+    const token = tokens2.issue(body.data.client);
     pairing.paired(body.data.client, "lan");
     log.info(`Paired a new phone: ${body.data.client.name}`, { platform: body.data.client.platform });
     sendJson(res, 200, { token, daemon: info });
@@ -40494,7 +41078,7 @@ async function startDaemon(opts = {}) {
     const verdict = codes.verify(credential);
     if (verdict === "too_many_attempts") pairing.voided();
     if (verdict !== "ok") return { ok: false, code: verdict };
-    const token = tokens.issue(client, { sealed: true });
+    const token = tokens2.issue(client, { sealed: true });
     pairing.paired(client, route2);
     log.info(`Paired a new phone: ${client.name}`, { platform: client.platform, route: route2 });
     return { ok: true, token };
@@ -40515,7 +41099,7 @@ async function startDaemon(opts = {}) {
   const attachments = createAttachmentStore(opts.attachmentsDir ?? paths.attachments);
   const push2 = startPush({
     registry: registry2,
-    tokens,
+    tokens: tokens2,
     daemon: info,
     staticKey: e2eKey,
     relay: () => opts.relay === false ? null : loadRelayConfig(opts.relayPath ?? paths.relay),
@@ -40531,7 +41115,7 @@ async function startDaemon(opts = {}) {
   prompts.on("answered", (id) => registry2.applyHook(id, "working", void 0, true));
   const screenPrompts = new ScreenPrompts(registry2, prompts, log, (id) => switchingModel.has(id));
   watchScreenBackground(registry2);
-  const backgroundWatch = new ClaudeBackgroundWatch(registry2, join17(opts.claudeDir ?? paths.claudeDir, "sessions"), log);
+  const backgroundWatch = new ClaudeBackgroundWatch(registry2, join18(opts.claudeDir ?? paths.claudeDir, "sessions"), log);
   backgroundWatch.start();
   registry2.on("removed", (id) => {
     prompts.closeSession(id);
@@ -40552,13 +41136,13 @@ async function startDaemon(opts = {}) {
     return closed;
   }
   const devices = {
-    list: () => tokens.list().map((r) => deviceOf(r, live2.routesOf(r.token))),
+    list: () => tokens2.list().map((r) => deviceOf(r, live2.routesOf(r.token))),
     unpair(id) {
-      const gone = tokens.revoke(id);
+      const gone = tokens2.revoke(id);
       return gone ? { closed: closeConnectionsOf([gone], `unpaired on the ${computerWord()}`) } : null;
     },
     unpairAll() {
-      const gone = tokens.revokeAll();
+      const gone = tokens2.revokeAll();
       return { removed: gone.length, closed: closeConnectionsOf(gone, `unpaired on the ${computerWord()}`) };
     }
   };
@@ -40569,19 +41153,19 @@ async function startDaemon(opts = {}) {
     sentInputs,
     activity,
     interrupted,
-    isValidToken: (t) => tokens.has(t),
+    isValidToken: (t) => tokens2.has(t),
     sealed: via.sealed,
     route: via.route,
     // Plain is for phones that were never encrypted, and only while the daemon allows it.
-    acceptsPlain: (t) => allowPlainLan && tokens.get(t)?.sealed !== true,
+    acceptsPlain: (t) => allowPlainLan && tokens2.get(t)?.sealed !== true,
     onHello(connection, token, client) {
       live2.add(token, connection);
-      tokens.touch(token, { sealed: via.sealed, client });
-      if (!via.sealed) log.warn(`${client.name} connected without encryption. Update Grenade on that phone.`, { device: tokens.get(token)?.id });
+      tokens2.touch(token, { sealed: via.sealed, client });
+      if (!via.sealed) log.warn(`${client.name} connected without encryption. Update Grenade on that phone.`, { device: tokens2.get(token)?.id });
     },
     onEnd(connection, token) {
       live2.remove(token, connection);
-      tokens.touch(token);
+      tokens2.touch(token);
     },
     pair: pairPhone,
     push: push2.pusher,
@@ -40590,20 +41174,22 @@ async function startDaemon(opts = {}) {
     groups: groupOrder,
     models,
     voice,
+    canvas,
+    limits: planLimits,
     conversations,
-    openTerm(open5) {
+    openTerm(open7) {
       const stream = new TermStream({
-        ...open5,
-        resize: (cols, rows, by) => registry2.resize(open5.sessionId, cols, rows, by),
-        release: (by) => registry2.releaseSize(open5.sessionId, by),
+        ...open7,
+        resize: (cols, rows, by) => registry2.resize(open7.sessionId, cols, rows, by),
+        release: (by) => registry2.releaseSize(open7.sessionId, by),
         log
       });
       stream.start();
       return stream;
     },
     unpair(token) {
-      const id = tokens.get(token)?.id;
-      const gone = id ? tokens.revoke(id) : void 0;
+      const id = tokens2.get(token)?.id;
+      const gone = id ? tokens2.revoke(id) : void 0;
       if (gone) closeConnectionsOf([gone], "unpaired on the phone");
     },
     daemon: info,
@@ -40631,7 +41217,7 @@ async function startDaemon(opts = {}) {
   });
   const deviceIdleMs = opts.deviceIdleMs ?? DEVICE_IDLE_MS;
   const unpairIdle = () => {
-    if (deviceIdleMs > 0) closeConnectionsOf(tokens.revokeIdle(deviceIdleMs), "not seen for a long time");
+    if (deviceIdleMs > 0) closeConnectionsOf(tokens2.revokeIdle(deviceIdleMs), "not seen for a long time");
   };
   unpairIdle();
   const idleTimer = setInterval(unpairIdle, 60 * 60 * 1e3);
@@ -40653,7 +41239,7 @@ async function startDaemon(opts = {}) {
       config: config2,
       name: info.name,
       version: VERSION,
-      accessHashes: () => [...tokens.list().map((t) => accessHash(t.token)), ...offerAccess()],
+      accessHashes: () => [...tokens2.list().map((t) => accessHash(t.token)), ...offerAccess()],
       localIps: () => localIpv4(networkInterfaces()),
       openPipe: (conn, send, onEnd) => new PhonePipe({ conn, staticKey: e2eKey, send, makeConnection: (out, close) => makeConnection(out, close, { route: "relay", sealed: true }), log, onEnd }),
       log
@@ -40673,7 +41259,7 @@ async function startDaemon(opts = {}) {
     auto: () => opts.updates?.auto ?? readAuto()
   });
   const relayStatus = () => relayLink?.status() ?? { state: "off", phones: 0, ...opts.relay === false ? { disabled: true } : {} };
-  tokens.onChange(() => relayLink?.tokensChanged());
+  tokens2.onChange(() => relayLink?.tokensChanged());
   startRelay();
   const control2 = createControlServer({
     registry: registry2,
@@ -40727,6 +41313,7 @@ async function startDaemon(opts = {}) {
       mirror.stop();
       poller.stop();
       relayLink?.stop();
+      canvas.stop();
       push2.stop();
       prompts.closeAll();
       summarizer?.stop();
@@ -40918,18 +41505,18 @@ program2.command("kill <name>").description("end a session").action(async (name)
   console.log(`killed ${id}`);
 });
 program2.command("install-hooks").description("also let a claude typed by hand in a Grenade shell report to grenaded (edits ~/.claude/settings.json); sessions Grenade starts have the hooks already").option("--port <port>", "daemon port the hooks post to", parsePort, DEFAULT_PORT).option("--print", "print the resulting settings instead of writing").option("--remove", "remove Grenade hooks").action((o) => {
-  const current = existsSync23(paths.claudeSettings) ? JSON.parse(readFileSync17(paths.claudeSettings, "utf8")) : {};
+  const current = existsSync23(paths.claudeSettings) ? JSON.parse(readFileSync18(paths.claudeSettings, "utf8")) : {};
   const { settings, changed } = o.remove ? removeHooks(current) : mergeHooks(current, o.port);
   if (o.print) return console.log(JSON.stringify(settings, null, 2));
   if (o.remove) removeOldCodexHooks();
   if (!changed) return console.log(`nothing to do: ${paths.claudeSettings} already up to date`);
-  mkdirSync16(dirname16(paths.claudeSettings), { recursive: true });
+  mkdirSync16(dirname17(paths.claudeSettings), { recursive: true });
   writeFileSync18(paths.claudeSettings, JSON.stringify(settings, null, 2) + "\n");
   console.log(`${o.remove ? "removed Grenade hooks from" : "installed Grenade hooks in"} ${paths.claudeSettings}`);
 });
 function removeOldCodexHooks() {
   if (!existsSync23(paths.codexHooks)) return;
-  const { settings, changed } = removeCodexHooks(JSON.parse(readFileSync17(paths.codexHooks, "utf8")));
+  const { settings, changed } = removeCodexHooks(JSON.parse(readFileSync18(paths.codexHooks, "utf8")));
   if (!changed) return;
   writeFileSync18(paths.codexHooks, JSON.stringify(settings, null, 2) + "\n");
   console.log(`removed Grenade hooks from ${paths.codexHooks}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holdgrenade/cli",
-  "version": "1.0.48",
+  "version": "1.0.50",
   "description": "Watch and drive AI coding agents (Claude Code, Codex, a shell) in your computer's terminals from your phone.",
   "type": "module",
   "bin": {