@hwip/cli 0.1.15 → 0.1.17

package/README.md

@@ -190,7 +190,8 @@ says it has no live timeline.
 | Codex CLI | `~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-*.jsonl` (`CODEX_HOME`) | `src/codex-transcript.ts` |
 | Gemini CLI | `~/.gemini/tmp/<project>/chats/session-*.jsonl` (`GEMINI_CLI_HOME`) | `src/gemini-transcript.ts` |
 | OpenCode 2.x | no file — the `session_message` table of `~/.local/share/opencode/opencode.db` (`OPENCODE_DB`, `XDG_DATA_HOME`), asked again when the store changes, at most once a second per session. The pane's session is the newest one in its directory written to since the pane started | `src/opencode-transcript.ts` |
-| Cursor, Hermes, Kimi, Grok, Antigravity, Qwen, Auggie, Kilo, Copilot, Kiro, Droid | — none yet | — |
+| Hermes | no file — the `messages` table of `~/.hermes/state.db`, asked again when the store changes, at most once a second per session. The pane's session is the newest one in its directory with a message since the pane started | `src/hermes-transcript.ts` |
+| Cursor, Kimi, Grok, Antigravity, Qwen, Auggie, Kilo, Copilot, Kiro, Droid | — none yet | — |
 
 Adding an agent means a projector file of its own, not another branch in an
 existing one: the formats share no vocabulary. Each projector is pinned to the
@@ -572,6 +573,17 @@ again picks up that run's conversation, not the newest one. If the name
 is live again by then, that run starts beside it under the next free name
 of the family (`<name>-2`, `<name>-3`, …) instead of being refused.
 
+The phone can also start a **new** session in a project this machine has
+run before: the same request with `fresh: true` starts the agent recorded
+for that session in its directory, with no conversation picked up, under
+the session's name or — when that runs — the next free name of its family.
+The directory and the agent still come only from this machine's record, so
+the phone cannot name either. The listener advertises `session-start-v1`
+so the apps offer it only to a build that knows it. Ending a session from
+the phone is `agent.session.exit.request`: `C-c`, the agent's own quit
+command, then `C-d` — never a forced kill, so an agent that will not quit is
+reported as still running.
+
 Two details worth knowing:
 
 - It fires at **user login**, not at boot. Without automatic login, the
@@ -705,12 +717,17 @@ When a session waits for your approval, the listener also sends what it is waiti
 for — the tool, the command or the diff, and the answers — so the app can show it
 and answer. That covers Claude Code (a Bash command, a file edit or a new file),
 Gemini CLI (its tool approvals), OpenCode (its permission request; the listener reads
-the screen with its colours, since only a colour marks the chosen button) and pi
-approval extensions that ask through `ctx.ui.select`. Codex's approval dialog is not
-read yet. It is sealed the same
+the screen with its colours, since only a colour marks the chosen button), pi
+approval extensions that ask through `ctx.ui.select` and Codex (a shell command or a file edit; the app answers with
+the arrow keys and Enter). It is sealed the same
 way as a chunk, for the same pinned devices, and turned off by the same
-`--no-turn-history`; the server stores ciphertext only. Other dialogs (a plan, a
-question, a trust prompt) send nothing beyond the state. An answer the app sends is
+`--no-turn-history`; the server stores ciphertext only. For Claude Code that
+includes a question it asks (one question, a multi-select with its Submit row,
+the review of several answers) and the plan it asks you to approve; a plan longer
+than the screen shows is cut where the screen cuts it, with the plan file's path
+as the note. Rows that need typed text (`Type something`, `Chat about this`,
+`Tell Claude what to change`) are not offered, and a dialog you are typing into is
+not read. Other dialogs (a trust prompt) send nothing beyond the state. An answer the app sends is
 typed only while that same prompt is still on screen: if you have moved the
 highlight or answered at the keyboard, the command is refused (`prompt_changed`)
 instead of landing on whatever is there now.

package/dist/agent-rules.default.d.ts

@@ -18,7 +18,7 @@
  *   still be working underneath, so it must not change the state.
  *
  * Every agent here carries the same rules the server manifest publishes
- * (hwip server/src/agent-rules/manifest.json, version 2026.10.21.1 — hwip#616, merged and deployed before this cli ships),
+ * (hwip server/src/agent-rules/manifest.json, version 2026.11.01.2 — the hwip mirror of this rule merges and deploys before this cli ships),
  * so a listener that never reaches the endpoint classifies them too. A fetched
  * manifest replaces this bundle whole for state reports; schedules read only
  * this bundle. An agent without rules here

package/dist/agent-rules.default.js

@@ -21,7 +21,7 @@ exports.DEFAULT_MANIFEST = void 0;
  *   still be working underneath, so it must not change the state.
  *
  * Every agent here carries the same rules the server manifest publishes
- * (hwip server/src/agent-rules/manifest.json, version 2026.10.21.1 — hwip#616, merged and deployed before this cli ships),
+ * (hwip server/src/agent-rules/manifest.json, version 2026.11.01.2 — the hwip mirror of this rule merges and deploys before this cli ships),
  * so a listener that never reaches the endpoint classifies them too. A fetched
  * manifest replaces this bundle whole for state reports; schedules read only
  * this bundle. An agent without rules here
@@ -31,7 +31,7 @@ exports.DEFAULT_MANIFEST = void 0;
 const agent_state_js_1 = require("./agent-state.js");
 exports.DEFAULT_MANIFEST = {
     engineVersion: agent_state_js_1.ENGINE_VERSION,
-    version: '2026.10.21.1',
+    version: '2026.11.01.2',
     agents: {
         claude: [
             {
@@ -61,6 +61,20 @@ exports.DEFAULT_MANIFEST = {
                 ],
                 not: [{ contains: ['esc to interrupt'] }],
             },
+            {
+                // Plan approval (ExitPlanMode) and the review of several AskUserQuestion answers: their option lists
+                // carry no "esc to cancel" / "enter to select" line, so the dialog rule above misses them and the
+                // `❯ 1.` row reads as an idle prompt. Anchored to the dialogs' own question lines, near the bottom.
+                id: 'claude-blocked-plan-or-review',
+                state: 'blocked',
+                priority: 900,
+                tailLines: 14,
+                any: [
+                    { regex: ['^\\s*Claude has written up a plan and is ready to execute'] },
+                    { regex: ['^\\s*Ready to submit your answers\\?\\s*$'] },
+                ],
+                not: [{ contains: ['esc to interrupt'] }],
+            },
             {
                 id: 'claude-working-interrupt-hint',
                 state: 'working',
@@ -125,15 +139,11 @@ exports.DEFAULT_MANIFEST = {
             // while a turn runs both stay drawn under a `• Working (… • esc to
             // interrupt)` line, so working must outrank idle.
             //
-            // KNOWN GAP — no tool ever ran (the workspace was out of credits),
-            // so the tool-approval dialog was never drawn and has no rule. The
-            // idle rule refuses a tail holding the markers those dialogs and
-            // older Codex approval prompts draw — a `› 1.` option list, a
-            // `(y)`/`(n)` key hint, a `· esc …` footer, `enter to confirm` or
-            // `esc to cancel` — so an approval dialog that kept the footer
-            // reads `unknown` as long as it draws one of them. One that draws
-            // none would read `idle`; capture it before trusting this rule
-            // further.
+            // The tool-approval dialog (captured on 0.166.0) has its own blocked
+            // rule. The idle rule still refuses a tail holding the markers
+            // approval prompts draw — a `› 1.` option list, a `(y)`/`(n)` key
+            // hint, a `· esc …` footer, `enter to confirm` or `esc to cancel` —
+            // so a variant the blocked rule misses reads `unknown`, not `idle`.
             {
                 id: 'codex-blocked-hooks-review',
                 state: 'blocked',
@@ -158,6 +168,20 @@ exports.DEFAULT_MANIFEST = {
                 priority: 900,
                 contains: ['trust this folder', 'enter continue'],
             },
+            {
+                // Tool approval (codex-cli 0.166.0, shell command or file edit): the question and the
+                // confirm footer. Both must be in view, so a transcript that
+                // only quotes one of them does not read blocked. The composer is hidden while it is drawn.
+                id: 'codex-blocked-tool-approval',
+                state: 'blocked',
+                priority: 900,
+                tailLines: 30,
+                regex: ['^\\s*Press enter to confirm or esc to cancel\\s*$'],
+                any: [
+                    { regex: ['^\\s*Would you like to run the following command\\?\\s*$'] },
+                    { regex: ['^\\s*Would you like to make the following edits\\?\\s*$'] },
+                ],
+            },
             {
                 id: 'codex-working-interrupt-hint',
                 state: 'working',

package/dist/blocked-prompt-claude-dialogs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Claude Code's other numbered dialogs: AskUserQuestion (a question, a multi-select, the review of several answers)
+ * and ExitPlanMode (the plan to approve). They come out as the same `permission`-shaped prompt the approval dialogs
+ * do, so a phone that reads those reads these too; only the title tells them apart.
+ *
+ * Rows that need typed text (`Type something`, `Chat about this`, `Tell Claude what to change`) are not options: an
+ * option has to be one answer a single press gives (in a multi-select a press toggles a box, and the screen it
+ * draws next is a new prompt). A dialog whose highlight sits on such a row is not read at all, as
+ * is one the user is typing into: the keys of the other options would land in the text.
+ */
+import { type ParsedPrompt } from './blocked-prompt.js';
+/** An AskUserQuestion dialog at the bottom of `pane`, or undefined. */
+export declare const parseClaudeQuestion: (pane: string) => ParsedPrompt | undefined;
+/** An ExitPlanMode dialog at the bottom of `pane`, or undefined. */
+export declare const parseClaudePlan: (pane: string) => ParsedPrompt | undefined;
+//# sourceMappingURL=blocked-prompt-claude-dialogs.d.ts.map

package/dist/blocked-prompt-claude-dialogs.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseClaudePlan = exports.parseClaudeQuestion = void 0;
+/**
+ * Claude Code's other numbered dialogs: AskUserQuestion (a question, a multi-select, the review of several answers)
+ * and ExitPlanMode (the plan to approve). They come out as the same `permission`-shaped prompt the approval dialogs
+ * do, so a phone that reads those reads these too; only the title tells them apart.
+ *
+ * Rows that need typed text (`Type something`, `Chat about this`, `Tell Claude what to change`) are not options: an
+ * option has to be one answer a single press gives (in a multi-select a press toggles a box, and the screen it
+ * draws next is a new prompt). A dialog whose highlight sits on such a row is not read at all, as
+ * is one the user is typing into: the keys of the other options would land in the text.
+ */
+const blocked_prompt_js_1 = require("./blocked-prompt.js");
+const FULL_RULE = /^\s*─{20,}$/;
+const DASHED_RULE = /^\s*╌{20,}$/;
+const OPTION = /^\s*([❯>])?\s*(\d{1,2})\.\s+(\S.*)$/;
+const TAB_LINE = /^\s*(?:←\s+)?[☐☒]\s/;
+const TAB_CHIP = /([☐☒✔])\s+(\S+)/g;
+const SUBMIT_ROW = /^\s*(❯)?\s+Submit\s*$/;
+const ASK_FOOTER = /Enter to select/;
+const PLAN_FOOTER = /^\s*ctrl\+g to edit/;
+const MULTI_LABEL = /^\[[ ✔]\]\s/;
+const OTHER_LABEL = /^(?:\[[ ✔]\]\s+)?Type something\.?$/;
+const CHAT_LABEL = /^Chat about this$/;
+const PLAN_TITLE = 'Ready to code?';
+const OWN_ANSWER = /^Tell Claude what to change$/;
+/** The hint under a plan option: it belongs to the row above, not to its label. */
+const PLAN_HINT = /^shift\+tab to /;
+/** The marker the viewport draws at a plan's last visible row when more is below (or above). */
+const SCROLL_MARK = /\s{2,}[↓↑]$/;
+const blank = (l) => l.trim() === '';
+const lastIndex = (lines, test) => {
+    for (let i = lines.length - 1; i >= 0; i--)
+        if (test(lines[i], i))
+            return i;
+    return -1;
+};
+const dedent = (lines) => {
+    const indent = Math.min(...lines.filter((l) => !blank(l)).map((l) => l.length - l.trimStart().length));
+    return Number.isFinite(indent) ? lines.map((l) => l.slice(indent)) : [...lines];
+};
+/** The numbered rows of `lines`; a more indented line under a row describes it. Undefined for any other line. */
+const readRows = (lines) => {
+    const rows = [];
+    for (const line of lines) {
+        if (blank(line))
+            continue;
+        const m = OPTION.exec(line);
+        if (m) {
+            rows.push({ n: Number(m[2]), label: m[3].trim(), selected: m[1] === '❯', note: [] });
+        }
+        else if (rows.length > 0 && /^\s{3,}\S/.test(line)) {
+            rows[rows.length - 1].note.push(line.trim());
+        }
+        else {
+            return undefined;
+        }
+    }
+    return rows.length > 0 ? rows : undefined;
+};
+/** `label — description`, or the label alone when the description only repeats it. */
+const withNote = (row) => {
+    const text = row.note.join(' ');
+    const bare = row.label.replace(/^\[[ ✔]\]\s+/, '');
+    return text === '' || text === bare ? row.label : `${row.label} — ${text}`;
+};
+/** An AskUserQuestion dialog at the bottom of `pane`, or undefined. */
+const parseClaudeQuestion = (pane) => {
+    const lines = pane.split('\n').map((l) => l.trimEnd());
+    let end = lines.length;
+    while (end > 0 && blank(lines[end - 1]))
+        end--;
+    const live = lines.slice(0, end);
+    const tabAt = lastIndex(live, (l, i) => i > 0 && TAB_LINE.test(l) && FULL_RULE.test(live[i - 1]));
+    if (tabAt < 0)
+        return undefined;
+    const tabs = live[tabAt];
+    // Below the options the dialog may draw its own rule, the "Chat about this" row and a footer; nothing else.
+    const rest = live.slice(tabAt + 1);
+    const ruleAt = rest.findIndex((l) => FULL_RULE.test(l));
+    const body = ruleAt < 0 ? rest : rest.slice(0, ruleAt);
+    if (ruleAt >= 0) {
+        for (const l of rest.slice(ruleAt + 1)) {
+            if (blank(l) || ASK_FOOTER.test(l))
+                continue;
+            if (CHAT_LABEL.test(OPTION.exec(l)?.[3]?.trim() ?? ''))
+                continue;
+            return undefined;
+        }
+        if (!rest.slice(ruleAt + 1).some((l) => ASK_FOOTER.test(l)))
+            return undefined;
+    }
+    // Text above the first row: paragraphs, the last one the question.
+    const firstRow = body.findIndex((l) => OPTION.test(l));
+    if (firstRow < 0)
+        return undefined;
+    const paragraphs = [];
+    for (const l of body.slice(0, firstRow)) {
+        if (blank(l))
+            paragraphs.push([]);
+        else
+            (paragraphs.length === 0 || paragraphs[paragraphs.length - 1].length === 0 ? paragraphs.push([l]) : paragraphs[paragraphs.length - 1].push(l));
+    }
+    const texts = paragraphs.filter((p) => p.length > 0);
+    const questionLines = texts.pop();
+    if (!questionLines)
+        return undefined;
+    // AskUserQuestion takes any text as the question; a "?" is not guaranteed.
+    const question = questionLines.map((l) => l.trim()).join(' ');
+    // Under the question: the numbered rows, then in a multi-select an unnumbered Submit row.
+    let rowLines = body.slice(firstRow);
+    let submit;
+    const submitAt = rowLines.findIndex((l) => SUBMIT_ROW.test(l));
+    if (submitAt >= 0) {
+        submit = { selected: SUBMIT_ROW.exec(rowLines[submitAt])[1] === '❯' };
+        if (rowLines.slice(submitAt + 1).some((l) => !blank(l)))
+            return undefined;
+        rowLines = rowLines.slice(0, submitAt);
+    }
+    const rows = readRows(rowLines);
+    if (!rows)
+        return undefined;
+    // A question with a free-text row ends in it; the review of the answers has none. On that row the user either has
+    // not typed yet or is typing: either way the other rows' keys would hit the text.
+    if (ruleAt >= 0) {
+        const other = rows[rows.length - 1];
+        if (other.selected || !OTHER_LABEL.test(other.label))
+            return undefined;
+        rows.pop();
+    }
+    if (rows.some((r) => OTHER_LABEL.test(r.label) || CHAT_LABEL.test(r.label)))
+        return undefined;
+    const multi = rows.length > 0 && rows.every((r) => MULTI_LABEL.test(r.label));
+    // Submit sits after the free-text row, which the key positions count: no such row, no known layout.
+    if (submit && (!multi || ruleAt < 0))
+        return undefined;
+    const options = rows.map((r) => ({ n: r.n, label: withNote(r), selected: r.selected }));
+    if (submit)
+        options.push({ n: rows.length + 1, label: 'Submit', selected: submit.selected });
+    const chips = [...tabs.matchAll(TAB_CHIP)].filter((m) => m[1] !== '✔').map((m) => `${m[1]} ${m[2]}`);
+    const heading = texts.length > 0 ? texts[0].map((l) => l.trim()).join(' ') : undefined;
+    const summary = texts.length > 1 ? texts.slice(1).flat() : [];
+    // The review screen heads itself; a question is known by the header chips of its tab line.
+    const review = heading !== undefined && /^Review your answers$/i.test(heading);
+    return (0, blocked_prompt_js_1.assemble)({
+        region: live.slice(tabAt),
+        title: review ? heading : 'Claude is asking',
+        subtitle: chips.join(' · '),
+        detail: review ? summary.map((l) => l.replace(/^ /, '')) : [],
+        question,
+        options,
+        // The numbered rows, then a free-text row the options skip, then Submit.
+        keys: (from, to) => {
+            const pos = (i) => (submit && i === options.length - 1 && multi ? i + 1 : i);
+            const steps = pos(to) - pos(from);
+            return [...Array(Math.abs(steps)).fill(steps > 0 ? 'down' : 'up'), 'enter'];
+        },
+    });
+};
+exports.parseClaudeQuestion = parseClaudeQuestion;
+/** An ExitPlanMode dialog at the bottom of `pane`, or undefined. */
+const parseClaudePlan = (pane) => {
+    const lines = pane.split('\n').map((l) => l.trimEnd());
+    let end = lines.length;
+    while (end > 0 && blank(lines[end - 1]))
+        end--;
+    const live = lines.slice(0, end);
+    // The footer names the plan file, and wraps when the pane is narrow: `ctrl+g to edit in Nvim · ~/.claude/…md`.
+    const footerAt = lastIndex(live, (l) => PLAN_FOOTER.test(l));
+    if (footerAt < 0)
+        return undefined;
+    const footerText = live.slice(footerAt).map((l) => l.trim());
+    const afterDot = footerText[0].split('·').slice(1).join('·').trim();
+    const path = [afterDot, ...footerText.slice(1)].join('').trim();
+    const note = path.startsWith('~/') || path.startsWith('/') ? path : undefined;
+    // The question sits under the last full rule above the footer; a numbered plan above it is not the options.
+    const lastQ = lastIndex(live.slice(0, footerAt), (l) => FULL_RULE.test(l));
+    if (lastQ < 0)
+        return undefined;
+    const optionAt = live.findIndex((l, i) => i > lastQ && i < footerAt && OPTION.exec(l)?.[2] === '1');
+    if (optionAt < 0)
+        return undefined;
+    const question = live.slice(lastQ + 1, optionAt).filter((l) => !blank(l)).map((l) => l.trim()).join(' ');
+    if (!question.endsWith('?'))
+        return undefined;
+    const rows = [];
+    for (const line of live.slice(optionAt, footerAt)) {
+        if (blank(line) || PLAN_HINT.test(line.trim()))
+            continue;
+        const m = OPTION.exec(line);
+        if (m)
+            rows.push({ n: Number(m[2]), label: m[3].trim(), selected: m[1] === '❯', note: [] });
+        else if (rows.length > 0 && /^\s{3,}\S/.test(line))
+            rows[rows.length - 1].label += ` ${line.trim()}`;
+        else
+            return undefined;
+    }
+    const options = rows.filter((r) => !OWN_ANSWER.test(r.label)).map((r) => ({ n: r.n, label: r.label, selected: r.selected }));
+    // Above the question: rule, plan between two dashed rules, and above them the title and subtitle.
+    // The title opens the dialog, under a rule; the plan sits between two dashed rules. The closing one is missing
+    // when the viewport cut the plan: the rule above the question ends it then.
+    const titleAt = lastIndex(live.slice(0, lastQ), (l) => l.trim() === PLAN_TITLE);
+    if (titleAt < 1 || !FULL_RULE.test(live[titleAt - 1]))
+        return undefined;
+    const topRule = titleAt - 1;
+    const dashedStart = live.findIndex((l, i) => i > titleAt && i < lastQ && DASHED_RULE.test(l));
+    if (dashedStart < 0)
+        return undefined;
+    const closing = live.findIndex((l, i) => i > dashedStart && i < lastQ && DASHED_RULE.test(l));
+    const dashedEnd = closing < 0 ? lastQ : closing;
+    const head = live.slice(titleAt + 1, dashedStart).filter((l) => !blank(l)).map((l) => l.trim());
+    let plan = live.slice(dashedStart + 1, dashedEnd);
+    while (plan.length > 0 && blank(plan[plan.length - 1]))
+        plan.pop();
+    let more = false;
+    plan = plan.map((l) => {
+        if (SCROLL_MARK.test(l))
+            more = true;
+        return l.replace(SCROLL_MARK, '');
+    });
+    const prompt = (0, blocked_prompt_js_1.assemble)({
+        region: live.slice(topRule + 1),
+        title: PLAN_TITLE,
+        subtitle: head.join(' '),
+        detail: dedent(plan),
+        ...(note ? { note } : {}),
+        question,
+        options,
+    });
+    return prompt && more ? { ...prompt, detailTruncated: true } : prompt;
+};
+exports.parseClaudePlan = parseClaudePlan;

package/dist/blocked-prompt.d.ts

@@ -30,6 +30,24 @@ export interface ParsedPrompt {
 export declare const isPromptId: (value: unknown) => value is string;
 /** `pane` without terminal escapes: what `capture-pane` without `-e` gives. */
 export declare const stripEscapes: (pane: string) => string;
+/** The checks and caps every reader shares: numbering 1..n, one highlight, label and detail limits. */
+export declare const assemble: (d: {
+    region: readonly string[];
+    title: string;
+    subtitle?: string;
+    detail: readonly string[];
+    note?: string;
+    question: string;
+    options: readonly {
+        n: number;
+        label: string;
+        selected: boolean;
+    }[];
+    /** Keys from the highlighted option to option `to`; up/down by default. */
+    keys?: (from: number, to: number) => string[];
+    /** Folded into the id when the highlight is not in the region's text. */
+    idSalt?: string;
+}) => ParsedPrompt | undefined;
 /** The approval dialog at the bottom of `pane`, read the way `kind` draws it; undefined when it is not one of those. */
 export declare const parseBlockedDialog: (pane: string, kind: AgentKind) => ParsedPrompt | undefined;
 /** True when some reader finds the prompt `id` on `pane`: an id hashes the exact dialog, so the kind need not be known. */

package/dist/blocked-prompt.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptPlaintext = exports.showsPrompt = exports.parseBlockedDialog = exports.stripEscapes = exports.isPromptId = exports.MAX_PROMPT_BYTES = exports.MAX_OPTIONS = exports.MAX_LABEL_CHARS = exports.MAX_DETAIL_LINE_CHARS = exports.MAX_DETAIL_LINES = exports.KNOWN_TITLES = void 0;
+exports.promptPlaintext = exports.showsPrompt = exports.parseBlockedDialog = exports.assemble = exports.stripEscapes = exports.isPromptId = exports.MAX_PROMPT_BYTES = exports.MAX_OPTIONS = exports.MAX_LABEL_CHARS = exports.MAX_DETAIL_LINE_CHARS = exports.MAX_DETAIL_LINES = exports.KNOWN_TITLES = void 0;
 /**
  * What a blocked agent session is waiting for, read off its screen.
  *
@@ -49,8 +49,13 @@ exports.promptPlaintext = exports.showsPrompt = exports.parseBlockedDialog = exp
  * row of buttons whose chosen one is told apart by background colour only (`parseOpencodePermission`). Its question
  * tool (v2.1.2) draws a `Questions` panel whose highlighted answer differs by the colour of its number
  * (`parseOpencodeQuestion`).
+ *
+ * Codex (codex-cli 0.166.0, `blocked-prompt-codex.test.ts`): a question, the reason or the destination and the
+ * `$ command`, numbered answers with `›` on the highlighted one and a `Press enter to confirm` footer
+ * (`parseCodexDialog`). Answered with up/down and enter like the rest: that lands on "No" the way esc does.
  */
 const node_crypto_1 = require("node:crypto");
+const blocked_prompt_claude_dialogs_js_1 = require("./blocked-prompt-claude-dialogs.js");
 /** Dialog titles whose layout was captured and is read. */
 exports.KNOWN_TITLES = ['Bash command', 'Edit file', 'Create file'];
 exports.MAX_DETAIL_LINES = 12;
@@ -69,7 +74,7 @@ const OPTION = /^\s*([❯>])?\s*(\d{1,2})\.\s+(\S.*)$/;
 const FOOTER = /^\s*(esc to cancel|enter to select)/i;
 // A choice that grants more than this one request: "don't ask again", "always allow", "allow all edits during this
 // session", "… for this session". Wider on purpose — a miss lets the app skip its extra confirmation.
-const PERSISTENT = /don.?t ask again|never ask|always|allow all|this session|from now on/i;
+const PERSISTENT = /don.?t ask again|never ask|always|allow all|this session|from now on|auto mode/i;
 /** The character the highlight is drawn with. A pane without it is not a dialog this module can answer. */
 const HIGHLIGHT = '❯';
 const cut = (text, max) => {
@@ -151,7 +156,7 @@ const parseClaudeDialog = (pane) => {
     while (detailLines.length > 0 && detailLines[detailLines.length - 1].trim() === '')
         detailLines.pop();
     const after = secondDash < 0 ? [] : rest.slice(secondDash + 1).map((l) => l.trim()).filter(Boolean);
-    return assemble({
+    return (0, exports.assemble)({
         region,
         title,
         subtitle: before.join(' '),
@@ -161,6 +166,77 @@ const parseClaudeDialog = (pane) => {
         options,
     });
 };
+const CODEX_FOOTER = /^\s*Press enter to confirm or esc to cancel$/;
+const CODEX_QUESTION = /^\s*(Would you like to (?:run the following command|make the following edits)\?)$/;
+const CODEX_OPTION = /^\s*(›)?\s*(\d{1,2})\.\s+(\S.*)$/;
+const CODEX_META = /^\s*(Environment|Reason|Description|Destination):\s*(.*)$/;
+/**
+ * Codex's tool approval (codex-cli 0.166.0): the question, `Reason:`/`Description:`/`Destination:` lines and the
+ * `$ command`, numbered answers with `›` on the highlighted one, then `Press enter to confirm or esc to cancel`. The
+ * dialog replaces the composer; the turn's history stays above it. Only the two questions captured are read.
+ */
+const parseCodexDialog = (pane) => {
+    const lines = pane.split('\n').map((l) => l.trimEnd());
+    let footer = lines.length - 1;
+    while (footer >= 0 && lines[footer].trim() === '')
+        footer--;
+    if (footer < 0 || !CODEX_FOOTER.test(lines[footer]))
+        return undefined;
+    let first = -1;
+    for (let i = footer - 1; i >= 0; i--) {
+        const m = CODEX_OPTION.exec(lines[i]);
+        if (m && m[2] === '1') {
+            first = i;
+            break;
+        }
+    }
+    if (first < 0)
+        return undefined;
+    const options = [];
+    for (const line of lines.slice(first, footer)) {
+        if (line.trim() === '')
+            continue;
+        const m = CODEX_OPTION.exec(line);
+        if (m) {
+            options.push({ n: Number(m[2]), label: m[3].trim(), selected: m[1] === '›' });
+        }
+        else if (/^\s{4,}\S/.test(line)) {
+            options[options.length - 1].label += ` ${line.trim()}`;
+        }
+        else {
+            return undefined;
+        }
+    }
+    let q = -1;
+    for (let i = first - 1; i >= Math.max(0, first - exports.MAX_DETAIL_LINES - 6); i--) {
+        if (CODEX_QUESTION.test(lines[i])) {
+            q = i;
+            break;
+        }
+    }
+    if (q < 0)
+        return undefined;
+    const question = CODEX_QUESTION.exec(lines[q])[1];
+    const detail = [];
+    let note = '';
+    for (const line of lines.slice(q + 1, first)) {
+        const meta = CODEX_META.exec(line);
+        if (meta?.[1] === 'Reason')
+            note = meta[2].trim();
+        else if (meta?.[1] === 'Environment')
+            continue;
+        else if (line.trim() !== '')
+            detail.push(line.trim());
+    }
+    return (0, exports.assemble)({
+        region: lines.slice(q, footer + 1),
+        title: question.includes('command') ? 'Run command' : 'Edit files',
+        detail,
+        note,
+        question,
+        options,
+    });
+};
 // CSI sequences (colours and the rest) and OSC ones (OSC 8 hyperlinks, ended by BEL or ST): what `-e` adds.
 const ESCAPES = /\u001b\[[0-?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g;
 /** `pane` without terminal escapes: what `capture-pane` without `-e` gives. */
@@ -267,7 +343,7 @@ const parseGeminiDialog = (pane) => {
             noteLines.push(text.trim());
     }
     const detail = dedent(trimBlank(detailLines));
-    return assemble({
+    return (0, exports.assemble)({
         region: lines.slice(top, end + 1),
         title: title.trim(),
         subtitle,
@@ -329,7 +405,7 @@ const parsePiSelect = (pane) => {
     const text = trimBlank(lines.slice(top + 1, first).map((l) => l.replace(/^ /, '')));
     if (text.length === 0)
         return undefined;
-    return assemble({
+    return (0, exports.assemble)({
         region: lines.slice(top, footer + 1),
         title: text[0].trim(),
         detail: dedent(trimBlank(text.slice(1, -1))),
@@ -400,7 +476,7 @@ const parsePiQuestion = (pane) => {
     if (asked === '')
         return undefined;
     const context = gap < 0 ? [] : trimBlank(text.slice(gap + 1)).map((l) => l.trim()).filter((l) => l !== '');
-    const prompt = assemble({
+    const prompt = (0, exports.assemble)({
         region: lines.slice(top, footer + 1),
         title: asked,
         detail: [...context, ...options.filter((o) => o.note !== undefined && o.n !== own).map((o) => `${o.label}: ${o.note}`)],
@@ -529,7 +605,7 @@ const parseOpencodePermission = (rows) => {
     const first = body.findIndex((l) => l.trim() !== '');
     const sub = first < 0 ? null : OPENCODE_SUBTITLE.exec(body[first].trim());
     const detail = dedent(trimBlank(sub ? body.slice(first + 1) : body));
-    return assemble({
+    return (0, exports.assemble)({
         region: rows.slice(head, bar + 1).map((r) => r.text.trimEnd()),
         title: 'Permission required',
         ...(sub ? { subtitle: sub[1].trim() } : {}),
@@ -595,7 +671,7 @@ const parseOpencodeQuestion = (rows) => {
     const asked = trimBlank(question).join(' ').trim();
     if (asked === '')
         return undefined;
-    const prompt = assemble({
+    const prompt = (0, exports.assemble)({
         region: rows.slice(head, footer + 1).map((r) => r.text.trimEnd()),
         title: 'Question',
         detail: options.filter((o) => o.note !== undefined && o.label !== OPENCODE_OWN_ANSWER).map((o) => `${o.label}: ${o.note}`),
@@ -637,14 +713,19 @@ const assemble = (d) => {
     }
     return prompt;
 };
+exports.assemble = assemble;
 /** One reader per agent kind whose approval dialog was captured. Each takes the pane as captured, escapes and all. */
 const READERS = {
-    claude: (pane) => parseClaudeDialog((0, exports.stripEscapes)(pane)),
+    claude: (pane) => {
+        const plain = (0, exports.stripEscapes)(pane);
+        return parseClaudeDialog(plain) ?? (0, blocked_prompt_claude_dialogs_js_1.parseClaudeQuestion)(plain) ?? (0, blocked_prompt_claude_dialogs_js_1.parseClaudePlan)(plain);
+    },
     gemini: (pane) => parseGeminiDialog((0, exports.stripEscapes)(pane)),
     pi: (pane) => {
         const plain = (0, exports.stripEscapes)(pane);
         return parsePiSelect(plain) ?? parsePiQuestion(plain);
     },
+    codex: (pane) => parseCodexDialog((0, exports.stripEscapes)(pane)),
     opencode: (pane) => {
         const rows = pane.split('\n').map(withColours);
         return parseOpencodePermission(rows) ?? parseOpencodeQuestion(rows);

package/dist/device-presence.d.ts

@@ -1,3 +1,9 @@
+/**
+ * This build reads `fresh` on a resume request (`listener.ts` `handleSessionResumeRequest`): the phone may start a new
+ * session in a recorded session's project. An older listener would resume the recorded conversation instead, so the apps
+ * offer it only to a computer that lists this.
+ */
+export declare const SESSION_START_CAPABILITY = "session-start-v1";
 /** The one message both halves of presence ride; the server answers
  *  `listener.presence.ack` or `listener.presence.error`. */
 export declare const LISTENER_PRESENCE = "listener.presence";

package/dist/device-presence.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDeviceKeyRegistration = exports.LISTENER_PRESENCE = void 0;
+exports.createDeviceKeyRegistration = exports.LISTENER_PRESENCE = exports.SESSION_START_CAPABILITY = void 0;
 /**
  * Per-device E2E (ADR-0007) — put this machine's public key on its device
  * record, so other devices can wrap pushes and files for it.
@@ -28,13 +28,20 @@ exports.createDeviceKeyRegistration = exports.LISTENER_PRESENCE = void 0;
  * a file in chunks only for a device that lists `file-chunk-v1`, and one over
  * the relay's ceiling over LAN only to one that lists `lan-large-v1`; an app
  * offers `once` schedules and schedules into a session only to one that lists
- * `schedule-session-v1`. In one frame
+ * `schedule-session-v1`, and a new session in a project only to one that
+ * lists `session-start-v1`. In one frame
  * with the key, because a server from before `capabilities` answers a frame
  * that carries nothing else it knows with an error.
  */
 const file_crypto_js_1 = require("./file-crypto.js");
 const lan_receiver_js_1 = require("./lan-receiver.js");
 const schedule_js_1 = require("./schedule.js");
+/**
+ * This build reads `fresh` on a resume request (`listener.ts` `handleSessionResumeRequest`): the phone may start a new
+ * session in a recorded session's project. An older listener would resume the recorded conversation instead, so the apps
+ * offer it only to a computer that lists this.
+ */
+exports.SESSION_START_CAPABILITY = 'session-start-v1';
 /** The one message both halves of presence ride; the server answers
  *  `listener.presence.ack` or `listener.presence.error`. */
 exports.LISTENER_PRESENCE = 'listener.presence';
@@ -45,7 +52,7 @@ const createDeviceKeyRegistration = (deps) => {
     const register = async () => {
         try {
             const publicKey = await deps.publicKey();
-            const sent = deps.send({ type: exports.LISTENER_PRESENCE, data: { publicKey, capabilities: [file_crypto_js_1.FILE_CHUNK_CAPABILITY, lan_receiver_js_1.LAN_LARGE_CAPABILITY, schedule_js_1.SCHEDULE_SESSION_CAPABILITY] } });
+            const sent = deps.send({ type: exports.LISTENER_PRESENCE, data: { publicKey, capabilities: [file_crypto_js_1.FILE_CHUNK_CAPABILITY, lan_receiver_js_1.LAN_LARGE_CAPABILITY, schedule_js_1.SCHEDULE_SESSION_CAPABILITY, exports.SESSION_START_CAPABILITY] } });
             if (!sent)
                 deps.log('device key: not registered — no connection right now, retried at the next open');
             return sent;

package/dist/hermes-transcript.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Hermes' session store, read into the events the timeline draws.
+ *
+ * Hermes keeps no transcript file: every conversation is rows of `messages` in
+ * `~/.hermes/state.db` (SQLite). Like opencode's, the row behind this agent
+ * carries a reader of its own (`readHermesTranscript`, a `TranscriptReader`)
+ * and a projector for what it hands back (`projectHermesEntries`).
+ *
+ * Shape measured 2026-11-01 against hermes 0.20.0 (schema_version 25), with
+ * `.schema` and the writer, `hermes_state.py`:
+ *
+ *  - `messages(id INTEGER AUTOINCREMENT, session_id, role, content,
+ *    tool_call_id, tool_calls, tool_name, timestamp REAL, active, compacted, …)`.
+ *    `timestamp` is **seconds** since the epoch, as a REAL.
+ *  - Rows are inserted once and never rewritten (the only UPDATEs touch
+ *    `display_*` and flip `active`/`compacted` when a conversation is rewound or
+ *    compressed), so `id` is a safe cursor: a row read is final.
+ *  - `role` is `user` · `assistant` · `tool`. An assistant row that calls tools
+ *    has `tool_calls`, a JSON array of `{ id, type: "function", function: {
+ *    name, arguments } }` where `arguments` is itself a JSON **string**; each
+ *    call is answered by a `tool` row whose `tool_call_id` is that `id`.
+ *
+ * Only rows with `active = 1` are drawn — a rewound turn is not part of the
+ * conversation any more.
+ */
+import { type TailRead, type TailState, type TranscriptProjector } from './transcript-tail.js';
+/**
+ * A Hermes session id (`<YYYYMMDD>_<HHMMSS>_<hash>`, measured). The query has
+ * nowhere to bind a parameter (`sqliteJson` runs the `sqlite3` binary), so an
+ * id goes into the SQL text only after it passes this.
+ */
+export declare const HERMES_SESSION_ID: RegExp;
+/** The transcript "path" a Hermes pane resolves to: the store and the session in one string. */
+export declare const hermesSourcePath: (db: string, sessionId: string) => string;
+/** One tool call of an assistant row, reduced in SQL to the fields drawn. */
+export interface HermesTool {
+    id?: string | null;
+    name?: string | null;
+    target?: string | null;
+}
+/** One `messages` row as the query below returns it. */
+export interface HermesRow {
+    id: number;
+    role: string;
+    /** Seconds since the epoch. */
+    ts?: number | null;
+    text?: string | null;
+    /** Assistant rows: the calls, as a JSON array (string) or already parsed. */
+    tools?: HermesTool[] | string | null;
+    /** `tool` rows: the id of the call answered. */
+    callId?: string | null;
+    /** `tool` rows: line count of the output. */
+    lines?: number | null;
+}
+/** Rows read on the first look at a session. */
+export declare const HERMES_BACKFILL_ROWS = 200;
+/** Rows read per look after that. */
+export declare const HERMES_ROWS_PER_READ = 500;
+/** The fewest milliseconds between two queries for one session. */
+export declare const HERMES_MIN_QUERY_MS = 1000;
+/**
+ * The rows of one session from message id `from` on, or its last
+ * `HERMES_BACKFILL_ROWS` when `from` is null. Read-only; exported for the test
+ * that pins the id check.
+ */
+export declare const hermesRowsSql: (sessionId: string, from: number | null) => string;
+/** Rows → one JSON event per line (what the projector reads back), in row order. */
+export declare const hermesLinesOf: (rows: readonly HermesRow[]) => string[];
+export interface HermesReadDeps {
+    /** Rows of a SQLite file, null when the read failed (`sqliteJson`). */
+    query: (db: string, sql: string) => unknown[] | null;
+    /** The store's files, size and mtime — any write shows up in one of them. */
+    stamp?: (db: string) => string | null;
+    now?: () => number;
+}
+/**
+ * What was added to one Hermes session since `prev`, or null when nothing was —
+ * the store's files have not moved, the last query was under
+ * `HERMES_MIN_QUERY_MS` ago, or the store cannot be read. The WAL moves on every
+ * write by every session on the machine, so the time floor is what keeps a busy
+ * neighbour from turning a 500 ms poll into a `sqlite3` spawn per tick.
+ */
+export declare const readHermesTranscript: (path: string, prev: TailState | null, deps: HermesReadDeps) => TailRead | null;
+/** The reader's lines back into events; names what the reader marked unknown. */
+export declare const projectHermesEntries: TranscriptProjector;
+//# sourceMappingURL=hermes-transcript.d.ts.map

package/dist/hermes-transcript.js

@@ -0,0 +1,262 @@
+"use strict";
+/**
+ * Hermes' session store, read into the events the timeline draws.
+ *
+ * Hermes keeps no transcript file: every conversation is rows of `messages` in
+ * `~/.hermes/state.db` (SQLite). Like opencode's, the row behind this agent
+ * carries a reader of its own (`readHermesTranscript`, a `TranscriptReader`)
+ * and a projector for what it hands back (`projectHermesEntries`).
+ *
+ * Shape measured 2026-11-01 against hermes 0.20.0 (schema_version 25), with
+ * `.schema` and the writer, `hermes_state.py`:
+ *
+ *  - `messages(id INTEGER AUTOINCREMENT, session_id, role, content,
+ *    tool_call_id, tool_calls, tool_name, timestamp REAL, active, compacted, …)`.
+ *    `timestamp` is **seconds** since the epoch, as a REAL.
+ *  - Rows are inserted once and never rewritten (the only UPDATEs touch
+ *    `display_*` and flip `active`/`compacted` when a conversation is rewound or
+ *    compressed), so `id` is a safe cursor: a row read is final.
+ *  - `role` is `user` · `assistant` · `tool`. An assistant row that calls tools
+ *    has `tool_calls`, a JSON array of `{ id, type: "function", function: {
+ *    name, arguments } }` where `arguments` is itself a JSON **string**; each
+ *    call is answered by a `tool` row whose `tool_call_id` is that `id`.
+ *
+ * Only rows with `active = 1` are drawn — a rewound turn is not part of the
+ * conversation any more.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectHermesEntries = exports.readHermesTranscript = exports.hermesLinesOf = exports.hermesRowsSql = exports.HERMES_MIN_QUERY_MS = exports.HERMES_ROWS_PER_READ = exports.HERMES_BACKFILL_ROWS = exports.hermesSourcePath = exports.HERMES_SESSION_ID = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const transcript_tail_js_1 = require("./transcript-tail.js");
+/**
+ * A Hermes session id (`<YYYYMMDD>_<HHMMSS>_<hash>`, measured). The query has
+ * nowhere to bind a parameter (`sqliteJson` runs the `sqlite3` binary), so an
+ * id goes into the SQL text only after it passes this.
+ */
+exports.HERMES_SESSION_ID = /^[A-Za-z0-9_-]{1,96}$/;
+/** The transcript "path" a Hermes pane resolves to: the store and the session in one string. */
+const hermesSourcePath = (db, sessionId) => `${db}#${sessionId}`;
+exports.hermesSourcePath = hermesSourcePath;
+const parseSourcePath = (path) => {
+    const at = path.lastIndexOf('#');
+    if (at <= 0)
+        return null;
+    const sessionId = path.slice(at + 1);
+    const db = path.slice(0, at);
+    // The path also comes back from the recorder's state file and goes to `sqlite3` as an argument:
+    // a relative one could start with `-` and read as an option.
+    return exports.HERMES_SESSION_ID.test(sessionId) && (0, node_path_1.isAbsolute)(db) ? { db, sessionId } : null;
+};
+const isRow = (value) => {
+    if (!value || typeof value !== 'object')
+        return false;
+    const row = value;
+    return typeof row.id === 'number' && Number.isSafeInteger(row.id) && typeof row.role === 'string';
+};
+/** Rows read on the first look at a session. */
+exports.HERMES_BACKFILL_ROWS = 200;
+/** Rows read per look after that. */
+exports.HERMES_ROWS_PER_READ = 500;
+/** The fewest milliseconds between two queries for one session. */
+exports.HERMES_MIN_QUERY_MS = 1_000;
+/**
+ * Which tool argument reads as "what this call is about", first match wins.
+ * `command` and `cmd` are absent on purpose: a command line is the argument
+ * most likely to carry a secret.
+ */
+const TARGET_KEYS = ['path', 'file_path', 'pattern', 'query', 'url', 'image_url', 'name'];
+const SQL_TEXT_CHARS = transcript_tail_js_1.MAX_EVENT_TEXT_CHARS + 1;
+/**
+ * The rows of one session from message id `from` on, or its last
+ * `HERMES_BACKFILL_ROWS` when `from` is null. Read-only; exported for the test
+ * that pins the id check.
+ */
+const hermesRowsSql = (sessionId, from) => {
+    if (!exports.HERMES_SESSION_ID.test(sessionId))
+        throw new Error('not a hermes session id');
+    if (from !== null && !Number.isSafeInteger(from))
+        throw new Error('not a row position');
+    const args = `json_extract(c.value, '$.function.arguments')`;
+    const arg = (key) => `CASE WHEN json_valid(${args}) THEN json_extract(${args}, '$.${key}') END`;
+    const target = `substr(coalesce(${TARGET_KEYS.map(arg).join(', ')}), 1, ${transcript_tail_js_1.MAX_EVENT_FIELD_CHARS + 1})`;
+    const tools = `CASE WHEN m.role = 'assistant' AND m.tool_calls IS NOT NULL AND json_valid(m.tool_calls)
+        THEN (SELECT json_group_array(json_object('id', coalesce(json_extract(c.value, '$.id'), json_extract(c.value, '$.call_id')),
+            'name', json_extract(c.value, '$.function.name'), 'target', ${target}))
+            FROM json_each(m.tool_calls) c) END`;
+    const select = `SELECT m.id AS id, m.role AS role, m.timestamp AS ts,
+        CASE WHEN m.role IN ('user', 'assistant') THEN substr(m.content, 1, ${SQL_TEXT_CHARS}) END AS text,
+        ${tools} AS tools,
+        CASE WHEN m.role = 'tool' THEN m.tool_call_id END AS callId,
+        CASE WHEN m.role = 'tool' THEN length(m.content) - length(replace(m.content, char(10), '')) + 1 END AS lines
+        FROM messages m
+        WHERE m.session_id = '${sessionId}' AND m.role IN ('user', 'assistant', 'tool') AND coalesce(m.active, 1) = 1`;
+    return from === null
+        ? `SELECT * FROM (${select} ORDER BY m.id DESC LIMIT ${exports.HERMES_BACKFILL_ROWS}) ORDER BY id`
+        : `${select} AND m.id >= ${from} ORDER BY m.id LIMIT ${exports.HERMES_ROWS_PER_READ}`;
+};
+exports.hermesRowsSql = hermesRowsSql;
+const isoOfSeconds = (seconds) => {
+    if (typeof seconds !== 'number' || !Number.isFinite(seconds))
+        return {};
+    const date = new Date(seconds * 1000);
+    return Number.isNaN(date.getTime()) ? {} : { at: date.toISOString() };
+};
+const toolsOf = (row) => {
+    if (row.tools === undefined || row.tools === null)
+        return [];
+    let parsed = row.tools;
+    if (typeof parsed === 'string') {
+        try {
+            parsed = JSON.parse(parsed);
+        }
+        catch {
+            return null;
+        }
+    }
+    return Array.isArray(parsed) ? parsed : null;
+};
+const num = (value) => (typeof value === 'number' && Number.isFinite(value) ? value : 0);
+const unknownLine = (what) => JSON.stringify({ unknown: what });
+/** Rows → one JSON event per line (what the projector reads back), in row order. */
+const hermesLinesOf = (rows) => {
+    const lines = [];
+    const warned = new Set();
+    const once = (key, what) => {
+        if (warned.has(key))
+            return;
+        warned.add(key);
+        lines.push(unknownLine(what));
+    };
+    for (const row of rows) {
+        const at = isoOfSeconds(row.ts);
+        if (row.role === 'user') {
+            const text = (typeof row.text === 'string' ? row.text : '').trim();
+            if (text)
+                lines.push(JSON.stringify({ kind: 'prompt', text: (0, transcript_tail_js_1.clamp)(text, transcript_tail_js_1.MAX_EVENT_TEXT_CHARS), ...at }));
+            continue;
+        }
+        if (row.role === 'assistant') {
+            const text = (typeof row.text === 'string' ? row.text : '').trim();
+            if (text)
+                lines.push(JSON.stringify({ kind: 'text', text: (0, transcript_tail_js_1.clamp)(text, transcript_tail_js_1.MAX_EVENT_TEXT_CHARS), ...at }));
+            const tools = toolsOf(row);
+            if (tools === null)
+                once(`${row.id}:x`, 'hermes tool_calls that are not a list');
+            for (const tool of tools ?? []) {
+                if (!tool || typeof tool !== 'object' || typeof tool.id !== 'string' || typeof tool.name !== 'string') {
+                    once(`${row.id}:x`, 'hermes tool call without an id or name');
+                    continue;
+                }
+                const line = (0, transcript_tail_js_1.oneLine)(typeof tool.target === 'string' ? tool.target : undefined);
+                const target = line ? (0, transcript_tail_js_1.clamp)(line) : undefined;
+                lines.push(JSON.stringify({ kind: 'tool', id: (0, transcript_tail_js_1.clamp)(tool.id), name: (0, transcript_tail_js_1.clamp)(tool.name), ...(target ? { target } : {}), ...at }));
+            }
+            continue;
+        }
+        if (row.role === 'tool') {
+            if (typeof row.callId !== 'string' || !row.callId) {
+                once(`${row.id}:x`, 'hermes tool result without a call id');
+                continue;
+            }
+            const count = num(row.lines);
+            lines.push(JSON.stringify({ kind: 'tool_result', id: (0, transcript_tail_js_1.clamp)(row.callId), ok: true, ...(count ? { lines: count } : {}), ...at }));
+        }
+    }
+    return lines;
+};
+exports.hermesLinesOf = hermesLinesOf;
+const cursorOf = (prev, session) => {
+    const c = prev?.cursor;
+    if (!c || typeof c !== 'object')
+        return null;
+    const { session: s, from, stamp, queriedAt } = c;
+    if (s !== session || typeof from !== 'number' || !Number.isSafeInteger(from))
+        return null;
+    if (typeof stamp !== 'string' || typeof queriedAt !== 'number')
+        return null;
+    return { session, from, stamp, queriedAt };
+};
+/** When a query last failed, per source path — so an unreadable store is not asked on every tick. */
+const failedAt = new Map();
+const fileStamp = (db) => {
+    const parts = [];
+    for (const path of [db, `${db}-wal`]) {
+        try {
+            const s = (0, node_fs_1.statSync)(path);
+            parts.push(`${s.size}:${s.mtimeMs}`);
+        }
+        catch {
+            parts.push('-');
+        }
+    }
+    return parts[0] === '-' ? null : parts.join('|');
+};
+/**
+ * What was added to one Hermes session since `prev`, or null when nothing was —
+ * the store's files have not moved, the last query was under
+ * `HERMES_MIN_QUERY_MS` ago, or the store cannot be read. The WAL moves on every
+ * write by every session on the machine, so the time floor is what keeps a busy
+ * neighbour from turning a 500 ms poll into a `sqlite3` spawn per tick.
+ */
+const readHermesTranscript = (path, prev, deps) => {
+    const source = parseSourcePath(path);
+    if (!source)
+        return null;
+    const now = deps.now ?? Date.now;
+    const stamp = (deps.stamp ?? fileStamp)(source.db);
+    if (stamp === null)
+        return null;
+    const cursor = cursorOf(prev, source.sessionId);
+    if (cursor && cursor.stamp === stamp)
+        return null;
+    const last = Math.max(cursor?.queriedAt ?? -Infinity, failedAt.get(path) ?? -Infinity);
+    if (now() - last < exports.HERMES_MIN_QUERY_MS)
+        return null;
+    const raw = deps.query(source.db, (0, exports.hermesRowsSql)(source.sessionId, cursor ? cursor.from : null));
+    if (raw === null) {
+        failedAt.set(path, now());
+        return null;
+    }
+    failedAt.delete(path);
+    const rows = raw.filter(isRow);
+    const newest = rows.reduce((max, r) => Math.max(max, r.id), cursor ? cursor.from - 1 : 0);
+    const state = {
+        offset: newest,
+        // `agent read` says there is more above when the read was a window.
+        size: !cursor && rows.length >= exports.HERMES_BACKFILL_ROWS ? transcript_tail_js_1.TRANSCRIPT_BACKFILL_BYTES + 1 : 0,
+        mtimeMs: 0,
+        ino: 0,
+        carry: '',
+        resyncing: false,
+        salvage: [],
+        cursor: { session: source.sessionId, from: newest + 1, stamp, queriedAt: now() },
+    };
+    return { lines: (0, exports.hermesLinesOf)(rows), state, bytesRead: 0, droppedLines: 0 };
+};
+exports.readHermesTranscript = readHermesTranscript;
+const EVENT_KINDS = new Set(['prompt', 'text', 'tool', 'tool_result']);
+/** The reader's lines back into events; names what the reader marked unknown. */
+const projectHermesEntries = (lines, opts = {}) => {
+    const events = [];
+    for (const raw of lines) {
+        let entry;
+        try {
+            const parsed = JSON.parse(raw);
+            if (!parsed || typeof parsed !== 'object')
+                continue;
+            entry = parsed;
+        }
+        catch {
+            continue;
+        }
+        if (typeof entry.unknown === 'string') {
+            opts.onUnknown?.(entry.unknown);
+            continue;
+        }
+        if (typeof entry.kind === 'string' && EVENT_KINDS.has(entry.kind))
+            events.push(entry);
+    }
+    return (0, transcript_tail_js_1.sliceSinceLastPrompt)(events, opts);
+};
+exports.projectHermesEntries = projectHermesEntries;

package/dist/listener.d.ts

@@ -551,6 +551,12 @@ export interface SessionResumeRequest {
      * it reads as a run id.
      */
     runId?: string;
+    /**
+     * A new session in that session's project, not the session again (hwip docs/session-runs.md Q47): the recorded
+     * directory and agent, no conversation picked up, and beside the name when it runs. Read only when it is `true`.
+     * Advertised as `SESSION_START_CAPABILITY` (`device-presence.ts`) — an older listener would resume the recorded conversation instead.
+     */
+    fresh?: boolean;
     requestId?: string;
 }
 export interface SessionResumeResult {

package/dist/listener.js

@@ -369,6 +369,12 @@ const RATE_LIMIT_TOKENS = 120;
 const RATE_LIMIT_WINDOW_MS = 60_000;
 /** What one command submit costs, keeping its ceiling at the old 30/min. */
 const SUBMIT_COST = 4;
+/**
+ * What a fresh start costs on its family's own bucket (`start:<family base>`): three new agents a minute. Each one is a
+ * process left running, and every name of the family leads to the same bucket, so a session budget of 30 a minute
+ * cannot fill the family's 20 names in one burst.
+ */
+const FRESH_START_COST = RATE_LIMIT_TOKENS / 3;
 // Shells are refused: a shell prompt + send-keys = arbitrary command exec.
 const SHELL_COMMANDS = new Set(['bash', 'zsh', 'fish', 'sh', 'dash', 'ksh', 'tcsh', 'csh', 'pwsh']);
 // Auth-failure close codes: retrying with the same bad credentials hammers
@@ -1546,13 +1552,16 @@ const handleSessionResumeRequest = (req, send) => {
     // the family `hwip cc` would pick (Q41), counted from the family base so a
     // busy `<base>-2` leads to `<base>-3`. A request without a run id is an
     // older app that only knows the name, and still gets the refusal it renders.
+    // A fresh start asks for a new session, so a live name is no refusal either, and no conversation is picked up —
+    // the live one holding the recorded conversation included.
+    const fresh = req.fresh === true;
     const live = new Set((0, tmux_liveness_js_1.liveSessionNames)() ?? []);
     const target = !live.has(sessionName)
         ? sessionName
-        : runId !== undefined
+        : runId !== undefined || fresh
             ? (0, wrapper_js_1.familyNames)(familyBase(sessionName)).find((name) => !live.has(name))
             : undefined;
-    if (!target || conversationRunning(known, live))
+    if (!target || (!fresh && conversationRunning(known, live)))
         return reply({ error: 'already_running' });
     if (!(0, session_registry_js_1.sessionDirectoryExists)(known)) {
         (0, listener_log_js_1.log)(`✗ resume ${sessionName}: ${known.cwd} is gone`);
@@ -1563,6 +1572,11 @@ const handleSessionResumeRequest = (req, send) => {
         (0, listener_log_js_1.log)(`✗ resume ${sessionName}: no binary for agent kind ${known.agentKind}`);
         return reply({ error: 'unknown_agent' });
     }
+    // A fresh start leaves one more process running each time, so the family pays on a bucket of its own as well —
+    // charged only here, where it starts one: a refusal above says why, not that the budget ran out.
+    if (fresh && !(0, exports.checkRateLimit)(`start:${familyBase(sessionName)}`, undefined, FRESH_START_COST)) {
+        return reply({ error: 'rate_limited' });
+    }
     // argv, never a shell string: the binary comes from the agent table and the
     // directory from our own record, and neither is concatenated into anything
     // a shell would re-parse. A recorded label means the session carried
@@ -1572,7 +1586,7 @@ const handleSessionResumeRequest = (req, send) => {
     const sidecar = known.label && known.project
         ? [';', 'set-option', config_js_1.SESSION_PROJECT_OPTION, known.project, ';', 'set-option', config_js_1.SESSION_LABEL_OPTION, known.label]
         : [];
-    const conversation = resumableConversation(agent, known);
+    const conversation = fresh ? null : resumableConversation(agent, known);
     // tmux gives the new pane this client's PATH. A login service's PATH has none
     // of the agent directories, so they go on as schedule launches add them —
     // otherwise the agent is not found and the session ends as it starts.
@@ -1583,7 +1597,7 @@ const handleSessionResumeRequest = (req, send) => {
     }
     const resumedFrom = conversation ? ` (conversation ${conversation.id.slice(0, 8)})` : '';
     const beside = target === sessionName ? '' : ` as ${target}`;
-    (0, listener_log_js_1.log)(`⟲ resume ${sessionName}${beside}: ${agent.binary}${resumedFrom} in ${known.cwd}`);
+    (0, listener_log_js_1.log)(`${fresh ? '＋ start' : '⟲ resume'} ${sessionName}${beside}: ${agent.binary}${resumedFrom} in ${known.cwd}`);
     return reply({ resumed: true, sessionName: target });
 };
 exports.handleSessionResumeRequest = handleSessionResumeRequest;

package/dist/remote-agents.d.ts

@@ -323,6 +323,8 @@ export declare const detectHermesSessionName: (paneCwd: string, panePid?: number
  * A `-c` picks back up a session started long before the pane, which the start-time match above cannot see.
  */
 export declare const detectHermesResumeId: (paneCwd: string, panePid?: number, deps?: StoreResolveDeps) => string | null;
+/** The store and the pane's session in one string, as opencode's. Null until the session has a message. */
+export declare const hermesTranscriptPath: (paneCwd: string | null, panePid?: number, deps?: StoreResolveDeps) => string | null;
 /**
  * The highest-numbered match, numerically. Codex versions its state file
  * (`state_5.sqlite` today) and moves to the next number on a schema migration,
@@ -413,6 +415,9 @@ declare const REMOTE_AGENT_TABLE: readonly [{
     readonly subcommands: readonly ["hermes"];
     readonly resolveSessionName: (paneCwd: string, panePid?: number, deps?: StoreResolveDeps) => ProviderName | null;
     readonly resolveResumeId: (paneCwd: string, panePid?: number, deps?: StoreResolveDeps) => string | null;
+    readonly resolveTranscript: (paneCwd: string, panePid: number | undefined) => string | null;
+    readonly projectTranscript: TranscriptProjector;
+    readonly readTranscript: (path: string, prev: import("./transcript-tail.js").TailState | null) => import("./transcript-tail.js").TailRead | null;
     readonly resumeArgs: (id: string) => string[];
 }, {
     readonly kind: "pi";

package/dist/remote-agents.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.matchAgentByPaneCommand = exports.findAgentBySubcommand = exports.REMOTE_AGENTS = exports.opencodeTranscriptPath = exports.detectOpencodeSession = exports.geminiTranscriptPath = exports.codexTranscriptPath = exports.detectCodexSessionName = exports.newestVersionedDb = exports.detectHermesResumeId = exports.detectHermesSessionName = exports.sqliteJson = exports.transcriptIdSince = exports.paneSince = exports.pickRowByProcStart = exports.detectPiSessionName = exports.piTranscriptPath = exports.claudeTranscriptPath = exports.detectClaudeSessionHandle = exports.detectClaudeProviderName = exports.detectClaudeSessionIdByPid = exports.detectClaudeSessionByPid = exports.pidSessionRecordsExist = exports.collectDescendantPids = exports.psStartTimes = exports.foregroundAgentFor = exports.readProcTable = exports.parseProcTable = exports.detectClaudeSessionId = exports.claudeProjectDirName = void 0;
+exports.matchAgentByPaneCommand = exports.findAgentBySubcommand = exports.REMOTE_AGENTS = exports.opencodeTranscriptPath = exports.detectOpencodeSession = exports.geminiTranscriptPath = exports.codexTranscriptPath = exports.detectCodexSessionName = exports.newestVersionedDb = exports.hermesTranscriptPath = exports.detectHermesResumeId = exports.detectHermesSessionName = exports.sqliteJson = exports.transcriptIdSince = exports.paneSince = exports.pickRowByProcStart = exports.detectPiSessionName = exports.piTranscriptPath = exports.claudeTranscriptPath = exports.detectClaudeSessionHandle = exports.detectClaudeProviderName = exports.detectClaudeSessionIdByPid = exports.detectClaudeSessionByPid = exports.pidSessionRecordsExist = exports.collectDescendantPids = exports.psStartTimes = exports.foregroundAgentFor = exports.readProcTable = exports.parseProcTable = exports.detectClaudeSessionId = exports.claudeProjectDirName = void 0;
 /**
  * Remote-control agent registry — the single table behind every
  * `hwip <agent>` subcommand, the listener's pane matching, and the
@@ -25,6 +25,7 @@ const pi_transcript_js_1 = require("./pi-transcript.js");
 const session_title_js_1 = require("./session-title.js");
 const codex_transcript_js_1 = require("./codex-transcript.js");
 const gemini_transcript_js_1 = require("./gemini-transcript.js");
+const hermes_transcript_js_1 = require("./hermes-transcript.js");
 const opencode_transcript_js_1 = require("./opencode-transcript.js");
 /**
  * A per-key TTL cache, bounded so a long-lived listener that has seen many keys
@@ -782,6 +783,21 @@ const detectHermesResumeId = (paneCwd, panePid, deps = {}) => {
     return best?.id ?? null;
 };
 exports.detectHermesResumeId = detectHermesResumeId;
+/** `sqliteJson` with its own warning: a failed transcript read costs the timeline, not the session list. */
+const queryHermesTranscript = (db, sql) => {
+    const rows = (0, exports.sqliteJson)(db, sql);
+    if (rows === null)
+        warnReaderOnce('hermes transcript', `sqlite3 ${(0, path_1.basename)(db)}`, 'hermes panes show no live timeline');
+    return rows;
+};
+/** The store and the pane's session in one string, as opencode's. Null until the session has a message. */
+const hermesTranscriptPath = (paneCwd, panePid, deps = {}) => {
+    if (!paneCwd)
+        return null;
+    const id = (0, exports.detectHermesResumeId)(paneCwd, panePid, deps);
+    return id ? (0, hermes_transcript_js_1.hermesSourcePath)(HERMES_STATE_DB, id) : null;
+};
+exports.hermesTranscriptPath = hermesTranscriptPath;
 // ── Codex ────────────────────────────────────────────────────────
 const CODEX_DIR = (0, path_1.join)((0, os_1.homedir)(), '.codex');
 const CODEX_STATE_DB = /^state_(\d+)\.sqlite$/;
@@ -1282,6 +1298,10 @@ const REMOTE_AGENT_TABLE = [
         // `<timestamp>_<hash>` string, and nothing on the wire consumes it yet.
         resolveSessionName: exports.detectHermesSessionName,
         resolveResumeId: exports.detectHermesResumeId,
+        // No file: the conversation is rows of `messages` in the state store.
+        resolveTranscript: (paneCwd, panePid) => (0, exports.hermesTranscriptPath)(paneCwd, panePid),
+        projectTranscript: hermes_transcript_js_1.projectHermesEntries,
+        readTranscript: (path, prev) => (0, hermes_transcript_js_1.readHermesTranscript)(path, prev, { query: queryHermesTranscript }),
         // Measured: `--resume <id>` carries the conversation on, and an id the
         // store lost starts a new session rather than exit — so, like opencode,
         // not checked against the store.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hwip/cli",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Hwip CLI + push notification SDK for AI agents",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",