workoffdesk 0.0.0-stage → 1.0.0

package/dist/server/agents/claude/hooks/status.js

@@ -0,0 +1,34 @@
+const TRANSITIONS = {
+    UserPromptSubmit: 'working',
+    PostToolUse: 'working',
+    PostToolUseFailure: 'working',
+    Notification: 'waiting',
+    Stop: 'idle',
+    // A turn ended by an API error, a rate limit or an overload.
+    StopFailure: 'idle',
+};
+// SessionStart says which transcript Claude writes from now on, and that a new one is at its prompt. A compaction's status
+// depends on what came before it, so the machine keeps it. SessionEnd comes on /clear too, while Claude goes on: whether
+// Claude ended is read off its process (machine.ts), which the hook only has looked at sooner.
+export const HOOK_EVENTS = [...Object.keys(TRANSITIONS), 'SessionStart', 'SessionEnd', 'PreCompact', 'PostCompact'];
+// Notifications that wait on the user: a permission prompt (which is also how a question from Claude
+// shows) and an MCP server asking for input. Claude also notifies when idle at its prompt for a minute,
+// which is not a wait; one without a type comes from a version that predates the types.
+const ASKS = new Set(['permission_prompt', 'elicitation_dialog']);
+export function nextStatus(prev, event, notificationType) {
+    if (event === 'Notification' && notificationType !== undefined && !ASKS.has(notificationType))
+        return prev;
+    // Asked something before it started (trust this folder?), it starts once that is answered.
+    if (event === 'SessionStart')
+        return prev === 'starting' || prev === 'waiting' ? 'idle' : prev;
+    return TRANSITIONS[event] ?? prev;
+}
+export function notificationFor(prev, next, title) {
+    if (!next || prev === next)
+        return null;
+    if (next === 'waiting')
+        return { title, event: 'waiting' };
+    if (next === 'idle' && prev === 'working')
+        return { title, event: 'idle' };
+    return null;
+}

package/dist/server/agents/claude/hooks/tracker.js

@@ -0,0 +1,79 @@
+import { askedOf, leftToScreen } from './asks.js';
+import { heldInTranscript, lastTurn, transcriptTail } from '../transcript/turn.js';
+import { nextStatus, notificationFor } from './status.js';
+import { shownTitle } from '../../../system/store.js';
+// How long a turn that ended with a message still in Claude's own queue waits for Claude to start the turn
+// that message makes, before it is taken as over after all.
+export const HELD_WAIT_MS = 5000;
+// Hook events after which no permission prompt of the session is still open, and those that say its tool ran.
+const ASKS_OVER = new Set(['UserPromptSubmit', 'Stop', 'StopFailure', 'SessionEnd']);
+const TOOL_DONE = new Set(['PostToolUse', 'PostToolUseFailure']);
+function mover(machine, notifier) {
+    return (termId, event, type, said = '') => {
+        const meta = machine.sessionMeta(termId);
+        if (!meta)
+            return;
+        const prev = machine.getStatus(termId);
+        const next = nextStatus(prev, event, type);
+        if (!next || next === prev)
+            return;
+        machine.setStatus(termId, next);
+        const n = notificationFor(prev, next, shownTitle(meta));
+        if (n)
+            void notifier.notify(termId, n.title, n.event, said).catch(() => { });
+    };
+}
+// A permission prompt is a wait from the moment its hook comes, seconds before Claude Code's notification,
+// which says only that one is open.
+export function createPermissionHandler(machine, notifier) {
+    const move = mover(machine, notifier);
+    return (termId, payload, hook) => {
+        if (machine.holdPermission(termId, payload, hook) || leftToScreen(payload))
+            move(termId, 'Notification', 'permission_prompt', askedOf(payload));
+    };
+}
+// What a hook's event was about, in Claude's words: the reply a turn ended with, or what an MCP server asks.
+// Claude Code's own notification of a prompt names no more than that one is open.
+function saidIn(payload, event) {
+    const said = event === 'Notification' ? (payload.notification_type === 'elicitation_dialog' ? payload.message : '') : payload.last_assistant_message;
+    return typeof said === 'string' ? said : '';
+}
+export function createHookHandler(machine, notifier) {
+    const held = new Map();
+    const move = mover(machine, notifier);
+    return (termId, payload) => {
+        if (!machine.sessionMeta(termId))
+            return;
+        if (typeof payload.session_id === 'string')
+            machine.setClaudeSessionId(termId, payload.session_id);
+        void machine.ingest(termId);
+        const event = String(payload.hook_event_name ?? '');
+        if (TOOL_DONE.has(event))
+            machine.asks.toolDone(termId, payload.tool_name, payload.tool_input);
+        if (ASKS_OVER.has(event))
+            machine.asks.endAll(termId);
+        clearTimeout(held.get(termId));
+        held.delete(termId);
+        if (event === 'SessionEnd')
+            return machine.claudeMayHaveQuit(termId);
+        if (event === 'PreCompact')
+            return machine.compactStarted(termId);
+        if (event === 'PostCompact')
+            return machine.compactEnded(termId, payload.trigger === 'manual');
+        // Claude goes on at once with what was typed into its own queue while it worked (a message sent now,
+        // out of its turn), however the turn ended: it is not over, and what waits here waits for the next.
+        const ended = event === 'Stop' || event === 'StopFailure';
+        if (ended && typeof payload.transcript_path === 'string' && heldInTranscript(payload.transcript_path).length > 0) {
+            held.set(termId, setTimeout(() => {
+                held.delete(termId);
+                // Started with no hook to say so: the next Stop ends it.
+                const lines = transcriptTail(payload.transcript_path);
+                if (lines && lastTurn(lines)?.over === false)
+                    return;
+                move(termId, event, undefined, saidIn(payload, event));
+            }, HELD_WAIT_MS));
+            return;
+        }
+        move(termId, event, typeof payload.notification_type === 'string' ? payload.notification_type : undefined, saidIn(payload, event));
+    };
+}

package/dist/server/agents/claude/offers/commands.js

@@ -0,0 +1,219 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { initialized } from './initialize.js';
+// Claude Code's own commands live in its binary, not in files, so these are written down here, for when
+// Claude Code cannot be asked for its list (initialize.ts).
+const BUILTIN = [
+    ['agents', 'Manage subagents'],
+    ['clear', 'Clear the conversation and start over'],
+    ['compact', 'Compact the conversation to free up context'],
+    ['config', 'Open settings'],
+    ['context', 'Show how much context is used'],
+    ['cost', 'Show what this session has cost'],
+    ['doctor', 'Check the Claude Code installation'],
+    ['export', 'Export the conversation'],
+    ['help', 'Help'],
+    ['hooks', 'Manage hooks'],
+    ['init', 'Write a CLAUDE.md for the project'],
+    ['mcp', 'Manage MCP servers'],
+    ['memory', 'Edit memory files'],
+    ['model', 'Switch the model'],
+    ['permissions', 'Manage permissions'],
+    ['plugin', 'Manage plugins'],
+    ['resume', 'Resume an earlier conversation'],
+    ['review', 'Review a pull request'],
+    ['rewind', 'Go back to an earlier point'],
+    ['status', 'Show version, account and connections'],
+    ['todos', 'Show the todo list'],
+    ['usage', 'Show how much of the plan is used'],
+];
+const DESCRIPTION_MAX = 120;
+async function readText(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+async function readJson(path) {
+    const text = await readText(path);
+    if (text === null)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+async function entries(dir) {
+    try {
+        return (await readdir(dir, { withFileTypes: true })).filter((e) => !e.name.startsWith('.'));
+    }
+    catch {
+        return [];
+    }
+}
+const unquote = (v) => (/^(["']).*\1$/.test(v) ? v.slice(1, -1) : v);
+// The simple keys of a markdown file's front matter, and the text after it. A value of `>` or `|` runs
+// on over the indented lines below it.
+function frontMatter(text) {
+    const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+    if (!m)
+        return { fields: {}, body: text };
+    const fields = {};
+    const lines = m[1].split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const kv = /^([A-Za-z][\w-]*):\s*(.*)$/.exec(lines[i]);
+        if (!kv)
+            continue;
+        let value = kv[2].trim();
+        if (value === '' || /^[>|][+-]?$/.test(value)) {
+            const more = [];
+            while (i + 1 < lines.length && /^\s+\S/.test(lines[i + 1]))
+                more.push(lines[++i].trim());
+            value = more.join(' ');
+        }
+        fields[kv[1]] = unquote(value);
+    }
+    return { fields, body: text.slice(m[0].length) };
+}
+function oneLine(text) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length <= DESCRIPTION_MAX ? flat : `${flat.slice(0, DESCRIPTION_MAX - 1).trimEnd()}…`;
+}
+const firstLine = (body) => body.split(/\r?\n/).map((l) => l.replace(/^#+\s*/, '').trim()).find((l) => l) ?? '';
+function describe(text, fallbackName) {
+    const { fields, body } = frontMatter(text);
+    const lines = body.split(/\r?\n/).filter((l) => l.trim() && !l.trim().startsWith('#'));
+    return {
+        name: fields.name || fallbackName,
+        description: oneLine(fields.description || lines[0] || firstLine(body)),
+        hidden: fields['user-invocable'] === 'false',
+    };
+}
+// <dir>/<folder>/SKILL.md, named by its front matter, else by its folder.
+async function skillsIn(dir) {
+    const found = [];
+    for (const e of await entries(dir)) {
+        if (!e.isDirectory() && !e.isSymbolicLink())
+            continue;
+        const text = await readText(join(dir, e.name, 'SKILL.md'));
+        if (text === null)
+            continue;
+        const s = describe(text, e.name);
+        if (!s.hidden)
+            found.push({ name: s.name, description: s.description });
+    }
+    return found;
+}
+// <dir>/**/<name>.md, a folder becoming `folder:` in front of the name.
+async function commandsIn(dir, prefix = '') {
+    const found = [];
+    for (const e of await entries(dir)) {
+        const path = join(dir, e.name);
+        if (e.isDirectory())
+            found.push(...(await commandsIn(path, `${prefix}${e.name}:`)));
+        else if (e.name.endsWith('.md')) {
+            const text = await readText(path);
+            if (text !== null)
+                found.push({ name: prefix + e.name.slice(0, -3), description: describe(text, '').description });
+        }
+    }
+    return found;
+}
+const both = async (root) => [...(await skillsIn(join(root, 'skills'))), ...(await commandsIn(join(root, 'commands')))];
+const record = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+// The plugins switched on for a session in `cwd`: the user's settings, then the project's, then its local ones.
+async function enabledPlugins(claudeDir, cwd) {
+    const on = new Map();
+    for (const path of [join(claudeDir, 'settings.json'), join(cwd, '.claude', 'settings.json'), join(cwd, '.claude', 'settings.local.json')]) {
+        for (const [key, value] of Object.entries(record(record(await readJson(path)).enabledPlugins)))
+            on.set(key, value === true);
+    }
+    return new Set([...on].filter(([, v]) => v).map(([k]) => k));
+}
+async function pluginCommands(claudeDir, cwd) {
+    const enabled = await enabledPlugins(claudeDir, cwd);
+    const installed = record(record(await readJson(join(claudeDir, 'plugins', 'installed_plugins.json'))).plugins);
+    const found = [];
+    for (const [key, installs] of Object.entries(installed)) {
+        if (!enabled.has(key) || !Array.isArray(installs))
+            continue;
+        const install = installs.map(record).find((i) => i.scope === 'user' || i.projectPath === cwd);
+        if (typeof install?.installPath !== 'string')
+            continue;
+        const plugin = key.split('@')[0];
+        for (const c of await both(install.installPath))
+            found.push({ ...c, name: `${plugin}:${c.name}` });
+    }
+    return found;
+}
+// Commands Claude Code takes only in its terminal, which it leaves out of the list it gives a program.
+const TERMINAL_ONLY = [
+    ['add-dir', 'Add a new working directory'],
+    ['btw', 'Ask a quick side question without interrupting the main conversation'],
+    ['export', 'Export the current conversation to a file or clipboard'],
+    ['help', 'Show help and available commands'],
+    ['hooks', 'Manage hooks'],
+    ['memory', 'Edit CLAUDE.md files and memory settings'],
+    ['permissions', 'Manage permissions'],
+    ['plugin', 'Manage plugins'],
+    ['resume', 'Resume a previous conversation'],
+    ['rewind', 'Restore the code and/or conversation to a previous point'],
+    ['status', 'Show Claude Code status including version, model, account, API connectivity, and tool statuses'],
+    ['tasks', 'View and manage everything running in the background'],
+];
+// Claude Code says where a command of the user's or the project's comes from after its description, and a
+// plugin's before it.
+function fromTold(c) {
+    // `__` marks one of its own, which its menu does not show.
+    if (typeof c.name !== 'string' || !c.name || c.name.startsWith('__'))
+        return null;
+    const said = typeof c.description === 'string' ? c.description : '';
+    const source = c.builtin === true ? 'builtin' : c.name.includes(':') ? 'plugin' : /\(project\)\s*$/.test(said) ? 'project' : 'user';
+    const unsourced = said.replace(/\s*\((user|project)\)\s*$/, '');
+    const description = source === 'plugin' ? unsourced.replace(/^\([^)]*\)\s*/, '') : unsourced;
+    return { name: c.name, description: oneLine(description), source };
+}
+const byNameOrder = (a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+// What can follow a `/` in a Claude session started in `cwd`: Claude Code's own list when `claudeBin` can be
+// asked for it, else read from the same files Claude Code reads.
+export async function listCommands(o) {
+    if (o.claudeBin && o.cwd) {
+        const told = await initialized(o.claudeBin, o.cwd).catch(() => null);
+        const list = Array.isArray(told?.commands) ? told.commands : null;
+        if (list) {
+            const byName = new Map();
+            for (const c of list.map(fromTold))
+                if (c && !byName.has(c.name))
+                    byName.set(c.name, c);
+            for (const [name, description] of TERMINAL_ONLY)
+                if (!byName.has(name))
+                    byName.set(name, { name, description, source: 'builtin' });
+            return [...byName.values()].sort(byNameOrder);
+        }
+    }
+    return filesListed(o);
+}
+// Read from the same files Claude Code reads. Where two share a name, the earlier source wins: built-in,
+// then the project, the user, a plugin.
+async function filesListed(o) {
+    const [project, user, plugin] = await Promise.all([
+        o.cwd ? both(join(o.cwd, '.claude')) : [],
+        both(o.claudeDir),
+        pluginCommands(o.claudeDir, o.cwd),
+    ]);
+    const byName = new Map();
+    const add = (source, list) => {
+        for (const c of list)
+            if (c.name && !byName.has(c.name))
+                byName.set(c.name, { ...c, source });
+    };
+    add('builtin', BUILTIN.map(([name, description]) => ({ name, description })));
+    add('project', project);
+    add('user', user);
+    add('plugin', plugin);
+    return [...byName.values()].sort(byNameOrder);
+}

package/dist/server/agents/claude/offers/files.js

@@ -0,0 +1,51 @@
+import { execFile } from 'node:child_process';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+// How many paths are offered at most, how deep a folder that is not a git repository is walked, and for how
+// long a listing is reused.
+const MAX_FILES = 5000;
+const MAX_DEPTH = 3;
+const GIT_TIMEOUT_MS = 3000;
+const KEPT_MS = 30_000;
+const SKIPPED = new Set(['node_modules', 'dist', 'build', 'target', 'vendor', '__pycache__']);
+const kept = new Map();
+// The files under cwd an `@` can name, relative to it: what git tracks or would (ignored ones left out);
+// outside a repository, a shallow walk past dot folders and dependency folders.
+export function listFiles(cwd, now = Date.now()) {
+    const hit = kept.get(cwd);
+    if (hit && now - hit.at < KEPT_MS)
+        return hit.files;
+    const files = gitFiles(cwd).catch(() => walk(cwd));
+    kept.set(cwd, { at: now, files });
+    files.catch(() => kept.delete(cwd));
+    return files;
+}
+async function gitFiles(cwd) {
+    const { stdout } = await run('git', ['ls-files', '-co', '--exclude-standard'], { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: 32 * 1024 * 1024 });
+    return stdout.split('\n').filter(Boolean).slice(0, MAX_FILES);
+}
+async function walk(cwd) {
+    const files = [];
+    const visit = async (rel, depth) => {
+        if (files.length >= MAX_FILES)
+            return;
+        const entries = await readdir(join(cwd, rel), { withFileTypes: true }).catch(() => []);
+        for (const e of entries) {
+            if (files.length >= MAX_FILES)
+                return;
+            if (e.name.startsWith('.') || SKIPPED.has(e.name))
+                continue;
+            const path = rel ? `${rel}/${e.name}` : e.name;
+            if (e.isDirectory()) {
+                if (depth < MAX_DEPTH)
+                    await visit(path, depth + 1);
+            }
+            else if (e.isFile())
+                files.push(path);
+        }
+    };
+    await visit('', 1);
+    return files;
+}

package/dist/server/agents/claude/offers/initialize.js

@@ -0,0 +1,59 @@
+import { spawn } from 'node:child_process';
+const ASK_MS = 15_000;
+const KEPT_MS = 5 * 60_000;
+const told = new Map();
+// Claude Code's answer in `cwd`, kept a while: it changes only with its settings, plugins and account.
+export function initialized(bin, cwd) {
+    const key = `${bin}\n${cwd}`;
+    const kept = told.get(key);
+    if (kept && Date.now() - kept.at < KEPT_MS)
+        return kept.answer;
+    const answer = askClaude(bin, cwd);
+    told.set(key, { at: Date.now(), answer });
+    answer.catch(() => told.get(key)?.answer === answer && told.delete(key));
+    return answer;
+}
+// Asked as a program asks it (`-p`, stream-json) before any turn, so nothing goes to the model; without hooks
+// or a transcript, so it leaves no trace.
+function askClaude(bin, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--no-session-persistence', '--settings', JSON.stringify({ disableAllHooks: true })], { cwd, stdio: ['pipe', 'pipe', 'ignore'] });
+        let done = false;
+        const finish = (error, answer = {}) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            child.kill();
+            if (error)
+                reject(error);
+            else
+                resolve(answer);
+        };
+        const timer = setTimeout(() => finish(new Error('claude did not answer initialize')), ASK_MS);
+        child.on('error', finish);
+        child.on('exit', () => finish(new Error('claude ended before answering initialize')));
+        let out = '';
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            out += chunk;
+            for (let end = out.indexOf('\n'); end >= 0; end = out.indexOf('\n')) {
+                const line = out.slice(0, end);
+                out = out.slice(end + 1);
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (msg?.type !== 'control_response')
+                    continue;
+                const answer = msg.response?.response;
+                return answer && typeof answer === 'object' ? finish(null, answer) : finish(new Error('claude answered initialize with nothing'));
+            }
+        });
+        child.stdin.on('error', () => { });
+        child.stdin.end(`${JSON.stringify({ type: 'control_request', request_id: 'initialize', request: { subtype: 'initialize' } })}\n`);
+    });
+}

package/dist/server/agents/claude/offers/models.js

@@ -0,0 +1,20 @@
+import { initialized } from './initialize.js';
+const str = (v) => (typeof v === 'string' ? v : '');
+// What /model is given is typed at the prompt: a name, an id, `opus[1m]`, never anything else.
+const VALUE = /^[\w.:[\]-]{1,40}$/;
+// The models Claude Code offers in `cwd`, in its own order; empty when it cannot be asked.
+export async function listModels(bin, cwd) {
+    const told = await initialized(bin, cwd).catch(() => null);
+    if (!Array.isArray(told?.models))
+        return [];
+    return told.models.flatMap((m) => {
+        if (!m || typeof m !== 'object')
+            return [];
+        const r = m;
+        const value = str(r.value);
+        if (!VALUE.test(value))
+            return [];
+        const efforts = r.supportsEffort === true && Array.isArray(r.supportedEffortLevels) ? r.supportedEffortLevels.filter((l) => typeof l === 'string') : [];
+        return [{ value, name: str(r.displayName) || value, about: str(r.description), efforts }];
+    });
+}

package/dist/server/agents/claude/screen/choices.js

@@ -0,0 +1,189 @@
+// A choice Claude Code is asking for (a permission prompt, a question, a picker), read off the screen:
+// the transcript has no record of it. Options are lines in one column, the current one marked ❯ and the
+// others indented to match; descriptions that wrap continue further in. Claude Code moves through them
+// with the arrow keys and takes one with Enter (number keys do nothing in some of them).
+//
+// A question that takes several answers draws a box before each option, ticked with Space, and a Submit
+// (Next while more questions follow) under the options, which sends them with Enter. The arrows reach it
+// as though it were one more option, so a cursor on it is `options.length`.
+const CONTEXT_LINES = 15;
+const RULE = /^\s*[─━▔═]{3,}\s*$/;
+const CHECKBOX = /^\[([ ✔√]?)\]\s*/;
+const SUBMIT = /^\s*(❯\s*)?(Submit|Next)$/;
+const TYPED = /^Type something\b/i;
+const THIS_SESSION_ONLY = /\bs to use this session only\b/;
+// The pickers a slash command opens: /model's, and the settings dialog /config opens on its Config tab.
+const OPENED_HEADINGS = /^(Select model|Settings\s{2,}Status\s{2,}Config\b.*)$/;
+const PLAN_FILE = /~\/\.claude\/plans\/([\w.-]+\.md)\b/;
+// /rewind lists the messages sent, each with what it changed on a line under it, apart by blank lines.
+const REWIND_HEAD = /^\s*Restore the code and\/or conversation to the point before/;
+const REWIND_HINT = /^\s*Enter to continue\b/;
+export function parseChoices(screen) {
+    const lines = screen.split('\n').map((l) => l.trimEnd());
+    const rewind = rewindChoices(lines);
+    if (rewind !== undefined)
+        return rewind;
+    // Earlier prompts stay in the scrollback, marked ❯ too: only the last one on screen can be live. A dialog
+    // opened while Claude works is drawn above its prompt, whose ❯ under the rule is not the dialog's.
+    let row = -1;
+    for (let i = lines.length - 1; i >= 0 && row < 0; i--)
+        if (lines[i].includes('❯') && !isPromptLine(lines, i))
+            row = i;
+    if (row < 0)
+        return null;
+    const onSubmit = SUBMIT.test(lines[row]);
+    if (onSubmit) {
+        // The options above are all unmarked, indented where the ❯ would go.
+        let i = row - 1;
+        while (i >= 0 && !/^\s* {2}\d+\. \S/.test(lines[i]))
+            i--;
+        if (i < 0)
+            return null;
+        row = i;
+    }
+    const cur = (onSubmit ? /^(\s*) {2}\d/ : /^(\s*)❯ \S/).exec(lines[row]);
+    if (!cur)
+        return null;
+    const c = cur[1].length;
+    // At the very edge, where earlier prompts and what follows them sit too, only numbered lines are options.
+    const isOption = (l) => l.slice(0, c).trim() === '' &&
+        ' ❯↓↑'.includes(l[c] ?? '') &&
+        l[c + 1] === ' ' &&
+        /^[^\s…]/.test(l.slice(c + 2)) &&
+        (c > 0 || /^\d+\. /.test(l.slice(c + 2)));
+    const isMore = (l) => l.slice(0, c + 3).trim() === '' && /^[^\s…]/.test(l.trim()) && !SUBMIT.test(l);
+    if (!isOption(lines[row]))
+        return null;
+    let start = row;
+    while (start > 0 && (isOption(lines[start - 1]) || isMore(lines[start - 1])))
+        start--;
+    while (!isOption(lines[start]))
+        start++;
+    let end = row;
+    while (end + 1 < lines.length && (isOption(lines[end + 1]) || isMore(lines[end + 1])))
+        end++;
+    const options = [];
+    let cursor = 0;
+    for (let i = start; i <= end; i++) {
+        if (isOption(lines[i])) {
+            if (i === row)
+                cursor = options.length;
+            const text = lines[i].slice(c + 2).replace(/^\d+\.\s+/, '');
+            const box = CHECKBOX.exec(text);
+            const [label, ...detail] = text.slice(box?.[0].length ?? 0).split(/\s{2,}/);
+            options.push({
+                label,
+                detail: detail.join(' '),
+                ...(box && { ticked: box[1].trim() !== '' }),
+                ...(TYPED.test(label) && { typed: true }),
+            });
+        }
+        else {
+            const last = options[options.length - 1];
+            last.detail = [last.detail, lines[i].trim()].filter(Boolean).join(' ');
+        }
+    }
+    if (options.length < 2)
+        return null;
+    const below = lines.slice(end + 1, end + 6);
+    const take = below.some((l) => THIS_SESSION_ONLY.test(l)) ? { take: 's' } : {};
+    const planFile = below.map((l) => PLAN_FILE.exec(l)?.[1]).find(Boolean);
+    if (!options.some((o) => 'ticked' in o)) {
+        if (onSubmit)
+            return null;
+        const context = contextAbove(lines, start);
+        const opened = OPENED_HEADINGS.test(context.split('\n')[0].trim()) ? { opened: true } : {};
+        return { context, options, cursor, ...take, ...(planFile && { planFile }), ...opened };
+    }
+    // Ticks with no Submit in sight could not be sent.
+    const submit = submitBelow(lines, end);
+    if (!submit)
+        return null;
+    return { context: contextAbove(lines, start), options, cursor: onSubmit ? options.length : cursor, submit };
+}
+// The line being typed at Claude's prompt: ❯ at the edge, right under the prompt's rule.
+function isPromptLine(lines, i) {
+    return lines[i].startsWith('❯') && i > 0 && /^─{10,}/.test(lines[i - 1]);
+}
+// The messages /rewind offers to go back to before, one option each; undefined when /rewind is not up.
+function rewindChoices(lines) {
+    let head = -1;
+    for (let i = lines.length - 1; i >= 0 && head < 0; i--)
+        if (REWIND_HEAD.test(lines[i]))
+            head = i;
+    if (head < 0)
+        return undefined;
+    let hint = head + 1;
+    while (hint < lines.length && !REWIND_HINT.test(lines[hint]))
+        hint++;
+    if (hint === lines.length)
+        return undefined;
+    const blocks = [[]];
+    for (const l of lines.slice(head + 1, hint)) {
+        if (l.trim())
+            blocks[blocks.length - 1].push(l);
+        else if (blocks[blocks.length - 1].length)
+            blocks.push([]);
+    }
+    const entries = blocks.filter((b) => b.length);
+    const cursor = entries.findIndex((b) => b[0].includes('❯'));
+    if (entries.length < 2 || cursor < 0)
+        return null;
+    return {
+        opened: true,
+        context: lines[head].trim(),
+        options: entries.map(([first, ...rest]) => ({ label: first.replace(/^\s*[❯↑↓]?\s*/, ''), detail: rest.map((l) => l.trim()).join(' ') })),
+        cursor,
+    };
+}
+// The Submit (or Next) right under the options, a blank line or a rule between them at most.
+function submitBelow(lines, end) {
+    for (let i = end + 1; i <= end + 2 && i < lines.length; i++) {
+        const m = SUBMIT.exec(lines[i]);
+        if (m)
+            return m[2];
+    }
+    return null;
+}
+// What the choice is about: the lines above it, back to a rule or a screenful's worth.
+function contextAbove(lines, start) {
+    const above = [];
+    for (let i = start - 1; i >= 0 && above.length < CONTEXT_LINES && !RULE.test(lines[i]); i--)
+        above.unshift(lines[i]);
+    const indent = Math.min(...above.filter(Boolean).map((l) => l.length - l.trimStart().length));
+    return above
+        .map((l) => (QUESTION_TABS.test(l.trim()) ? questionsOf(l) : l.slice(indent)))
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+// Several questions asked at once have a row of tabs over them, `←  ☒ Color  ☐ Fruits  ✔ Submit  →`, a box
+// ticked for each answered; said as `✓ Color · ○ Fruits`.
+const QUESTION_TABS = /^←\s.*[☐☒].*→$/;
+function questionsOf(line) {
+    return [...line.matchAll(/([☐☒])\s(.+?)(?=\s{2,}|\s*→$)/g)].map(([, box, name]) => `${box === '☒' ? '✓' : '○'} ${name}`).join(' · ');
+}
+const UP = '\x1b[A';
+const DOWN = '\x1b[B';
+// Moves to option `to` and takes it. An answer to be typed is only moved onto: Enter on it while empty
+// declines the question, so the text and its Enter come after (ClaudeScreen.choose).
+export function keysToChoose(c, to) {
+    const move = to > c.cursor ? DOWN.repeat(to - c.cursor) : UP.repeat(c.cursor - to);
+    return c.options[to]?.typed ? move : `${move}${c.take ?? '\r'}`;
+}
+// Presses Space on each option whose tick differs from `ticked`, then goes on down to Submit and presses
+// Enter. `ticked` must not hold an answer of one's own: Space in it would be typed.
+export function keysToTick(c, ticked) {
+    let at = c.cursor;
+    const moveTo = (to) => {
+        const keys = to > at ? DOWN.repeat(to - at) : UP.repeat(at - to);
+        at = to;
+        return keys;
+    };
+    let keys = '';
+    c.options.forEach((o, i) => {
+        if (!!o.ticked !== ticked.includes(i))
+            keys += `${moveTo(i)} `;
+    });
+    return `${keys}${moveTo(c.options.length)}\r`;
+}