claude-term-tabs 0.0.0-bootstrap

package/dist/handoff.js

@@ -0,0 +1,116 @@
+import { closeSync, fstatSync, openSync, readSync } from 'node:fs';
+const DEFAULT_TAIL_BYTES = 128 * 1024;
+const HANDOFF_LINE = /^\s*(?:#+\s*|\*\*)?HANDOFF\b(?!S)/m;
+/**
+ * Text of the newest assistant transcript entry that has a text block, when it was written at or
+ * after `sinceMs`. Undefined when the newest such entry is older, none exists, or the file is missing.
+ */
+export function latestAssistantText(path, sinceMs, opts = {}) {
+    let fd;
+    try {
+        fd = openSync(path, 'r');
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const { size } = fstatSync(fd);
+        let window = Math.max(1, opts.tailBytes ?? DEFAULT_TAIL_BYTES);
+        for (;;) {
+            const start = Math.max(0, size - window);
+            const found = newestAssistantText(readRange(fd, start, size - start), start > 0);
+            if (found !== undefined)
+                return found.at >= sinceMs ? found.text : undefined;
+            if (start === 0)
+                return undefined;
+            window *= 2;
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** True when some line of `text` starts with a HANDOFF heading. */
+export function hasHandoff(text) {
+    return text !== undefined && HANDOFF_LINE.test(text);
+}
+function newestAssistantText(chunk, dropFirst) {
+    const lines = chunk.split('\n');
+    const usable = dropFirst ? lines.slice(1) : lines;
+    for (let i = usable.length - 1; i >= 0; i--) {
+        const entry = parse(usable[i]);
+        if (entry?.type !== 'assistant')
+            continue;
+        const text = textOf(entry.message);
+        const at = Date.parse(String(entry.timestamp));
+        if (text !== undefined && Number.isFinite(at))
+            return { text, at };
+    }
+    return undefined;
+}
+function parse(line) {
+    if (line.trim() === '')
+        return undefined;
+    try {
+        const v = JSON.parse(line);
+        return typeof v === 'object' && v !== null ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function textOf(message) {
+    const content = message?.content;
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return undefined;
+    const texts = content
+        .filter((b) => typeof b === 'object' && b !== null && b.type === 'text' && typeof b.text === 'string')
+        .map(b => b.text);
+    return texts.length === 0 ? undefined : texts.join('\n');
+}
+function readRange(fd, start, length) {
+    const buf = Buffer.alloc(length);
+    const read = readSync(fd, buf, 0, length, start);
+    return buf.subarray(0, read).toString('utf8');
+}
+/**
+ * Newest assistant text written after the newest user message that starts with `promptStart` and is
+ * timestamped at or after `sinceMs`. Undefined when that prompt message, or any reply to it, is missing.
+ */
+export function latestAssistantAfterPrompt(path, promptStart, sinceMs, opts = {}) {
+    let fd;
+    try {
+        fd = openSync(path, 'r');
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        const { size } = fstatSync(fd);
+        let window = Math.max(1, opts.tailBytes ?? DEFAULT_TAIL_BYTES);
+        for (;;) {
+            const start = Math.max(0, size - window);
+            const lines = readRange(fd, start, size - start).split('\n');
+            const entries = (start > 0 ? lines.slice(1) : lines).flatMap(l => parse(l) ?? []);
+            const promptAt = findLastIndex(entries, e => e.type === 'user' && Date.parse(String(e.timestamp)) >= sinceMs && (textOf(e.message) ?? '').trimStart().startsWith(promptStart));
+            if (promptAt >= 0) {
+                const replies = entries.slice(promptAt + 1).filter(e => e.type === 'assistant').map(e => textOf(e.message)).filter((t) => t !== undefined);
+                return replies.at(-1);
+            }
+            if (start === 0)
+                return undefined;
+            window *= 2;
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function findLastIndex(items, pred) {
+    for (let i = items.length - 1; i >= 0; i--)
+        if (pred(items[i]))
+            return i;
+    return -1;
+}

package/dist/help.js

@@ -0,0 +1,38 @@
+import { COMMANDS, SEARCH_FLAGS } from "./args.js";
+const MIN_COLUMN = 17;
+/**
+ * One line per flag, from the same table that parsing and tab completion use. Descriptions start in a
+ * column at least 17 wide and two spaces past the longest label. Subcommand sections leave out
+ * -h/--help, which the search section already lists.
+ */
+export function flagLines(flags, opts = {}) {
+    const rows = Object.entries(flags).filter(([name]) => opts.help !== false || name !== 'help').map(([name, f]) => [`${f.short !== undefined ? `-${f.short}, ` : ''}--${name}${f.value !== undefined ? ` ${f.value}` : ''}`, f.describe]);
+    const column = Math.max(MIN_COLUMN, ...rows.map(([label]) => label.length + 2));
+    return rows.map(([label, describe]) => `  ${label.padEnd(column)}${describe}`).join('\n');
+}
+/** `ctt pause [--auto-close] [--timeout MIN]`, from a subcommand's table; -h/--help left out. */
+function usage(name) {
+    const c = COMMANDS[name];
+    const flags = Object.entries(c.flags).filter(([flag]) => flag !== 'help').map(([flag, f]) => `[--${flag}${f.value !== undefined ? ` ${f.value}` : ''}]`);
+    return ['ctt', name, ...flags, ...(c.args !== undefined ? [c.args] : [])].join(' ');
+}
+/** Usage text for ctt and its subcommands. */
+export const HELP = `usage: ctt [query...] [options]
+${Object.keys(COMMANDS).map(name => `       ${usage(name)}`).join('\n')}
+
+Find a Claude Code session by what you remember and switch to its tab.
+
+${flagLines(SEARCH_FLAGS)}
+
+ctt pause: ${COMMANDS.pause.describe}.
+${flagLines(COMMANDS.pause.flags, { help: false })}
+
+ctt resume: ${COMMANDS.resume.describe}.
+${flagLines(COMMANDS.resume.flags, { help: false })}
+
+ctt completion: ${COMMANDS.completion.describe}.
+  ctt completion zsh >> ~/.zshrc, or ctt completion bash >> ~/.bashrc (bash 4 or later)
+
+Use ctt -- pause to search for the word "pause".
+
+Config: ~/.config/claude-term-tabs/config.json  {"resumeCommand": "claude --resume {id}", "excludeDirs": ["~/scratch"]}`;

package/dist/history.js

@@ -0,0 +1,46 @@
+import { readdirSync, statSync } from 'node:fs';
+import { isAbsolute, join, normalize, sep } from 'node:path';
+import { extractDigest } from "./transcript.js";
+const DEFAULT_RESUME = 'claude --resume {id}';
+const SESSION_ID = /^[A-Za-z0-9][A-Za-z0-9-]{0,127}$/;
+/** Closed sessions: every top-level transcript under projectsDir whose id is not live and whose latest cwd is not excluded. */
+export function listClosedSessions(opts) {
+    return readdirSync(opts.projectsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .flatMap(d => readdirSync(join(opts.projectsDir, d.name), { withFileTypes: true })
+        .filter(f => f.isFile() && f.name.endsWith('.jsonl'))
+        .map(f => ({ path: join(opts.projectsDir, d.name, f.name), sessionId: f.name.slice(0, -'.jsonl'.length) })))
+        .filter(t => !opts.liveIds.has(t.sessionId))
+        .map(t => opts.cache.get(t.path, () => extractDigest(t.path, { sessionId: t.sessionId })))
+        .filter(digest => !isExcluded(digest.cwd, opts.excludeDirs))
+        .map(digest => ({ digest, live: false, status: 'unknown', dirGone: !isResumableDir(digest.cwd, opts.dirExists) }));
+}
+/** True when cwd is one of `dirs` or below one of them. An unknown (empty) cwd is never excluded. */
+export function isExcluded(cwd, dirs) {
+    if (cwd === '')
+        return false;
+    const c = normalize(cwd);
+    return dirs.some(d => c === d || c.startsWith(d.endsWith(sep) ? d : d + sep));
+}
+/** Shell command that resumes a session, from config `resumeCommand` (must contain `{id}`). */
+export function resumeCommand(config, sessionId) {
+    const template = config.resumeCommand ?? DEFAULT_RESUME;
+    if (!template.includes('{id}'))
+        throw new Error('config resumeCommand must contain {id}');
+    if (!SESSION_ID.test(sessionId))
+        throw new Error(`refusing to resume unexpected session id "${sessionId}"`);
+    return template.replaceAll('{id}', sessionId);
+}
+/** True when `p` is an existing directory. */
+export function dirExists(p) {
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** True when cwd is an absolute, normalized path to an existing directory. */
+export function isResumableDir(cwd, exists) {
+    return cwd !== '' && isAbsolute(cwd) && normalize(cwd) === cwd && exists(cwd);
+}

package/dist/live.js

@@ -0,0 +1,86 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { transcriptPath } from "./paths.js";
+import { extractDigest } from "./transcript.js";
+const STATUSES = new Set(['idle', 'busy', 'shell', 'waiting']);
+const PID_REUSE_SLACK_MS = 120_000;
+/** Live interactive Claude Code sessions, joined with their tty and digest. Throws when `ps` fails. */
+export function collectLiveSessions(opts) {
+    const procs = listProcs(opts.exec, (opts.now ?? Date.now)());
+    return readPidFiles(opts.sessionsDir)
+        .filter(f => f.entrypoint === 'cli' && isSameProcess(f, procs.get(f.pid)))
+        .map(f => {
+        const path = transcriptFor(opts.projectsDir, f.cwd, f.sessionId);
+        const digest = opts.cache.get(path, () => extractDigest(path, { sessionId: f.sessionId, cwd: f.cwd }));
+        return {
+            digest,
+            live: true,
+            pid: f.pid,
+            status: toStatus(f.status),
+            tty: procs.get(f.pid)?.tty
+        };
+    });
+}
+function isSameProcess(f, p) {
+    if (p === undefined || basename(p.comm) !== 'claude')
+        return false;
+    return f.startedAt === undefined || p.startedMs <= f.startedAt + PID_REUSE_SLACK_MS;
+}
+function listProcs(exec, now) {
+    const r = exec('ps', ['-axo', 'pid=,tty=,etime=,comm=']);
+    if (r.status !== 0)
+        throw new Error(`ps failed (${r.status}): ${r.stderr.trim()}`);
+    const rows = r.stdout.split('\n').flatMap(line => {
+        const m = /^\s*(\d+)\s+(\S+)\s+([\d:-]+)\s+(.+?)\s*$/.exec(line);
+        if (m === null)
+            return [];
+        const tty = m[2] === '??' || m[2] === '-' ? undefined : `/dev/${m[2]}`;
+        return [[Number(m[1]), { tty, comm: m[4], startedMs: now - etimeMs(m[3]) }]];
+    });
+    return new Map(rows);
+}
+function etimeMs(etime) {
+    const [days, clock] = etime.includes('-') ? etime.split('-') : ['0', etime];
+    const parts = clock.split(':').map(Number).reverse();
+    const [s = 0, m = 0, h = 0] = parts;
+    return (((Number(days) * 24 + h) * 60 + m) * 60 + s) * 1000;
+}
+function readPidFiles(dir) {
+    let names;
+    try {
+        names = readdirSync(dir);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+    return names
+        .filter(name => /^\d+\.json$/.test(name))
+        .flatMap(name => {
+        try {
+            const parsed = JSON.parse(readFileSync(join(dir, name), 'utf8'));
+            if (typeof parsed.pid !== 'number' || typeof parsed.sessionId !== 'string' || typeof parsed.cwd !== 'string')
+                return [];
+            return [parsed];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+/** Transcript path for a session, falling back to a search by id across project directories. */
+export function transcriptFor(projectsDir, cwd, sessionId) {
+    const direct = transcriptPath(projectsDir, cwd, sessionId);
+    if (existsSync(direct))
+        return direct;
+    for (const dir of readdirSync(projectsDir)) {
+        const candidate = join(projectsDir, dir, `${sessionId}.jsonl`);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return direct;
+}
+function toStatus(s) {
+    return s !== undefined && STATUSES.has(s) ? s : 'unknown';
+}

package/dist/llm.js

@@ -0,0 +1,105 @@
+/** Most candidates sent to Haiku in one call. */
+export const MAX_LLM_CANDIDATES = 15;
+const FIELD_CHARS = 120;
+const HAIKU_TIMEOUT_MS = 20_000;
+const SYSTEM_PROMPT = [
+    'You match a user\'s loose description to coding sessions.',
+    'Each session line is: id | repo | branch | title | last prompt.',
+    'Return only sessions that plausibly match, best first, each with a summary of at most 12 words.',
+    'Return an empty list when none match.'
+].join(' ');
+const SCHEMA = JSON.stringify({
+    type: 'object',
+    properties: {
+        matches: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: { sessionId: { type: 'string' }, summary: { type: 'string' } },
+                required: ['sessionId', 'summary']
+            }
+        }
+    },
+    required: ['matches']
+});
+/** CLI args and stdin for a minimal, unsaved `claude -p` Haiku call. */
+export function buildHaikuArgs(query, cands) {
+    const args = [
+        '-p',
+        '--model', 'haiku',
+        '--no-session-persistence',
+        '--tools', '',
+        '--strict-mcp-config',
+        '--setting-sources', '',
+        '--output-format', 'json',
+        '--json-schema', SCHEMA,
+        '--system-prompt', SYSTEM_PROMPT
+    ];
+    const lines = cands.slice(0, MAX_LLM_CANDIDATES).map(c => {
+        const d = c.digest;
+        return [d.sessionId, d.worktree !== undefined ? `${d.repo}/${d.worktree}` : d.repo, d.branch, d.title, d.lastPrompt]
+            .map(v => clean(v)).join(' | ');
+    });
+    return { args, input: `Description: ${clean(query)}\n\nSessions:\n${lines.join('\n')}\n` };
+}
+/** Parse `claude -p --output-format json` output into matches with known ids. Throws on malformed output. */
+export function parseHaikuRanking(stdout, knownIds) {
+    let envelope;
+    try {
+        envelope = JSON.parse(stdout);
+    }
+    catch {
+        throw new Error('Haiku output was not JSON');
+    }
+    const payload = envelope.structured_output ?? parseResultText(envelope.result);
+    const matches = payload?.matches;
+    if (!Array.isArray(matches))
+        throw new Error('Haiku output had no matches array');
+    const known = matches.flatMap(m => {
+        const id = m?.sessionId;
+        const summary = m?.summary;
+        return typeof id === 'string' && knownIds.has(id) ? [{ sessionId: id, summary: typeof summary === 'string' ? summary : '' }] : [];
+    });
+    if (matches.length > 0 && known.length === 0)
+        throw new Error('Haiku returned only unknown session ids');
+    return known;
+}
+/** Ask Haiku to rank candidates. Returns undefined (after warning) when the call fails in any way. */
+export function askHaiku(query, cands, exec, warn) {
+    const sent = cands.slice(0, MAX_LLM_CANDIDATES);
+    const { args, input } = buildHaikuArgs(query, sent);
+    const r = exec('claude', args, input, { timeoutMs: HAIKU_TIMEOUT_MS });
+    if (r.status === 124) {
+        warn(`claude-term-tabs: Haiku call timed out after ${HAIKU_TIMEOUT_MS / 1000} s; using local ranking`);
+        return undefined;
+    }
+    if (r.status === 127) {
+        warn('claude-term-tabs: claude not found, using local ranking');
+        return undefined;
+    }
+    if (r.status !== 0) {
+        warn(`claude-term-tabs: Haiku call failed (${r.status}): ${(r.stderr || r.stdout).trim().slice(0, 200)}; using local ranking`);
+        return undefined;
+    }
+    try {
+        return parseHaikuRanking(r.stdout, new Set(sent.map(c => c.digest.sessionId)));
+    }
+    catch (err) {
+        warn(`claude-term-tabs: ${err.message}; using local ranking`);
+        return undefined;
+    }
+}
+function parseResultText(result) {
+    if (typeof result !== 'string')
+        return undefined;
+    const body = result.replace(/^\s*```(?:json)?\s*/, '').replace(/\s*```\s*$/, '');
+    try {
+        return JSON.parse(body);
+    }
+    catch {
+        return undefined;
+    }
+}
+function clean(v) {
+    return (v ?? '').replace(/[\s|]+/g, ' ').trim().slice(0, FIELD_CHARS);
+}

package/dist/output.js

@@ -0,0 +1,30 @@
+import { writeSync } from 'node:fs';
+const pause = new Int32Array(new SharedArrayBuffer(4));
+/**
+ * A line writer for fd that writes every byte. A short write or EAGAIN (a non-blocking pipe that is
+ * full) is retried; once the reader has gone (EPIPE, as in `ctt --json | head`), the rest of the
+ * output is dropped without an error and ctt carries on.
+ */
+export function lineWriter(fd) {
+    let closed = false;
+    return s => {
+        const buf = Buffer.from(`${s}\n`);
+        let off = 0;
+        while (!closed && off < buf.length) {
+            let n = 0;
+            try {
+                n = writeSync(fd, buf, off);
+            }
+            catch (err) {
+                const code = err.code;
+                if (code === 'EPIPE')
+                    closed = true;
+                else if (code !== 'EAGAIN')
+                    throw err;
+            }
+            off += n;
+            if (n === 0 && !closed)
+                Atomics.wait(pause, 0, 0, 5); // the reader is behind (EAGAIN or no progress); wait without spinning
+        }
+    };
+}

package/dist/paths.js

@@ -0,0 +1,29 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const WORKTREE_MARKER = '/.claude/worktrees/';
+/** Repo name for a session cwd, unwrapping `<repo>/.claude/worktrees/<slug>`. */
+export function repoName(cwd) {
+    const clean = cwd.replace(/\/+$/, '');
+    const at = clean.indexOf(WORKTREE_MARKER);
+    if (at >= 0) {
+        const worktree = clean.slice(at + WORKTREE_MARKER.length).split('/')[0];
+        return { repo: lastSegment(clean.slice(0, at)), worktree };
+    }
+    return { repo: lastSegment(clean) };
+}
+function lastSegment(p) {
+    const parts = p.split('/').filter(Boolean);
+    return parts[parts.length - 1] ?? p;
+}
+/** Path of a session transcript: projects/<cwd with non-alphanumerics as '-'>/<id>.jsonl. */
+export function transcriptPath(projectsDir, cwd, sessionId) {
+    return join(projectsDir, cwd.replace(/[^A-Za-z0-9]/g, '-'), `${sessionId}.jsonl`);
+}
+/** Default locations, overridable for tests. */
+export const defaultDirs = {
+    sessions: join(homedir(), '.claude', 'sessions'),
+    projects: join(homedir(), '.claude', 'projects'),
+    cache: join(homedir(), '.cache', 'claude-term-tabs', 'digests.json'),
+    config: join(homedir(), '.config', 'claude-term-tabs', 'config.json'),
+    snapshots: join(homedir(), '.local', 'state', 'claude-term-tabs', 'snapshots')
+};

package/dist/pause/run.js

@@ -0,0 +1,167 @@
+import { hasHandoff, latestAssistantAfterPrompt } from "../handoff.js";
+import { cleanField, formatAge } from "../picker.js";
+import { pruneSnapshots, saveSnapshot, snapshotFrom } from "../snapshot.js";
+import { classify, STRAGGLER_STATES } from "./state.js";
+/** How long `/exit` gets before a session is marked exit-failed. */
+export const EXIT_GRACE_MS = 10_000;
+const SNAPSHOT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+const EXIT_COMMAND = '/exit';
+const PROMPT_START_CHARS = 60;
+const TYPEABLE = new Set(['idle', 'busy']);
+const LABELS = {
+    done: 'done',
+    closing: 'closing',
+    closed: 'closed',
+    'exit-failed': 'exit failed',
+    busy: 'busy',
+    'may-need-you': 'may need you',
+    'waiting-on-you': 'waiting on you',
+    'idle-no-handoff': 'idle, no HANDOFF',
+    'in-shell-mode': 'in shell mode',
+    'cant-reach': "can't reach",
+    exited: 'exited'
+};
+/** Snapshot every live session, then type the stop prompt into each one that can take it. */
+export function startPause(deps, opts) {
+    const now = deps.now();
+    const cands = deps.collect();
+    pruneSnapshots(deps.snapshotDir, now, SNAPSHOT_MAX_AGE_MS);
+    const snapshot = snapshotFrom(cands, deps.adapter?.name, now);
+    deps.onSnapshot?.(saveSnapshot(deps.snapshotDir, snapshot));
+    const tracked = cands.map(cand => {
+        const typeable = TYPEABLE.has(cand.status);
+        const sent = typeable && sendStop(cand, deps.adapter, deps.config.stopPrompt, deps.warn, deps.inFront);
+        const size = safeSize(deps, deps.transcriptOf(cand));
+        const classified = classify({ alive: true, status: cand.status, hasPane: canType(cand, deps.adapter), handoff: false, msSinceGrowth: 0 });
+        const state = typeable && !sent ? 'cant-reach' : classified;
+        return { cand, state, since: now, lastSize: size, lastGrowth: now };
+    });
+    return { startedAt: now, snapshot, tracked, autoClose: opts.autoClose };
+}
+/** Advance every session one step: refresh facts, classify, and run auto-close. Returns a new run. */
+export function tickPause(run, deps) {
+    const now = deps.now();
+    const live = new Map(deps.collect().map(c => [c.digest.sessionId, c]));
+    const tracked = run.tracked.map(t => step(t, live.get(t.cand.digest.sessionId), run, deps, now));
+    const newlyDone = tracked.filter((t, i) => isDone(t.state) && !isDone(run.tracked[i].state));
+    if (newlyDone.length === 0)
+        return { ...run, tracked };
+    const doneIds = new Set(tracked.filter(t => isDone(t.state)).map(t => t.cand.digest.sessionId));
+    const snapshot = { ...run.snapshot, sessions: run.snapshot.sessions.map(s => ({ ...s, handoffWritten: doneIds.has(s.sessionId) })) };
+    deps.onSnapshot?.(saveSnapshot(deps.snapshotDir, snapshot));
+    return { ...run, snapshot, tracked };
+}
+/** Type the stop prompt into one session. Refuses (and warns) unless it is idle or busy, reachable, and Claude is in front. */
+export function sendStop(cand, adapter, prompt, warn, inFront) {
+    const name = cand.digest.title ?? cand.digest.sessionId;
+    if (cand.status === 'shell') {
+        warn(`claude-term-tabs: ${name} is in shell mode; not typing into it`);
+        return false;
+    }
+    if (!TYPEABLE.has(cand.status)) {
+        warn(`claude-term-tabs: ${name} is ${cand.status === 'waiting' ? 'waiting on a prompt' : `in status ${cand.status}`}; not typing into it`);
+        return false;
+    }
+    if (adapter === undefined || cand.pane === undefined) {
+        warn(`claude-term-tabs: ${name} is not in a supported terminal pane`);
+        return false;
+    }
+    if (inFront(cand) !== 'claude') {
+        warn(`claude-term-tabs: Claude is not in front of the tab for ${name}; not typing into it`);
+        return false;
+    }
+    try {
+        adapter.sendText(cand.pane, prompt);
+        return true;
+    }
+    catch (err) {
+        warn(`claude-term-tabs: could not type into ${name}: ${err.message}`);
+        return false;
+    }
+}
+/** Picker-style lines for sessions still in a straggler state. */
+export function stragglerLines(run, now) {
+    return run.tracked.filter(t => STRAGGLER_STATES.has(t.state)).map(t => {
+        const d = t.cand.digest;
+        const fields = [d.title ?? '(untitled)', d.repo, LABELS[t.state], formatAge(t.since, now), t.cand.pane !== undefined ? `tab ${t.cand.pane.tabIndex}` : undefined];
+        return `${d.sessionId}\t${fields.filter((f) => f !== undefined).map(cleanField).join(' · ')}`;
+    });
+}
+/** Final report and exit code: 0 only when every session finished. */
+export function pauseSummary(run) {
+    const total = run.tracked.length;
+    const done = run.tracked.filter(t => isDone(t.state)).length;
+    const closed = run.tracked.filter(t => t.state === 'closed').length;
+    const short = (t) => [t.cand.digest.title ?? t.cand.digest.sessionId, t.cand.digest.repo, LABELS[t.state]].map(cleanField).join(' · ');
+    const left = run.tracked.filter(t => STRAGGLER_STATES.has(t.state) && t.state !== 'exit-failed').map(short);
+    const unclosed = run.tracked.filter(t => t.state === 'exit-failed').map(short);
+    const head = `${done} of ${total} sessions wrote a HANDOFF${run.autoClose ? `, ${closed} closed` : ''}.`;
+    const failedLines = unclosed.length > 0 ? [`${unclosed.length} sessions could not be closed; close them yourself:`, ...unclosed.map(l => `  - ${l}`)] : [];
+    if (left.length === 0)
+        return { text: [head, ...failedLines, 'Safe to restart.'].join('\n'), exitCode: 0 };
+    return {
+        text: [head, ...failedLines, ...left.map(l => `  - ${l}`), `${left.length} sessions have no HANDOFF; they are still recorded.`].join('\n'),
+        exitCode: 1
+    };
+}
+function step(t, cur, run, deps, now) {
+    if (t.state === 'closed' || t.state === 'exit-failed')
+        return t;
+    if (t.state === 'closing')
+        return stepClosing(t, deps, now);
+    const cand = cur ?? t.cand;
+    const path = deps.transcriptOf(cand);
+    const size = safeSize(deps, path);
+    const lastGrowth = size !== t.lastSize ? now : t.lastGrowth;
+    const alive = cur !== undefined;
+    const handoff = hasHandoff(latestAssistantAfterPrompt(path, promptStart(deps.config.stopPrompt), run.startedAt));
+    const state = classify({ alive, status: cand.status, hasPane: canType(cand, deps.adapter), handoff, msSinceGrowth: now - lastGrowth });
+    const next = { ...t, cand, state, since: state === t.state ? t.since : now, lastSize: size, lastGrowth };
+    if (state !== 'done' || !run.autoClose || !alive || cand.status !== 'idle' || !canType(cand, deps.adapter) || deps.inFront(cand) !== 'claude')
+        return next;
+    try {
+        deps.adapter?.sendText(cand.pane, EXIT_COMMAND);
+        return { ...next, state: 'closing', since: now, closeRequestedAt: now };
+    }
+    catch (err) {
+        deps.warn(`claude-term-tabs: could not exit ${cand.digest.title ?? cand.digest.sessionId}: ${err.message}`);
+        return next;
+    }
+}
+function stepClosing(t, deps, now) {
+    const pid = t.cand.pid;
+    if (pid !== undefined && !deps.isAlive(pid)) {
+        if (deps.inFront(t.cand) !== 'shell') {
+            deps.warn(`claude-term-tabs: ${t.cand.digest.title ?? t.cand.digest.sessionId} exited, but something other than its shell is in front; leaving the tab open`);
+            return { ...t, state: 'done', since: now };
+        }
+        try {
+            if (t.cand.pane !== undefined)
+                deps.adapter?.closePane(t.cand.pane);
+        }
+        catch (err) {
+            deps.warn(`claude-term-tabs: could not close the tab for ${t.cand.digest.title ?? t.cand.digest.sessionId}: ${err.message}`);
+        }
+        return { ...t, state: 'closed', since: now };
+    }
+    if (now - (t.closeRequestedAt ?? now) > EXIT_GRACE_MS)
+        return { ...t, state: 'exit-failed', since: now };
+    return t;
+}
+function isDone(s) {
+    return s === 'done' || s === 'closing' || s === 'closed' || s === 'exit-failed';
+}
+function promptStart(prompt) {
+    return prompt.trimStart().split('\n')[0].slice(0, PROMPT_START_CHARS);
+}
+function canType(c, adapter) {
+    return adapter !== undefined && c.pane !== undefined;
+}
+function safeSize(deps, path) {
+    try {
+        return deps.sizeOf(path);
+    }
+    catch {
+        return -1;
+    }
+}

package/dist/pause/state.js

@@ -0,0 +1,24 @@
+/** Busy this long with no transcript growth reads as "may need you" (likely a permission prompt). */
+export const MAY_NEED_YOU_AFTER_MS = 120_000;
+/** States that keep a session in the straggler list. */
+export const STRAGGLER_STATES = new Set([
+    'busy', 'may-need-you', 'waiting-on-you', 'idle-no-handoff', 'in-shell-mode', 'cant-reach', 'exited', 'exit-failed'
+]);
+/** States that no longer change; a pause can stop waiting once every session is in one. */
+export const FINAL_STATES = new Set(['done', 'closed', 'exited', 'exit-failed']);
+/** Classify a session from its facts. Never returns closing, closed or exit-failed; the run sets those. */
+export function classify(i) {
+    if (i.handoff && (!i.alive || i.status !== 'busy'))
+        return 'done';
+    if (!i.alive)
+        return 'exited';
+    if (!i.hasPane)
+        return 'cant-reach';
+    if (i.status === 'shell')
+        return 'in-shell-mode';
+    if (i.status === 'waiting')
+        return 'waiting-on-you';
+    if (i.status === 'busy')
+        return i.msSinceGrowth > MAY_NEED_YOU_AFTER_MS ? 'may-need-you' : 'busy';
+    return 'idle-no-handoff';
+}