claude-code-kanban 5.3.0 → 6.0.0

package/lib/dispatch.js

@@ -1,179 +1,32 @@
-// Dispatch: one Claude Code session started by another through cck, and the report it
-// settles with. In memory on purpose: the PTYs die with the server, so nothing a
-// restart drops could still settle.
-//
-// The child holds a per-dispatch capability, never the terminal token, so it can
-// report its own outcome and nothing else. A stale or duplicate child is refused
-// because a record settles once.
+// Dispatch: a Claude Code session one session started in cck's terminal. In memory on
+// purpose: an entry lives as long as its PTY, which dies with the server.
 
-const crypto = require('node:crypto');
-const { tokenMatches } = require('./terminal');
-const { clampWait, EVENT_PREFIX } = require('./session-events');
+function createDispatchRegistry({ now = Date.now } = {}) {
+  const entries = new Map();
 
-const OUTCOMES = new Set(['succeeded', 'failed']);
-const MAX_SUMMARY = 4000;
-// Settled records outlive their session long enough for a parent to collect them.
-const KEEP_SETTLED_MS = 24 * 60 * 60 * 1000;
-const ID_RE = /^d_[0-9a-f]{12}$/;
-// The peer name lands verbatim in the started session's prompt.
-const PEER_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
-
-const isPeerName = (v) => typeof v === 'string' && PEER_RE.test(v);
-
-// With neither --report nor --peer the started session gets the task alone, like one the user typed.
-function formatPreamble(record, cli = 'claude-code-kanban') {
-  if (!record.report && !record.peer) return record.spec;
-  const lines = [`[cck dispatch ${record.id}] Another Claude Code session started you through claude-code-kanban to do the task below.`];
-  if (record.peer) {
-    lines.push(
-      `That session is the peer "${record.peer}". Ask it, not the user: when you need a decision, or find something that changes the task, send a short message with the SendMessage tool to "${record.peer}".`,
-      'Keep working on what does not depend on the answer. The reply arrives as a new message.',
-    );
-  }
-  if (record.report) {
-    lines.push(
-      'When the task is done, or you cannot finish it, report exactly once with this command, then stop:',
-      `${cli} dispatch done ${record.id} --cap ${record.cap} --outcome succeeded --summary "<what changed, what you found, what remains>"`,
-      record.peer
-        ? 'Use --outcome failed when the task cannot be finished. If the command refuses because the dispatch already ended, send the summary to the peer instead.'
-        : 'Use --outcome failed when the task is not done. Do not ask the user questions the other session must answer; report failed with the question instead.',
-    );
-  }
-  lines.push('', 'Task:', record.spec);
-  return lines.join('\n');
-}
-
-// The line reaches the parent through the postman at hook trust level; the summary is
-// last so no summary text can pose as a further field.
-const DISPATCH_OUTCOME = {
-  succeeded: 'reported success',
-  failed: 'reported failure',
-  exited: 'ended without a report',
-};
-
-function formatDispatchLine(r) {
-  const outcome = DISPATCH_OUTCOME[r.status] || r.status;
-  const head = `${EVENT_PREFIX} Dispatch ${r.id} (session ${r.session}) ${outcome}.`;
-  return r.summary ? `${head} Summary: ${r.summary}` : head;
-}
-
-function publicView(r) {
-  const { cap: _cap, ...rest } = r;
-  return rest;
-}
-
-function createDispatchRegistry({ onSettle, now = Date.now } = {}) {
-  const records = new Map();
-  const waiters = new Set();
-
-  function prune() {
-    const cutoff = now() - KEEP_SETTLED_MS;
-    for (const [id, r] of records) if (r.settledAt && r.settledAt < cutoff) records.delete(id);
-  }
-
-  function create({ parent, spec, name, report, peer, group, worktree }) {
-    prune();
-    const r = {
-      id: `d_${crypto.randomBytes(6).toString('hex')}`,
-      cap: crypto.randomBytes(16).toString('hex'),
+  function add({ session, parent, cwd, name, group, worktree }) {
+    entries.set(session, {
+      session,
       parent: parent || null,
-      session: null,
-      cwd: null,
+      cwd,
       name: name || null,
-      report: !!report,
-      peer: peer || null,
       group: group || null,
       worktree: worktree || null,
-      spec,
-      status: 'running',
-      summary: null,
       startedAt: now(),
-      settledAt: null,
-    };
-    records.set(r.id, r);
-    return r;
-  }
-
-  // The preamble carries the id, so the record exists before its session does.
-  function attach(id, { session, cwd }) {
-    const r = records.get(id);
-    if (r) Object.assign(r, { session, cwd });
-  }
-
-  function discard(id) {
-    records.delete(id);
-  }
-
-  function finish(r, status, summary) {
-    r.status = status;
-    r.summary = summary;
-    r.settledAt = now();
-    onSettle?.(r);
-    for (const wake of [...waiters]) wake();
-  }
-
-  // Returns null when settled, or {status, error} naming the refusal.
-  function settle(id, cap, outcome, summary) {
-    const r = typeof id === 'string' && ID_RE.test(id) ? records.get(id) : null;
-    if (!r) return { status: 404, error: 'no such dispatch' };
-    if (!tokenMatches(r.cap, cap)) return { status: 403, error: 'wrong capability' };
-    if (r.status !== 'running') return { status: 409, error: `already ${r.status}` };
-    if (!OUTCOMES.has(outcome)) return { status: 400, error: 'outcome must be succeeded or failed' };
-    // biome-ignore lint/suspicious/noControlCharactersInRegex: strips control characters on purpose
-    const text = typeof summary === 'string' ? summary.replace(/[\x00-\x1f\x7f]/g, ' ').trim().slice(0, MAX_SUMMARY) : '';
-    finish(r, outcome, text || null);
-    return null;
-  }
-
-  // The PTY ended with no report: the parent must not wait on it forever.
-  function sessionExited(sessionId) {
-    for (const r of records.values()) if (r.session === sessionId && r.status === 'running') finish(r, 'exited', null);
-  }
-
-  function select({ ids, parent } = {}) {
-    prune();
-    let out = [...records.values()];
-    if (ids?.length) out = out.filter((r) => ids.includes(r.id));
-    else if (parent) out = out.filter((r) => r.parent === parent);
-    return out;
-  }
-
-  function list(filter) {
-    return select(filter).map(publicView);
+    });
   }
 
-  // Resolves once any selected record is settled, or after `waitSec`. Stateless for the
-  // caller: it passes the ids still running on the next call. `onClose(stop)` returns an
-  // unsubscribe, called once the wait ends.
-  function wait(filter, waitSec, onClose) {
-    const sec = clampWait(waitSec);
-    const snapshot = () => {
-      const rows = select(filter);
-      return {
-        settled: rows.filter((r) => r.status !== 'running').map(publicView),
-        running: rows.filter((r) => r.status === 'running').map(publicView),
-      };
-    };
-    const first = snapshot();
-    if (first.settled.length || !first.running.length || !sec) return Promise.resolve({ ...first, timeout: false });
-    return new Promise((resolve) => {
-      let unsubscribe;
-      const done = (timeout) => {
-        if (!waiters.delete(wake)) return;
-        clearTimeout(timer);
-        unsubscribe?.();
-        resolve({ ...snapshot(), timeout });
-      };
-      const wake = () => {
-        if (select(filter).some((r) => r.status !== 'running')) done(false);
-      };
-      const timer = setTimeout(() => done(true), sec * 1000);
-      waiters.add(wake);
-      unsubscribe = onClose?.(() => done(true));
-    });
+  function list({ parent } = {}) {
+    const out = [...entries.values()];
+    return parent ? out.filter((e) => e.parent === parent) : out;
   }
 
-  return { create, attach, discard, settle, sessionExited, list, wait };
+  return {
+    add,
+    list,
+    has: (session) => entries.has(session),
+    remove: (session) => entries.delete(session),
+  };
 }
 
-module.exports = { createDispatchRegistry, formatPreamble, formatDispatchLine, isPeerName, DISPATCH_OUTCOME };
+module.exports = { createDispatchRegistry };

package/lib/git-branch.js

@@ -0,0 +1,62 @@
+// Read from HEAD rather than by spawning git: a sync spawn on the session-list path blocks the
+// event loop for up to half a second per cwd on Windows, and terminal input waits behind it.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REF_RE = /^ref:\s*refs\/heads\/(.+)$/;
+const GITDIR_RE = /^gitdir:\s*(.+)$/;
+
+// `.git` is a directory in an ordinary checkout and a `gitdir:` pointer file in a linked
+// worktree or a submodule.
+function headFile(dir, readFile) {
+  const dotGit = path.join(dir, '.git');
+  let text;
+  try {
+    text = readFile(dotGit);
+  } catch (e) {
+    if (e.code === 'EISDIR') return path.join(dotGit, 'HEAD');
+    return null;
+  }
+  const m = GITDIR_RE.exec(text.trim());
+  return m ? path.join(path.resolve(dir, m[1]), 'HEAD') : null;
+}
+
+/**
+ * @param {string} cwd
+ * @param {(file: string) => string} [readFile]
+ * @returns {string|null} null outside a repo and on a detached HEAD
+ */
+function readGitBranch(cwd, readFile = (f) => fs.readFileSync(f, 'utf8')) {
+  for (let dir = path.resolve(cwd); ; ) {
+    const head = headFile(dir, readFile);
+    if (head) {
+      try {
+        const m = REF_RE.exec(readFile(head).trim());
+        return m ? m[1] : null;
+      } catch {
+        return null;
+      }
+    }
+    const up = path.dirname(dir);
+    if (up === dir) return null;
+    dir = up;
+  }
+}
+
+/**
+ * Reads HEAD only where the transcript's `gitBranch` is wrong: cwd moved away from the launch
+ * project, or the project is a worktree (a `claude -w` session records the main checkout's
+ * branch on every line).
+ * @param {{cwd?: string, project?: string, gitBranch?: string}} meta
+ * @param {boolean} isWorktree whether `meta.project` is a linked worktree
+ * @param {(cwd: string) => string|null} branchAt
+ */
+function sessionGitBranch(meta, isWorktree, branchAt) {
+  if (meta.cwd && meta.project && (meta.cwd !== meta.project || isWorktree)) {
+    return branchAt(meta.cwd) || meta.gitBranch || null;
+  }
+  return meta.gitBranch || null;
+}
+
+module.exports = { readGitBranch, sessionGitBranch };

package/lib/parsers.js

@@ -4,6 +4,21 @@ const path = require('node:path');
 const os = require('node:os');
 const { StringDecoder } = require('node:string_decoder');
 
+// Full-transcript scans stream the file instead of reading it whole: a transcript can
+// reach hundreds of megabytes, and the event loop it would block also carries the
+// embedded terminal's keystrokes. Yields the same lines as content.split('\n').
+async function* readLines(file) {
+  const decoder = new StringDecoder('utf8');
+  let rest = '';
+  for await (const chunk of fs.createReadStream(file, { highWaterMark: 1 << 20 })) {
+    const parts = decoder.write(chunk).split('\n');
+    parts[0] = rest + parts[0];
+    rest = parts.pop();
+    yield* parts;
+  }
+  yield rest + decoder.end();
+}
+
 function parseTask(raw) {
   const task = typeof raw === 'string' ? JSON.parse(raw) : raw;
   return {
@@ -347,12 +362,24 @@ function scrapeScalarFromBlob(blob, re) {
 const sessionInfoCache = new Map();
 const SESSION_INFO_CACHE_MAX = 2000;
 
+// A prompt line carries the mode it was sent in. After a Shift+Tab, Claude Code writes an
+// auto_mode / auto_mode_exit attachment with the next tool result, and later rewrites a
+// permission-mode line with the live mode, often tens of seconds after.
+const modeOf = (data) => {
+  if (data.type === 'attachment') {
+    const t = data.attachment?.type;
+    return t === 'auto_mode' ? 'auto' : t === 'auto_mode_exit' ? 'default' : null;
+  }
+  return (data.type === 'user' || data.type === 'permission-mode') && data.permissionMode || null;
+};
+
 // gitBranch in the JSONL is pinned to the launch-time repo by Claude Code
 // and goes stale once cwd shifts (Bash `cd`, submodule). Callers needing the
 // live branch must resolve it from cwd separately. Cache is reset on inode
 // change or truncation (size < scannedUpTo).
+
 function readSessionInfoFromJsonl(jsonlPath) {
-  const result = { slug: null, projectPath: null, cwd: null, gitBranch: null, customTitle: null, logicalParentUuid: null, compactBoundaryUuid: null };
+  const result = { slug: null, projectPath: null, cwd: null, gitBranch: null, customTitle: null, logicalParentUuid: null, compactBoundaryUuid: null, permissionMode: null };
   let stat;
   let fd;
   try {
@@ -372,6 +399,7 @@ function readSessionInfoFromJsonl(jsonlPath) {
       gitBranch: cached.gitBranch,
       logicalParentUuid: cached.logicalParentUuid || null,
       compactBoundaryUuid: cached.compactBoundaryUuid || null,
+      permissionMode: cached.permissionMode || null,
       customTitle: readCustomTitle(jsonlPath, stat)
     };
   }
@@ -383,6 +411,7 @@ function readSessionInfoFromJsonl(jsonlPath) {
     result.gitBranch = cached.gitBranch;
     result.logicalParentUuid = cached.logicalParentUuid || null;
     result.compactBoundaryUuid = cached.compactBoundaryUuid || null;
+    result.permissionMode = cached.permissionMode || null;
   }
 
   let lastCwdSeen = result.cwd;
@@ -395,6 +424,8 @@ function readSessionInfoFromJsonl(jsonlPath) {
         lastCwdSeen = data.cwd;
       }
       if (data.gitBranch) result.gitBranch = data.gitBranch;
+      const mode = modeOf(data);
+      if (mode) result.permissionMode = mode;
       if (data.subtype === 'compact_boundary' && data.logicalParentUuid && !result.logicalParentUuid) {
         result.logicalParentUuid = data.logicalParentUuid;
         // The boundary record's own uuid: a fork copies it verbatim from the
@@ -466,6 +497,7 @@ function readSessionInfoFromJsonl(jsonlPath) {
         const tn = fs.readSync(fd, tailBuf, 0, TAIL_SIZE, tailStart);
         const lines = tailBuf.toString('utf8', 0, tn).split('\n');
         let latestTailCwd = null;
+        let latestTailMode = null;
         for (let i = lines.length - 1; i >= 0; i--) {
           try {
             const data = JSON.parse(lines[i]);
@@ -473,10 +505,12 @@ function readSessionInfoFromJsonl(jsonlPath) {
             if (!result.projectPath && data.cwd) result.projectPath = data.cwd;
             if (!result.gitBranch && data.gitBranch) result.gitBranch = data.gitBranch;
             if (!latestTailCwd && data.cwd) latestTailCwd = data.cwd;
-            if (latestTailCwd && result.slug && result.projectPath && result.gitBranch) break;
+            if (!latestTailMode) latestTailMode = modeOf(data);
+            if (latestTailCwd && latestTailMode && result.slug && result.projectPath && result.gitBranch) break;
           } catch {}
         }
         if (latestTailCwd) lastCwdSeen = latestTailCwd;
+        if (latestTailMode) result.permissionMode = latestTailMode;
       }
       scannedUpTo = stat.size;
     }
@@ -498,7 +532,8 @@ function readSessionInfoFromJsonl(jsonlPath) {
       gitBranch: result.gitBranch,
       cwd: result.cwd,
       logicalParentUuid: result.logicalParentUuid,
-      compactBoundaryUuid: result.compactBoundaryUuid
+      compactBoundaryUuid: result.compactBoundaryUuid,
+      permissionMode: result.permissionMode
     });
     if (sessionInfoCache.size > SESSION_INFO_CACHE_MAX) {
       const firstKey = sessionInfoCache.keys().next().value;
@@ -1064,12 +1099,10 @@ function readRecentMessages(jsonlPath, limit = 10) {
   }
 }
 
-function readFullToolResult(jsonlPath, toolUseId) {
+async function readFullToolResult(jsonlPath, toolUseId) {
   if (!toolUseId || !jsonlPath || !existsSync(jsonlPath)) return null;
   try {
-    const content = readFileSync(jsonlPath, 'utf8');
-    const lines = content.split('\n');
-    for (const line of lines) {
+    for await (const line of readLines(jsonlPath)) {
       if (!line || line.indexOf(toolUseId) === -1) continue;
       try {
         const obj = JSON.parse(line);
@@ -1092,14 +1125,12 @@ function readFullToolResult(jsonlPath, toolUseId) {
   return null;
 }
 
-function readUserImage(jsonlPath, msgUuid, blockIndex) {
+async function readUserImage(jsonlPath, msgUuid, blockIndex) {
   if (!msgUuid || !jsonlPath) return null;
   const idx = Number(blockIndex);
   if (!Number.isInteger(idx) || idx < 0) return null;
   try {
-    const content = readFileSync(jsonlPath, 'utf8');
-    const lines = content.split('\n');
-    for (const line of lines) {
+    for await (const line of readLines(jsonlPath)) {
       if (!line || line.indexOf(msgUuid) === -1) continue;
       try {
         const obj = JSON.parse(line);
@@ -1119,14 +1150,12 @@ function readUserImage(jsonlPath, msgUuid, blockIndex) {
 
 // Read the Nth base64 image embedded in a tool_result block (e.g. the output of
 // a Read on an image file). Scans for the tool_result matching toolUseId.
-function readToolResultImage(jsonlPath, toolUseId, n) {
+async function readToolResultImage(jsonlPath, toolUseId, n) {
   if (!toolUseId || !jsonlPath) return null;
   const idx = Number(n);
   if (!Number.isInteger(idx) || idx < 0) return null;
   try {
-    const content = readFileSync(jsonlPath, 'utf8');
-    const lines = content.split('\n');
-    for (const line of lines) {
+    for await (const line of readLines(jsonlPath)) {
       if (!line || line.indexOf(toolUseId) === -1) continue;
       let obj;
       try { obj = JSON.parse(line); } catch (_) { continue; }
@@ -1196,14 +1225,13 @@ function readMessagesPage(jsonlPath, limit = 10, beforeTimestamp = null) {
   };
 }
 
-function buildSessionDigest(jsonlPath) {
+async function buildSessionDigest(jsonlPath) {
   const map = {};
   const terminated = new Map();
   const rejectedToolUseIds = new Set();
   const promptByToolUseId = {};
   const killedAgentIds = new Set();
   try {
-    const content = readFileSync(jsonlPath, 'utf8');
     const re = /"type":"agent_progress"[^}]*"agentId":"([^"]+)"/;
     const parentRe = /"parentToolUseID":"([^"]+)"/;
     const promptRe = /"prompt":"((?:[^"\\]|\\.)*)"/;
@@ -1215,7 +1243,7 @@ function buildSessionDigest(jsonlPath) {
     const nameByToolUseId = {};
     const descByToolUseId = {};
     const usageByToolUseId = {};
-    for (const line of content.split('\n')) {
+    for await (const line of readLines(jsonlPath)) {
       // Terminated-teammate detection: check first since cheap substring guards
       if (line.includes('teammate-message') &&
           (line.includes('teammate_terminated') || line.includes('shutdown_response'))) {
@@ -1346,8 +1374,8 @@ function buildSessionDigest(jsonlPath) {
   return { progressMap: map, terminated, rejectedAgentIds, rejectedPrompts, killedAgentIds };
 }
 
-function buildAgentProgressMap(jsonlPath) {
-  return buildSessionDigest(jsonlPath).progressMap;
+async function buildAgentProgressMap(jsonlPath) {
+  return (await buildSessionDigest(jsonlPath)).progressMap;
 }
 
 const ARTIFACT_URL_RE = /https:\/\/claude\.ai\/\S*artifact\/[A-Za-z0-9_-]+/;
@@ -1365,7 +1393,7 @@ function toolResultText(content) {
 // only when its tool_use_id belongs to a publish call — an artifact URL quoted
 // back by a grep or a file read would otherwise register another session's page as
 // this session's own, and a `read` of someone else's artifact is not a publish.
-function readArtifactLinks(jsonlPath) {
+async function readArtifactLinks(jsonlPath) {
   const byUrl = new Map();
   const publishedFileByToolUseId = new Map();
   const upsert = (url, ts) => {
@@ -1378,8 +1406,7 @@ function readArtifactLinks(jsonlPath) {
     return a;
   };
   try {
-    const content = readFileSync(jsonlPath, 'utf8');
-    for (const line of content.split('\n')) {
+    for await (const line of readLines(jsonlPath)) {
       if (!line.includes('"frame-link"') && !line.includes('"name":"Artifact"') && !line.includes('claude.ai'))
         continue;
       let obj;
@@ -1426,11 +1453,10 @@ const SCRATCH_NAME_RE = /\bscratch\s+new\s+(?:"([^"]+)"|'([^']+)'|(?!-)(\S+))/;
 // the manifest is the 4th of ~13 printed lines, so any `| tail -N` cuts it off. `name`
 // stands in because it is what the manifest stores as its own `name`; the path is not
 // recovered from the command, which would mean tracking the `cd` and a relative `--dir`.
-function readScratchpadCreations(jsonlPath) {
+async function readScratchpadCreations(jsonlPath) {
   const calls = new Map();
   try {
-    const content = readFileSync(jsonlPath, 'utf8');
-    for (const line of content.split('\n')) {
+    for await (const line of readLines(jsonlPath)) {
       // Substring reject before JSON.parse: transcripts reach tens of megabytes and
       // only a handful of lines can ever match.
       const isCall = line.includes('scratch new');
@@ -1456,13 +1482,12 @@ function readScratchpadCreations(jsonlPath) {
   return [...calls.values()];
 }
 
-function readCompactSummaries(jsonlPath) {
+async function readCompactSummaries(jsonlPath) {
   const results = [];
   // Inline format: newer Claude Code stores the summary directly in the parent
   // session JSONL as a user message with isCompactSummary: true (no subagent file).
   try {
-    const content = readFileSync(jsonlPath, 'utf8');
-    for (const line of content.split('\n')) {
+    for await (const line of readLines(jsonlPath)) {
       if (!line.trim() || !line.includes('isCompactSummary')) continue;
       try {
         const obj = JSON.parse(line);
@@ -1515,8 +1540,8 @@ function readCompactSummaries(jsonlPath) {
   return results.sort((a, b) => (a.timestamp || '').localeCompare(b.timestamp || ''));
 }
 
-function findTerminatedTeammates(jsonlPath) {
-  return buildSessionDigest(jsonlPath).terminated;
+async function findTerminatedTeammates(jsonlPath) {
+  return (await buildSessionDigest(jsonlPath)).terminated;
 }
 
 function extractPromptFromTranscript(jsonlPath) {
@@ -1585,28 +1610,28 @@ function extractModelFromTranscript(jsonlPath) {
 // output tokens, and first/last timestamps (for duration). COLD PATH ONLY —
 // used by the workflow run view on demand, never from the session-scan hot
 // path (a full read per agent would blow the /api/sessions budget).
-function extractTranscriptStats(jsonlPath) {
-  let content;
-  try { content = readFileSync(jsonlPath, 'utf8'); } catch (_) { return null; }
+async function extractTranscriptStats(jsonlPath) {
   let model = null;
   let outputTokens = 0;
   let firstTs = null;
   let lastTs = null;
-  for (const line of content.split('\n')) {
-    if (!line.trim()) continue;
-    let obj;
-    try { obj = JSON.parse(line); } catch (_) { continue; }
-    if (obj.timestamp) {
-      if (!firstTs) firstTs = obj.timestamp;
-      lastTs = obj.timestamp;
-    }
-    const msg = obj.message;
-    if (msg && typeof msg === 'object') {
-      if (!model && msg.model) model = msg.model;
-      const out = msg.usage?.output_tokens;
-      if (typeof out === 'number') outputTokens += out;
+  try {
+    for await (const line of readLines(jsonlPath)) {
+      if (!line.trim()) continue;
+      let obj;
+      try { obj = JSON.parse(line); } catch (_) { continue; }
+      if (obj.timestamp) {
+        if (!firstTs) firstTs = obj.timestamp;
+        lastTs = obj.timestamp;
+      }
+      const msg = obj.message;
+      if (msg && typeof msg === 'object') {
+        if (!model && msg.model) model = msg.model;
+        const out = msg.usage?.output_tokens;
+        if (typeof out === 'number') outputTokens += out;
+      }
     }
-  }
+  } catch (_) { return null; }
   return { model, outputTokens, firstTs, lastTs };
 }
 
@@ -1625,7 +1650,9 @@ function formatStructuredResult(input) {
 // Some subagents end their run on a tool call and never emit a text response, so
 // their lastMessage is empty: workflow subagents given a schema call StructuredOutput,
 // background subagents report through SubagentHandback. Tail-read the transcript and
-// take the LAST such tool_use as the agent's result. Returns null when absent.
+// take the LAST such tool_use as the agent's result. Without one, take the last
+// assistant text: the plugin's mod records no lastMessage, because Claude Code's
+// turn.complete carries an empty answer for a subagent. Returns null when neither exists.
 const RESULT_TOOLS = {
   StructuredOutput: formatStructuredResult,
   SubagentHandback: (input) => (typeof input.message === 'string' && input.message) || null,
@@ -1649,16 +1676,25 @@ function extractAgentResultFromTranscript(jsonlPath) {
     const text = buf.toString('utf8');
     // Drop the leading partial line unless we read from the very start.
     const clean = start > 0 ? text.slice(text.indexOf('\n') + 1) : text;
-    if (!RESULT_TOOL_TEXT.some((t) => clean.includes(t))) return null;
     const lines = clean.split('\n');
-    for (let i = lines.length - 1; i >= 0; i--) {
-      if (!RESULT_TOOL_TEXT.some((t) => lines[i].includes(t))) continue;
-      let obj;
-      try { obj = JSON.parse(lines[i]); } catch (_) { continue; }
-      const content = obj?.message?.content;
-      const result = Array.isArray(content) && content.map(resultFromBlock).findLast(Boolean);
-      if (result) return result;
-    }
+    const lastAssistant = (needle, pick) => {
+      for (let i = lines.length - 1; i >= 0; i--) {
+        if (!needle(lines[i])) continue;
+        let obj;
+        try { obj = JSON.parse(lines[i]); } catch (_) { continue; }
+        const content = obj?.message?.content;
+        const found = obj?.type === 'assistant' && Array.isArray(content) && pick(content);
+        if (found) return found;
+      }
+      return null;
+    };
+    return lastAssistant(
+      (line) => RESULT_TOOL_TEXT.some((t) => line.includes(t)),
+      (content) => content.map(resultFromBlock).findLast(Boolean),
+    ) ?? lastAssistant(
+      (line) => line.includes('"type":"assistant"'),
+      (content) => toolResultText(content).trim(),
+    );
   } catch (_) {
   } finally {
     closeSync(fd);
@@ -1831,5 +1867,6 @@ module.exports = {
   extractPromptFromTranscript,
   extractModelFromTranscript,
   extractAgentResultFromTranscript,
-  extractTranscriptStats
+  extractTranscriptStats,
+  readLines
 };

package/lib/plugin-status.js

@@ -31,7 +31,7 @@ function pluginStatus(claudeDir, bundledManifest = BUNDLED_MANIFEST) {
 
 // --dir rather than CLAUDE_CONFIG_DIR=…, so the same line runs in bash, PowerShell and cmd.
 function installCommand(claudeDir) {
-  const base = 'claude-code-kanban --install --plugin-only';
+  const base = 'claude-code-kanban --install --yes';
   return isDefaultClaudeDir(claudeDir) ? base : `${base} --dir "${claudeDir}"`;
 }