@hwip/cli 0.1.4 → 0.1.6

package/dist/listener.js

@@ -100,6 +100,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");
@@ -319,11 +320,14 @@ const knownSessionsToReport = (live, now = Date.now(), seqs = (0, run_seqs_js_1.
         ...(e.startedAt ? { startedAt: e.startedAt } : {}),
         ...(e.runId ? seqs.get((0, run_seqs_js_1.runSeqsKey)(e.name, e.runId)) : undefined),
         ...(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(',') ?? ''}`).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([
@@ -1363,6 +1367,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}$/;
 /**
@@ -1378,6 +1389,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.
@@ -1421,14 +1452,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`);
@@ -1449,14 +1493,15 @@ 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'] });
+    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'] });
     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;
 /**
@@ -1616,7 +1661,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`);
@@ -1750,11 +1795,11 @@ const handleScreenHistoryRequest = (req, send) => {
         return reply({ error: 'capture_failed' });
     // Everything below this line the caller already has.
     const held = before;
-    // Scrolled past the oldest line. An empty page rather than an error — the
-    // view stops, and stopping is not a failure. Nothing to seal either.
-    if (depth <= held)
-        return reply({ before, content: '', lines: 0, hasMore: false });
-    const captured = capturePaneRange(req.sessionName, -(held + lines), -(held + 1));
+    // Scrolled past the oldest line: an empty page rather than an error — the
+    // view stops, and stopping is not a failure.
+    const captured = depth <= held
+        ? { content: '', truncated: false }
+        : capturePaneRange(req.sessionName, -(held + lines), -(held + 1));
     if (!captured)
         return reply({ error: 'capture_failed' });
     const returned = countLines(captured.content);
@@ -1766,11 +1811,21 @@ const handleScreenHistoryRequest = (req, send) => {
     };
     if (!stream.subscriberPublicKey)
         return reply({ ...page, content: captured.content });
-    // Encrypted stream: the page rides ONLY inside the envelope, and a failed
-    // seal is an error rather than a plaintext page — the same rule the frame
-    // path follows when its encrypt fails.
-    (0, crypto_js_1.sealV2)('screen.history', captured.content, stream.subscriberPublicKey, req.sessionName)
-        .then((encrypted) => send({ ...base, ...page, encrypted }))
+    // Encrypted stream: the page and its numbers ride ONLY inside the envelope
+    // — the empty last page too, or a relay could end the paging with one — and
+    // a failed seal is an error rather than a plaintext page, the same rule the
+    // frame path follows when its encrypt fails.
+    const sealed = {
+        sessionName: req.sessionName,
+        requestId: req.requestId,
+        ...(stream.nonce ? { nonce: stream.nonce } : {}),
+        epoch: stream.epoch,
+        ...page,
+        historySize: depth,
+        content: captured.content,
+    };
+    (0, crypto_js_1.sealV2)('screen.history', JSON.stringify(sealed), stream.subscriberPublicKey, req.sessionName)
+        .then((encrypted) => send({ ...base, encrypted }))
         .catch((err) => {
         (0, listener_log_js_1.log)(`⧉ history ${req.sessionName}: seal failed (${err instanceof Error ? err.message : err})`);
         send({ ...base, error: 'encrypt_failed' });
@@ -3639,6 +3694,8 @@ const collectSessionsVerbose = () => {
         startedAt: s.createdAt,
         tmuxRunId: runIdOfIso(s.createdAt),
         agentSessionId: ownResumeId(s.name),
+        providerSessionName: s.providerSessionName,
+        providerSessionNameSource: s.providerSessionNameSource,
     })));
     return { sessions, rejected, targets, subagentTranscripts, recordable };
 };
@@ -4617,7 +4674,7 @@ const openSealedCommand = async (push, deps) => {
     return { text: opened.body ?? '', sender: senderKey, files: named, keys, ifPrompt, schedule };
 };
 /**
- * A phone's request to make or remove a schedule (F8). The decisions are `applyPhoneSchedule`'s; this spends
+ * A phone's request to make, change or remove a schedule (F8). The decisions are `applyPhoneSchedule`'s; this spends
  * the session's rate budget the way a typed command does and reports a refusal the way every command does.
  * Never types anything. A push no one addressed to this machine is not acted on: it changes files, and a
  * push.new reaches every listener of the account.

package/dist/mcp-command.d.ts

@@ -45,7 +45,7 @@ export declare const MCP_SERVERS_ENTRY: {
  */
 export declare const OPENCODE_MCP_ENTRY: {
     type: string;
-    command: ("mcp" | "hwip")[];
+    command: ("hwip" | "mcp")[];
     enabled: boolean;
 };
 export declare const GEMINI_MCP_ADD: string;

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/schedule-command.d.ts

@@ -1,5 +1,5 @@
 /**
- * `hwip schedule` — add, list and remove scheduled sessions (F8).
+ * `hwip schedule` — add, list, edit and remove scheduled sessions (F8).
  *
  * This only writes and reads the files in `schedule.ts`. The listener starts the sessions
  * (`schedule-runner.ts`), so nothing here needs a running listener except the sessions firing.
@@ -16,6 +16,11 @@ export interface ScheduleCommandDeps {
     listenerRunning: () => boolean;
     /** The agent kinds a prompt can be scheduled for: those whose detection rules can say `idle` (`schedule-ready.ts`). */
     promptKinds: () => readonly string[];
+    /**
+     * Has a running listener of an older build replaced (`ensureListenerRunning`): an old one would skip a file it cannot read.
+     * False when one still runs after it.
+     */
+    refreshListener: () => Promise<boolean>;
     out: (line: string) => void;
     err: (line: string) => void;
 }
@@ -27,6 +32,11 @@ interface Built {
 }
 /** The schedule `hwip schedule add <words>` asks for, before it has an id. */
 export declare const buildSchedule: (words: string[], deps: ScheduleCommandDeps) => Promise<Checked<Built>>;
+/**
+ * Runs `work` with what it prints going to stderr: the listener refresh reports on stdout (`ensureListenerRunning`),
+ * and `hwip schedule edit --json` promises one JSON line there.
+ */
+export declare const onStderr: (work: () => Promise<void>) => Promise<void>;
 /** `words`: argv after `schedule`. Returns the exit code. */
 export declare const runSchedule: (words: string[], deps: ScheduleCommandDeps) => Promise<number>;
 export declare const liveScheduleDeps: () => ScheduleCommandDeps;

package/dist/schedule-command.js

@@ -1,12 +1,12 @@
 "use strict";
 /**
- * `hwip schedule` — add, list and remove scheduled sessions (F8).
+ * `hwip schedule` — add, list, edit and remove scheduled sessions (F8).
  *
  * This only writes and reads the files in `schedule.ts`. The listener starts the sessions
  * (`schedule-runner.ts`), so nothing here needs a running listener except the sessions firing.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleSchedule = exports.liveScheduleDeps = exports.runSchedule = exports.buildSchedule = exports.describeWhen = void 0;
+exports.handleSchedule = exports.liveScheduleDeps = exports.runSchedule = exports.onStderr = exports.buildSchedule = exports.describeWhen = void 0;
 const args_js_1 = require("./args.js");
 const schedule_js_1 = require("./schedule.js");
 const config_js_1 = require("./config.js");
@@ -16,6 +16,7 @@ const schedule_ready_js_1 = require("./schedule-ready.js");
 const wrapper_js_1 = require("./wrapper.js");
 const worktree_js_1 = require("./worktree.js");
 const USAGE = "usage: hwip schedule add <agent> (--at HH:MM [--days daily|weekdays|mon,wed,…] | --every <N>m|<N>h) [--prompt <text>] [--label <x>] [--wt <branch>] [--max-runtime <N>m|<N>h] [-- <agent args…>]\n"
+    + '       hwip schedule edit <id> [--at HH:MM] [--days …] [--every <N>m|<N>h] [--prompt <text>] [--max-runtime <N>m|<N>h]\n'
     + '       hwip schedule [list] [--json]\n'
     + '       hwip schedule rm <id>';
 const LISTENER_NOTE = "hwip: schedules start only while the listener runs ('hwip listener --install-service' keeps it running at login)";
@@ -142,7 +143,7 @@ const handleAdd = async (words, json, deps) => {
         return 2;
     }
     const { schedule } = added;
-    const next = (0, schedule_js_1.nextOccurrence)(schedule.when, deps.now(), Date.parse(schedule.createdAt));
+    const next = (0, schedule_js_1.nextOccurrence)(schedule.when, deps.now(), (0, schedule_js_1.scheduleAnchor)(schedule));
     if (json) {
         deps.out(JSON.stringify({ ...schedule, nextAt: isoOrNull(next) }));
     }
@@ -159,7 +160,7 @@ const handleList = (json, deps) => {
     const state = (0, schedule_js_1.readScheduleState)().schedules;
     const now = deps.now();
     const rows = schedules.map((schedule) => {
-        const next = (0, schedule_js_1.nextOccurrence)(schedule.when, now, Date.parse(schedule.createdAt));
+        const next = (0, schedule_js_1.nextOccurrence)(schedule.when, now, (0, schedule_js_1.scheduleAnchor)(schedule));
         const last = state[schedule.id]?.last;
         return { schedule, next, last, running: state[schedule.id]?.running !== undefined };
     });
@@ -216,6 +217,108 @@ const handleRemove = (id, deps) => {
     deps.out(`removed ${id}. A session it already started keeps running; end it yourself if you want it gone.`);
     return 0;
 };
+/**
+ * Runs `work` with what it prints going to stderr: the listener refresh reports on stdout (`ensureListenerRunning`),
+ * and `hwip schedule edit --json` promises one JSON line there.
+ */
+const onStderr = async (work) => {
+    const log = console.log;
+    console.log = console.error;
+    try {
+        await work();
+    }
+    finally {
+        console.log = log;
+    }
+};
+exports.onStderr = onStderr;
+/** The schedule's new `when` from the flags given: what is not given is kept, so `--at` keeps the days and `--days` the time. */
+const editedWhen = (current, at, days, every) => {
+    if (at === undefined && days === undefined && every === undefined)
+        return { ok: true, value: undefined };
+    if (every !== undefined || at !== undefined) {
+        const keptDays = current.kind === 'daily' ? current.days.map((day) => schedule_js_1.DAY_NAMES[day]).join(',') : undefined;
+        return (0, schedule_js_1.parseWhen)({ at, every, days: days ?? (every === undefined ? keptDays : undefined) });
+    }
+    if (current.kind !== 'daily')
+        return { ok: false, error: '--days needs --at HH:MM for a schedule that runs --every' };
+    return (0, schedule_js_1.parseWhen)({ at: current.at, days });
+};
+const buildChange = (current, flags, deps) => {
+    if (flags._arg1)
+        return { ok: false, error: `unexpected word '${String(flags._arg1)}'` };
+    const fixed = ['label', 'wt'].find((name) => flags[name] !== undefined);
+    if (fixed)
+        return { ok: false, error: `--${fixed} cannot be edited: the session is named for it; remove the schedule and add it again` };
+    const read = (name) => flagText(flags, name);
+    const [at, days, every, prompt, maxRuntime] = ['at', 'days', 'every', 'prompt', 'max-runtime'].map(read);
+    const bad = [at, days, every, prompt, maxRuntime].find((r) => !r.ok);
+    if (bad && !bad.ok)
+        return bad;
+    const value = (r) => (r.ok ? r.value : undefined);
+    const when = editedWhen(current.when, value(at), value(days), value(every));
+    if (!when.ok)
+        return when;
+    const change = when.value === undefined ? {} : { when: when.value };
+    const text = value(prompt);
+    if (text !== undefined) {
+        if (text.trim() === '')
+            return { ok: false, error: '--prompt must not be empty' };
+        if (!deps.promptKinds().includes(current.agentKind)) {
+            return { ok: false, error: `${current.agentKind} cannot take a scheduled --prompt: hwip has no rule that tells when it is idle` };
+        }
+        change.prompt = text;
+    }
+    if (value(maxRuntime) !== undefined) {
+        const parsed = (0, schedule_js_1.parseDuration)(value(maxRuntime), '--max-runtime', '90m or 2h');
+        if (!parsed.ok)
+            return parsed;
+        change.maxRuntimeMin = parsed.value;
+    }
+    if (Object.keys(change).length === 0)
+        return { ok: false, error: 'edit needs --at, --days, --every, --prompt or --max-runtime' };
+    return { ok: true, value: change };
+};
+const handleEdit = async (words, json, deps) => {
+    // `parseArgs` reads the words after the program name and script; the first word is the id.
+    const flags = (0, args_js_1.parseArgs)(['node', 'hwip', ...words]);
+    const id = flags._command === undefined ? '' : String(flags._command);
+    if (!(0, schedule_js_1.isScheduleId)(id)) {
+        deps.err(id ? `hwip schedule: '${id}' is not a schedule id` : 'hwip schedule: edit needs a schedule id');
+        return 2;
+    }
+    const current = (0, schedule_js_1.listSchedules)().schedules.find((schedule) => schedule.id === id);
+    if (!current) {
+        deps.err(`hwip schedule: no schedule ${id}`);
+        return 1;
+    }
+    const change = buildChange(current, flags, deps);
+    if (!change.ok) {
+        deps.err(`hwip schedule: ${change.error}`);
+        return 2;
+    }
+    // A new time writes `updatedAt`, which an older listener does not know: it would skip the file and the schedule would stop.
+    if (deps.listenerRunning() && !(await deps.refreshListener()) && change.value.when !== undefined) {
+        deps.err('hwip schedule: the listener running is an older hwip that could not be replaced, and it would stop running this schedule: restart it, then edit again');
+        return 1;
+    }
+    const updated = (0, schedule_js_1.updateSchedule)(id, change.value, deps.now());
+    if (!updated.ok) {
+        deps.err(`hwip schedule: ${updated.error}`);
+        return updated.failure === 'missing' ? 1 : 2;
+    }
+    const { schedule } = updated;
+    const next = (0, schedule_js_1.nextOccurrence)(schedule.when, deps.now(), (0, schedule_js_1.scheduleAnchor)(schedule));
+    if (json) {
+        deps.out(JSON.stringify({ ...schedule, nextAt: isoOrNull(next) }));
+    }
+    else {
+        deps.out(`updated ${schedule.id}: ${(0, exports.describeWhen)(schedule.when)}${next === null ? '' : `, next ${formatTime(next)}`} (ends after ${schedule.maxRuntimeMin}m)`);
+    }
+    if (!deps.listenerRunning())
+        deps.err(LISTENER_NOTE);
+    return 0;
+};
 const JSON_ON = new Set(['--json', '--json=true', '--json=1', '--json=yes']);
 /** `words`: argv after `schedule`. Returns the exit code. */
 const runSchedule = async (words, deps) => {
@@ -229,6 +332,8 @@ const runSchedule = async (words, deps) => {
     switch (sub) {
         case 'add':
             return handleAdd(rest, json, deps);
+        case 'edit':
+            return handleEdit(rest, json, deps);
         case 'list':
             if (rest.length > 0)
                 break;
@@ -252,6 +357,10 @@ const liveScheduleDeps = () => ({
     validBranch: (root, name) => (0, worktree_js_1.isValidBranchName)(root, name),
     listenerRunning: () => (0, listener_process_js_1.runningListenerPid)() !== null,
     promptKinds: () => (0, schedule_ready_js_1.promptableScheduleKinds)(remote_agents_js_1.REMOTE_AGENTS.map((a) => a.kind)),
+    refreshListener: async () => {
+        await (0, exports.onStderr)(() => (0, wrapper_js_1.ensureListenerRunning)(false));
+        return (0, listener_process_js_1.runningListenerPid)() === null || !(0, wrapper_js_1.listenerVersionDrifted)((0, listener_process_js_1.runningListenerVersion)(), config_js_1.VERSION);
+    },
     out: (line) => console.log(line),
     err: (line) => console.error(line),
 });

package/dist/schedule-launch.d.ts

@@ -2,7 +2,8 @@
  * Runs `hwip <agent> --detach …` for a scheduled session, as a child of the listener (F8). The child gets the schedule's
  * directory as its cwd and none of the project-dir env vars, so it resolves its project from that directory and not from
  * whatever shell once started the listener; and it is told it is the listener's own, so it does not "repair" the listener
- * that is running it (see `LISTENER_LAUNCH_ENV`).
+ * that is running it (see `LISTENER_LAUNCH_ENV`). Its PATH also gets the directories the person's shell found agents in
+ * (agent-dirs.ts): the service's own PATH has none of them.
  */
 import { execFile as nodeExecFile } from 'child_process';
 import type { LaunchResult } from './schedule-runner.js';
@@ -10,6 +11,7 @@ export interface LaunchDeps {
     execFile?: typeof nodeExecFile;
     cliPath?: () => string | null;
     env?: NodeJS.ProcessEnv;
+    agentPath?: (path: string | undefined) => string;
 }
 export declare const launchHwip: (argv: string[], cwd: string, timeoutMs: number, deps?: LaunchDeps) => Promise<LaunchResult>;
 //# sourceMappingURL=schedule-launch.d.ts.map

package/dist/schedule-launch.js

@@ -3,11 +3,13 @@
  * Runs `hwip <agent> --detach …` for a scheduled session, as a child of the listener (F8). The child gets the schedule's
  * directory as its cwd and none of the project-dir env vars, so it resolves its project from that directory and not from
  * whatever shell once started the listener; and it is told it is the listener's own, so it does not "repair" the listener
- * that is running it (see `LISTENER_LAUNCH_ENV`).
+ * that is running it (see `LISTENER_LAUNCH_ENV`). Its PATH also gets the directories the person's shell found agents in
+ * (agent-dirs.ts): the service's own PATH has none of them.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.launchHwip = void 0;
 const child_process_1 = require("child_process");
+const agent_dirs_js_1 = require("./agent-dirs.js");
 const config_js_1 = require("./config.js");
 const listener_process_js_1 = require("./listener-process.js");
 const launchHwip = (argv, cwd, timeoutMs, deps = {}) => new Promise((resolve) => {
@@ -17,6 +19,7 @@ const launchHwip = (argv, cwd, timeoutMs, deps = {}) => new Promise((resolve) =>
     const env = { ...(deps.env ?? process.env), [listener_process_js_1.LISTENER_LAUNCH_ENV]: '1' };
     for (const key of config_js_1.PROJECT_DIR_ENV_VARS)
         delete env[key];
+    env.PATH = (deps.agentPath ?? agent_dirs_js_1.withAgentDirs)(env.PATH);
     (deps.execFile ?? child_process_1.execFile)(process.execPath, [cliPath, ...argv], { cwd, env, encoding: 'utf-8', timeout: timeoutMs }, (err, _stdout, stderr) => {
         resolve(err ? { ok: false, error: stderr || err.message } : { ok: true });
     });

package/dist/schedule-remote.d.ts

@@ -15,6 +15,11 @@ export interface PhoneScheduleItem {
     session: string;
     when: ScheduleWhen;
     prompt?: string;
+    /**
+     * The phone cannot change the prompt: what is here is not all of it (cut, or left out for room), or the schedule has
+     * agent arguments the computer gave. The app shows it and leaves it to `hwip schedule edit`.
+     */
+    promptLocked?: true;
     maxRuntimeMin: number;
     /** ISO time of the next run; null when there is none. */
     nextAt: string | null;
@@ -70,7 +75,8 @@ export interface PhoneScheduleDeps {
 export declare const livePhoneScheduleDeps: PhoneScheduleDeps;
 /**
  * Carry out one change the phone asked for: `{ op: 'create', when, prompt, agentKind?, maxRuntimeMin? }` for the
- * recorded session `session`, or `{ op: 'remove', id }` for the schedule whose session that is. Nothing here
+ * recorded session `session`, `{ op: 'update', id, when?, prompt?, maxRuntimeMin? }` or `{ op: 'remove', id }` for the
+ * schedule whose session that is. Nothing here
  * types into a session. `request` is whatever the phone sealed, so every field is checked as it is used.
  */
 export declare const applyPhoneSchedule: (request: unknown, session: string, deps?: PhoneScheduleDeps) => PhoneScheduleResult;