@hwip/cli 0.1.1 → 0.1.3

package/README.md

@@ -535,6 +535,11 @@ 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.
 
 Two details worth knowing:
 
@@ -646,6 +651,21 @@ transcript, then forgotten. A session that has been quiet for a long time keeps
 state while its transcript exists, so nothing already sent is sent again (an OpenCode
 session, which has no file to check, for 30 days).
 
+A tmux name is used again when an agent starts in the same folder, so each
+chunk also names its **run** — the tmux session it was recorded in (`runId`,
+tmux's `session_created` in epoch seconds). The app uses it to keep one run's
+conversation apart from the one before it under the same name; a chunk read
+after a restart keeps the run it was recorded in. The listener's record of past
+sessions keeps runs apart the same way: closing `hwip cc` and starting it again
+in the same folder leaves the first run as a past session of its own (the
+newest ten runs of a name are kept, 100 in all, and up to 50 are reported to
+the phone). Each run is reported with the block of chunk numbers it took — the
+first and, once it has ended, the last — kept in `run-seqs.json` next to the
+registry, so the server reads one run's conversation from that range instead of
+every chunk the name ever had. Deleting a past run from the phone forgets that
+run on this machine too, even while a later run of the same name is going; the
+run that is going is refused (`still_running`).
+
 When a session waits for your approval, the listener also sends what it is waiting
 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),
@@ -1249,7 +1269,7 @@ hwip notify --title "Hello" --json
 | `verify` | Check installation health across detected agents (`--ping` for a live API call, with the key and API base every command resolves: `--key`, `--base-url`, then env, then config; `--json` prints the checks as one JSON object). Reports whether tmux is on PATH and whether the listener is running — both warnings, since notifications alone need neither. A settings file it cannot parse is a `!` line, not "not registered". Shows the last failed push, if any (see *Last push failure*). Also reports the resolved WebSocket URL **and where it came from** — `--ws-url`, config, the deprecated `HWIP_WS_URL`, or the built-in default — warns when the socket and the API base are on different stages, and warns when the running listener is on a different URL than the one that resolves now (it reads the config once, at startup) |
 | `check-update` | Check whether a newer Hwip version is on npm |
 | `notify` | Send a push notification |
-| `ask` | Ask the phone a question and wait for the answer — for hooks, which cannot call the MCP `hwip_ask` tool. `--title` (required), `--body`, `--actions id:Label,…`, `--timeout <s>` (default 60), `--accepts-exit` for an agent's own ask (the phone may "send and exit", and the answer settles REMOTE like `hwip_ask`). Key and API base resolve like every command. Prints one JSON line — `{"answered":true,"actionId":…}` or `{"value":…}`, else `{"answered":false,"reason":"cancelled"\|"timeout"\|"error"}`; `"resumed":true` is added when the outcome is of a question an earlier run of the same command put up (see "A question cut short"). Exit 0 answered, 1 not. The question and the answer travel sealed, always (see Encryption); an answer that cannot be verified is an error, never an approval. With no app signed in to the account it prints `no app is signed in to this account` and exits 1 |
+| `ask` | Ask the phone a question and wait for the answer — for hooks, which cannot call the MCP `hwip_ask` tool. `--title` (required), `--body`, `--actions id:Label,…`, `--timeout <s>` (default 60), `--accepts-exit` for an agent's own ask (the phone may "send and exit" and attach files, and the answer settles REMOTE like `hwip_ask`; attached files are saved sealed-and-opened to `~/.hwip/attachments/<eventId>/`, their paths follow the text in `value` and are listed in `files`, and `missingFiles` names any not saved). Key and API base resolve like every command. Prints one JSON line — `{"answered":true,"actionId":…}` or `{"value":…}`, else `{"answered":false,"reason":"cancelled"\|"timeout"\|"error"}`; `"resumed":true` is added when the outcome is of a question an earlier run of the same command put up (see "A question cut short"). Exit 0 answered, 1 not. The question and the answer travel sealed, always (see Encryption); an answer that cannot be verified is an error, never an approval. With no app signed in to the account it prints `no app is signed in to this account` and exits 1 |
 | `ask-context [status\|on\|off\|show] [--global]` | The switch for the context a sealed question carries (a git diff against HEAD and the terminal's last lines, masked, sealed on every send — see Encryption). On unless turned off: `off` for the project the current directory is in (its repository root), `off --global` for every project, `on` to undo either; `status` says which applies. It is a state file under `$XDG_STATE_HOME/hwip` (`ask-context-off-<project hash>`, `ask-context-off-default`) and never leaves this machine; `HWIP_ASK_CONTEXT=0` switches it off for one run. A switch file that cannot be read counts as off. `show` prints one JSON line, `{"context": …}` — the summary and the masked original a question asked from the current directory would carry, `null` when there is nothing, with `"off"` naming why when the switch is off — and sends nothing (the MCP `hwip_ask` tool reads it) |
 | `file-view [status\|on\|off\|log] [--global]` | The switch for the phone browsing this computer's files (a session's repository — see Defense). On unless turned off: `off` for the project the current directory is in (its repository root), `off --global` for every project, `on` to undo either; `status` says which applies. A state file under `$XDG_STATE_HOME/hwip` (`file-view-off-<project hash>`, `file-view-off-default`) that never leaves this machine; a switch file that cannot be read counts as off. `log` prints the last 50 reads the phone made, from `~/.hwip/listener.log` (time, device, session, listing or file, path, bytes, secrets masked, result) |
 | `list` | List recent push notifications. An end-to-end encrypted push reads `[encrypted]` — this host cannot open it |

package/dist/answer-files.d.ts

@@ -0,0 +1,39 @@
+import type { SealedFileMeta } from './crypto.js';
+/**
+ * Files attached to a sealed answer of `hwip ask`. The answer's seal names each file (`SealedFileMeta`:
+ * its real name, type and size, matched by `iv`); the response's wire `files` carry the sealed bytes'
+ * `fileKey` and one wrapped key per device. The bytes are fetched and opened by the listener's
+ * `downloadSealedEach` — the same fetch and open as a sealed command's attachments, one file at a time — into
+ * `~/.hwip/attachments/<eventId>/`.
+ */
+/** One wire file as the server keeps it for a sealed answer (hwip `server/src/functions/hooks.ts`). */
+export interface AnswerWireFile {
+    fileKey: string;
+    fileName: string;
+    fileType?: string;
+    fileSize?: number;
+    iv: string;
+    deviceKeyMap: Record<string, string>;
+}
+export interface SavedAnswerFiles {
+    /** Absolute paths of the files saved. */
+    paths: string[];
+    /** One `<name>: <why>` per file the seal names that was not saved. */
+    missing: string[];
+}
+/** Who opens the files: this machine's slot, and the phone key the answer's seal was checked against. */
+export interface AnswerFileOpener {
+    deviceId: string;
+    senderPublicKey: string;
+}
+/** The listener's per-file sealed download (`listener.ts` `downloadSealedEach`): each file saved or named with why. */
+export type DownloadSealed = (dirId: string, files: AnswerWireFile[], sealed: AnswerFileOpener & {
+    files: SealedFileMeta[];
+}) => Promise<SavedAnswerFiles>;
+/**
+ * Save what the seal names and the wire delivered for this machine. A file the seal names with no wire
+ * file, or no slot here, is reported missing; the rest go to the listener's download in the seal's
+ * order, each saved or reported on its own. A download that throws as a whole reports each file with why.
+ */
+export declare const saveAnswerFiles: (eventId: string, wire: unknown, metas: SealedFileMeta[], opener: AnswerFileOpener, download: DownloadSealed) => Promise<SavedAnswerFiles>;
+//# sourceMappingURL=answer-files.d.ts.map

package/dist/answer-files.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveAnswerFiles = void 0;
+/** A relay's wire file, parsed: an object with a fileKey, an iv and a key map. */
+const isWireFile = (f) => {
+    if (typeof f !== 'object' || f === null)
+        return false;
+    const { fileKey, iv, deviceKeyMap } = f; // reading an unknown object's fields, each checked here
+    return typeof fileKey === 'string' && fileKey !== '' && typeof iv === 'string' && typeof deviceKeyMap === 'object' && deviceKeyMap !== null;
+};
+/**
+ * Save what the seal names and the wire delivered for this machine. A file the seal names with no wire
+ * file, or no slot here, is reported missing; the rest go to the listener's download in the seal's
+ * order, each saved or reported on its own. A download that throws as a whole reports each file with why.
+ */
+const saveAnswerFiles = async (eventId, wire, metas, opener, download) => {
+    const given = Array.isArray(wire) ? wire.filter(isWireFile) : [];
+    const pairs = metas.map((meta) => ({
+        meta,
+        file: given.find((f) => f.iv === meta.iv && typeof f.deviceKeyMap[opener.deviceId] === 'string'),
+    }));
+    const missing = pairs.filter((p) => !p.file).map((p) => `${p.meta.name}: not delivered`);
+    const delivered = pairs.flatMap((p) => (p.file ? [{ meta: p.meta, file: p.file }] : []));
+    if (delivered.length === 0)
+        return { paths: [], missing };
+    try {
+        const saved = await download(eventId, delivered.map((d) => d.file), { ...opener, files: delivered.map((d) => d.meta) });
+        return { paths: saved.paths, missing: [...missing, ...saved.missing] };
+    }
+    catch (err) {
+        const why = err instanceof Error ? err.message : String(err);
+        return { paths: [], missing: [...missing, ...delivered.map((d) => `${d.meta.name}: ${why}`)] };
+    }
+};
+exports.saveAnswerFiles = saveAnswerFiles;

package/dist/ask-seal.d.ts

@@ -94,11 +94,15 @@ export type PreparedAsk = {
     why?: RegisterWhy;
     detail?: string;
 };
-export type OpenedAnswer = {
+export type OpenedAnswer = 
+/** `files` comes with the key that sealed them, which opens each file's slot (answer-files.ts). */
+{
     ok: true;
     actionId?: string;
     value?: string;
     exit?: true;
+    files?: SealedFileMeta[];
+    senderPublicKey?: string;
 } | {
     ok: false;
     cause: AskRefusal;

package/dist/ask-seal.js

@@ -163,13 +163,16 @@ const openAnswer = async (response, askId, offered, deps) => {
     const { actionId, exit } = opened.answer;
     if (actionId !== undefined && (offered === undefined || !offered.includes(actionId)))
         return { ok: false, cause: 'unknown-action' };
-    if (actionId === undefined && !opened.body && exit !== true)
+    // What the seal says each attached file is; the bytes come with the response's wire `files` (answer-files.ts).
+    const files = opened.files?.length ? opened.files : undefined;
+    if (actionId === undefined && !opened.body && exit !== true && !files)
         return { ok: false, cause: 'empty-answer' };
     return {
         ok: true,
         ...(actionId === undefined ? {} : { actionId }),
         ...(opened.body ? { value: opened.body } : {}),
         ...(exit === true ? { exit } : {}),
+        ...(files ? { files, senderPublicKey: sealed.senderPublicKey } : {}),
     };
 };
 exports.openAnswer = openAnswer;

package/dist/ask.d.ts

@@ -1,3 +1,5 @@
+import { type SealedFileMeta } from './crypto.js';
+import { type AnswerFileOpener, type SavedAnswerFiles } from './answer-files.js';
 import { type AskSealDeps } from './ask-seal.js';
 import { type PendingAsks } from './ask-pending.js';
 /** Poll cadence: every second for the first 30 s, when a tap is most likely
@@ -33,6 +35,11 @@ export interface AskOptions {
      * stray `exitRemote` on its answer is dropped.
      */
     acceptsExit?: boolean;
+    /**
+     * Lets the phone attach files to a typed answer; they are saved to `~/.hwip/attachments/<eventId>/`
+     * and their paths follow the text. Set with `acceptsExit`: only an agent's own ask reads a reply.
+     */
+    acceptsFiles?: boolean;
 }
 /** Injected so the poll loop is testable without a clock or a network. */
 export interface AskDeps {
@@ -43,6 +50,8 @@ export interface AskDeps {
     seal: AskSealDeps;
     /** Where a question that went up is kept, so one cut short can be taken up again. Without it, every ask is a new question. */
     pending?: PendingAsks;
+    /** Saves the files a sealed answer names (answer-files.ts). Without it they are left on the server. */
+    saveFiles?: (eventId: string, wire: unknown, metas: SealedFileMeta[], opener: AnswerFileOpener) => Promise<SavedAnswerFiles>;
 }
 /** Why an ask ended unanswered: the user cancelled it on the phone, nobody
  *  answered in time, or the server could not be reached or refused. */
@@ -54,6 +63,10 @@ export type AskOutcome = ({
     readonly answered: true;
     readonly value: string;
     readonly exitRemote?: true;
+    /** Where the answer's files were saved; their paths also follow the text in `value`. */
+    readonly files?: readonly string[];
+    /** `<name>: <why>` for each attached file that was not saved. */
+    readonly missingFiles?: readonly string[];
 } | {
     readonly answered: false;
     readonly reason: UnansweredReason;

package/dist/ask.js

@@ -29,6 +29,7 @@ const insecure_url_js_1 = require("./insecure-url.js");
 const args_js_1 = require("./args.js");
 const api_js_1 = require("./api.js");
 const crypto_js_1 = require("./crypto.js");
+const answer_files_js_1 = require("./answer-files.js");
 const listener_device_id_js_1 = require("./listener-device-id.js");
 const config_js_2 = require("./config.js");
 const self_register_js_1 = require("./self-register.js");
@@ -211,6 +212,7 @@ const trigger = async (deps, opts, deadline, prepared) => {
         agentDeviceId: opts.agentDeviceId,
         agentSessionName: opts.agentSessionName,
         ...(opts.acceptsExit ? { acceptsExit: true } : {}),
+        ...(opts.acceptsFiles ? { acceptsFiles: true } : {}),
     });
     const payload = { body, headers: { 'Idempotency-Key': (0, node_crypto_1.randomUUID)() } };
     let backoffs = 0;
@@ -238,18 +240,38 @@ const trigger = async (deps, opts, deadline, prepared) => {
         }
     }
 };
-/** What an opened answer means to the caller: the choice, or the text (with the exit when this ask offers it). */
-const sealedOutcome = (opened, acceptsExit) => {
+/**
+ * What an opened answer means to the caller: the choice, or the text (with the exit when this ask offers
+ * it). Saved files' paths follow the text, so a reader of `value` alone still finds them.
+ */
+const sealedOutcome = (opened, acceptsExit, saved) => {
     if (!opened.ok)
         return { answered: false, reason: 'error', error: (0, ask_seal_js_1.refusalMessage)(opened.cause) };
     if (opened.actionId !== undefined)
         return { answered: true, actionId: opened.actionId };
+    const value = [opened.value ?? '', ...(saved?.paths ?? [])].filter(Boolean).join('\n');
+    const files = {
+        ...(saved?.paths.length ? { files: saved.paths } : {}),
+        ...(saved?.missing.length ? { missingFiles: saved.missing } : {}),
+    };
     if (opened.exit === true && acceptsExit)
-        return { answered: true, value: opened.value ?? '', exitRemote: true };
-    if (opened.value)
-        return { answered: true, value: opened.value };
+        return { answered: true, value, exitRemote: true, ...files };
+    if (value || saved)
+        return { answered: true, value, ...files };
     return { answered: false, reason: 'error', error: (0, ask_seal_js_1.refusalMessage)('empty-answer') };
 };
+/** The answer's files, saved — when this ask took files, the answer names some, and this machine has its key. */
+const saveFilesOf = async (deps, opts, eventId, response, opened) => {
+    if (!opened.ok || !opened.files || !opened.senderPublicKey)
+        return undefined;
+    // Not offered on this ask: said, not dropped.
+    if (!opts.acceptsFiles || !deps.saveFiles)
+        return { paths: [], missing: opened.files.map((m) => `${m.name}: this ask does not take files`) };
+    const deviceId = deps.seal.self()?.deviceId;
+    if (!deviceId)
+        return { paths: [], missing: opened.files.map((m) => `${m.name}: this machine has no key`) };
+    return deps.saveFiles(eventId, response?.files, opened.files, { deviceId, senderPublicKey: opened.senderPublicKey });
+};
 /**
  * Read the question's answer until there is one, the question ends without, or `until` passes — once
  * at least, whatever the clock says: the answer may be there already.
@@ -277,7 +299,8 @@ const awaitAnswer = async (deps, opts, asked, until, unconfirmed) => {
                     lastError = new Error((0, ask_seal_js_1.refusalMessage)(opened.cause));
                 }
                 else {
-                    return { outcome: sealedOutcome(opened, opts.acceptsExit === true), end: mayPass ? 'open' : 'over' };
+                    const saved = await saveFilesOf(deps, opts, asked.eventId, event.data.response, opened);
+                    return { outcome: sealedOutcome(opened, opts.acceptsExit === true, saved), end: mayPass ? 'open' : 'over' };
                 }
             }
             if (event.data?.status === 'cancelled')
@@ -478,6 +501,13 @@ const liveDeps = (account) => ({
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     seal: (0, exports.liveSealDeps)(account.apiKey, account.baseUrl, account.deadline),
     pending: (0, ask_pending_js_1.pendingAsks)((0, gate_js_1.stateDir)()),
+    saveFiles: async (eventId, wire, metas, opener) => {
+        // The listener's download, borrowed: its log is the daemon's stdout, and this command's stdout is one JSON line.
+        const { downloadSealedEach } = await import('./listener.js');
+        const { silenceListenerLog } = await import('./listener-log.js');
+        silenceListenerLog();
+        return (0, answer_files_js_1.saveAnswerFiles)(eventId, wire, metas, opener, (dirId, files, sealed) => downloadSealedEach(dirId, files, { apiKey: account.apiKey, baseUrl: account.baseUrl }, sealed));
+    },
 });
 exports.liveDeps = liveDeps;
 /**
@@ -536,6 +566,7 @@ const handleAsk = async (args) => {
         timeoutSeconds: windowSeconds,
         ...((0, agent_session_js_1.agentSessionContext)() ?? {}),
         acceptsExit,
+        acceptsFiles: acceptsExit,
     }, (0, exports.liveDeps)({ apiKey, baseUrl: baseUrl.replace(/\/+$/, ''), deadline: Date.now() + windowSeconds * 1000 }));
     // The agent's own ask settles REMOTE as mcp-server's hwip_ask does and
     // reports it in the same `hwipState` field; an approval gate leaves the

package/dist/config.d.ts

@@ -51,6 +51,20 @@ export declare const HERDR_SESSION_OPTIONS: {
     readonly HERDR_SOCKET_PATH: "@hwip_herdr_socket";
     readonly HERDR_BIN_PATH: "@hwip_herdr_bin";
 };
+/**
+ * The env herdr gives the processes of its panes, and its native agent integrations
+ * (`herdr integration install <agent>`) read to find their pane. Under tmux an agent
+ * inherits the tmux server's global env, copied from the terminal that started the
+ * server: a herdr pane long closed, never the pane attaching now. The wrapper sets
+ * them on every session it creates (wrapper `herdrEnvArgs`).
+ */
+export declare const HERDR_ENV_VARS: readonly ["HERDR_ENV", "HERDR_PANE_ID", "HERDR_SOCKET_PATH", "HERDR_BIN_PATH", "HERDR_TAB_ID", "HERDR_WORKSPACE_ID", "HERDR_STARTUP_CWD"];
+/**
+ * Agent kinds hwip reports to herdr itself (`HERDR_SESSION_OPTIONS`). herdr's native
+ * integration must stay silent for them: a second report on the pane replaces hwip's
+ * label, and its release drops both (measured on herdr 0.9.3).
+ */
+export declare const HERDR_SELF_REPORTING_KINDS: ReadonlySet<string>;
 /**
  * Set by `hwip sh` on the session it opens, to that session's own name. The
  * one exception to the listener's shell-pane refusal. Only a process on this

package/dist/config.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = exports.saveConfig = exports.configWriteProblem = exports.resolveBaseUrl = exports.checkBaseUrl = exports.fileKeyBaseRefusal = exports.keyIsFromFile = exports.configIgnoredBecause = exports.loadConfig = exports.configModeProblem = exports.detectProjectDir = exports.PROJECT_DIR_ENV_VARS = exports.groupOf = exports.checkoutOf = exports.tmuxName = exports.SESSION_SHELL_OPTION = exports.HERDR_SESSION_OPTIONS = exports.SESSION_LABEL_OPTION = exports.SESSION_PROJECT_OPTION = exports.resolveHookId = exports.resolvedEnv = exports.unreadableConfigDefaults = exports.TRUST_FILE = exports.CONFIG_FILE = exports.CONFIG_DIR = void 0;
+exports.VERSION = exports.saveConfig = exports.configWriteProblem = exports.resolveBaseUrl = exports.checkBaseUrl = exports.fileKeyBaseRefusal = exports.keyIsFromFile = exports.configIgnoredBecause = exports.loadConfig = exports.configModeProblem = exports.detectProjectDir = exports.PROJECT_DIR_ENV_VARS = exports.groupOf = exports.checkoutOf = exports.tmuxName = exports.SESSION_SHELL_OPTION = exports.HERDR_SELF_REPORTING_KINDS = exports.HERDR_ENV_VARS = exports.HERDR_SESSION_OPTIONS = exports.SESSION_LABEL_OPTION = exports.SESSION_PROJECT_OPTION = exports.resolveHookId = exports.resolvedEnv = exports.unreadableConfigDefaults = exports.TRUST_FILE = exports.CONFIG_FILE = exports.CONFIG_DIR = void 0;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const os_1 = require("os");
@@ -42,6 +42,28 @@ exports.HERDR_SESSION_OPTIONS = {
     HERDR_SOCKET_PATH: '@hwip_herdr_socket',
     HERDR_BIN_PATH: '@hwip_herdr_bin',
 };
+/**
+ * The env herdr gives the processes of its panes, and its native agent integrations
+ * (`herdr integration install <agent>`) read to find their pane. Under tmux an agent
+ * inherits the tmux server's global env, copied from the terminal that started the
+ * server: a herdr pane long closed, never the pane attaching now. The wrapper sets
+ * them on every session it creates (wrapper `herdrEnvArgs`).
+ */
+exports.HERDR_ENV_VARS = [
+    'HERDR_ENV',
+    'HERDR_PANE_ID',
+    'HERDR_SOCKET_PATH',
+    'HERDR_BIN_PATH',
+    'HERDR_TAB_ID',
+    'HERDR_WORKSPACE_ID',
+    'HERDR_STARTUP_CWD',
+];
+/**
+ * Agent kinds hwip reports to herdr itself (`HERDR_SESSION_OPTIONS`). herdr's native
+ * integration must stay silent for them: a second report on the pane replaces hwip's
+ * label, and its release drops both (measured on herdr 0.9.3).
+ */
+exports.HERDR_SELF_REPORTING_KINDS = new Set(['claude', 'pi']);
 /**
  * Set by `hwip sh` on the session it opens, to that session's own name. The
  * one exception to the listener's shell-pane refusal. Only a process on this

package/dist/listener.d.ts

@@ -22,6 +22,7 @@
  */
 import { type HwipConfig } from './config.js';
 import { type ShellAuditEntry } from './shell-audit.js';
+import { type KnownSession } from './session-registry.js';
 import { type AgentKind } from './remote-agents.js';
 import { type TranscriptSource } from './transcript-tail.js';
 import { type AgentState } from './agent-state.js';
@@ -39,6 +40,7 @@ import { silenceListenerLog } from './listener-log.js';
 import { invalidateTmuxSocketCache, tmuxArgs } from './tmux-socket.js';
 import { detectRemoteAgent, isSubagentSessionName, recordSubagentTranscripts, recordTargets, subagentTranscriptFor, tmuxTargetFor } from './tmux-pane.js';
 import { liveSessionNames, sessionExists, sessionLiveness } from './tmux-liveness.js';
+import { type RunSeqs } from './run-seqs.js';
 import { type PhoneScheduleDeps } from './schedule-remote.js';
 import { type ScheduleRunnerDeps } from './schedule-runner.js';
 export declare const PING_IDLE_MS = 240000;
@@ -120,6 +122,16 @@ interface AgentSession {
      */
     providerSessionName?: string | null;
     createdAt?: string;
+    /**
+     * Which run of the name this is (hwip docs/session-runs.md): tmux
+     * `session_created` in epoch seconds, as a decimal string — the same
+     * instant as `createdAt`. A name is handed out again when an agent starts
+     * in the same folder; this is what tells the two apart. Absent on subagent
+     * rows, which are panes of their parent's run.
+     */
+    runId?: string;
+    /** The smallest seq this run's chunks took (hwip docs/session-runs.md Q24): the server reads its conversation from there up. */
+    firstSeq?: number;
     lastActivityAt?: string;
     /**
      * Detected agent state (wire contract — flows to the server and the
@@ -196,15 +208,25 @@ export type StaleConnectionAction =
  * tested as what it is: two guards around one lever.
  */
 export declare const staleConnectionAction: (message: unknown, drops: number) => StaleConnectionAction;
-export declare const KNOWN_SESSIONS_REPORTED = 30;
+export declare const KNOWN_SESSIONS_REPORTED = 50;
 export interface ReportedKnownSession {
     name: string;
     agentKind: string;
     project?: string;
     label?: string;
+    /** The run's id and start (hwip docs/session-runs.md); absent for entries recorded before runs. */
+    runId?: string;
+    startedAt?: string;
+    /** The seq block the run's chunks took (Q24): the server reads its conversation from that key range alone. */
+    firstSeq?: number;
+    lastSeq?: number;
+    /** The later tmux sessions the run went on in (Q35): the server ends another run's push window at their start. */
+    tmuxRunIds?: string[];
     lastSeenAt: string;
 }
-export declare const knownSessionsToReport: (live: readonly AgentSession[], now?: number) => ReportedKnownSession[];
+/** Each live run's first seq, for the report (Q24). A run that has recorded nothing yet has none. */
+export declare const withRunSeqs: (sessions: AgentSession[], seqs?: Map<string, RunSeqs>) => AgentSession[];
+export declare const knownSessionsToReport: (live: readonly AgentSession[], now?: number, seqs?: Map<string, RunSeqs>) => ReportedKnownSession[];
 export declare const knownSessionsFingerprint: (known: ReportedKnownSession[]) => string;
 export declare const sessionsFingerprint: (sessions: AgentSession[]) => string;
 /** True when this cycle's inventory must be sent: it changed, or the
@@ -270,6 +292,20 @@ export declare const parseSessionName: (name: string, sidecar?: {
 } | null;
 /** Test seam: how many directories have been looked up. */
 export declare const __checkoutCacheSize: () => number;
+/**
+ * A run's id from tmux's `session_created` (hwip docs/session-runs.md): the
+ * whole epoch seconds as a decimal string. The server derives the same string
+ * from `createdAt` for listeners that do not send one (`runIdOf`), so the two
+ * must agree: `epochToIso` keeps whole seconds and this floors them.
+ */
+export declare const runIdOfEpoch: (epoch: string | undefined) => string | undefined;
+/**
+ * Each live session's run once the sweep has read the conversations (hwip
+ * docs/session-runs.md §3): a session carrying on an earlier run's
+ * conversation reports — and its recorder tags — that run instead of its new
+ * tmux session. `sessions` and `recordable` are this sweep's, changed in place.
+ */
+export declare const continueRuns: (sessions: AgentSession[], recordable: Record<string, RecordableSession>, conversationOf: (name: string) => string | null | undefined, known?: readonly KnownSession[]) => void;
 /** Test hook. */
 export declare const resetSessionStates: () => void;
 /**
@@ -514,6 +550,8 @@ export interface SessionForgetRequest {
      *  the phone deletes the row it is looking at. Absent (older phone) deletes
      *  every run under the name, which is what the request used to mean. */
     agentKind?: string;
+    /** With `agentKind`, the one run of it to delete (hwip docs/session-runs.md). Absent: every run of that agent. */
+    runId?: string;
     requestId?: string;
 }
 export interface SessionForgetResult {
@@ -1211,6 +1249,26 @@ export declare const downloadAttachments: (pushId: string, files: PushFileAttach
     apiKey: string;
     baseUrl: string;
 }, sealed?: SealedAttachments, io?: AttachmentIo) => Promise<string[]>;
+/**
+ * The most a sealed answer file may download as: its seal's size padded, and the tag. The relay
+ * points at the bytes, so it could name a larger object; nothing past this is read.
+ */
+export declare const answerFileBound: (size: number | undefined) => number;
+/**
+ * The attachments of a sealed answer (`hwip ask`, answer-files.ts), saved one by one to
+ * `~/.hwip/attachments/<eventId>/<name>`. Unlike a command's, a file that fails does not take the
+ * others with it: the answer is the user's word either way, and each file not saved is named with why.
+ * `sealed.files` gives each file's meta in the same order.
+ */
+export declare const downloadSealedEach: (eventId: string, files: PushFileAttachment[], ctx: {
+    apiKey: string;
+    baseUrl: string;
+}, sealed: SealedAttachments & {
+    files: SealedFileMeta[];
+}, io?: AttachmentIo) => Promise<{
+    paths: string[];
+    missing: string[];
+}>;
 export interface SaveFileDeps {
     ctx: {
         apiKey: string;