claude-code-kanban 3.2.4 → 3.4.0

package/cli.js

@@ -0,0 +1,458 @@
+const path = require('path');
+
+// Help is auto-generated from this table — keep flags/usage in sync with `run` behavior.
+const COMMANDS = {
+  preview: {
+    summary: 'Open a markdown file in the preview modal on connected browser tabs',
+    usage: 'claude-code-kanban preview <file.md> [--session <id>]',
+    flags: {
+      '--session <id>': 'Switch focused session in the browser (does not link the file)',
+    },
+    run: runPreviewCli,
+  },
+  session: {
+    summary: 'List or open Claude Code sessions',
+    verbs: {
+      list: {
+        summary: 'List sessions',
+        usage: 'claude-code-kanban session list [--active] [--days <n>] [--project <name>] [--limit <n|all>] [--json]',
+        flags: {
+          '--active': 'Only sessions with recent activity (sidebar-style filter)',
+          '--days <n>': 'Only sessions modified within the last N days (fractional ok, e.g. 0.5)',
+          '--project <name>': 'Filter by project name (substring match)',
+          '--limit <n|all>': 'Max rows to display (default: 10). Use "all" for no cap.',
+          '--json': 'Output JSON instead of a table',
+        },
+        run: runSessionListCli,
+      },
+      open: {
+        summary: 'Focus a session in the browser (Active tab)',
+        usage: 'claude-code-kanban session open <id>',
+        flags: {
+          '<id>': 'Full session id, or a unique prefix',
+        },
+        run: runSessionOpenCli,
+      },
+      view: {
+        summary: 'Show full session stats (metadata + context window + cost)',
+        usage: 'claude-code-kanban session view <id> [--json]',
+        flags: {
+          '<id>': 'Full session id, or a unique prefix',
+          '--json': 'Output JSON instead of formatted sections',
+        },
+        run: runSessionViewCli,
+      },
+      peek: {
+        summary: 'Show the last N messages from a session',
+        usage: 'claude-code-kanban session peek <id> [--limit <n>] [--json]',
+        flags: {
+          '<id>': 'Full session id, or a unique prefix',
+          '--limit <n>': 'Number of messages (default: 10, max: 50)',
+          '--json': 'Output JSON instead of formatted lines',
+        },
+        run: runSessionPeekCli,
+      },
+    },
+  },
+};
+
+function runCli(argv) {
+  if (argv.includes('--version') || argv.includes('-v')) {
+    console.log(require('./package.json').version);
+    process.exit(0);
+  }
+  const cli = resolveCliCommand(argv);
+  if (cli.kind === 'server') return false;
+  if (cli.kind === 'help') {
+    if (cli.target && Object.hasOwn(COMMANDS, cli.target)) printNounHelp(cli.target);
+    else printTopHelp();
+    process.exit(0);
+  }
+  if (cli.kind === 'unknown-noun') {
+    console.error(`Unknown command: ${cli.noun}\n`);
+    printTopHelp();
+    process.exit(1);
+  }
+  if (cli.kind === 'unknown-verb') {
+    console.error(`Unknown subcommand: ${cli.noun} ${cli.verb}\n`);
+    printNounHelp(cli.noun);
+    process.exit(1);
+  }
+  if (cli.kind === 'noun') {
+    printNounHelp(cli.noun);
+    process.exit(0);
+  }
+  if (cli.kind === 'leaf') {
+    if (cli.args.includes('--help') || cli.args.includes('-h')) {
+      printLeafHelp(cli.name, cli.entry);
+      process.exit(0);
+    }
+    cli.entry.run(cli.args)
+      .then(code => { process.exitCode = code; })
+      .catch(e => { console.error(e.message); process.exitCode = 1; });
+    return true;
+  }
+  return true;
+}
+
+function resolveCliCommand(argv) {
+  const noun = argv[2] && !argv[2].startsWith('-') ? argv[2] : null;
+  const hasHelp = (a) => a.includes('--help') || a.includes('-h');
+  if (!noun) return hasHelp(argv) ? { kind: 'help' } : { kind: 'server' };
+  if (noun === 'help') return { kind: 'help', target: argv[3] };
+  if (!Object.hasOwn(COMMANDS, noun)) return { kind: 'unknown-noun', noun };
+  const entry = COMMANDS[noun];
+  if (!entry.verbs) return { kind: 'leaf', name: noun, entry, args: argv.slice(3) };
+  const verb = argv[3] && !argv[3].startsWith('-') ? argv[3] : null;
+  if (!verb) return { kind: 'noun', noun };
+  if (!Object.hasOwn(entry.verbs, verb)) return { kind: 'unknown-verb', noun, verb };
+  return { kind: 'leaf', name: `${noun} ${verb}`, entry: entry.verbs[verb], args: argv.slice(4) };
+}
+
+function printTopHelp() {
+  console.log('Usage: claude-code-kanban <command> [args] [--flags]\n');
+  console.log('Commands:');
+  for (const [name, cmd] of Object.entries(COMMANDS)) {
+    console.log(`  ${name.padEnd(20)}${cmd.summary}`);
+    if (cmd.verbs) {
+      for (const [vName, v] of Object.entries(cmd.verbs)) {
+        console.log(`    ${`${name} ${vName}`.padEnd(18)}${v.summary}`);
+      }
+    }
+  }
+  console.log(`  ${'help'.padEnd(20)}Show help for a command (claude-code-kanban help <command>)`);
+  console.log('\nFlags:');
+  console.log('  --help, -h            Show help (top-level, noun-level, or leaf-level)');
+  console.log('  --version, -v         Print version and exit');
+  console.log('\nServer mode (no subcommand):');
+  console.log('  --port <n>            Port to listen on (default 3456)');
+  console.log('  --dir <path>          Override Claude config dir (default ~/.claude)');
+  console.log('  --open                Open browser on start');
+  console.log('  --install, --uninstall    Install or remove the agent-spy hook');
+}
+
+function printNounHelp(noun) {
+  const entry = COMMANDS[noun];
+  console.log(`${entry.summary}\n`);
+  if (entry.verbs) {
+    console.log(`Usage: claude-code-kanban ${noun} <subcommand> [args] [--flags]\n`);
+    console.log('Subcommands:');
+    for (const [vName, v] of Object.entries(entry.verbs)) {
+      console.log(`  ${vName.padEnd(12)}${v.summary}`);
+    }
+    console.log(`\nRun \`claude-code-kanban ${noun} <subcommand> --help\` for details.`);
+  } else {
+    printLeafHelp(noun, entry);
+  }
+}
+
+function printLeafHelp(name, entry) {
+  console.log(`${entry.summary}\n`);
+  console.log(`Usage: ${entry.usage}`);
+  if (entry.flags && Object.keys(entry.flags).length) {
+    const pad = Math.max(...Object.keys(entry.flags).map(f => f.length));
+    console.log('\nFlags:');
+    for (const [flag, desc] of Object.entries(entry.flags)) {
+      console.log(`  ${flag.padEnd(pad + 2)}${desc}`);
+    }
+  }
+  console.log('\n  --help, -h            Show this help');
+}
+
+function getArgValue(args, name) {
+  const idx = args.findIndex(a => a === `--${name}` || a.startsWith(`--${name}=`));
+  if (idx === -1) return null;
+  const arg = args[idx];
+  if (arg.includes('=')) return arg.split('=').slice(1).join('=');
+  return args[idx + 1] && !args[idx + 1].startsWith('--') ? args[idx + 1] : null;
+}
+
+function cliPort() { return process.env.PORT || 3456; }
+function unreachable() { return `Cannot reach cck server on port ${cliPort()}. Start it first with "claude-code-kanban".`; }
+
+class CliUnreachable extends Error { constructor() { super(unreachable()); this.code = 'unreachable'; } }
+
+async function cliFetch(urlPath, init) {
+  try {
+    return await fetch(`http://127.0.0.1:${cliPort()}${urlPath}`, init);
+  } catch (e) {
+    if (e.cause?.code === 'ECONNREFUSED' || /fetch failed/i.test(e.message)) throw new CliUnreachable();
+    throw e;
+  }
+}
+
+function reportCliError(e) {
+  console.error(e.code === 'unreachable' ? e.message : (e.message || String(e)));
+}
+
+async function runPreviewCli(args) {
+  const filePathArg = args.find(a => !a.startsWith('--'));
+  if (!filePathArg) {
+    printLeafHelp('preview', COMMANDS.preview);
+    return 1;
+  }
+  const sessionId = getArgValue(args, 'session') || process.env.PREVIEW_SESSION || null;
+  const abs = path.resolve(filePathArg);
+  try {
+    const res = await cliFetch('/api/preview', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ path: abs, sessionId })
+    });
+    if (!res.ok) {
+      console.error(`Preview failed (${res.status}): ${await res.text()}`);
+      return 1;
+    }
+    console.log(`Preview opened: ${abs}${sessionId ? ` (session ${sessionId})` : ''}`);
+    return 0;
+  } catch (e) { reportCliError(e); return 1; }
+}
+
+// Mirror of `isSessionActive` in public/app.js — keep in sync (different runtimes, no shared module).
+function isSessionActive(s) {
+  return s.hasRecentLog || s.inProgress > 0 || s.hasActiveAgents || s.hasWaitingForUser;
+}
+
+function sessionStatus(s) {
+  if (!isSessionActive(s)) return 'idle';
+  if (s.hasWaitingForUser) return 'wait';
+  if (s.inProgress > 0) return 'busy';
+  return 'active';
+}
+
+function parseLimit(args, { fallback, allowAll = false }) {
+  const raw = getArgValue(args, 'limit');
+  if (raw === null) return { ok: true, limit: fallback };
+  if (allowAll && raw === 'all') return { ok: true, limit: null };
+  const n = parseInt(raw, 10);
+  if (Number.isNaN(n) || n <= 0) return { ok: false, error: `Invalid --limit value: ${raw}` };
+  return { ok: true, limit: n };
+}
+
+async function fetchSessionsList(limit) {
+  const q = limit === null ? 'all' : String(limit);
+  const res = await cliFetch(`/api/sessions?limit=${q}`);
+  if (!res.ok) throw new Error(`Failed to fetch sessions (${res.status})`);
+  return res.json();
+}
+
+async function resolveSessionByIdOrPrefix(idArg) {
+  let res;
+  try {
+    res = await cliFetch(`/api/session/resolve?id=${encodeURIComponent(idArg)}`);
+  } catch (e) {
+    reportCliError(e);
+    return null;
+  }
+  if (res.status === 404) {
+    console.error(`No session matches: ${idArg}`);
+    return null;
+  }
+  if (res.status === 409) {
+    const { matches = [] } = await res.json().catch(() => ({}));
+    console.error(`Ambiguous prefix "${idArg}" matches ${matches.length} sessions:`);
+    for (const m of matches.slice(0, 10)) console.error(`  ${m.id}  ${m.customTitle || ''}`);
+    return null;
+  }
+  if (!res.ok) {
+    console.error(`Resolve failed (${res.status}): ${await res.text()}`);
+    return null;
+  }
+  return res.json();
+}
+
+async function runSessionListCli(args) {
+  const activeOnly = args.includes('--active');
+  const projectFilter = getArgValue(args, 'project');
+  const daysArg = getArgValue(args, 'days');
+  const days = daysArg !== null ? parseFloat(daysArg) : null;
+  if (daysArg !== null && (Number.isNaN(days) || days <= 0)) {
+    console.error(`Invalid --days value: ${daysArg}`);
+    return 1;
+  }
+  const parsed = parseLimit(args, { fallback: 10, allowAll: true });
+  if (!parsed.ok) { console.error(parsed.error); return 1; }
+  const limit = parsed.limit;
+  const asJson = args.includes('--json');
+  const hasClientFilter = activeOnly || days !== null || projectFilter;
+  let list;
+  try {
+    list = await fetchSessionsList(hasClientFilter ? null : limit);
+  } catch (e) {
+    reportCliError(e);
+    return 1;
+  }
+  if (activeOnly) list = list.filter(isSessionActive);
+  if (days !== null) {
+    const cutoff = Date.now() - days * 86_400_000;
+    list = list.filter(s => s.modifiedAt && new Date(s.modifiedAt).getTime() >= cutoff);
+  }
+  if (projectFilter) {
+    const needle = projectFilter.toLowerCase();
+    list = list.filter(s => (s.project || '').toLowerCase().includes(needle));
+  }
+  const totalMatched = list.length;
+  if (limit !== null && list.length > limit) list = list.slice(0, limit);
+  if (asJson) {
+    console.log(JSON.stringify(list, null, 2));
+    return 0;
+  }
+  if (!list.length) {
+    console.log('No sessions match.');
+    return 0;
+  }
+  const rows = list.map(s => ({
+    id: s.id.slice(0, 8),
+    status: sessionStatus(s),
+    age: s.modifiedAt ? formatAge(Date.now() - new Date(s.modifiedAt).getTime()) : '-',
+    tasks: `${s.completed}/${s.taskCount}`,
+    project: path.basename(s.project || ''),
+    title: s.customTitle || s.name || s.slug || '',
+  }));
+  const w = {
+    id: 8,
+    status: Math.max(6, ...rows.map(r => r.status.length)),
+    age: Math.max(3, ...rows.map(r => r.age.length)),
+    tasks: Math.max(5, ...rows.map(r => r.tasks.length)),
+    project: Math.max(7, ...rows.map(r => r.project.length)),
+  };
+  console.log(`${'ID'.padEnd(w.id)}  ${'STATUS'.padEnd(w.status)}  ${'AGE'.padEnd(w.age)}  ${'TASKS'.padEnd(w.tasks)}  ${'PROJECT'.padEnd(w.project)}  TITLE`);
+  for (const r of rows) {
+    console.log(`${r.id.padEnd(w.id)}  ${r.status.padEnd(w.status)}  ${r.age.padEnd(w.age)}  ${r.tasks.padEnd(w.tasks)}  ${r.project.padEnd(w.project)}  ${r.title}`);
+  }
+  if (limit !== null && totalMatched > limit) {
+    console.log(`\n... ${totalMatched - limit} more. Use --limit <n> or --limit all to see them.`);
+  }
+  return 0;
+}
+
+function formatAge(ms) {
+  if (ms < 0) return '0s';
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h`;
+  const d = Math.floor(h / 24);
+  return `${d}d`;
+}
+
+async function runSessionOpenCli(args) {
+  const idArg = args.find(a => !a.startsWith('--'));
+  if (!idArg) {
+    printLeafHelp('session open', COMMANDS.session.verbs.open);
+    return 1;
+  }
+  const resolved = await resolveSessionByIdOrPrefix(idArg);
+  if (!resolved) return 1;
+  try {
+    const res = await cliFetch('/api/session/open', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ id: resolved.id })
+    });
+    if (!res.ok) {
+      console.error(`Open failed (${res.status}): ${await res.text()}`);
+      return 1;
+    }
+    console.log(`Session opened: ${resolved.id}${resolved.customTitle ? ` (${resolved.customTitle})` : ''}`);
+    return 0;
+  } catch (e) { reportCliError(e); return 1; }
+}
+
+async function runSessionViewCli(args) {
+  const idArg = args.find(a => !a.startsWith('--'));
+  if (!idArg) {
+    printLeafHelp('session view', COMMANDS.session.verbs.view);
+    return 1;
+  }
+  const asJson = args.includes('--json');
+  const resolved = await resolveSessionByIdOrPrefix(idArg);
+  if (!resolved) return 1;
+  let list;
+  try {
+    list = await fetchSessionsList(null);
+  } catch (e) { reportCliError(e); return 1; }
+  const s = list.find(x => x.id === resolved.id);
+  if (!s) {
+    console.error(`Session ${resolved.id} not found in /api/sessions response.`);
+    return 1;
+  }
+  if (asJson) {
+    console.log(JSON.stringify(s, null, 2));
+    return 0;
+  }
+  const status = sessionStatus(s);
+  const title = s.customTitle || s.name || s.slug || '';
+  const age = s.modifiedAt ? formatAge(Date.now() - new Date(s.modifiedAt).getTime()) : '-';
+  const fmtTok = (n) => typeof n === 'number' ? (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n)) : '-';
+  const fmtCost = (n) => typeof n === 'number' ? `$${n.toFixed(2)}` : '-';
+  const lines = [];
+  lines.push(`${s.id.slice(0, 8)} — ${title} [${status}]`);
+  if (s.project) lines.push(`  ${path.basename(s.project)}${s.gitBranch ? ` · ${s.gitBranch}` : ''} · modified ${age} ago`);
+  lines.push(`  Tasks: ${s.completed}/${s.taskCount}${s.inProgress ? ` (${s.inProgress} in progress)` : ''}${s.pending ? ` · ${s.pending} pending` : ''}`);
+  const ctx = s.contextStatus;
+  if (ctx) {
+    const cw = ctx.context_window || {};
+    const cost = ctx.cost || {};
+    const rl = ctx.rate_limits || {};
+    const modelName = ctx.model?.display_name || ctx.model?.id || '-';
+    const modelExtras = [
+      ctx.effort?.level,
+      ctx.thinking?.enabled ? 'thinking' : null,
+      ctx.fast_mode ? 'fast' : null,
+    ].filter(Boolean).join(' · ');
+    lines.push(`  Model: ${modelName}${modelExtras ? ` (${modelExtras})` : ''}`);
+    if (cw.used_percentage != null) {
+      lines.push(`  Context: ${cw.used_percentage}% used · ${fmtTok(cw.total_input_tokens)} in / ${fmtTok(cw.total_output_tokens)} out · cache ${fmtTok(cw.current_usage?.cache_read_input_tokens)} read`);
+    }
+    lines.push(`  Cost: ${fmtCost(cost.total_cost_usd)} · ${cost.total_api_duration_ms != null ? formatAge(cost.total_api_duration_ms) : '-'} api / ${cost.total_duration_ms != null ? formatAge(cost.total_duration_ms) : '-'} total · +${cost.total_lines_added || 0}/-${cost.total_lines_removed || 0}`);
+    if (rl.five_hour || rl.seven_day) {
+      lines.push(`  Limits: 5h ${rl.five_hour?.used_percentage ?? '-'}% · 7d ${rl.seven_day?.used_percentage ?? '-'}%`);
+    }
+  }
+  console.log(lines.join('\n'));
+  return 0;
+}
+
+async function runSessionPeekCli(args) {
+  const idArg = args.find(a => !a.startsWith('--'));
+  if (!idArg) {
+    printLeafHelp('session peek', COMMANDS.session.verbs.peek);
+    return 1;
+  }
+  const parsed = parseLimit(args, { fallback: 10 });
+  if (!parsed.ok) { console.error(parsed.error); return 1; }
+  const limit = parsed.limit;
+  const asJson = args.includes('--json');
+  const resolved = await resolveSessionByIdOrPrefix(idArg);
+  if (!resolved) return 1;
+  try {
+    const res = await cliFetch(`/api/sessions/${resolved.id}/messages?limit=${Math.min(limit, 50)}`);
+    if (!res.ok) {
+      console.error(`Peek failed (${res.status}): ${await res.text()}`);
+      return 1;
+    }
+    const { messages } = await res.json();
+    const ordered = [...messages].reverse();
+    if (asJson) {
+      console.log(JSON.stringify(ordered, null, 2));
+      return 0;
+    }
+    if (!ordered.length) {
+      console.log(`No messages for session ${resolved.id.slice(0, 8)}.`);
+      return 0;
+    }
+    console.log(`Session ${resolved.id.slice(0, 8)}${resolved.customTitle ? ` — ${resolved.customTitle}` : ''}`);
+    for (const m of ordered) {
+      const ts = m.timestamp ? new Date(m.timestamp).toLocaleTimeString('en-GB', { hour12: false }) : '--:--:--';
+      const label = (m.type === 'tool_use' ? (m.tool || 'tool') : m.type).padEnd(10);
+      const body = (m.text || m.detail || m.description || '').replace(/\s+/g, ' ').trim();
+      console.log(`[${ts}] ${label} ${body.slice(0, 120)}${body.length > 120 ? '…' : ''}`);
+    }
+    return 0;
+  } catch (e) { reportCliError(e); return 1; }
+}
+
+module.exports = { runCli };

package/lib/parsers.js

@@ -582,8 +582,9 @@ function readMessagesPage(jsonlPath, limit = 10, beforeTimestamp = null) {
   };
 }
 
-function buildAgentProgressMap(jsonlPath) {
+function buildSessionDigest(jsonlPath) {
   const map = {};
+  const terminated = new Map();
   try {
     const content = readFileSync(jsonlPath, 'utf8');
     const re = /"type":"agent_progress"[^}]*"agentId":"([^"]+)"/;
@@ -596,6 +597,34 @@ function buildAgentProgressMap(jsonlPath) {
     const nameByToolUseId = {};
     const descByToolUseId = {};
     for (const line of content.split('\n')) {
+      // Terminated-teammate detection: check first since cheap substring guards
+      if (line.includes('teammate-message') &&
+          (line.includes('teammate_terminated') || line.includes('shutdown_response'))) {
+        try {
+          const obj = JSON.parse(line);
+          if (obj.type === 'user') {
+            const text = typeof obj.message?.content === 'string' ? obj.message.content : null;
+            if (text) {
+              const ts = obj.timestamp || null;
+              for (const tmMatch of text.matchAll(/<teammate-message\s+[^>]*teammate_id="([^"]+)"[^>]*>([\s\S]*?)<\/teammate-message>/g)) {
+                try {
+                  const tid = tmMatch[1];
+                  const body = tmMatch[2].trim();
+                  const protocol = JSON.parse(body);
+                  if (protocol.type === 'teammate_terminated') {
+                    const name = protocol.from || (protocol.message?.match(/^(\S+)\s/)?.[1]) || tid;
+                    if (name !== 'system') terminated.set(name, ts);
+                  } else if (protocol.type === 'shutdown_response' && protocol.approve) {
+                    const name = protocol.from || tid;
+                    if (name !== 'system') terminated.set(name, ts);
+                  }
+                } catch (_) {}
+              }
+            }
+          }
+        } catch (_) {}
+      }
+
       if (line.includes('"agent_progress"')) {
         const agentMatch = re.exec(line);
         const parentMatch = parentRe.exec(line);
@@ -657,7 +686,11 @@ function buildAgentProgressMap(jsonlPath) {
       if (descByToolUseId[key]) entry.description = descByToolUseId[key];
     }
   } catch (_) {}
-  return map;
+  return { progressMap: map, terminated };
+}
+
+function buildAgentProgressMap(jsonlPath) {
+  return buildSessionDigest(jsonlPath).progressMap;
 }
 
 function readCompactSummaries(jsonlPath) {
@@ -699,36 +732,7 @@ function readCompactSummaries(jsonlPath) {
 }
 
 function findTerminatedTeammates(jsonlPath) {
-  const terminated = new Map();
-  try {
-    const content = readFileSync(jsonlPath, 'utf8');
-    for (const line of content.split('\n')) {
-      if (!line.includes('teammate-message')) continue;
-      if (!line.includes('teammate_terminated') && !line.includes('shutdown_response')) continue;
-      try {
-        const obj = JSON.parse(line);
-        if (obj.type !== 'user') continue;
-        const text = typeof obj.message?.content === 'string' ? obj.message.content : null;
-        if (!text) continue;
-        const ts = obj.timestamp || null;
-        for (const tmMatch of text.matchAll(/<teammate-message\s+[^>]*teammate_id="([^"]+)"[^>]*>([\s\S]*?)<\/teammate-message>/g)) {
-          try {
-            const tid = tmMatch[1];
-            const body = tmMatch[2].trim();
-            const protocol = JSON.parse(body);
-            if (protocol.type === 'teammate_terminated') {
-              const name = protocol.from || (protocol.message?.match(/^(\S+)\s/)?.[1]) || tid;
-              if (name !== 'system') terminated.set(name, ts);
-            } else if (protocol.type === 'shutdown_response' && protocol.approve) {
-              const name = protocol.from || tid;
-              if (name !== 'system') terminated.set(name, ts);
-            }
-          } catch (_) {}
-        }
-      } catch (_) {}
-    }
-  } catch (_) {}
-  return terminated;
+  return buildSessionDigest(jsonlPath).terminated;
 }
 
 function extractPromptFromTranscript(jsonlPath) {
@@ -766,6 +770,36 @@ function extractPromptFromTranscript(jsonlPath) {
   return null;
 }
 
+function extractModelFromTranscript(jsonlPath) {
+  const { openSync, readSync, closeSync } = fs;
+  const MAX_READ = 65536;
+  const CHUNK = 4096;
+  const fd = openSync(jsonlPath, 'r');
+  try {
+    let accumulated = '';
+    const buf = Buffer.alloc(CHUNK);
+    while (accumulated.length < MAX_READ) {
+      const bytesRead = readSync(fd, buf, 0, CHUNK, null);
+      if (bytesRead === 0) break;
+      accumulated += buf.toString('utf8', 0, bytesRead);
+      let nlIdx;
+      while ((nlIdx = accumulated.indexOf('\n')) !== -1) {
+        const line = accumulated.slice(0, nlIdx);
+        accumulated = accumulated.slice(nlIdx + 1);
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+          const model = obj.model || (obj.message && obj.message.model);
+          if (model) return model;
+        } catch (_) {}
+      }
+    }
+  } finally {
+    closeSync(fd);
+  }
+  return null;
+}
+
 module.exports = {
   parseTask,
   parseAgent,
@@ -777,7 +811,9 @@ module.exports = {
   readRecentMessages,
   readMessagesPage,
   buildAgentProgressMap,
+  buildSessionDigest,
   readCompactSummaries,
   findTerminatedTeammates,
-  extractPromptFromTranscript
+  extractPromptFromTranscript,
+  extractModelFromTranscript
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-kanban",
-  "version": "3.2.4",
+  "version": "3.4.0",
   "description": "A web-based Kanban board for viewing Claude Code tasks with agent teams support",
   "main": "server.js",
   "bin": {
@@ -44,6 +44,7 @@
   },
   "files": [
     "server.js",
+    "cli.js",
     "install.js",
     "plugin/**/*",
     "lib/**/*",

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

@@ -1,5 +1,5 @@
 {
   "name": "claude-code-kanban",
-  "version": "1.0.1",
+  "version": "1.1.3",
   "description": "Agent activity tracking for claude-code-kanban dashboard"
 }

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

@@ -0,0 +1,52 @@
+---
+name: kanban
+description: Drive the claude-code-kanban browser dashboard from this Claude session. Use this skill when the user mentions "kanban" together with "session" — e.g. "open this session in kanban", "show kanban", "focus current session in kanban", "preview this file in kanban", or asks to peek/view a kanban session.
+compatibility: Requires the `claude-code-kanban` CLI on PATH and the server running locally (default port 3456).
+---
+
+# Kanban Skill
+
+Drive the kanban from this Claude session. Every command corresponds to something the user could do in the kanban dashboard.
+
+The current Claude session id is available as `${CLAUDE_SESSION_ID}` (substituted when this skill loads), so the user never needs to look it up.
+
+NOTE, sometimes user prefers `npx claude-code-kanban` to `claude-code-kanban` — both work, as long as the CLI is available. Use npx as fallback or when user instructed explicitly.
+
+## Open the current session in kanban
+
+Primary use case. Pins the active Claude session in the kanban sidebar and switches to the Active tab.
+
+```bash
+claude-code-kanban session open ${CLAUDE_SESSION_ID}
+```
+
+Trigger phrases: "show this session in kanban", "focus current session", "open in kanban".
+
+## Preview a file in kanban
+
+Opens a markdown file in the preview modal:
+
+```bash
+claude-code-kanban preview <path-to-file.md> --session ${CLAUDE_SESSION_ID}   # prefer this one
+```
+
+Relative paths are fine — the server resolves to absolute.
+
+## Inspect sessions (read-only)
+
+When the user asks "what's going on in kanban?" or wants stats:
+
+```bash
+claude-code-kanban session list --active                            # recent active sessions
+claude-code-kanban session list --project <name>                    # filter by project
+claude-code-kanban session view ${CLAUDE_SESSION_ID}                # full stats for current session
+claude-code-kanban session peek ${CLAUDE_SESSION_ID} --limit 20     # last 20 messages
+```
+
+Add `--json` to any list-style verb for machine-readable output.
+
+## Troubleshooting
+
+- **"Cannot reach cck server on port 3456"** → ask the user to start it: `claude-code-kanban` (or `npm start` in the cck repo).
+- **Different port** → set `PORT=<n>` env var when invoking the CLI.
+- **Ambiguous session prefix (HTTP 409)** → use the full id. With `${CLAUDE_SESSION_ID}` this won't happen.