claude-code-kanban 7.7.0 → 7.9.0

package/README.md

@@ -108,7 +108,7 @@ Run `claude` in any project. You do not configure anything per project. Claude C
 With no subcommand, `claude-code-kanban` starts the server. Subcommands talk to a server that already runs:
 
 - `session list|search|open|view|plan|agents|pin|group|ungroup` to read, focus and group sessions. `session list` shows the active sessions, as the sidebar's Active view does; `--all` shows every session.
-- `group list` to list the session groups, dispatch groups included, with the members the sidebar's Active view shows (active, pinned or sticky); `--all` for every member.
+- `group list` to list the session groups, temporary ones included, with the members the sidebar's Active view shows (active, pinned or sticky); `--all` for every member.
 - `task list` and `project list` to read tasks and projects.
 - `doc link|unlink|list|preview` to link a file or URL to a session, or show it in the preview.
 - `pane add|rm|list` to add live panes to a session's view.

package/cli.js

@@ -1,10 +1,8 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { getClaudeDir, displayPath } = require('./lib/claude-dir');
-const { isGroupName, suggestGroupName } = require('./lib/dispatch-groups');
 const { linkUrl } = require('./public/link-url');
 const { sessionProjectKey } = require('./public/project-match');
-const { DISPATCH_PREFIX, placeSession } = require('./lib/user-groups');
 // Help is auto-generated from this table — keep flags/usage in sync with `run` behavior.
 const SESSION_FLAG = '--session <id>';
 const SESSION_FLAG_HELP = 'Session, full id or unique prefix (default: $PREVIEW_SESSION, else $CLAUDE_CODE_SESSION_ID)';
@@ -180,7 +178,7 @@ const COMMANDS = {
         usage: 'claude-code-kanban session pin <id> [--sticky] [--unpin]',
         flags: {
           '<id>': 'Full session id, or a unique prefix',
-          '--sticky': 'Set sticky state (always shown, top of list)',
+          '--sticky': 'Set sticky state (always shown in the list)',
           '--unpin': 'Clear pin/sticky state',
         },
         examples: [
@@ -217,7 +215,7 @@ const COMMANDS = {
           '<id>': 'Full session id, or a unique prefix',
           '--json': 'Output JSON ({left, rev})',
         },
-        notes: 'Also takes it out of its dispatch group. A session whose project is in a group still shows there; move the project on the board.',
+        notes: 'A session whose project is in a group still shows there; move the project on the board.',
         examples: ['claude-code-kanban session ungroup $CLAUDE_SESSION_ID'],
         run: runSessionUngroupCli,
       },
@@ -231,17 +229,18 @@ const COMMANDS = {
         usage: 'claude-code-kanban group list [--all] [--json]',
         flags: {
           '--all': 'Every member, active or not',
-          '--json': 'Output JSON ({rev, groups: [{id, name, parent, visible, total, members}]}); a dispatch group has dispatch: true and id dispatch:<name>; a session member has title, branch, status, pinned and age, or missing: true; a project member has sessions (its shown sessions)',
+          '--json': 'Output JSON ({rev, groups: [{id, name, parent, transient?, visible, total, members}]}); a session member has title, branch, status, pinned and age, or missing: true; a project member has sessions (its shown sessions)',
         },
-        notes: 'A project member shows when it has a session the Active view shows. visible/total counts the members shown. A session started with `dispatch start --group` shows in that dispatch group, marked (dispatch) and listed after the user groups, unless a user group holds it or its project; a user group with the same name takes it in. Dispatch groups go when their sessions end. Pass a user group\'s name, path (parent/child) or id to `session group`; dispatch:<name> there makes the user group <name>, which keeps the sessions after they end.',
+        notes: 'A project member shows when it has a session the Active view shows. visible/total counts the members shown. A group marked (transient) goes when the board\'s Active view shows none of its sessions; Keep or a rename on the board, or `group rename`, keeps it. `dispatch start --group` and `group create --transient` make transient groups. Pass a group\'s name, path (parent/child) or id to `session group`.',
         examples: ['claude-code-kanban group list', 'claude-code-kanban group list --all --json'],
         run: runGroupListCli,
       },
       create: {
         summary: 'Make a group, and the missing parents of a path',
-        usage: 'claude-code-kanban group create <name|path> [--json]',
+        usage: 'claude-code-kanban group create <name|path> [--transient] [--json]',
         flags: {
-          '<name|path>': 'Name of a new top-level group, or a path from the top (parent/child); dispatch:<name> makes a user group that takes in that dispatch group',
+          '<name|path>': 'Name of a new top-level group, or a path from the top (parent/child)',
+          '--transient': 'The groups it makes go when the Active view shows none of their sessions',
           '--json': 'Output JSON ({group, name, path, rev})',
         },
         notes: 'Fails when the group exists.',
@@ -266,7 +265,7 @@ const COMMANDS = {
           '<group>': 'Group name (any case), path from the top (parent/child) or id, from `group list`',
           '--json': 'Output JSON ({removed: {id, name, path}, ungrouped, rev})',
         },
-        notes: 'Its members leave the group and show as with no group: in their project\'s group, their dispatch group or the top level. Its child groups move up one level. A dispatch group cannot be removed: it goes when its sessions end.',
+        notes: 'Its members leave the group and show as with no group: in their project\'s group or the top level. Its child groups move up one level.',
         examples: ['claude-code-kanban group rm presales-cloud'],
         run: runGroupRmCli,
       },
@@ -329,7 +328,7 @@ const COMMANDS = {
           '--spec <text>': 'The task, self-contained; sent as the first message',
           '--spec-file <path>': 'Read the task from a file',
           '--name <n>': 'Session name; also its peer name for SendMessage',
-          '--group <g>': 'Show it with this session in a kebab-case group (default: this session\'s group)',
+          '--group <g>': 'Add it to this group: a name, path or id. The groups it makes are transient (see `help group list`)',
           '--model <m>': 'fable, opus, sonnet or haiku',
           '--worktree [name]': 'Run in a new git worktree',
           '--task-list [id]': 'Use this task list instead of its own (default: this session\'s list), so its cards show on one board with yours. Off unless given',
@@ -638,11 +637,14 @@ async function runPreviewCli(args) {
   if (url) return previewUrlCli(url, args);
   // No $CLAUDE_CODE_SESSION_ID fallback: a session here switches the board's focus, and the
   // agent must not move the board unless asked.
-  const sessionId = getArgValue(args, 'session') || process.env.PREVIEW_SESSION || null;
+  const sessionArg = getArgValue(args, 'session') || process.env.PREVIEW_SESSION || null;
+  const resolved = sessionArg && await resolveSessionByIdOrPrefix(sessionArg);
+  if (sessionArg && !resolved) return 1;
+  const sessionId = resolved?.id || null;
   const abs = cliPath(filePathArg);
   try {
     if (!await cliPostJson('/api/preview', { path: abs, sessionId }, 'Preview')) return 1;
-    console.log(`Preview opened: ${abs}${sessionId ? ` (session ${sessionId})` : ''}`);
+    console.log(`Preview opened: ${abs}${sessionId ? ` (session ${sessionId.slice(0, 8)})` : ''}`);
     return 0;
   } catch (e) { reportCliError(e); return 1; }
 }
@@ -1023,7 +1025,8 @@ async function runGroupCreateCli(args, entry) {
     printLeafHelp(entry);
     return 1;
   }
-  return groupVerb(args, '/api/groups/path', { path: pathArg }, 'Create', (r) => `Created group "${r.path}" (${r.group})`);
+  const transient = args.includes('--transient');
+  return groupVerb(args, '/api/groups/path', { path: pathArg, transient }, 'Create', (r) => `Created group "${r.path}" (${r.group})${transient ? ', transient' : ''}`);
 }
 
 async function runGroupRenameCli(args, entry) {
@@ -1089,37 +1092,20 @@ function describeGroupMembers(groups, sessions, activeOnly) {
   });
 }
 
-// Dispatch groups are listed after the user groups, as in the sidebar.
-function placeDispatched(groups, sessions, released = []) {
-  const dispatchGroups = new Map();
-  for (const s of sessions) {
-    if (!s.dispatchGroup) continue;
-    const { named, dispatch } = placeSession(groups, released, { ref: s.id, project: sessionProjectKey(s), dispatchGroup: s.dispatchGroup });
-    if (dispatch && !dispatchGroups.has(dispatch)) {
-      dispatchGroups.set(dispatch, { id: `${DISPATCH_PREFIX}${dispatch}`, name: dispatch, parent: null, dispatch: true, members: [] });
-    }
-    (named || dispatchGroups.get(dispatch))?.members.push({ type: 'session', ref: s.id });
-  }
-  return [...groups, ...dispatchGroups.values()];
-}
-
 async function runGroupListCli(args) {
   const activeOnly = !args.includes('--all');
   let rev;
   let groups;
   try {
-    let released;
-    let dispatch;
-    ({ rev, groups, released, dispatch } = await cliGetJson('/api/groups?dispatch=1', 'Group list'));
-    const memberRefs = groups.flatMap((g) => g.members.filter((m) => m.type === 'session').map((m) => m.ref));
-    const sessionRefs = [...new Set([...memberRefs, ...Object.keys(dispatch || {})])];
+    ({ rev, groups } = await cliGetJson('/api/groups', 'Group list'));
+    const sessionRefs = [...new Set(groups.flatMap((g) => g.members.filter((m) => m.type === 'session').map((m) => m.ref)))];
     // An inactive session held by id is still listed, so only the active list needs the id lookups.
     const lists = await Promise.all([
       fetchSessionsList({ limit: null, activeOnly, lite: true }, 'Group list'),
       activeOnly ? fetchSessionsByIds(sessionRefs, 'Group list', { lite: true }) : [],
     ]);
     const sessions = uniqueById(lists.flat());
-    groups = describeGroupMembers(placeDispatched(groups, sessions, released), sessions, activeOnly);
+    groups = describeGroupMembers(groups, sessions, activeOnly);
   } catch (e) { reportCliError(e); return 1; }
   if (args.includes('--json')) {
     console.log(JSON.stringify({ rev, groups }, null, 2));
@@ -1133,7 +1119,7 @@ async function runGroupListCli(args) {
   const add = (parent, depth) => {
     const pad = '  '.repeat(depth);
     for (const g of groups.filter((x) => x.parent === parent)) {
-      rows.push([g.dispatch ? '-' : g.id, '', '', '', `${pad}${g.name}${g.dispatch ? ' (dispatch)' : ''} (${g.visible}/${g.total})`]);
+      rows.push([g.id, '', '', '', `${pad}${g.name}${g.transient ? ' (transient)' : ''} (${g.visible}/${g.total})`]);
       for (const m of g.members) {
         if (m.type === 'project') rows.push(['project', '', '', '', `${pad}  ${m.ref} (${m.sessions} sessions)`]);
         else if (m.missing) rows.push([m.ref.slice(0, 8), 'gone', '-', '', `${pad}  (no such session)`]);
@@ -1420,10 +1406,7 @@ async function runDispatchStartCli(argv) {
   }
   const hasGroup = args.some(a => a === '--group' || a.startsWith('--group='));
   const group = hasGroup ? getArgValue(args, 'group') || '' : null;
-  if (hasGroup && !isGroupName(group)) {
-    const hint = suggestGroupName(group);
-    return usageError(COMMANDS.dispatch.verbs.start, `Group names are kebab-case${hint ? `: try --group ${hint}` : ', e.g. auth-refactor'}`);
-  }
+  if (hasGroup && !group.trim()) return usageError(COMMANDS.dispatch.verbs.start, '--group needs a group name, path or id');
   const worktree = args.includes('--worktree') ? getArgValue(args, 'worktree') || true : false;
   const hasTaskList = args.some(a => a === '--task-list' || a.startsWith('--task-list='));
   const ownList = process.env.CLAUDE_CODE_TASK_LIST_ID || process.env.CLAUDE_CODE_SESSION_ID;
@@ -1446,8 +1429,8 @@ async function runDispatchStartCli(argv) {
     const out = await cliPostJson('/api/dispatch', body, 'Dispatch', { 'x-terminal-token': token });
     if (!out) return 1;
     if (args.includes('--json')) console.log(JSON.stringify(out, null, 2));
-    else console.log(`Started session ${out.session} in ${out.cwd}${out.group ? ` [${out.group}]` : ''}`);
-    if (out.group) await noteJoinedGroup(out.session, out.group);
+    else console.log(`Started session ${out.session} in ${out.cwd}${out.group ? ` [${out.group}${out.transient ? ', transient' : ''}]` : ''}`);
+    if (out.groupError) console.error(`Not grouped: ${out.groupError}`);
     return 0;
   } catch (e) { reportCliError(e); return 1; }
 }
@@ -1458,15 +1441,6 @@ async function fetchDispatches(all) {
   return (await cliGetJson(`/api/dispatch?${q}`, 'Dispatch list')).running.sort((a, b) => b.startedAt - a.startedAt);
 }
 
-// A user group named like the dispatch group takes the session in; say so, or the board looks wrong.
-async function noteJoinedGroup(session, dispatchGroup) {
-  try {
-    const { groups, released } = await cliGetJson('/api/groups', 'Group list');
-    const { named } = placeSession(groups, released, { ref: session, dispatchGroup });
-    if (named) console.error(`Joins user group "${named.name}" (${named.id}), which has the same name.`);
-  } catch (_) { /* the session started; the note is optional */ }
-}
-
 const dispatchLine = (r) => `${r.session}${r.name ? `  ${r.name}` : ''}${r.group ? `  [${r.group}]` : ''}`;
 
 async function runDispatchListCli(args) {

package/hub-app.json

@@ -7,8 +7,8 @@
   "publishes": ["session.changed"],
   "keys": { "keeps": ["ctrl+alt+n", "ctrl+alt+r", "ctrl+alt+s", "ctrl+shift+k", "ctrl+shift+p", "ctrl+shift+z"] },
   "plugin": {
-    "id": "claude-code-kanban@claude-code-kanban",
-    "path": "plugin/plugins/claude-code-kanban",
+    "marketplace": "plugin",
+    "name": "claude-code-kanban",
     "install": "claude-code-kanban --install --yes"
   },
   "provides": {

package/install.js

@@ -163,15 +163,7 @@ async function runInstall({ yes = false } = {}) {
     // on stdout — so a re-copied plugin keeps running from the old cached version
     // until `update` pulls the new one in. That is how a config dir ends up serving
     // a plugin older than the board it talks to.
-    if (alreadyInstalled) {
-      const upgrade = runCLI('claude plugin update claude-code-kanban', ['already at the latest']);
-      if (upgrade.ok) {
-        const line = (upgrade.output || '').split('\n').find(l => l.includes('updated from'));
-        console.log(`    ${green('✓')} ${line ? line.replace(/^[^A-Za-z]*/, '') : 'Already at the latest version'}`);
-      } else {
-        console.log(`    ${yellow('⚠')} Plugin update failed: ${upgrade.error}`);
-      }
-    }
+    if (alreadyInstalled) updatePlugin(PLUGIN_ID, 'Plugin');
   } else {
     console.log(`    ${dim('Skipped')}`);
   }
@@ -181,6 +173,16 @@ async function runInstall({ yes = false } = {}) {
   printSummary(failed);
 }
 
+function updatePlugin(id, label) {
+  const upgrade = runCLI(`claude plugin update ${id}`, ['already at the latest']);
+  if (upgrade.ok) {
+    const line = (upgrade.output || '').split('\n').find(l => l.includes('updated from'));
+    console.log(`    ${green('✓')} ${label}: ${line ? line.replace(/^[^A-Za-z]*/, '') : 'already at the latest version'}`);
+  } else {
+    console.log(`    ${yellow('⚠')} ${label} update failed: ${upgrade.error}`);
+  }
+}
+
 function printSummary(failed = false) {
   if (failed) {
     console.log(`\n  ${red('Setup incomplete — see the errors above.')}\n`);

package/lib/live-sessions.js

@@ -16,7 +16,7 @@ function readLiveSessions(sessionsDir) {
     try {
       const s = JSON.parse(fs.readFileSync(path.join(sessionsDir, file), 'utf8'));
       if (s?.sessionId && s.kind === 'interactive') {
-        sessions.push({ sessionId: s.sessionId, pid: s.pid || null, cwd: s.cwd || null, startedAt: s.startedAt || 0, status: s.status || null, name: s.name || null });
+        sessions.push({ sessionId: s.sessionId, pid: s.pid || null, cwd: s.cwd || null, startedAt: s.startedAt || 0, status: s.status || null, statusUpdatedAt: s.statusUpdatedAt || null, name: s.name || null });
       }
     } catch { /* skip invalid */ }
   }
@@ -36,4 +36,19 @@ function isSessionLive(sessions, sessionId, exceptPid = null) {
   });
 }
 
-module.exports = { readLiveSessions, isPidAlive, isSessionLive };
+// /clear and /resume keep claude's process and registry file and swap its sessionId, so the id
+// that pid held before is finished even though its transcript was written moments ago. `replaced`
+// maps that id to when the swap was seen; an id that shows up live again leaves it.
+function noteReplacedSessions(prev, next, replaced, now, ttlMs) {
+  for (const [id, at] of replaced) if (now - at > ttlMs) replaced.delete(id);
+  if (prev) {
+    const byPid = new Map(next.filter((s) => s.pid).map((s) => [s.pid, s.sessionId]));
+    for (const s of prev) {
+      const id = s.pid && byPid.get(s.pid);
+      if (id && id !== s.sessionId) replaced.set(s.sessionId, now);
+    }
+  }
+  for (const s of next) replaced.delete(s.sessionId);
+}
+
+module.exports = { readLiveSessions, isPidAlive, isSessionLive, noteReplacedSessions };

package/lib/retention.js

@@ -78,6 +78,15 @@ function createDispatchedStore({ load, save, now = Date.now }) {
     persist();
   }
 
+  function move(from, to) {
+    const e = entries.get(from);
+    if (!e || entries.has(to)) return false;
+    entries.delete(from);
+    entries.set(to, e);
+    persist();
+    return true;
+  }
+
   // Returns how many entries went; writes only when one did.
   function prune({ known, maxAgeMs }) {
     const removed = pruneMap(entries, (e) => e.at, { known, maxAgeMs, now: now() });
@@ -95,7 +104,7 @@ function createDispatchedStore({ load, save, now = Date.now }) {
     return out;
   }
 
-  return { record, prune, running, get: (id) => entries.get(id) || null, entries: () => entries.entries() };
+  return { record, move, prune, running, get: (id) => entries.get(id) || null, entries: () => entries.entries() };
 }
 
 // Names only, no stat or parse: the sweep needs which transcripts exist, not what they hold.

package/lib/terminal-client.js

@@ -33,6 +33,7 @@ function hostError(message) {
  * @param {(data: {sessions: string[]}) => void} [o.save]
  * @param {() => void} [o.onChange]
  * @param {(id: string) => void} [o.onExit]
+ * @param {(from: string, to: string) => void} [o.onRekey]
  */
 function createTerminalClient(o) {
   const { config, net } = o;
@@ -42,6 +43,7 @@ function createTerminalClient(o) {
   let hostReason = null;
   let ids = [];
   let terminalIds = [];
+  let awaitingTrust = [];
   let serverUrl = null;
   let restoreAsked = false;
   let stopped = false;
@@ -78,9 +80,11 @@ function createTerminalClient(o) {
       hostReason = msg.reason;
       ids = msg.ids;
       terminalIds = msg.terminalIds || [];
+      awaitingTrust = msg.awaitingTrust || [];
       settle(hostReason);
       o.onChange?.();
     } else if (msg.t === 'exit') o.onExit?.(msg.id);
+    else if (msg.t === 'rekey') o.onRekey?.(msg.from, msg.to);
     else if (msg.t === 'save') o.save?.(msg.data);
     else if (msg.t === 'reply') {
       const pending = calls.get(msg.id);
@@ -121,6 +125,7 @@ function createTerminalClient(o) {
     const lost = ids;
     ids = [];
     terminalIds = [];
+    awaitingTrust = [];
     for (const id of lost) o.onExit?.(id);
     o.onChange?.();
     const now = Date.now();
@@ -228,6 +233,7 @@ function createTerminalClient(o) {
     token, handleUpgrade, clientConfig, unavailableReason, authorized, isRunning, hasTerminal, sessionOfTerminal, startNew, end, paste, restore,
     setServerUrl, sessions, stats, shutdown, started,
     ids: () => [...ids],
+    awaitingTrust: () => [...awaitingTrust],
   };
 }
 

package/lib/terminal-host.js

@@ -28,7 +28,13 @@ function ask(op, arg) {
 // The service reports every attach and detach too; cck needs only a change of ids or reason.
 function pushState() {
   const live = service.list();
-  const state = { t: 'state', reason: service.unavailableReason(), ids: live.map((s) => s.id), terminalIds: live.map((s) => s.terminalId) };
+  const state = {
+    t: 'state',
+    reason: service.unavailableReason(),
+    ids: live.map((s) => s.id),
+    terminalIds: live.map((s) => s.terminalId),
+    awaitingTrust: live.filter((s) => s.awaitingTrust).map((s) => s.id),
+  };
   const key = JSON.stringify(state);
   if (key === lastState) return;
   lastState = key;
@@ -55,6 +61,7 @@ function init(msg) {
     save: (data) => send({ t: 'save', data }),
     onChange: pushState,
     onExit: (id) => send({ t: 'exit', id }),
+    onRekey: (from, to) => send({ t: 'rekey', from, to }),
   });
   pushState();
 }

package/lib/terminal.js

@@ -34,6 +34,7 @@ const WORKTREE_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 // Claude Code keeps a list in tasks/<id>/, so the id must stay one path segment.
 const TASK_LIST_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 const MODELS = new Set(['fable', 'opus', 'sonnet', 'haiku']);
+const EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
 // 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
@@ -47,6 +48,12 @@ const OWNED_FLAGS = new Set([
 ]);
 const MAX_PROMPT = 32 * 1024;
 const PROMPT_QUIET_MS = 400;
+const SUBMIT_POLL_MS = 1000;
+const SUBMIT_CHECKS = 5;
+const SUBMIT_RETRIES = 2;
+// The answer lines of Claude Code's folder-trust dialog, current and earlier wording. They tell the
+// board the dialog is up; the looser onTrustScreen only holds the prompt back, where a miss is worse.
+const TRUST_DIALOG = /Yes, I trust this folder|Do you trust the files in this folder\?/;
 // Watermarks from https://xtermjs.org/docs/guides/flowcontrol/ — pause the PTY while a
 // client lags, so a runaway process cannot grow the socket buffer without bound.
 const HIGH_WATER = 128 * 1024;
@@ -187,6 +194,7 @@ function claudeArgsFor(mode, id, spec) {
     const args = [...fork, ...own, ...(spec.extraArgs || [])];
     if (spec.name) args.push('--name', spec.name);
     if (spec.model) args.push('--model', spec.model);
+    if (spec.effort) args.push('--effort', spec.effort);
     // Last, because its value is optional and a following flag must not be taken for it.
     if (spec.worktree === true) args.push('-w');
     else if (spec.worktree) args.push('-w', spec.worktree);
@@ -218,6 +226,8 @@ function parseNewSpec(msg) {
   if (typeof worktree !== 'boolean' && !(typeof worktree === 'string' && WORKTREE_RE.test(worktree))) return 'worktree name';
   const model = msg.model || null;
   if (model && !MODELS.has(model)) return 'model';
+  const effort = msg.effort || null;
+  if (effort && !EFFORTS.has(effort)) return 'effort';
   const taskList = msg.taskList || null;
   if (taskList && !(typeof taskList === 'string' && TASK_LIST_RE.test(taskList))) return 'task list id';
   const edit = msg.edit === true;
@@ -232,7 +242,7 @@ function parseNewSpec(msg) {
   if (bad) return bad;
   if (forkOf && worktree) return 'worktree: a fork runs in its parent session folder';
   const restore = msg.restore !== false;
-  return { cwd: forkOf ? null : msg.cwd, forkOf, resume, name: name || null, worktree, model, taskList, prompt: prompt || null, extraArgs, edit, restore };
+  return { cwd: forkOf ? null : msg.cwd, forkOf, resume, name: name || null, worktree, model, effort, taskList, prompt: prompt || null, extraArgs, edit, restore };
 }
 
 function samePath(a, b) {
@@ -341,6 +351,7 @@ function clientConfigFor(config, available) {
  * @param {(cmd: string) => string|null} o.which
  * @param {string} [o.token]
  * @param {() => void} [o.onChange]  a terminal started, ended or moved to another session id
+ * @param {(from: string, to: string) => void} [o.onRekey]  a terminal moved to another session id
  * @param {() => {sessions?: string[], taskLists?: Object<string, string>}|null} [o.load]  the saved list, read when config.restore is on
  * @param {(data: {sessions: string[], taskLists?: Object<string, string>}) => void} [o.save]  the session ids to resume on the next start, and the shared task list of each that has one
  * @param {object} [o.pty]  stands in for @lydell/node-pty in tests
@@ -362,6 +373,7 @@ function createTerminalService(o) {
   const saveDelayMs = o.saveDelayMs ?? SAVE_DELAY_MS;
   const restoreGapMs = o.restoreGapMs ?? RESTORE_GAP_MS;
   const exitPollMs = o.exitPollMs ?? CLAUDE_EXIT_POLL_MS;
+  const submitPollMs = o.submitPollMs ?? SUBMIT_POLL_MS;
   const pidAlive = o.isPidAlive || isPidAlive;
   const exitTimer = setInterval(checkExits, exitPollMs);
   exitTimer.unref();
@@ -484,13 +496,24 @@ function createTerminalService(o) {
 
   // Waits for claude to turn on bracketed paste (its input box is live), then for the
   // screen to settle. A folder-trust question also takes input, and Enter there would
-  // answer it, so the prompt waits for as long as that question is on screen.
+  // answer it, so the prompt waits for as long as that question is on screen. Once it is
+  // answered, claude turns paste off and redraws for seconds; text sent then is lost.
   function bracketed(text) {
     return `\x1b[200~${text.replace(/\r?\n/g, '\r')}\x1b[201~`;
   }
 
+  // The folder and session names show on claude's main screen, so a "trust" in them is not the dialog.
   function onTrustScreen(s) {
-    return /\btrust\b/i.test(screenText(s.term));
+    let text = screenText(s.term);
+    for (const own of [path.basename(s.cwd), s.name]) if (own) text = text.split(own).join('');
+    return /\btrust\b/i.test(text);
+  }
+
+  // Checked only while the session's first prompt waits, so it ends for good once the prompt is sent.
+  function setAwaitingTrust(s, on) {
+    if (s.awaitingTrust === on) return;
+    s.awaitingTrust = on;
+    changed();
   }
 
   // `submit` is claude's prompt: wait for its input box, then press Enter. Without it the text
@@ -502,18 +525,47 @@ function createTerminalService(o) {
     let timer = null;
     const text = bracketed(raw);
     s.onOutput = (data) => {
-      if (!armed && data.includes('\x1b[?2004h')) armed = true;
-      if (!armed) return;
+      if (submit) {
+        const on = data.lastIndexOf('\x1b[?2004h');
+        const off = data.lastIndexOf('\x1b[?2004l');
+        if (on !== off) armed = on > off;
+      }
       clearTimeout(timer);
+      if (!armed) return;
       timer = setTimeout(() => {
-        if (s.exited || (submit && onTrustScreen(s))) return;
+        if (s.exited) return;
+        if (submit && onTrustScreen(s)) return setAwaitingTrust(s, TRUST_DIALOG.test(screenText(s.term)));
+        setAwaitingTrust(s, false);
         s.onOutput = null;
         s.pty.write(text);
-        if (submit) setTimeout(() => { if (!s.exited) s.pty.write('\r'); }, 100);
+        if (submit) setTimeout(() => submitPrompt(s), 100);
       }, PROMPT_QUIET_MS);
     };
   }
 
+  // claude sometimes drops the Enter after the paste and leaves the prompt typed but not sent.
+  // It bumps statusUpdatedAt in its registry entry when a turn starts, so while the entry stays
+  // idle and older than the Enter, Enter is pressed again. Only an idle entry gets it: a turn
+  // that started can show a permission dialog, and Enter there would pick its default.
+  function submitPrompt(s) {
+    if (s.exited) return;
+    let at = Date.now();
+    let checks = 0;
+    let retries = 0;
+    s.pty.write('\r');
+    s.submitTimer = setInterval(() => {
+      const entry = ownEntry(o.liveSessions(), s, s.startedAt);
+      const unsent = !s.exited && entry?.status === 'idle' && typeof entry.statusUpdatedAt === 'number' && entry.statusUpdatedAt < at;
+      if (!unsent || (++checks === SUBMIT_CHECKS && retries === SUBMIT_RETRIES)) return clearInterval(s.submitTimer);
+      if (checks < SUBMIT_CHECKS) return;
+      checks = 0;
+      retries++;
+      at = Date.now();
+      s.pty.write('\r');
+    }, submitPollMs);
+    s.submitTimer.unref();
+  }
+
   // The process a viewer types into: claude, found through its registry entry, or the shell.
   function inputPid(s, registry) {
     if (s.mode === 'shell') return s.pty.pid;
@@ -545,7 +597,12 @@ function createTerminalService(o) {
       const pid = inputPid(s, live);
       // An edit terminal starts claude whenever the user presses Enter, after syncBoost stopped looking.
       if (pid && pid !== had) syncBoost(s);
-      if (!pid || (live.some((l) => l.pid === pid) && pidAlive(pid))) continue;
+      if (!pid) continue;
+      const entry = live.find((l) => l.pid === pid);
+      if (entry && pidAlive(pid)) {
+        if (entry.sessionId !== s.id && s.mode !== 'pick' && !s.resumeOf) followSession(s, entry.sessionId);
+        continue;
+      }
       s.claudeExitedAt = Date.now();
       s.claudePid = null;
       moved = true;
@@ -605,7 +662,7 @@ function createTerminalService(o) {
     term.loadAddon(serializer);
     const s = {
       id, terminalId, mode, cwd, pty: proc, term, serializer, sockets: new Set(), exited: false, ended: false, paused: false, startedAt: Date.now(),
-      name: spec?.name || null, worktree: spec?.worktree || false, taskList, onOutput: null, edit: !!spec?.edit,
+      name: spec?.name || null, worktree: spec?.worktree || false, taskList, onOutput: null, awaitingTrust: false, edit: !!spec?.edit,
       forkOf: spec?.forkOf || null, resumeOf: spec?.resume || null, restore: spec?.restore !== false,
     };
     if (s.edit) queueText(s, claudeCommand(shell, claudeArgs, spec.prompt), false);
@@ -624,6 +681,7 @@ function createTerminalService(o) {
       s.exited = true;
       clearInterval(s.pickTimer);
       clearInterval(s.boostTimer);
+      clearInterval(s.submitTimer);
       if (sessions.get(s.id) === s) sessions.delete(s.id);
       o.onExit?.(s.id);
       if (!s.ended) changed();
@@ -644,7 +702,7 @@ function createTerminalService(o) {
   // 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(async () => {
-      if (s.pickChecking) return;
+      if (s.resolving) return;
       const live = o.liveSessions();
       const entry = s.claudePid && live.find((l) => l.pid === s.claudePid);
       if (!entry) {
@@ -656,10 +714,7 @@ function createTerminalService(o) {
       }
       const picked = entry.sessionId;
       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;
+      if (!(await hasTranscript(s, picked)) || 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
@@ -671,16 +726,37 @@ function createTerminalService(o) {
         for (const ws of sockets) send(ws, { t: 'rekey', id: picked, duplicate: true });
         return;
       }
-      const elsewhere = o.isLiveElsewhere(picked, s.claudePid);
-      sessions.delete(s.id);
-      s.id = picked;
-      s.mode = 'resume';
-      sessions.set(picked, s);
-      changed();
-      for (const ws of s.sockets) send(ws, { t: 'rekey', id: picked, elsewhere });
+      rekey(s, picked);
     }, PICK_POLL_MS);
   }
 
+  // /clear and /resume swap the session id under the same claude process. The terminal follows
+  // once the new id has a transcript, so the new session's card holds it and the old one can end.
+  async function followSession(s, id) {
+    if (s.resolving || sessions.has(id)) return;
+    if (!(await hasTranscript(s, id)) || s.ended || sessions.has(id)) return;
+    rekey(s, id);
+  }
+
+  async function hasTranscript(s, id) {
+    s.resolving = true;
+    const known = await o.resolveCwd(id);
+    s.resolving = false;
+    return known !== null && !s.exited;
+  }
+
+  function rekey(s, id) {
+    const elsewhere = o.isLiveElsewhere(id, s.claudePid);
+    const from = s.id;
+    sessions.delete(from);
+    s.id = id;
+    s.mode = 'resume';
+    sessions.set(id, s);
+    o.onRekey?.(from, id);
+    changed();
+    for (const ws of s.sockets) send(ws, { t: 'rekey', id, elsewhere });
+  }
+
   function attach(ws, s, attached) {
     ws.unacked = 0;
     s.sockets.add(ws);
@@ -817,7 +893,7 @@ function createTerminalService(o) {
   function list() {
     return [...sessions.values()].filter((s) => !s.ended).map((s) => ({
       id: s.id, terminalId: s.terminalId, mode: s.mode, cwd: s.cwd, pid: s.pty.pid, clients: s.sockets.size, startedAt: s.startedAt,
-      name: s.name, worktree: s.worktree, edit: s.edit, forkOf: s.forkOf, claudeExited: !!s.claudeExitedAt,
+      name: s.name, worktree: s.worktree, edit: s.edit, forkOf: s.forkOf, claudeExited: !!s.claudeExitedAt, awaitingTrust: s.awaitingTrust,
     }));
   }