@hwip/cli 0.1.5 → 0.1.7

package/README.md

@@ -557,11 +557,17 @@ offers it during setup and `hwip uninstall` takes it away again.
 What you get back after a reboot is your **past sessions**, ready to
 resume from the phone — not live agents. tmux does not survive a reboot
 either, and this doesn't try to bring those sessions back to life.
-A resume starts the agent in the directory it last ran in; for Claude Code
-and OpenCode it also picks up the conversation that session last had
-(`--resume <id>` / `--session <id>`, the id this machine read off the live
-pane's own process — an id two panes both answered to is not kept). Claude Code starts fresh when that conversation is no longer on disk,
-and the other agents always start a new one.
+A resume starts the agent in the directory it last ran in; for Claude Code,
+OpenCode, Codex, Pi and Hermes it also picks up the conversation that session
+last had (`claude --resume <id>`, `opencode --session <id>`,
+`codex resume <thread>`, `pi --session <file>`, `hermes --resume <id>` — the
+id this machine read off the live pane's own process; an id two panes both
+answered to is not kept). Claude Code, Codex and Pi start fresh when that
+conversation is no longer on disk, and the other agents always start a new one.
+Each ended run of a name is its own row on the phone, and starting one
+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.
 
 Two details worth knowing:
 

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.18.1 — hwip#532, merged and deployed before this cli ships),
+ * (hwip server/src/agent-rules/manifest.json, version 2026.10.21.1 — hwip#616, merged and deployed 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.18.1 — hwip#532, merged and deployed before this cli ships),
+ * (hwip server/src/agent-rules/manifest.json, version 2026.10.21.1 — hwip#616, merged and deployed 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.18.1',
+    version: '2026.10.21.1',
     agents: {
         claude: [
             {
@@ -237,8 +237,8 @@ exports.DEFAULT_MANIFEST = {
             // guarded by any button or footer string so the phrase in tool
             // output or agent text alone is not a dialog. tailLines 30
             // because an edit request draws its diff between that line and
-            // the buttons. Other prompts (the agent asking a question) are
-            // not captured and report `unknown`.
+            // the buttons. Other prompts (anything but a permission request or
+            // the question tool, below) are not read and report `unknown`.
             // No idle rule: at rest the footer is only `ctrl+p commands`,
             // which says nothing the absence of `esc interrupt` does not.
             {
@@ -253,6 +253,17 @@ exports.DEFAULT_MANIFEST = {
                     { contains: ['enter confirm'] },
                 ],
             },
+            {
+                // The question tool's panel (captured on opencode 2.1.2).
+                // tailLines 40: answers carry notes. `esc interrupt` means a
+                // turn still running, so these words in agent text do not count.
+                id: 'opencode-blocked-question',
+                state: 'blocked',
+                priority: 900,
+                tailLines: 40,
+                contains: ['questions', 'enter submit', 'esc dismiss'],
+                not: [{ contains: ['esc interrupt'] }],
+            },
             {
                 id: 'opencode-working-interrupt-hint',
                 state: 'working',

package/dist/blocked-prompt.js

@@ -42,10 +42,13 @@ exports.promptPlaintext = exports.showsPrompt = exports.parseBlockedDialog = exp
  * numbered answers. No footer.
  *
  * pi has no approval dialog of its own; extensions that gate tools ask through
- * `ctx.ui.select` (`parsePiSelect`, `blocked-prompt-pi.test.ts`).
+ * `ctx.ui.select` (`parsePiSelect`, `blocked-prompt-pi.test.ts`). The `ask_user_question` extension draws its own
+ * picker (`parsePiQuestion`).
  *
  * OpenCode (v2.0.29, `blocked-prompt-opencode.test.ts`): a `┃` panel, `△ Permission required`, the request, and a
- * row of buttons whose chosen one is told apart by background colour only (`parseOpencodePermission`).
+ * 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`).
  */
 const node_crypto_1 = require("node:crypto");
 /** Dialog titles whose layout was captured and is read. */
@@ -334,14 +337,91 @@ const parsePiSelect = (pane) => {
         options,
     });
 };
+/** A line indented under an answer, as both question pickers draw a note. */
+const QUESTION_NOTE = /^ {5}(\S.*)$/;
+const appendNote = (option, text) => {
+    option.note = option.note === undefined ? text.trim() : `${option.note} ${text.trim()}`;
+};
+const PI_QUESTION_FOOTER = /^ ↑↓ navigate • Enter select • Esc cancel$/;
+const PI_QUESTION_OPTION = /^(> | {2})(?:(\d{1,2})\. )?(\S.*)$/;
+/**
+ * The `ask_user_question` extension's single-answer picker (pi 0.85.1, `pi-blocked.txt`): a full-width rule, the
+ * question, an optional context, numbered answers with `> ` on the highlighted one and an indented note under any,
+ * an unnumbered last answer that opens a text field (left out: keys cannot fill it), then the
+ * `↑↓ navigate • Enter select • Esc cancel` footer and a closing rule.
+ */
+const parsePiQuestion = (pane) => {
+    const lines = pane.split('\n').map((l) => l.trimEnd());
+    let footer = -1;
+    for (let i = lines.length - 1; i >= 0 && footer < 0; i--)
+        if (PI_QUESTION_FOOTER.test(lines[i]))
+            footer = i;
+    if (footer < 0 || !FULL_RULE.test(lines[footer + 1] ?? ''))
+        return undefined;
+    let top = -1;
+    for (let i = footer - 1; i >= 0 && top < 0; i--)
+        if (FULL_RULE.test(lines[i]))
+            top = i;
+    if (top < 0)
+        return undefined;
+    // The picker takes the editor's place, so one rule follows it; the same text in the agent's output sits above
+    // the editor and its two rules.
+    if (lines.slice(footer + 1).filter((l) => FULL_RULE.test(l)).length > 1)
+        return undefined;
+    // Answers run up to the footer's gap; the question and context sit above the first one's gap.
+    let first = top + 1;
+    while (first < footer && !/^(> | {2})1\. /.test(lines[first]))
+        first++;
+    if (first >= footer || lines[first - 1] !== '')
+        return undefined;
+    const options = [];
+    let own;
+    for (const line of lines.slice(first, footer)) {
+        if (line === '')
+            continue;
+        const note = QUESTION_NOTE.exec(line);
+        if (note && options.length > 0) {
+            appendNote(options[options.length - 1], note[1]);
+            continue;
+        }
+        const m = PI_QUESTION_OPTION.exec(line);
+        if (!m || own !== undefined)
+            return undefined;
+        const n = m[2] === undefined ? options.length + 1 : Number(m[2]);
+        if (m[2] === undefined)
+            own = n;
+        options.push({ n, label: m[3].trim(), selected: m[1] === '> ' });
+    }
+    if (own === undefined)
+        return undefined;
+    const text = lines.slice(top + 1, first).map((l) => l.replace(/^ /, ''));
+    const gap = text.indexOf('');
+    const asked = (gap < 0 ? text : text.slice(0, gap)).join(' ').trim();
+    if (asked === '')
+        return undefined;
+    const context = gap < 0 ? [] : trimBlank(text.slice(gap + 1)).map((l) => l.trim()).filter((l) => l !== '');
+    const prompt = 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}`)],
+        question: asked,
+        options,
+    });
+    return prompt && { ...prompt, options: prompt.options.filter((o) => o.n !== own) };
+};
 // One SGR sequence and its parameters; any other escape is dropped without changing the background.
 const SGR = /^\u001b\[([0-9;:]*)m/;
 const ANY_ESCAPE = new RegExp(`^(?:${ESCAPES.source})`);
-/** `line` without escapes, and the background each of its UTF-16 units is drawn on ('7' = reverse video). */
-const withBackground = (line) => {
+/**
+ * `line` without escapes, and the background ('7' = reverse video) and foreground each of its UTF-16 units is drawn
+ * in ('' = the default).
+ */
+const withColours = (line) => {
     let text = '';
     const bg = [];
+    const fg = [];
     let current = '';
+    let ink = '';
     let reverse = false;
     for (let i = 0; i < line.length;) {
         const sgr = SGR.exec(line.slice(i));
@@ -351,6 +431,7 @@ const withBackground = (line) => {
                 const code = Number(p[j]);
                 if (code === 0) {
                     current = '';
+                    ink = '';
                     reverse = false;
                 }
                 else if (code === 7)
@@ -359,12 +440,18 @@ const withBackground = (line) => {
                     reverse = false;
                 else if (code === 49)
                     current = '';
+                else if (code === 39)
+                    ink = '';
                 else if ((code >= 40 && code <= 47) || (code >= 100 && code <= 107))
                     current = String(code);
+                else if ((code >= 30 && code <= 37) || (code >= 90 && code <= 97))
+                    ink = String(code);
                 else if (code === 38 || code === 48 || code === 58) {
                     const span = p[j + 1] === '2' ? 3 : p[j + 1] === '5' ? 1 : 0;
                     if (code === 48)
                         current = p.slice(j, j + 2 + span).join(';');
+                    if (code === 38)
+                        ink = p.slice(j, j + 2 + span).join(';');
                     j += 1 + span;
                 }
             }
@@ -378,27 +465,27 @@ const withBackground = (line) => {
         }
         text += line[i];
         bg.push(reverse ? '7' : current);
+        fg.push(ink);
         i++;
     }
-    return { text, bg };
+    return { text, bg, fg };
 };
 const OPENCODE_BAR = '┃';
 const OPENCODE_HEADER = /^\s*△ Permission required$/;
 const OPENCODE_HINTS = /ctrl\+|⇆|enter confirm/;
 const OPENCODE_SUBTITLE = /^→ (\S.*)$/;
+/** The column after the panel bar on a row drawn in the panel; -1 for any other row. */
+const inPanel = (row) => {
+    const at = row.text.indexOf(OPENCODE_BAR);
+    return at >= 0 && row.text.slice(0, at).trim() === '' ? at + 1 : -1;
+};
 /**
  * OpenCode's permission request: `△ Permission required` in a `┃` panel, the request (a `$ command`, or `→ Edit file`
  * over its diff), then a row of buttons `Allow once   Always allow   Reject` beside `… enter confirm`. The chosen
  * button differs from the others only by its background, so this reads the pane with its escapes: a plain capture
  * yields nothing. Left/right move the choice; the dialog draws no question, so the question is a fixed one.
  */
-const parseOpencodePermission = (pane) => {
-    const rows = pane.split('\n').map(withBackground);
-    // Text after the panel bar, with the bar's column, for every row drawn in the panel.
-    const inPanel = (row) => {
-        const at = row.text.indexOf(OPENCODE_BAR);
-        return at >= 0 && row.text.slice(0, at).trim() === '' ? at + 1 : -1;
-    };
+const parseOpencodePermission = (rows) => {
     let head = -1;
     for (let i = rows.length - 1; i >= 0 && head < 0; i--) {
         const at = inPanel(rows[i]);
@@ -453,6 +540,71 @@ const parseOpencodePermission = (pane) => {
         idSalt: `opencode:selected=${selected}`,
     });
 };
+const OPENCODE_QUESTION_HEADER = /^\s*Questions$/;
+/** The one footer captured: a single question, single answer. Several questions add `tab`, several answers a toggle. */
+const OPENCODE_QUESTION_FOOTER = /^\s*↑↓ select {2}enter submit {2}esc dismiss$/;
+const OPENCODE_QUESTION_OPTION = /^ {2}(\d{1,2})\. (\S.*)$/;
+/** The answer OpenCode adds to every question: it opens a text field, which keys cannot fill. */
+const OPENCODE_OWN_ANSWER = 'Type your own answer';
+/**
+ * OpenCode's question tool (v2.1.2): `Questions` in a `┃` panel, the question, numbered answers each over an
+ * optional indented note, and a `↑↓ select  enter submit  esc dismiss` footer. The highlighted answer differs only by
+ * the colour of its number, so this too reads the pane with its escapes. Up/down move the highlight.
+ */
+const parseOpencodeQuestion = (rows) => {
+    const textOf = (i) => rows[i].text.slice(inPanel(rows[i])).trimEnd();
+    let footer = -1;
+    for (let i = rows.length - 1; i >= 0 && footer < 0; i--) {
+        if (inPanel(rows[i]) >= 0 && OPENCODE_QUESTION_FOOTER.test(textOf(i)))
+            footer = i;
+    }
+    if (footer < 0)
+        return undefined;
+    let head = footer - 1;
+    while (head >= 0 && inPanel(rows[head]) >= 0 && !OPENCODE_QUESTION_HEADER.test(textOf(head)))
+        head--;
+    if (head < 0 || inPanel(rows[head]) < 0)
+        return undefined;
+    const question = [];
+    const options = [];
+    const numberInk = [];
+    for (let i = head + 1; i < footer; i++) {
+        const text = textOf(i);
+        const option = OPENCODE_QUESTION_OPTION.exec(text);
+        if (option) {
+            options.push({ n: Number(option[1]), label: option[2].trim(), selected: false });
+            numberInk.push(rows[i].fg[inPanel(rows[i]) + 2]);
+            continue;
+        }
+        const note = QUESTION_NOTE.exec(text);
+        if (options.length > 0 && note) {
+            appendNote(options[options.length - 1], note[1]);
+        }
+        else if (options.length > 0 && text.trim() !== '') {
+            return undefined;
+        }
+        else if (options.length === 0) {
+            question.push(text.trim());
+        }
+    }
+    // The highlighted answer: the one number ink no other answer shares, the rest all alike.
+    const odd = numberInk.filter((ink) => numberInk.filter((other) => other === ink).length === 1);
+    if (odd.length !== 1 || new Set(numberInk).size !== 2)
+        return undefined;
+    options[numberInk.indexOf(odd[0])].selected = true;
+    const asked = trimBlank(question).join(' ').trim();
+    if (asked === '')
+        return undefined;
+    const prompt = 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}`),
+        question: asked,
+        options,
+        idSalt: `opencode-question:selected=${options.findIndex((o) => o.selected)}`,
+    });
+    return prompt && { ...prompt, options: prompt.options.filter((o) => o.label !== OPENCODE_OWN_ANSWER) };
+};
 /** The checks and caps every reader shares: numbering 1..n, one highlight, label and detail limits. */
 const assemble = (d) => {
     const { options } = d;
@@ -489,8 +641,14 @@ const assemble = (d) => {
 const READERS = {
     claude: (pane) => parseClaudeDialog((0, exports.stripEscapes)(pane)),
     gemini: (pane) => parseGeminiDialog((0, exports.stripEscapes)(pane)),
-    pi: (pane) => parsePiSelect((0, exports.stripEscapes)(pane)),
-    opencode: parseOpencodePermission,
+    pi: (pane) => {
+        const plain = (0, exports.stripEscapes)(pane);
+        return parsePiSelect(plain) ?? parsePiQuestion(plain);
+    },
+    opencode: (pane) => {
+        const rows = pane.split('\n').map(withColours);
+        return parseOpencodePermission(rows) ?? parseOpencodeQuestion(rows);
+    },
 };
 /** The approval dialog at the bottom of `pane`, read the way `kind` draws it; undefined when it is not one of those. */
 const parseBlockedDialog = (pane, kind) => READERS[kind]?.(pane);

package/dist/listener.d.ts

@@ -232,6 +232,8 @@ export interface ReportedKnownSession {
     /** The last name the agent gave the run, and who gave it (hwip docs/session-runs.md Q39): what the phone calls it once ended. */
     providerSessionName?: string;
     providerSessionNameSource?: ProviderNameSource;
+    /** Whether starting the run again picks its conversation back up (Q43) — never the conversation id itself. */
+    resumable: boolean;
     lastSeenAt: string;
 }
 /** Each live run's first seq, for the report (Q24). A run that has recorded nothing yet has none. */
@@ -505,6 +507,13 @@ export interface SessionResumeRequest {
      * the same answer a phone too old to send it gets.
      */
     agentKind?: string;
+    /**
+     * Which run of that name and agent (docs/session-runs.md Q41–Q46): the
+     * earlier-runs fold starts one conversation, not the newest. Selects among
+     * runs this machine recorded; one it never had is refused. Read only when
+     * it reads as a run id.
+     */
+    runId?: string;
     requestId?: string;
 }
 export interface SessionResumeResult {

package/dist/listener.js

@@ -36,6 +36,7 @@ const os_1 = require("os");
 const path_1 = require("path");
 const ws_1 = __importDefault(require("ws"));
 const config_js_1 = require("./config.js");
+const agent_dirs_js_1 = require("./agent-dirs.js");
 const api_js_1 = require("./api.js");
 const shell_audit_js_1 = require("./shell-audit.js");
 const insecure_url_js_1 = require("./insecure-url.js");
@@ -100,6 +101,7 @@ const tmux_liveness_js_1 = require("./tmux-liveness.js");
 Object.defineProperty(exports, "liveSessionNames", { enumerable: true, get: function () { return tmux_liveness_js_1.liveSessionNames; } });
 Object.defineProperty(exports, "sessionExists", { enumerable: true, get: function () { return tmux_liveness_js_1.sessionExists; } });
 Object.defineProperty(exports, "sessionLiveness", { enumerable: true, get: function () { return tmux_liveness_js_1.sessionLiveness; } });
+const wrapper_js_1 = require("./wrapper.js");
 const run_seqs_js_1 = require("./run-seqs.js");
 const args_js_1 = require("./args.js");
 const schedule_js_1 = require("./schedule.js");
@@ -321,11 +323,12 @@ const knownSessionsToReport = (live, now = Date.now(), seqs = (0, run_seqs_js_1.
         ...(e.tmuxRunIds?.length ? { tmuxRunIds: e.tmuxRunIds } : {}),
         ...(e.providerSessionName ? { providerSessionName: e.providerSessionName } : {}),
         ...(e.providerSessionName && e.providerSessionNameSource ? { providerSessionNameSource: e.providerSessionNameSource } : {}),
+        resumable: isResumable(e),
         lastSeenAt: e.lastSeenAt,
     }));
 };
 exports.knownSessionsToReport = knownSessionsToReport;
-const knownSessionsFingerprint = (known) => known.map((k) => `${k.name}${k.agentKind}${k.runId ?? ''}${k.lastSeenAt}${k.firstSeq ?? ''}${k.lastSeq ?? ''}${k.tmuxRunIds?.join(',') ?? ''} ${k.providerSessionNameSource ?? ''} ${k.providerSessionName ?? ''}`).sort().join('|');
+const knownSessionsFingerprint = (known) => known.map((k) => `${k.name}${k.agentKind}${k.runId ?? ''}${k.lastSeenAt}${k.firstSeq ?? ''}${k.lastSeq ?? ''}${k.tmuxRunIds?.join(',') ?? ''} ${k.providerSessionNameSource ?? ''} ${k.providerSessionName ?? ''} ${k.resumable}`).sort().join('|');
 exports.knownSessionsFingerprint = knownSessionsFingerprint;
 const sessionsFingerprint = (sessions) => sessions
     .map((s) => JSON.stringify([
@@ -1365,6 +1368,13 @@ const handleScheduleListRequest = (req, send) => {
     return true;
 };
 exports.handleScheduleListRequest = handleScheduleListRequest;
+/** A run id as the registry writes it: tmux `session_created`, epoch seconds. */
+const RUN_ID = /^\d{1,12}$/;
+/** The name a wrapper family counts from: `hwip-x-3` → `hwip-x`. */
+const familyBase = (name) => {
+    const base = /^(.+)-\d+$/.exec(name)?.[1];
+    return base !== undefined && (0, wrapper_js_1.familyNames)(base).includes(name) ? base : name;
+};
 /** What an agent conversation id looks like — a value, never an option. */
 const CONVERSATION_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
 /**
@@ -1380,6 +1390,26 @@ const resumableConversation = (agent, known) => {
     const args = agent.resumeArgs?.(id, known.cwd);
     return args ? { id, args } : null;
 };
+/**
+ * A live session is on this run's conversation already: the run started beside
+ * its name before, or the live run under it picked the conversation up. The
+ * ended entry stays in the registry, so without this every tap on it would
+ * start one more agent on one transcript.
+ */
+const conversationRunning = (known, live) => {
+    const id = known.agentSessionId;
+    if (!id)
+        return false;
+    return [...live].some((name) => {
+        const current = (0, session_registry_js_1.recallSession)(name);
+        return current?.agentKind === known.agentKind && current.agentSessionId === id;
+    });
+};
+/** What the report says about a run: the same answer a resume of it would act on. */
+const isResumable = (known) => {
+    const agent = remote_agents_js_1.REMOTE_AGENTS.find((a) => a.kind === known.agentKind);
+    return agent !== undefined && resumableConversation(agent, known) !== null;
+};
 /**
  * Start a remembered session again, detached, and tell the phone what happened.
  * Returns true when the message was ours to answer.
@@ -1423,14 +1453,27 @@ const handleSessionResumeRequest = (req, send) => {
     // newest run would start claude for a phone that asked for pi — silently,
     // which is the exact failure this path exists to remove. A phone that names
     // nothing still means the newest run.
+    const runId = typeof req.runId === 'string' && RUN_ID.test(req.runId) ? req.runId : undefined;
     const known = typeof req.agentKind === 'string'
-        ? (0, session_registry_js_1.recallRun)(sessionName, req.agentKind)
-        : (0, session_registry_js_1.recallSession)(sessionName);
+        ? (0, session_registry_js_1.recallRun)(sessionName, req.agentKind, Date.now(), runId)
+        : (0, session_registry_js_1.recallSession)(sessionName, Date.now(), runId);
     if (!known) {
         (0, listener_log_js_1.log)(`✗ resume ${sessionName}: never seen on this machine`);
         return reply({ error: 'unknown_session' });
     }
-    if ((0, tmux_liveness_js_1.sessionExists)(sessionName))
+    // A live name is refused unless the request names a run: then the phone
+    // asked for one earlier conversation, and the session holding the name is
+    // a different one — so it starts beside it, under the next free name of
+    // 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.
+    const live = new Set((0, tmux_liveness_js_1.liveSessionNames)() ?? []);
+    const target = !live.has(sessionName)
+        ? sessionName
+        : runId !== undefined
+            ? (0, wrapper_js_1.familyNames)(familyBase(sessionName)).find((name) => !live.has(name))
+            : undefined;
+    if (!target || 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`);
@@ -1451,14 +1494,18 @@ const handleSessionResumeRequest = (req, send) => {
         ? [';', '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 started = (0, child_process_1.spawnSync)('tmux', (0, tmux_socket_js_1.tmuxArgs)(['new-session', '-d', '-s', sessionName, '-c', known.cwd, agent.binary, ...(conversation?.args ?? []), ...sidecar]), { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] });
+    // 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.
+    const started = (0, child_process_1.spawnSync)('tmux', (0, tmux_socket_js_1.tmuxArgs)(['new-session', '-d', '-s', target, '-c', known.cwd, agent.binary, ...(conversation?.args ?? []), ...sidecar]), { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, PATH: (0, agent_dirs_js_1.withAgentDirs)(process.env.PATH) } });
     if (started.status !== 0) {
         (0, listener_log_js_1.log)(`✗ resume ${sessionName}: tmux refused (${(started.stderr ?? '').trim() || 'no detail'})`);
         return reply({ error: 'start_failed' });
     }
     const resumedFrom = conversation ? ` (conversation ${conversation.id.slice(0, 8)})` : '';
-    (0, listener_log_js_1.log)(`⟲ resume ${sessionName}: ${agent.binary}${resumedFrom} in ${known.cwd}`);
-    return reply({ resumed: true });
+    const beside = target === sessionName ? '' : ` as ${target}`;
+    (0, listener_log_js_1.log)(`⟲ resume ${sessionName}${beside}: ${agent.binary}${resumedFrom} in ${known.cwd}`);
+    return reply({ resumed: true, sessionName: target });
 };
 exports.handleSessionResumeRequest = handleSessionResumeRequest;
 /**
@@ -1618,7 +1665,7 @@ const handleSessionForgetRequest = (req, send) => {
     // alternative is an irreversible delete (registry AND scrollback) justified
     // by a question that failed to be asked. It says so in the log, because
     // from the phone the two refusals are the same sentence.
-    const runId = typeof req.runId === 'string' && /^\d{1,12}$/.test(req.runId) ? req.runId : undefined;
+    const runId = typeof req.runId === 'string' && RUN_ID.test(req.runId) ? req.runId : undefined;
     const liveness = (0, tmux_liveness_js_1.sessionLiveness)(sessionName);
     if (liveness === 'unknown') {
         (0, listener_log_js_1.log)(`✗ forget ${sessionName}: no tmux answered, so nothing was deleted`);

package/dist/remote-agents.d.ts

@@ -380,6 +380,7 @@ declare const REMOTE_AGENT_TABLE: readonly [{
     readonly resolveTranscript: (paneCwd: string, panePid: number | undefined) => string | null;
     readonly projectTranscript: TranscriptProjector;
     readonly resolveResumeId: (paneCwd: string, panePid: number | undefined) => string | null;
+    readonly resumeArgs: (id: string) => string[] | null;
 }, {
     readonly kind: "cursor";
     readonly displayName: "Cursor CLI";
@@ -400,6 +401,7 @@ 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 resumeArgs: (id: string) => string[];
 }, {
     readonly kind: "pi";
     readonly displayName: "Pi";
@@ -409,6 +411,7 @@ declare const REMOTE_AGENT_TABLE: readonly [{
     readonly projectTranscript: TranscriptProjector;
     readonly resolveResumeId: (paneCwd: string, panePid: number | undefined) => string | null;
     readonly resolveSessionName: (paneCwd: string, panePid: number | undefined) => ProviderName | null;
+    readonly resumeArgs: (id: string, cwd: string) => string[] | null;
 }, {
     readonly kind: "opencode";
     readonly displayName: "OpenCode";

package/dist/remote-agents.js

@@ -462,6 +462,15 @@ const claudeTranscriptPath = (paneCwd, panePid) => {
     return claudeConversationFile(paneCwd, sessionId);
 };
 exports.claudeTranscriptPath = claudeTranscriptPath;
+/** A regular file is there: what a resume flag needs before it names one. */
+const isFileAt = (path) => {
+    try {
+        return (0, fs_1.statSync)(path).isFile();
+    }
+    catch {
+        return false;
+    }
+};
 /**
  * Where Claude Code keeps conversation `sessionId` begun in `cwd`, or null
  * when no such file is there. Proven, not computed: the pid path never touches
@@ -470,12 +479,7 @@ exports.claudeTranscriptPath = claudeTranscriptPath;
  */
 const claudeConversationFile = (cwd, sessionId) => {
     const path = (0, path_1.join)(CLAUDE_PROJECTS_DIR, (0, exports.claudeProjectDirName)(cwd), `${sessionId}.jsonl`);
-    try {
-        return (0, fs_1.statSync)(path).isFile() ? path : null;
-    }
-    catch {
-        return null;
-    }
+    return isFileAt(path) ? path : null;
 };
 // ── pi ───────────────────────────────────────────────────────────
 /**
@@ -524,6 +528,11 @@ const piSessionDirName = (cwd) => {
     const resolved = (0, path_1.resolve)(expanded);
     return `--${resolved.replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`;
 };
+/** `--session <file>` for a pi session still on disk, or null. */
+const piSessionFile = (cwd, id) => {
+    const path = (0, path_1.join)(piSessionsDir(), piSessionDirName(cwd), `${id}.jsonl`);
+    return isFileAt(path) ? ['--session', path] : null;
+};
 /**
  * Newest session file pi wrote for this directory.
  *
@@ -849,6 +858,15 @@ const codexSessionsDir = () => {
     const home = override ? override.replace(/^~(?=\/|$)/, (0, os_1.homedir)()) : CODEX_DIR;
     return (0, path_1.join)(home, 'sessions');
 };
+/** `rollout-YYYY-MM-DDThh-mm-ss-<uuid>`: the day it shards under, and the thread it carries. */
+const CODEX_ROLLOUT = /^rollout-(\d{4})-(\d{2})-(\d{2})T[\d-]+-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
+/** The thread id of a rollout that is still on disk, or null. */
+const codexRolloutThread = (rolloutId) => {
+    const m = CODEX_ROLLOUT.exec(rolloutId);
+    if (!m)
+        return null;
+    return isFileAt((0, path_1.join)(codexSessionsDir(), m[1], m[2], m[3], `${rolloutId}.jsonl`)) ? m[4] : null;
+};
 /**
  * The two newest `sessions/<YYYY>/<MM>/<DD>` shards.
  *
@@ -1211,8 +1229,15 @@ const REMOTE_AGENT_TABLE = [
         resolveSessionName: exports.detectCodexSessionName,
         resolveTranscript: (paneCwd, panePid) => (0, exports.codexTranscriptPath)(paneCwd, panePid),
         projectTranscript: codex_transcript_js_1.projectCodexEntries,
-        // Read only to tell a resumed conversation's run (no `resumeArgs`): the rollout a resume appends to.
+        // The rollout a resume appends to, by file name.
         resolveResumeId: (paneCwd, panePid) => paneTranscriptId((0, exports.codexTranscriptPath)(paneCwd, panePid), panePid),
+        // `codex resume` takes the thread's UUID; the rollout's file name reads as
+        // a thread NAME and starts a new conversation (measured on 0.163.0). An
+        // unknown UUID exits at once, so only a rollout still on disk.
+        resumeArgs: (id) => {
+            const thread = codexRolloutThread(id);
+            return thread ? ['resume', thread] : null;
+        },
     },
     {
         // The pane binary is `cursor-agent`, Cursor's terminal TUI — NOT the
@@ -1250,6 +1275,10 @@ const REMOTE_AGENT_TABLE = [
         // `<timestamp>_<hash>` string, and nothing on the wire consumes it yet.
         resolveSessionName: exports.detectHermesSessionName,
         resolveResumeId: exports.detectHermesResumeId,
+        // 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.
+        resumeArgs: (id) => ['--resume', id],
     },
     {
         kind: 'pi',
@@ -1260,6 +1289,10 @@ const REMOTE_AGENT_TABLE = [
         projectTranscript: pi_transcript_js_1.projectPiEntries,
         resolveResumeId: (paneCwd, panePid) => paneTranscriptId((0, exports.piTranscriptPath)(paneCwd, panePid), panePid),
         resolveSessionName: (paneCwd, panePid) => (0, exports.detectPiSessionName)(paneCwd, panePid),
+        // The session file itself: `--session` takes a path or a UUID, and the
+        // recorded id is the file name, which it does not match. A session pi
+        // cannot find exits at once (measured), so only a file still on disk.
+        resumeArgs: (id, cwd) => piSessionFile(cwd, id),
     },
     {
         kind: 'opencode',

package/dist/session-registry.d.ts

@@ -89,8 +89,9 @@ export declare const runKey: (name: string, agentKind: string, runId?: string) =
 /** Sessions this machine has seen, newest first, expired ones dropped. */
 export declare const knownSessions: (now?: number) => KnownSession[];
 /** One remembered session, or null when this machine never saw that name.
- *  The newest run under that name — which is the one a bare resume means. */
-export declare const recallSession: (name: string, now?: number) => KnownSession | null;
+ *  The newest run under that name — which is the one a bare resume means.
+ *  With `runId`, that run of the name and nothing else (Q46). */
+export declare const recallSession: (name: string, now?: number, runId?: string) => KnownSession | null;
 /**
  * One specific run: the newest under this name that ran THIS agent.
  *
@@ -99,8 +100,12 @@ export declare const recallSession: (name: string, now?: number) => KnownSession
  * which row was tapped and says so; this is how that answer is honoured.
  * Null when this machine never saw that agent under that name — the caller
  * decides whether to fall back to the newest run or refuse.
+ *
+ * With `runId`, that run of the name and nothing else (docs/session-runs.md
+ * Q46): the earlier-runs fold asks for one conversation, and the newest run is
+ * a different one.
  */
-export declare const recallRun: (name: string, agentKind: string, now?: number) => KnownSession | null;
+export declare const recallRun: (name: string, agentKind: string, now?: number, runId?: string) => KnownSession | null;
 /** tmux sessions remembered per run: an `exit` and `-c` every few minutes all day stays a short list. */
 export declare const MAX_TMUX_RUNS_PER_RUN = 10;
 /**

package/dist/session-registry.js

@@ -104,9 +104,12 @@ const knownSessions = (now = Date.now()) => readAll()
     .filter((e) => now - Date.parse(e.lastSeenAt) < exports.KNOWN_SESSION_TTL_MS)
     .sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt));
 exports.knownSessions = knownSessions;
+/** No run asked for, or that run. */
+const ofRun = (e, runId) => runId === undefined || e.runId === runId;
 /** One remembered session, or null when this machine never saw that name.
- *  The newest run under that name — which is the one a bare resume means. */
-const recallSession = (name, now = Date.now()) => (0, exports.knownSessions)(now).find((e) => e.name === name) ?? null;
+ *  The newest run under that name — which is the one a bare resume means.
+ *  With `runId`, that run of the name and nothing else (Q46). */
+const recallSession = (name, now = Date.now(), runId) => (0, exports.knownSessions)(now).find((e) => e.name === name && ofRun(e, runId)) ?? null;
 exports.recallSession = recallSession;
 /**
  * One specific run: the newest under this name that ran THIS agent.
@@ -116,8 +119,12 @@ exports.recallSession = recallSession;
  * which row was tapped and says so; this is how that answer is honoured.
  * Null when this machine never saw that agent under that name — the caller
  * decides whether to fall back to the newest run or refuse.
+ *
+ * With `runId`, that run of the name and nothing else (docs/session-runs.md
+ * Q46): the earlier-runs fold asks for one conversation, and the newest run is
+ * a different one.
  */
-const recallRun = (name, agentKind, now = Date.now()) => (0, exports.knownSessions)(now).find((e) => e.name === name && e.agentKind === agentKind) ?? null;
+const recallRun = (name, agentKind, now = Date.now(), runId) => (0, exports.knownSessions)(now).find((e) => e.name === name && e.agentKind === agentKind && ofRun(e, runId)) ?? null;
 exports.recallRun = recallRun;
 /** tmux sessions remembered per run: an `exit` and `-c` every few minutes all day stays a short list. */
 exports.MAX_TMUX_RUNS_PER_RUN = 10;

package/dist/wrapper.d.ts

@@ -44,6 +44,8 @@ export declare const installedTmuxVersion: () => string;
 export declare const tmuxSessionName: (project: string) => string;
 /** The first name in the family no live session holds — for a launch that can only create. */
 export declare const firstFreeSession: (base: string) => string;
+/** `<base>`, `<base>-2`, `<base>-3`, … — the session family for one project. */
+export declare const familyNames: (base: string) => string[];
 /**
  * Pick a tmux session name that won't steal focus from another live
  * `hwip cc`. Strategy:

package/dist/wrapper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleShellSession = exports.shellTargets = exports.readShellSessionState = exports.planShellSession = exports.handleAgentSession = exports.tmuxMissingMessage = exports.inPaneNote = exports.handOffExec = exports.ensureListenerRunning = exports.takeListenerLaunchMarker = exports.listenerVersionDrifted = exports.targetForAgent = exports.splitAgentOptions = exports.sanitizeLabel = exports.findAvailableSession = exports.firstFreeSession = exports.tmuxSessionName = exports.installedTmuxVersion = exports.herdrEnvArgs = exports.herdrSessionArgs = exports.sessionSidecarArgs = exports.detectProjectName = exports.detectProjectDir = exports.safeBasename = void 0;
+exports.handleShellSession = exports.shellTargets = exports.readShellSessionState = exports.planShellSession = exports.handleAgentSession = exports.tmuxMissingMessage = exports.inPaneNote = exports.handOffExec = exports.ensureListenerRunning = exports.takeListenerLaunchMarker = exports.listenerVersionDrifted = exports.targetForAgent = exports.splitAgentOptions = exports.sanitizeLabel = exports.findAvailableSession = exports.familyNames = exports.firstFreeSession = exports.tmuxSessionName = exports.installedTmuxVersion = exports.herdrEnvArgs = exports.herdrSessionArgs = exports.sessionSidecarArgs = exports.detectProjectName = exports.detectProjectDir = exports.safeBasename = void 0;
 /**
  * `hwip cc` / `hwip codex` / `hwip gemini` — spawn an agent inside a named
  * tmux session so the resident listener (`hwip listener`) can address it
@@ -172,11 +172,12 @@ const MAX_SUFFIX_ATTEMPTS = 20;
 /** The first name in the family no live session holds — for a launch that can only create. */
 const firstFreeSession = (base) => {
     const live = liveSessions();
-    return familyNames(base).find((name) => !live.has(name)) ?? `${base}-${MAX_SUFFIX_ATTEMPTS + 1}`;
+    return (0, exports.familyNames)(base).find((name) => !live.has(name)) ?? `${base}-${MAX_SUFFIX_ATTEMPTS + 1}`;
 };
 exports.firstFreeSession = firstFreeSession;
 /** `<base>`, `<base>-2`, `<base>-3`, … — the session family for one project. */
 const familyNames = (base) => Array.from({ length: MAX_SUFFIX_ATTEMPTS }, (_, i) => (i === 0 ? base : `${base}-${i + 1}`));
+exports.familyNames = familyNames;
 /**
  * Pick a tmux session name that won't steal focus from another live
  * `hwip cc`. Strategy:
@@ -208,7 +209,7 @@ agentKind,
 /** Test seam: what this machine recorded about a session name. */
 recall = session_registry_js_1.recallSession) => {
     const live = liveSessions();
-    const family = familyNames(base);
+    const family = (0, exports.familyNames)(base);
     /**
      * Whether a detached session can host this agent.
      *

package/package.json

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