@hwip/cli 0.1.14 → 0.1.16

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
@@ -705,12 +706,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/cli.js

@@ -487,7 +487,8 @@ const handleNotify = async (args) => {
     // dial now works for every hook-driven agent. Gated-out → silent success.
     // With no dial the mode falls back to --pushmode-default, then to quiet.
     // Quiet still pushes when the user has left the terminal (presence.ts).
-    if ((0, args_js_1.flagOn)(args, 'auto')) {
+    const isAuto = (0, args_js_1.flagOn)(args, 'auto');
+    if (isAuto) {
         const marker = (0, gate_js_1.normalizeMarker)(typeof args.marker === 'string' ? args.marker : undefined);
         const pushMode = (0, gate_js_1.autoPushMode)(projectDir, args[gate_js_1.PUSHMODE_DEFAULT_FLAG]);
         const verdict = (0, gate_js_1.decidePush)({
@@ -505,7 +506,7 @@ const handleNotify = async (args) => {
     }
     // Past the gates, this IS a push attempt — its outcome is recorded for
     // `hwip verify` and the plugin (notify-failure.ts), since hooks discard stderr.
-    const hook = createHook(args, (0, args_js_1.flagOn)(args, 'auto') ? HOOK_REQUEST_TIMEOUT_MS : undefined);
+    const hook = createHook(args, isAuto ? HOOK_REQUEST_TIMEOUT_MS : undefined);
     if (!hook) {
         (0, notify_failure_js_1.recordNotifyFailure)({ kind: 'no-key', status: null, code: null });
         return 3;
@@ -532,10 +533,11 @@ const handleNotify = async (args) => {
             targetDeviceId: args.device,
             sessionId,
         }));
+        // Hook mode: stdout is the hook's response (Codex parses it as JSON), so stay silent.
         if (isJson) {
             printJson({ pushId: result.pushId, status: 'ok' });
         }
-        else {
+        else if (!isAuto) {
             console.log(`Push sent: ${result.pushId}`);
         }
         return 0;

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/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.14",
+  "version": "0.1.16",
   "description": "Hwip CLI + push notification SDK for AI agents",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",