claude-code-kanban 5.4.0 → 6.1.0

package/lib/terminal.js

@@ -7,6 +7,10 @@
 // (net-guard upgradeVerdict), refusal when the server is exposed, and a per-launch
 // token sent in the first message. The token is the only one that stops a
 // non-browser local process.
+//
+// The service runs in its own process (lib/terminal-host.js): cck checks the first two
+// gates and hands the upgraded socket over, so no keystroke or output byte waits on
+// cck's main thread.
 
 const crypto = require('node:crypto');
 const fs = require('node:fs');
@@ -26,6 +30,17 @@ const PICK_START_SLACK_MS = 2000;
 const NAME_RE = /^[A-Za-z0-9][A-Za-z0-9 ._-]{0,79}$/;
 const WORKTREE_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 const MODELS = new Set(['fable', 'opus', 'sonnet', 'haiku']);
+// Extra claude args reach the command line inside plain quotes (quoteArg), so a character
+// that ends or expands those quotes in any of the shells is refused.
+// biome-ignore lint/suspicious/noControlCharactersInRegex: refuses control characters on purpose
+const EXTRA_ARG_RE = /^[^\x00-\x1f\x7f'"%]*$/;
+const MAX_EXTRA_ARGS = 64;
+const MAX_EXTRA_ARG = 4096;
+// cck sets these itself, or they would start something other than a new session.
+const OWNED_FLAGS = new Set([
+  '--session-id', '-n', '--name', '--model', '-w', '--worktree',
+  '-r', '--resume', '-c', '--continue', '--fork-session', '-p', '--print',
+]);
 const MAX_PROMPT = 32 * 1024;
 const PROMPT_QUIET_MS = 400;
 // Watermarks from https://xtermjs.org/docs/guides/flowcontrol/ — pause the PTY while a
@@ -118,8 +133,8 @@ function resolveShell(value, which, platform = process.platform, env = process.e
 }
 
 // claudeArgs is null for a plain shell. Its items are fixed flags, a validated UUID, or
-// values that passed NAME_RE / WORKTREE_RE, so plain quoting is enough to keep a space
-// from splitting an argument and nothing can break out of the quotes.
+// values that passed NAME_RE / WORKTREE_RE / EXTRA_ARG_RE, so plain quoting is enough to
+// keep a space from splitting an argument and nothing can break out of the quotes.
 function quoteArg(arg, family) {
   if (/^[A-Za-z0-9._-]+$/.test(arg)) return arg;
   return family === 'cmd' ? `"${arg}"` : `'${arg}'`;
@@ -142,7 +157,7 @@ function claudeArgsFor(mode, id, spec) {
   if (mode === 'fork') return ['--resume', id, '--fork-session'];
   if (mode === 'pick') return ['--resume'];
   if (mode === 'new') {
-    const args = ['--session-id', id];
+    const args = ['--session-id', id, ...(spec.extraArgs || [])];
     if (spec.name) args.push('--name', spec.name);
     if (spec.model) args.push('--model', spec.model);
     // Last, because its value is optional and a following flag must not be taken for it.
@@ -153,6 +168,16 @@ function claudeArgsFor(mode, id, spec) {
   return ['--resume', id];
 }
 
+function extraArgsError(args) {
+  if (!Array.isArray(args) || args.length > MAX_EXTRA_ARGS) return `claude args (at most ${MAX_EXTRA_ARGS})`;
+  for (const a of args) {
+    if (typeof a !== 'string' || a.length > MAX_EXTRA_ARG || !EXTRA_ARG_RE.test(a)) return 'claude arg: no quotes, % or control characters';
+    const flag = a.split('=')[0];
+    if (OWNED_FLAGS.has(flag)) return `claude arg: cck sets ${flag}`;
+  }
+  return null;
+}
+
 // Returns the new-session options from a hello, or a string naming the bad field.
 function parseNewSpec(msg) {
   if (typeof msg.cwd !== 'string' || !msg.cwd) return 'folder';
@@ -165,7 +190,10 @@ function parseNewSpec(msg) {
   // biome-ignore lint/suspicious/noControlCharactersInRegex: strips ESC so a prompt cannot carry terminal sequences
   const prompt = typeof msg.prompt === 'string' ? msg.prompt.replace(/\x1b/g, '').trim() : '';
   if (prompt.length > MAX_PROMPT) return 'prompt';
-  return { cwd: msg.cwd, name: name || null, worktree, model, prompt: prompt || null };
+  const extraArgs = msg.extraArgs ?? [];
+  const bad = extraArgsError(extraArgs);
+  if (bad) return bad;
+  return { cwd: msg.cwd, name: name || null, worktree, model, prompt: prompt || null, extraArgs };
 }
 
 function samePath(a, b) {
@@ -225,15 +253,43 @@ function refuse(socket, status, reason) {
   socket.end(`HTTP/1.1 ${status}\r\nConnection: close\r\nContent-Type: text/plain\r\n\r\n${reason}\n`);
 }
 
+function localUnavailableReason(config, net) {
+  if (!config.enabled) return 'disabled';
+  if (net.EXPOSED) return 'refused while listening on a non-loopback address';
+  return null;
+}
+
+function refuseUpgrade(req, socket, reasonFor) {
+  let pathname;
+  try { pathname = new URL(req.url, 'http://x').pathname; } catch { pathname = ''; }
+  if (pathname !== WS_PATH) {
+    refuse(socket, '404 Not Found', 'no such endpoint');
+    return true;
+  }
+  const reason = reasonFor();
+  if (reason) refuse(socket, '403 Forbidden', reason);
+  return !!reason;
+}
+
+function clientConfigFor(config, available) {
+  return {
+    available,
+    fontFamily: config.fontFamily,
+    fontSize: config.fontSize,
+    scrollback: config.scrollback,
+    maxSessions: config.maxSessions,
+  };
+}
+
 /**
  * @param {object} o
  * @param {ReturnType<typeof readTerminalConfig>} o.config
  * @param {{EXPOSED: boolean, upgradeVerdict: (req: any) => string|null}} o.net
  * @param {string} o.claudeDir
  * @param {boolean} o.isDefaultDir
- * @param {(id: string) => string|null} o.resolveCwd  null = unknown session
+ * @param {(id: string) => string|null|Promise<string|null>} o.resolveCwd  null = unknown session
  * @param {(id: string, exceptPid?: number) => boolean} o.isLiveElsewhere
- * @param {(dir: string) => boolean} o.isAllowedFolder  where a new session may start
+ * @param {(dir: string) => boolean|Promise<boolean>} o.isAllowedFolder  where a new session may start
  * @param {() => {pid: number|null, sessionId: string, cwd: string|null, startedAt: number}[]} o.liveSessions
  *   claude's live-session registry, read fresh
  * @param {(cmd: string) => string|null} o.which
@@ -286,10 +342,7 @@ function createTerminalService(o) {
   }
 
   function unavailableReason() {
-    if (!config.enabled) return 'disabled';
-    if (net.EXPOSED) return 'refused while listening on a non-loopback address';
-    if (!load()) return loadError;
-    return null;
+    return localUnavailableReason(config, net) || (load() ? null : loadError);
   }
 
   function changed() {
@@ -319,11 +372,11 @@ function createTerminalService(o) {
   function restore() {
     if (!restoreQueue.length || unavailableReason()) return;
     console.log(`Restoring ${restoreQueue.length} terminal(s)`);
-    const next = () => {
+    const next = async () => {
       while (restoreQueue.length && !shuttingDown) {
         const id = restoreQueue.shift();
         if (sessions.has(id) || o.isLiveElsewhere(id)) continue;
-        const r = start(id, 'resume', {}, HEADLESS_COLS, HEADLESS_ROWS);
+        const r = await start(id, 'resume', {}, HEADLESS_COLS, HEADLESS_ROWS);
         if (!r.error) break;
         console.log(`Could not restore terminal ${id}: ${r.error}`);
       }
@@ -474,7 +527,8 @@ function createTerminalService(o) {
   // Claude's registry entry keeps its pid and swaps its sessionId to the picked one; the entry
   // is found by folder and start time, and the pick shows as an id with a transcript behind it.
   function watchPick(s) {
-    s.pickTimer = setInterval(() => {
+    s.pickTimer = setInterval(async () => {
+      if (s.pickChecking) return;
       const live = o.liveSessions();
       const entry = s.claudePid && live.find((l) => l.pid === s.claudePid);
       if (!entry) {
@@ -485,7 +539,11 @@ function createTerminalService(o) {
         return;
       }
       const picked = entry.sessionId;
-      if (picked === s.id || o.resolveCwd(picked) === null) return;
+      if (picked === s.id) return;
+      s.pickChecking = true;
+      const known = await o.resolveCwd(picked);
+      s.pickChecking = false;
+      if (known === null || s.exited || s.mode !== 'pick') return;
       clearInterval(s.pickTimer);
       // Two claude processes on one session write the same transcript. When cck already runs it,
       // the pick is ended and its viewers move to that terminal; the sockets leave first so no
@@ -538,7 +596,7 @@ function createTerminalService(o) {
     });
   }
 
-  function onHello(ws, msg) {
+  async function onHello(ws, msg) {
     if (!msg || msg.t !== 'hello' || !tokenMatches(token, msg.token)) {
       send(ws, { t: 'error', msg: 'The terminal token is out of date. Reload the hub window.' });
       return ws.close(4001);
@@ -560,36 +618,43 @@ function createTerminalService(o) {
       send(ws, { t: 'live' });
       return ws.close(1000);
     }
-    const r = start(id, mode, msg, cols, rows);
+    const r = await start(id, mode, msg, cols, rows);
+    if (r.running) return attach(ws, r.running, true);
     if (r.error) {
       send(ws, { t: 'error', msg: r.error });
       return ws.close(r.code);
     }
+    // The viewer left while the PTY started; it runs headless until the next attach.
+    if (ws.readyState !== 1) return;
     attach(ws, r.session, false);
   }
 
   // The admission rules shared by the socket hello and startNew. A refusal carries both a
   // WebSocket close code and an HTTP status, so each caller maps it its own way.
-  function start(id, mode, msg, cols, rows, extraEnv) {
-    if (sessions.size >= config.maxSessions) {
-      return { code: 4003, status: 429, error: `${config.maxSessions} terminals are open; end one first` };
+  // resolveCwd and isAllowedFolder may answer later, so the limits are checked again after them.
+  async function start(id, mode, msg, cols, rows, extraEnv) {
+    const full = { code: 4003, status: 429, error: `${config.maxSessions} terminals are open; end one first` };
+    if (sessions.size >= config.maxSessions) return full;
+    let spec = null;
+    if (mode === 'new') {
+      spec = parseNewSpec(msg);
+      if (typeof spec === 'string') return { code: 4002, status: 400, error: `invalid ${spec}` };
     }
-    const known = o.resolveCwd(id);
+    const known = await o.resolveCwd(id);
     let cwd = known;
-    let spec = null;
     if (mode === 'new' || mode === 'pick') {
-      if (mode === 'new') {
-        spec = parseNewSpec(msg);
-        if (typeof spec === 'string') return { code: 4002, status: 400, error: `invalid ${spec}` };
-      }
       if (known !== null) return { code: 4006, status: 409, error: 'session id already in use' };
-      if (typeof msg.cwd !== 'string' || !o.isAllowedFolder(msg.cwd)) {
+      if (typeof msg.cwd !== 'string' || !(await o.isAllowedFolder(msg.cwd))) {
         return { code: 4004, status: 403, error: 'folder is not a known project or a folder picked in this run' };
       }
       cwd = msg.cwd;
     } else if (mode !== 'shell' && known === null) {
       return { code: 4004, status: 404, error: 'unknown session' };
     }
+    if (shuttingDown) return { code: 1001, status: 503, error: 'the terminal is shutting down' };
+    const running = sessions.get(id);
+    if (running && !running.ended) return { running, code: 4006, status: 409, error: 'session id already in use' };
+    if (sessions.size >= config.maxSessions) return full;
     try {
       return { session: spawnSession(id, mode === 'auto' ? 'resume' : mode, cwd, cols, rows, spec, extraEnv) };
     } catch (e) {
@@ -598,31 +663,24 @@ function createTerminalService(o) {
   }
 
   function handleUpgrade(req, socket, head) {
-    let pathname;
-    try { pathname = new URL(req.url, 'http://x').pathname; } catch { pathname = ''; }
-    if (pathname !== WS_PATH) return refuse(socket, '404 Not Found', 'no such endpoint');
-    const reason = unavailableReason() || net.upgradeVerdict(req);
-    if (reason) return refuse(socket, '403 Forbidden', reason);
+    if (refuseUpgrade(req, socket, () => unavailableReason() || net.upgradeVerdict(req))) return;
     wss.handleUpgrade(req, socket, head, (ws) => {
       const timer = setTimeout(() => ws.close(4001), HELLO_TIMEOUT_MS);
       ws.once('message', (raw, isBinary) => {
         clearTimeout(timer);
         let msg = null;
         if (!isBinary) { try { msg = JSON.parse(raw.toString()); } catch { /* treated as bad hello */ } }
-        onHello(ws, msg);
+        onHello(ws, msg).catch((e) => {
+          send(ws, { t: 'error', msg: `failed to start the terminal: ${e.message}` });
+          ws.close(1011);
+        });
       });
       ws.on('error', () => {});
     });
   }
 
   function clientConfig() {
-    return {
-      available: !unavailableReason(),
-      fontFamily: config.fontFamily,
-      fontSize: config.fontSize,
-      scrollback: config.scrollback,
-      maxSessions: config.maxSessions,
-    };
+    return clientConfigFor(config, !unavailableReason());
   }
 
   // kill() returns before the process is gone, so an ended session leaves list() at once.
@@ -669,10 +727,11 @@ function createTerminalService(o) {
 
   // A 'new' session for a caller with no socket. The PTY runs headless until a browser
   // attaches, and a later attach resizes it.
-  function startNew(msg, extraEnv) {
+  async function startNew(msg, extraEnv) {
     const reason = unavailableReason();
     if (reason) return { status: 403, error: reason };
-    const r = start(crypto.randomUUID(), 'new', msg, HEADLESS_COLS, HEADLESS_ROWS, extraEnv);
+    if (msg.id != null && !(typeof msg.id === 'string' && UUID_RE.test(msg.id))) return { status: 400, error: 'invalid session id' };
+    const r = await start(msg.id || crypto.randomUUID(), 'new', msg, HEADLESS_COLS, HEADLESS_ROWS, extraEnv);
     return r.error ? r : { id: r.session.id, cwd: r.session.cwd };
   }
 
@@ -700,4 +759,4 @@ function createTerminalService(o) {
   return { token, handleUpgrade, clientConfig, list, claudePids, isRunning, end, authorized, startNew, paste, restore, shutdown, unavailableReason };
 }
 
-module.exports = { createTerminalService, readTerminalConfig, ptyEnv, shellArgs, resolveShell, claudeArgsFor, parseNewSpec, findPickProcess, tokenMatches };
+module.exports = { createTerminalService, readTerminalConfig, localUnavailableReason, refuseUpgrade, clientConfigFor, ptyEnv, shellArgs, resolveShell, claudeArgsFor, parseNewSpec, findPickProcess, tokenMatches };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "5.4.0",
+  "version": "6.1.0",
   "description": "A web-based Kanban board for viewing Claude Code tasks with agent teams support",
   "main": "server.js",
   "type": "commonjs",

package/plugin/plugins/claude-code-kanban/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "2.21.4",
+  "version": "2.23.0",
   "description": "claude-code-kanban dashboard integration: agent activity tracking, context and cost tracking, skills to drive the board from a session and to follow it",
   "experimental": {
     "monitors": "./monitors.json"

package/plugin/plugins/claude-code-kanban/hooks/context.ts

@@ -12,9 +12,10 @@ export function displayName(model: string) {
 const toEpochSeconds = (iso?: string) => (iso ? Math.floor(Date.parse(iso) / 1000) : undefined)
 
 // The board reads the statusLine's JSON shape, so the file keeps its field names.
-export function toStatus(model: string, m: Measure, usage: ModelUsage | undefined) {
+export function toStatus(model: string, m: Measure, usage: ModelUsage | undefined, requestAt?: number) {
   const { context } = m
   return {
+    ...(requestAt && { cache: { last_request_at: requestAt } }),
     model: { id: model, display_name: displayName(model) },
     cost: { total_cost_usd: m.cost?.usd ?? 0 },
     context_window: {
@@ -43,6 +44,7 @@ function cckDir($: EngineInterface) {
 
 let lastUsage: ModelUsage | undefined
 let lastModel: string | undefined
+let lastRequestAt: number | undefined
 const lastWritten = new Map<string, string>()
 
 async function write($: EngineInterface, m: Measure) {
@@ -51,7 +53,7 @@ async function write($: EngineInterface, m: Measure) {
     lastModel ?? $.session.model(),
     cckDir($),
   ])
-  const text = JSON.stringify(toStatus(model, m, lastUsage))
+  const text = JSON.stringify(toStatus(model, m, lastUsage, lastRequestAt))
   const file = `${dir}/context-status/${sessionId}.json`
   if (lastWritten.get(file) === text) return
   await $.fs.write(file, text)
@@ -65,6 +67,7 @@ export const register: Register = on => {
       const { model, ...usage } = result.usage
       lastUsage = usage
       lastModel = model
+      lastRequestAt = Date.now()
       await write($, await $.session.usage())
     }
     return result

package/plugin/plugins/claude-code-kanban/monitors.json

@@ -4,11 +4,5 @@
     "description": "Notifies this session when its tasks are moved on the kanban board or the user sends it review comments.",
     "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/postman.js\"",
     "when": "on-skill-invoke:claude-code-kanban:follow"
-  },
-  {
-    "name": "kanban-dispatch-inbox",
-    "description": "Notifies this session when a session it dispatched through cck reports or exits.",
-    "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/postman.js\" --topic dispatch --keep-backlog",
-    "when": "on-skill-invoke:claude-code-kanban:dispatch"
   }
 ]

package/plugin/plugins/claude-code-kanban/scripts/postman.js

@@ -29,10 +29,6 @@ const RETRY_MS = 15000;
 // Windows sometimes fails a loopback connect with ETIMEDOUT, or resets it once open, while the
 // board is up, so those errors get a few short waits before the normal one.
 const CONNECT_RETRY_MS = [250, 500, 1000, 2000];
-// `--topic dispatch` is the dispatch inbox: reports from sessions this one started.
-const TOPIC = process.argv.includes('--topic') ? process.argv[process.argv.indexOf('--topic') + 1] : null;
-// A dispatch report is a result, not an instruction, so a late attach still wants it.
-const KEEP_BACKLOG = process.argv.includes('--keep-backlog');
 
 if (!SESSION_ID) process.exit(0);
 
@@ -53,12 +49,11 @@ function serverUrl() {
 // Once per process, not once per poll: the grant means "follow the board from here on", so
 // the first attach throws away whatever queued up before it. A later reconnect must not
 // discard again -- by then the queue holds events the user is owed.
-let firstAttach = !KEEP_BACKLOG;
+let firstAttach = true;
 
 async function poll(base) {
   const first = firstAttach ? '&first=1' : '';
-  const topic = TOPIC ? `&topic=${encodeURIComponent(TOPIC)}` : '';
-  const url = `${base}/api/sessions/${encodeURIComponent(SESSION_ID)}/events?wait=${WAIT_SEC}${first}${topic}`;
+  const url = `${base}/api/sessions/${encodeURIComponent(SESSION_ID)}/events?wait=${WAIT_SEC}${first}`;
   const res = await fetch(url, { signal: AbortSignal.timeout((WAIT_SEC + 15) * 1000) });
   if (!res.ok) throw new Error(`HTTP ${res.status}`);
   firstAttach = false;

package/plugin/plugins/claude-code-kanban/skills/dispatch/SKILL.md

@@ -1,23 +1,29 @@
 ---
 name: dispatch
-description: Dispatch a task to another Claude Code session through the kanban board (cck), fire-and-forget or with a report back. Use when the user asks to dispatch, delegate, or start a session for a task, or to collect or check on a dispatched session's result.
-argument-hint: '<task> [--no-report] [--group <name>] [--model haiku|sonnet|opus|fable] [--worktree [name]]'
+description: Dispatch tasks to new Claude Code sessions in the kanban board's terminal. Use when the user asks to dispatch or delegate a task to another session.
+argument-hint: '<task> [--handoff] [--group <name>] [--model haiku|sonnet|opus|fable] [--worktree [name]] [-- <claude args>]'
 ---
 
 # Kanban dispatch
 
-This file only points at the guide. The guide ships with the `claude-code-kanban` binary, so it always matches the commands that binary accepts.
-
-Invoking this skill also arms this session's dispatch inbox: when a session you dispatched with `--report` reports or exits, a line arrives here:
-
-```
-[kanban board] Dispatch <dispatch-id> (session <uuid>) <reported success|reported failure|ended without a report>. Summary: <text>
-```
-
-Load the guide before running any dispatch command:
+The guide ships with the `claude-code-kanban` binary, so it always matches the commands that binary accepts. Load it before running any dispatch command:
 
 ```bash
 claude-code-kanban skills get dispatch
 ```
 
 Fall back to `npx claude-code-kanban` when the bare binary is not on PATH. If `skills get` is unknown, the installed cck is too old: tell the user to update it, and do not guess commands.
+
+## Reply
+
+End every spec with the reply line, because you usually need the result to continue:
+
+```text
+When you are done, or cannot finish, send the result to <your peer name> with the SendMessage tool, then stop.
+```
+
+`--handoff` is a skill argument that drops the reply line: the session owns the task, and the user follows it on the board. Keep it out of the `dispatch start` command.
+
+## Orchestration patterns
+
+Use request-reply, handoff or orchestrator-workers directly. When another shape fits better (a separate reviewer, steps that feed each other, a sub-orchestrator, a decision for the user), propose it in one line, the pattern and why, and dispatch only after the user agrees, unless the user named it. Details: [references/orchestration-patterns.md](references/orchestration-patterns.md).

package/plugin/plugins/claude-code-kanban/skills/dispatch/references/orchestration-patterns.md

@@ -0,0 +1,50 @@
+# Orchestration patterns
+
+Each pattern is only `dispatch start` plus `SendMessage`; the specs decide who talks to whom. A **worker** is a session you dispatch.
+
+## Select
+
+Use one of these directly:
+
+| Pattern | When |
+|---|---|
+| Request-reply | The default |
+| Handoff | The user passed `--handoff` or asked for no reply |
+| Orchestrator-workers | The task splits into parts that do not depend on each other |
+
+Propose these first, unless the user named one. Each adds steps, rounds or sessions the user did not ask for.
+
+| Pattern | Fits when |
+|---|---|
+| Prompt chaining | A step needs the previous step's output |
+| Evaluator-optimizer | There is a clear acceptance bar and a second look improves the result |
+| Hierarchical | A part is itself large enough to split |
+| Human-in-the-loop | The spec leaves a choice the user should make |
+
+## Request-reply
+
+One worker, one reply. The reply can go to any peer. When another session owns the work and should act on the result, name it in the reply line, and ask for a one-line note to you as well, so you know the worker finished.
+
+## Handoff
+
+One worker, no reply line. The worker owns the task, and you save the turn a reply costs.
+
+## Orchestrator-workers
+
+One worker per independent part, all started before you wait on any. They run at the same time, and each holds only its own part in context. Give each a unique `--name` and one shared `--group`, then combine the replies.
+
+## Prompt chaining
+
+Workers in sequence; each spec carries the previous reply. You check each output before you start the next step, and stop the chain when a check fails.
+
+## Evaluator-optimizer
+
+A generator and an evaluator that message each other until the evaluator accepts. A separate evaluator judges the work with fresh eyes. Give each the other's name, and cap the rounds in both specs: `stop after 3 rounds and send what you have`.
+
+## Hierarchical
+
+A worker that dispatches its own workers and replies once they all have. Your context then holds one reply per part instead of one per leaf. Its spec says to wait for its workers and to give them its own peer name.
+
+## Human-in-the-loop
+
+Add to the worker's spec: `When you need a decision, ask <your peer name> with the SendMessage tool and keep working on what does not depend on the answer.` Ask the user when the decision is theirs, and reply with `SendMessage`. You can steer a running worker the same way at any time.

package/plugin/plugins/claude-code-kanban/tests/context.test.ts

@@ -1,6 +1,6 @@
 import type { On, SessionMeasureInput } from 'claude-code'
 import { expect, test } from 'claude-code/testing'
-import { displayName } from '../hooks/context'
+import { displayName, toStatus } from '../hooks/context'
 
 const MEASURE: SessionMeasureInput = {
   context: { tokens: 129_174, window: 1_000_000, percent: 13 },
@@ -45,6 +45,19 @@ test('session.measure writes the statusLine shape the board reads', async ($, on
   expect(status.rate_limits.seven_day.used_percentage).toBe(7.5)
 })
 
+test('session.measure writes no cache entry before the first request', async ($, on) => {
+  const writes = engine(on, { CLAUDE_CONFIG_DIR: 'C:/cfg' }, 'sid-4')
+
+  await $.session.measure(MEASURE)
+
+  expect(JSON.parse(writes[0]?.text ?? '{}').cache).toBeUndefined()
+})
+
+test('toStatus adds the last request time', async () => {
+  const status = toStatus('claude-opus-5-5', MEASURE, undefined, 1_790_000_000_000)
+  expect(status.cache).toEqual({ last_request_at: 1_790_000_000_000 })
+})
+
 test('skips a write when the status has not changed', async ($, on) => {
   const writes = engine(on, { CLAUDE_CONFIG_DIR: 'C:/cfg' }, 'sid-3')