@hwip/cli 0.1.4 → 0.1.5

package/README.md

@@ -645,8 +645,9 @@ went.
 - **The prompt** (`--prompt`) is typed once, and only when the agent is the foreground program of the pane and its detection rules read the screen as `idle` — not working, not a dialog. If that does not happen within 90 seconds the prompt is not typed, the session stays, and the phone is told. **Only agents that have an `idle` rule can take a prompt** (today Claude Code, Codex, Gemini CLI and pi): for any other agent nothing separates "ready" from a trust or permission dialog, and the Enter that submits a prompt would answer the dialog's default with nobody there to read it. `hwip schedule add … --prompt` refuses those agents and says which ones work; a schedule without `--prompt` starts any agent. The rules that decide this are the ones shipped in the `hwip` package, not the detection rules the listener updates over the air: a phone's input is typed by someone who has seen the screen, a schedule by nobody, and a rule set that arrives over the air is not signed — it must not be able to call a dialog `idle` and have your prompt and Enter typed into it.
 - **The cap**: a session that runs longer than `--max-runtime` is asked to end the way the phone's *end session* does — the agent's own quit command, then signals. It is never killed; one that stays keeps the schedule from starting its next run (`overlap`).
 - **The phone is told** with one push per listener tick, listing each schedule with how many times and why (`<label> · 놓침 31회` — the push is in Korean). A run skipped because the last one is still going counts once until the result changes; a push that does not go out is tried again after 30 seconds, then 1, 2, 4 … minutes up to 30 (only a refusal by the server, such as the daily limit, is not tried again; a timeout, a proxy or a captive portal in the way is), and is dropped after 24 hours. The push has one title per kind of news — skipped or missed, over its runtime, or a prompt not typed — and a general one when a push holds several kinds. The prompt is never in it. A free account sends at most 100 pushes a day (`pushPerDay`), which is why these are batched.
-- **State** is files under `~/.local/state/hwip`: one `schedules/<id>.json` per schedule (limit 20) and `schedule-state.json`, written only by the listener, with where each schedule has got to.
-- **From the phone**: the app lists the schedules of a computer, makes one for a session this computer has run, and removes one. It names the session, a time and what to do; the directory, the agent's command and its arguments are never the phone's (see *Defense*). A schedule made there needs an agent that can take a prompt, and shows in `hwip schedule` like any other.
+- **Editing**: `hwip schedule edit <id>` changes the time (`--at`, `--days`, `--every`), `--prompt` and `--max-runtime` of a schedule in place; the id, the session, the directory and the agent stay. What a flag does not name is kept — `--at` keeps the days, `--days` the time. A changed time counts from the edit: the times before it are neither started nor counted as missed, and an `--every` schedule runs one period after the edit; changing only the prompt or the run time keeps the schedule on its times. A session already running keeps going. A listener of an older build is restarted first, because it would skip the edited file as unreadable; when it cannot be replaced, a new time is not written (exit 1) and the schedule keeps running as it was.
+- **State** is files under `~/.local/state/hwip`: one `schedules/<id>.json` per schedule (limit 20) and `schedule-state.json`, written only by the listener, with where each schedule has got to. `agent-dirs.json` holds the directories `hwip <agent>` typed in a shell found its agent in: a listener run as a login service has only the PATH its service file baked, so a scheduled launch adds these to it — run an agent from a shell once (`hwip cc`) before scheduling it, or the run is skipped with `'claude' not found on PATH` in `~/.hwip/listener.log`.
+- **From the phone**: the app lists the schedules of a computer, makes one for a session this computer has run, edits one, and removes one. It names the session, a time and what to do; the directory, the agent's command and its arguments are never the phone's (see *Defense*). A schedule made there needs an agent that can take a prompt, and shows in `hwip schedule` like any other.
 
 ### Session history
 
@@ -832,7 +833,7 @@ The phone also reads this machine's schedules (see [Scheduled sessions](#schedul
 { subtype: 'agent.schedule.list.result',  requestId, at, schedules | encrypted | error }
 ```
 
-`schedules` is the list as a JSON string; `encrypted` is the list sealed for the asking device (purpose `schedule.list`, bound to this machine's device id) as `{ v: 1, requestId, at, schedules: [...], unreadable? }` — the app checks that the `requestId` inside is the one it asked, so an older sealed list is not taken for a newer answer. `unreadable` is how many schedule files could not be read; a directory that cannot be listed at all, or that holds more than 20 files, is the error `read_failed`, never an empty list (and a remove then fails as `schedule_failed`; `hwip schedule rm` still works on the computer). A list too long for one frame has its prompts shortened, step by step (`too_large` only when it does not fit even without them). Each entry holds `id`, `source`, `agentKind`, `project` (the directory's name, not its path), `session`, `when`, `prompt` (cut to 500 characters, shorter when the list would not fit), `maxRuntimeMin`, `nextAt` and the `last` result — never a directory path or the agent's arguments.
+`schedules` is the list as a JSON string; `encrypted` is the list sealed for the asking device (purpose `schedule.list`, bound to this machine's device id) as `{ v: 1, requestId, at, schedules: [...], unreadable? }` — the app checks that the `requestId` inside is the one it asked, so an older sealed list is not taken for a newer answer. `unreadable` is how many schedule files could not be read; a directory that cannot be listed at all, or that holds more than 20 files, is the error `read_failed`, never an empty list (and a remove then fails as `schedule_failed`; `hwip schedule rm` still works on the computer). A list too long for one frame has its prompts shortened, step by step (`too_large` only when it does not fit even without them). Each entry holds `id`, `source`, `agentKind`, `project` (the directory's name, not its path), `session`, `when`, `prompt` (cut to 500 characters, shorter when the list would not fit; `promptLocked: true` says the phone cannot change it — it is not the whole text, or the schedule has agent arguments — so the app leaves it to `hwip schedule edit`), `maxRuntimeMin`, `nextAt` and the `last` result — never a directory path or the agent's arguments.
 
 ### Your API key and redirects
 
@@ -972,7 +973,12 @@ handing the listener a key:
   session name, its `seq`/`epoch` and that nonce, so a relay that cannot
   swap in a key of its own (below) can't move one to another stream,
   replay one from an earlier subscription, or hand one back as input —
-  or as anything else this listener sealed for the phone. Your
+  or as anything else this listener sealed for the phone. A history page
+  (scrolling up past the live window) holds the same nonce and `epoch`,
+  the request id it answers and where it sits in the scrollback, so a
+  relay can't hand an earlier page back under a new request or move
+  where the next one is asked for; only the request id rides beside it
+  in the clear. Your
   keystrokes are sealed for this listener as `stream.input` with their
   `seq`/`epoch` stamps, the stream's start epoch and the phone's device
   id inside, so a forged restart can't replay them. The start answer (`agent.stream.start.ok`)
@@ -1188,7 +1194,7 @@ device, takes plain commands as before; an unreadable
 forgets the pins, and with them goes back to taking plain commands until a
 device is pinned again.
 
-**A schedule request** — the phone making or removing a scheduled session — rides
+**A schedule request** — the phone making, changing or removing a scheduled session — rides
 the same `agent.command` push, with a `schedule` field and no `body`. It carries
 a time, a prompt and, if the phone says so, an agent and a run time — and nothing
 else. The directory and the agent come from what this machine recorded for the
@@ -1197,8 +1203,11 @@ schedule at another directory; it cannot send agent arguments, a worktree or a
 label either, and a request that carries one is refused rather than ignored
 (`schedule_invalid`; `schedule_limit` at 20 schedules; `unknown_session` for a
 session this machine never recorded; `schedule_failed` when this machine's own
-files would not read or write). A remove names the schedule's own
-session, so it cannot reach another. Applying a request never types into a
+files would not read or write). A change (`op: 'update'`) carries the schedule's id
+and any of the time, the prompt and the run time; what it leaves out stays as it was,
+and a change with none of them is refused. A schedule made on the computer with agent arguments keeps its prompt: the phone may change its time and run time, not what is typed under those arguments. A change and a remove name the schedule's own
+session, so they cannot reach another. A listener of an older build refuses a change as
+`schedule_invalid`. Applying a request never types into a
 session. The request is sealed like any
 command — the whole of it inside the body, only `op` beside it, and the sender,
 label and counter checks above apply, so a replay or a swapped `op` changes

package/dist/agent-dirs.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Where the person's own shell finds their agents (F8). A schedule is started by the listener, and the listener run by
+ * launchd or systemd has only the PATH its service file baked: tmux's and node's directories and the system ones. An
+ * agent installed anywhere else — `~/.local/bin/claude` — is not on it, and the scheduled session's pane dies at once
+ * with "command not found". So every `hwip <agent>` typed in a shell writes down the directory its agent was found in,
+ * and a schedule launch adds those directories to its PATH.
+ *
+ * Builtins only: wrapper.ts writes this on the `hwip cc` hot path.
+ */
+export declare const agentDirsPath: () => string;
+/** Writes down the directory of `binary`, an absolute path the shell resolved. Best-effort: a launch never fails on it. */
+export declare const rememberAgentDir: (binary: string) => void;
+/** `path` with every written-down directory it lacks appended: what the listener has first, so nothing it runs changes. */
+export declare const withAgentDirs: (path: string | undefined) => string;
+//# sourceMappingURL=agent-dirs.d.ts.map

package/dist/agent-dirs.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Where the person's own shell finds their agents (F8). A schedule is started by the listener, and the listener run by
+ * launchd or systemd has only the PATH its service file baked: tmux's and node's directories and the system ones. An
+ * agent installed anywhere else — `~/.local/bin/claude` — is not on it, and the scheduled session's pane dies at once
+ * with "command not found". So every `hwip <agent>` typed in a shell writes down the directory its agent was found in,
+ * and a schedule launch adds those directories to its PATH.
+ *
+ * Builtins only: wrapper.ts writes this on the `hwip cc` hot path.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAgentDirs = exports.rememberAgentDir = exports.agentDirsPath = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const gate_js_1 = require("./gate.js");
+const private_files_js_1 = require("./private-files.js");
+/** More than anyone has agents in; bounds what a schedule launch puts on PATH. */
+const MAX_DIRS = 16;
+const agentDirsPath = () => (0, node_path_1.join)((0, gate_js_1.stateDir)(), 'agent-dirs.json');
+exports.agentDirsPath = agentDirsPath;
+/**
+ * Whether the file is the user's own regular file that only they can write: a directory put on PATH by someone else runs
+ * their programs as the agent. 'missing' when there is none yet.
+ */
+const fileState = (path) => {
+    try {
+        const info = (0, node_fs_1.lstatSync)(path);
+        const mine = typeof process.getuid !== 'function' || info.uid === process.getuid();
+        return info.isFile() && mine && (info.mode & 0o022) === 0 ? 'ok' : 'refused';
+    }
+    catch {
+        return 'missing';
+    }
+};
+const readDirs = () => {
+    try {
+        const path = (0, exports.agentDirsPath)();
+        if (fileState(path) !== 'ok')
+            return [];
+        const parsed = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf-8'));
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((dir) => typeof dir === 'string' && (0, node_path_1.isAbsolute)(dir)).slice(0, MAX_DIRS);
+    }
+    catch {
+        return [];
+    }
+};
+/** Writes down the directory of `binary`, an absolute path the shell resolved. Best-effort: a launch never fails on it. */
+const rememberAgentDir = (binary) => {
+    if (!(0, node_path_1.isAbsolute)(binary))
+        return;
+    const dir = (0, node_path_1.dirname)(binary);
+    const path = (0, exports.agentDirsPath)();
+    // Never written through a link, nor into a file that is not read back: either would be writing for nothing, or elsewhere.
+    if (fileState(path) === 'refused')
+        return;
+    const dirs = readDirs();
+    if (dirs.includes(dir))
+        return;
+    try {
+        (0, private_files_js_1.mkdirHandedBack)((0, gate_js_1.stateDir)(), 0o700);
+        (0, node_fs_1.writeFileSync)(path, JSON.stringify([...dirs, dir].slice(-MAX_DIRS)), { mode: 0o600 });
+        (0, private_files_js_1.handBackToSudoUser)(path);
+    }
+    catch {
+        // The schedule launch then says the agent is not on PATH, which is the truth.
+    }
+};
+exports.rememberAgentDir = rememberAgentDir;
+/** `path` with every written-down directory it lacks appended: what the listener has first, so nothing it runs changes. */
+const withAgentDirs = (path) => {
+    const have = (path ?? '').split(node_path_1.delimiter).filter(Boolean);
+    return [...have, ...readDirs().filter((dir) => !have.includes(dir))].join(node_path_1.delimiter);
+};
+exports.withAgentDirs = withAgentDirs;

package/dist/listener.d.ts

@@ -229,6 +229,9 @@ export interface ReportedKnownSession {
     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[];
+    /** 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;
     lastSeenAt: string;
 }
 /** Each live run's first seq, for the report (Q24). A run that has recorded nothing yet has none. */
@@ -640,6 +643,27 @@ export interface ScreenHistorySnapshot {
     error?: string;
     capturedAt: string;
 }
+/**
+ * What a sealed history page's envelope holds (as JSON): the page and every
+ * number a viewer pages by, bound to the request it answers and to the
+ * subscription it was sealed for. On a sealed stream the snapshot carries
+ * only `requestId` (for routing) beside this — a relay that hands an earlier
+ * page back under a new request, or rewrites where it sits, is caught on open.
+ */
+export type SealedHistoryPage = {
+    sessionName: string;
+    requestId: string;
+    nonce?: string;
+    epoch: number;
+    before: number;
+    lines: number;
+    hasMore: boolean;
+    truncated: boolean;
+    /** The pane's history size when this page was captured, so the viewer can
+     *  tell how much the history grew between its request and the capture. */
+    historySize: number;
+    content: string;
+};
 /**
  * Answer a phone's request for one page of scrollback above the live window.
  * Returns true when the message was ours to answer, so the caller stops routing

package/dist/listener.js

@@ -319,11 +319,13 @@ 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 } : {}),
         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 ?? ''}`).sort().join('|');
 exports.knownSessionsFingerprint = knownSessionsFingerprint;
 const sessionsFingerprint = (sessions) => sessions
     .map((s) => JSON.stringify([
@@ -1750,11 +1752,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 +1768,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 +3651,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 +4631,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/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;

package/dist/schedule-remote.js

@@ -25,6 +25,12 @@ const clip = (text, max) => {
     const last = cut.charCodeAt(cut.length - 1);
     return `${last >= 0xd800 && last <= 0xdbff ? cut.slice(0, -1) : cut}…`;
 };
+const listedPrompt = (schedule, max) => {
+    const { prompt } = schedule;
+    const listed = prompt !== undefined && max > 0 ? clip(prompt, max) : undefined;
+    const locked = listed !== prompt || schedule.agentArgs !== undefined;
+    return { ...(listed === undefined ? {} : { prompt: listed }), ...(locked ? { promptLocked: true } : {}) };
+};
 const isoOrNull = (ms) => {
     if (ms === null)
         return null;
@@ -47,9 +53,9 @@ const phoneScheduleList = (now, promptChars = exports.LIST_PROMPT_CHARS) => {
             project: (0, node_path_1.basename)(schedule.cwd),
             session: schedule.session,
             when: schedule.when,
-            ...(schedule.prompt !== undefined && promptChars > 0 ? { prompt: clip(schedule.prompt, promptChars) } : {}),
+            ...listedPrompt(schedule, promptChars),
             maxRuntimeMin: schedule.maxRuntimeMin,
-            nextAt: isoOrNull((0, schedule_js_1.nextOccurrence)(schedule.when, now, Date.parse(schedule.createdAt))),
+            nextAt: isoOrNull((0, schedule_js_1.nextOccurrence)(schedule.when, now, (0, schedule_js_1.scheduleAnchor)(schedule))),
             ...(last && lastAt ? { last: { outcome: last.outcome, at: lastAt } } : {}),
         };
     });
@@ -144,9 +150,48 @@ const remove = (request, session) => {
     const removed = (0, schedule_js_1.removeSchedule)(id);
     return removed === 'invalid' ? refuse('schedule_invalid', 'not a schedule id') : { ok: true };
 };
+const UPDATE_KEYS = new Set(['op', 'id', 'when', 'prompt', 'maxRuntimeMin']);
+const update = (request, session, deps) => {
+    const extra = Object.keys(request).find((k) => !UPDATE_KEYS.has(k));
+    if (extra !== undefined)
+        return refuse('schedule_invalid', `an update carries ${extra}`);
+    const { id, when, prompt, maxRuntimeMin } = request;
+    if (typeof id !== 'string')
+        return refuse('schedule_invalid', 'an update needs an id');
+    const read = (0, schedule_js_1.listSchedules)();
+    if (read.incomplete)
+        return refuse('schedule_failed', 'the schedules could not be listed');
+    // As for a remove: the push names the schedule's own session, so it cannot change another one.
+    const target = read.schedules.find((schedule) => schedule.id === id);
+    if (!target || target.session !== session)
+        return refuse('schedule_invalid', 'no such schedule for that session');
+    // A prompt the list cut is left out by the app, so a missing one keeps the file's whole text.
+    // Arguments the computer gave (a permissions bypass, say) were chosen for its own prompt: the phone cannot put another under them.
+    if (prompt !== undefined && target.agentArgs !== undefined)
+        return refuse('schedule_invalid', 'a schedule with agent arguments takes its prompt from hwip schedule edit');
+    // As `hwip schedule edit`: a prompt of spaces would be typed as nothing.
+    if (typeof prompt === 'string' && prompt.trim() === '')
+        return refuse('schedule_invalid', 'the prompt is empty');
+    if (prompt !== undefined && !deps.canPrompt(target.agentKind))
+        return refuse('schedule_invalid', 'that agent cannot take a scheduled prompt');
+    // Unchecked here: `updateSchedule` validates the whole schedule they make before it writes.
+    const change = {};
+    if (when !== undefined)
+        change.when = when;
+    if (prompt !== undefined)
+        change.prompt = prompt;
+    if (maxRuntimeMin !== undefined)
+        change.maxRuntimeMin = maxRuntimeMin;
+    const updated = (0, schedule_js_1.updateSchedule)(id, change, deps.now());
+    if (updated.ok)
+        return { ok: true };
+    // Gone between the list and the write is the same as never there for this session.
+    return refuse(updated.failure === 'io' ? 'schedule_failed' : 'schedule_invalid', updated.error);
+};
 /**
  * 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.
  */
 const applyPhoneSchedule = (request, session, deps = exports.livePhoneScheduleDeps) => {
@@ -155,6 +200,8 @@ const applyPhoneSchedule = (request, session, deps = exports.livePhoneScheduleDe
     try {
         if (request.op === 'create')
             return create(request, session, deps);
+        if (request.op === 'update')
+            return update(request, session, deps);
         if (request.op === 'remove')
             return remove(request, session);
     }
@@ -162,6 +209,6 @@ const applyPhoneSchedule = (request, session, deps = exports.livePhoneScheduleDe
         // A file that would not read or write is this machine's trouble, not a mistake in the request.
         return refuse('schedule_failed', err instanceof Error ? err.message : String(err));
     }
-    return refuse('schedule_invalid', 'op is neither create nor remove');
+    return refuse('schedule_invalid', 'op is not create, update or remove');
 };
 exports.applyPhoneSchedule = applyPhoneSchedule;

package/dist/schedule-runner.js

@@ -142,7 +142,10 @@ const createScheduleRunner = (deps) => {
         for (const schedule of schedules) {
             // No record of a schedule in a damaged file may mean "nothing ran" or "the record was lost": start from now, so
             // neither a pile of old runs is counted as missed nor a run that already happened is started again.
-            state[schedule.id] = previous[schedule.id] ?? { cursor: file.damaged ? tickNow : Date.parse(schedule.createdAt) };
+            // An edit restarts the count: the times before it belong to the schedule as it was.
+            const prior = previous[schedule.id];
+            const anchor = (0, schedule_js_1.scheduleAnchor)(schedule);
+            state[schedule.id] = { ...prior, cursor: Math.max(prior?.cursor ?? (file.damaged ? tickNow : anchor), anchor) };
         }
         // A state entry whose schedule file is gone is dropped — but only when the list is whole: a file that could not be
         // read this time is still there, and losing its cursor would repeat or miscount runs. A session that ended on its own is no longer running.
@@ -206,7 +209,7 @@ const createScheduleRunner = (deps) => {
         for (const schedule of schedules) {
             const st = state[schedule.id];
             const now = tickNow + (clock() - tickStart);
-            const due = (0, schedule_js_1.occurrencesBetween)(schedule.when, st.cursor, now, Date.parse(schedule.createdAt));
+            const due = (0, schedule_js_1.occurrencesBetween)(schedule.when, st.cursor, now, (0, schedule_js_1.scheduleAnchor)(schedule));
             if (due.count === 0 || due.latest === null)
                 continue;
             const runs = now - due.latest <= exports.GRACE_MS;

package/dist/schedule.d.ts

@@ -21,6 +21,8 @@ export interface Schedule {
     /** Lowercase base36, 6 characters. It becomes a file name, so nothing else is accepted. */
     id: string;
     createdAt: string;
+    /** Set by `updateSchedule` when an edit changes `when`: the schedule counts its runs from here, not from `createdAt` (see `scheduleAnchor`). */
+    updatedAt?: string;
     source: 'cli' | 'phone';
     /** `REMOTE_AGENTS` kind. Checked against the table when it runs, not here: a hand-edited file is the runner's to refuse. */
     agentKind: string;
@@ -75,6 +77,7 @@ export interface Occurrences {
 export declare const occurrencesBetween: (when: ScheduleWhen, after: number, until: number, anchor: number) => Occurrences;
 /** The first time after `after` the schedule comes due; null for a `daily` with no days (a file `validateSchedule` would refuse). */
 export declare const nextOccurrence: (when: ScheduleWhen, after: number, anchor: number) => number | null;
+export declare const isScheduleId: (value: unknown) => value is string;
 /**
  * Whether `input` is a schedule this machine will run. The file reader, `hwip schedule add` and (in
  * the remote PR) the phone's request all pass through here, so a limit lives in one place. Unknown
@@ -105,6 +108,34 @@ export type AddResult = {
  * is drawn.
  */
 export declare const addSchedule: (make: (id: string) => Schedule, newId?: () => string) => AddResult;
+/** What an edit may change. Everything else — the session, the directory, the agent — is what the schedule is. */
+export interface ScheduleChange {
+    when?: ScheduleWhen;
+    prompt?: string;
+    maxRuntimeMin?: number;
+}
+/** A change as it arrives from outside (the phone): its values are checked with the schedule they make. */
+export type UncheckedScheduleChange = {
+    [K in keyof ScheduleChange]?: unknown;
+};
+/** `missing` — no such schedule; `invalid` — the id or the changed schedule was refused; `io` — the file could not be written. */
+export type UpdateResult = {
+    ok: true;
+    schedule: Schedule;
+} | {
+    ok: false;
+    error: string;
+    failure: 'missing' | 'invalid' | 'io';
+};
+/**
+ * Change a schedule in place. The result passes `validateSchedule` before it is written, and is written whole (a
+ * listener reading it at the same time sees the old file or the new one). A new `when` sets `updatedAt` to `now`:
+ * the runner counts the edited schedule's runs from then, so the times it had before are neither run nor counted as
+ * missed. A change of the prompt or the run time only keeps the count where it was — an hourly run stays on its hour.
+ */
+export declare const updateSchedule: (id: string, change: UncheckedScheduleChange, now: number) => UpdateResult;
+/** The time a schedule's runs are counted from: its last edit, else its creation. */
+export declare const scheduleAnchor: (schedule: Schedule) => number;
 /** `invalid` means the id could not name a schedule file; nothing was touched. */
 export type RemoveResult = 'removed' | 'missing' | 'invalid';
 export declare const removeSchedule: (id: string) => RemoveResult;

package/dist/schedule.js

@@ -10,7 +10,7 @@
  * Everything here is pure or touches only that directory. The clock is a parameter.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeScheduleState = exports.readScheduleState = exports.scheduleStatePath = exports.removeSchedule = exports.addSchedule = exports.listSchedules = exports.schedulesDir = exports.validateSchedule = exports.nextOccurrence = exports.occurrencesBetween = exports.parseWhen = exports.parseDuration = exports.WEEKDAYS = exports.ALL_DAYS = exports.DAY_NAMES = exports.defaultMaxRuntimeMin = exports.MAX_SCHEDULES = void 0;
+exports.writeScheduleState = exports.readScheduleState = exports.scheduleStatePath = exports.removeSchedule = exports.scheduleAnchor = exports.updateSchedule = exports.addSchedule = exports.listSchedules = exports.schedulesDir = exports.validateSchedule = exports.isScheduleId = exports.nextOccurrence = exports.occurrencesBetween = exports.parseWhen = exports.parseDuration = exports.WEEKDAYS = exports.ALL_DAYS = exports.DAY_NAMES = exports.defaultMaxRuntimeMin = exports.MAX_SCHEDULES = void 0;
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -163,8 +163,9 @@ exports.nextOccurrence = nextOccurrence;
 const SCHEDULE_ID = /^[a-z0-9]{6}$/;
 const LABEL = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
 const AGENT_KIND = /^[A-Za-z0-9_-]{1,32}$/;
-const KEYS = new Set(['v', 'id', 'createdAt', 'source', 'agentKind', 'cwd', 'label', 'session', 'wt', 'agentArgs', 'prompt', 'when', 'maxRuntimeMin']);
+const KEYS = new Set(['v', 'id', 'createdAt', 'updatedAt', 'source', 'agentKind', 'cwd', 'label', 'session', 'wt', 'agentArgs', 'prompt', 'when', 'maxRuntimeMin']);
 const isScheduleId = (value) => typeof value === 'string' && SCHEDULE_ID.test(value);
+exports.isScheduleId = isScheduleId;
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const noControl = (text) => !/[\u0000-\u001f\u007f]/.test(text);
 /**
@@ -202,13 +203,18 @@ const validateSchedule = (input) => {
     const unknownKey = Object.keys(input).find((k) => !KEYS.has(k));
     if (unknownKey !== undefined)
         return fail(`schedule has a field it does not know: ${unknownKey}`);
-    const { v, id, createdAt, source, agentKind, cwd, label, session, wt, agentArgs, prompt, when, maxRuntimeMin } = input;
+    const { v, id, createdAt, updatedAt, source, agentKind, cwd, label, session, wt, agentArgs, prompt, when, maxRuntimeMin } = input;
     if (v !== 1)
         return fail('schedule.v must be 1');
-    if (!isScheduleId(id))
+    if (!(0, exports.isScheduleId)(id))
         return fail('schedule.id must be 6 lowercase letters or digits');
     if (typeof createdAt !== 'string' || createdAt.length > 40 || !Number.isFinite(Date.parse(createdAt)))
         return fail('schedule.createdAt must be a date');
+    if (updatedAt !== undefined && (typeof updatedAt !== 'string' || updatedAt.length > 40 || !Number.isFinite(Date.parse(updatedAt))))
+        return fail('schedule.updatedAt must be a date');
+    // Before the schedule existed, it would count runs from a time it was not there for.
+    if (typeof updatedAt === 'string' && Date.parse(updatedAt) < Date.parse(createdAt))
+        return fail('schedule.updatedAt cannot be before createdAt');
     if (source !== 'cli' && source !== 'phone')
         return fail("schedule.source must be 'cli' or 'phone'");
     if (typeof agentKind !== 'string' || !AGENT_KIND.test(agentKind))
@@ -287,7 +293,7 @@ const listSchedules = () => {
         if (!name.endsWith('.json'))
             continue;
         const id = name.slice(0, -'.json'.length);
-        const schedule = isScheduleId(id) ? readOne(id) : null;
+        const schedule = (0, exports.isScheduleId)(id) ? readOne(id) : null;
         if (schedule)
             schedules.push(schedule);
         else
@@ -343,8 +349,40 @@ const addSchedule = (make, newId = newScheduleId) => {
     return { ok: false, error: 'could not find a free schedule id', failure: 'io' };
 };
 exports.addSchedule = addSchedule;
+/**
+ * Change a schedule in place. The result passes `validateSchedule` before it is written, and is written whole (a
+ * listener reading it at the same time sees the old file or the new one). A new `when` sets `updatedAt` to `now`:
+ * the runner counts the edited schedule's runs from then, so the times it had before are neither run nor counted as
+ * missed. A change of the prompt or the run time only keeps the count where it was — an hourly run stays on its hour.
+ */
+const updateSchedule = (id, change, now) => {
+    if (!(0, exports.isScheduleId)(id))
+        return { ok: false, error: 'not a schedule id', failure: 'invalid' };
+    if (change.when === undefined && change.prompt === undefined && change.maxRuntimeMin === undefined) {
+        return { ok: false, error: 'nothing to change', failure: 'invalid' };
+    }
+    const current = readOne(id);
+    if (!current)
+        return { ok: false, error: `no schedule ${id}`, failure: 'missing' };
+    // The same time sent again (an app sends the sheet's) is not a new one: the count stays where it was.
+    const retimed = change.when !== undefined && JSON.stringify(change.when) !== JSON.stringify(current.when);
+    const checked = (0, exports.validateSchedule)({ ...current, ...change, ...(retimed ? { updatedAt: new Date(now).toISOString() } : {}) });
+    if (!checked.ok)
+        return { ok: false, error: checked.error, failure: 'invalid' };
+    try {
+        (0, replace_file_js_1.replaceFile)(schedulePath(id), `${JSON.stringify(checked.value, null, 2)}\n`, undefined, 0o600);
+        return { ok: true, schedule: checked.value };
+    }
+    catch (err) {
+        return { ok: false, error: `could not write the schedule: ${err instanceof Error ? err.message : String(err)}`, failure: 'io' };
+    }
+};
+exports.updateSchedule = updateSchedule;
+/** The time a schedule's runs are counted from: its last edit, else its creation. */
+const scheduleAnchor = (schedule) => Date.parse(schedule.updatedAt ?? schedule.createdAt);
+exports.scheduleAnchor = scheduleAnchor;
 const removeSchedule = (id) => {
-    if (!isScheduleId(id))
+    if (!(0, exports.isScheduleId)(id))
         return 'invalid';
     try {
         (0, node_fs_1.unlinkSync)(schedulePath(id));
@@ -401,7 +439,7 @@ const readScheduleState = () => {
         if (!isRecord(raw) || !isRecord(raw.schedules))
             return { ...state, damaged: true };
         for (const [id, entry] of Object.entries(raw.schedules)) {
-            const runState = isScheduleId(id) ? readRunState(entry) : null;
+            const runState = (0, exports.isScheduleId)(id) ? readRunState(entry) : null;
             if (runState)
                 state.schedules[id] = runState;
             else

package/dist/session-registry.d.ts

@@ -14,6 +14,7 @@
  * relay posing as one) sends can point the daemon at another directory or
  * another program.
  */
+import type { ProviderNameSource } from './session-title.js';
 export interface KnownSession {
     /** tmux session name — the key the phone addresses. */
     name: string;
@@ -43,6 +44,14 @@ export interface KnownSession {
      * run (`continuedRunId`). Absent for a run that has had one tmux session.
      */
     tmuxRunIds?: string[];
+    /**
+     * The last name the agent gave this run (Claude's ai-title or `/rename`,
+     * …) and who gave it, as the sweep read them: what the phone calls the run
+     * once it has ended (hwip docs/session-runs.md Q39). Absent for a run never
+     * named, and in files written before it.
+     */
+    providerSessionName?: string;
+    providerSessionNameSource?: ProviderNameSource;
     /** Last time this machine saw the session running. */
     lastSeenAt: string;
 }
@@ -138,6 +147,9 @@ export declare const rememberSessions: (live: Array<{
      * run's alone to resume — the run forgets it.
      */
     agentSessionId?: string | null;
+    /** The name the agent gives the run now, and who gave it. None this sweep: the run keeps the one it had. */
+    providerSessionName?: string | null;
+    providerSessionNameSource?: ProviderNameSource;
 }>, now?: number) => void;
 /**
  * Forget one session, by name. Returns false when this machine never knew it.

package/dist/session-registry.js

@@ -35,6 +35,14 @@ exports.MAX_RUNS_PER_NAME = 10;
  *  likely to have moved than to be what the user meant. */
 exports.KNOWN_SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const registryPath = () => (0, path_1.join)((0, gate_js_1.stateDir)(), 'known-sessions.json');
+const isNameSource = (v) => v === 'user' || v === 'auto';
+/** A run's name as the file holds it: a name that is not a string goes, and with it its source; a source that is not one goes alone. */
+const withReadableName = (e) => {
+    const { providerSessionName: name, providerSessionNameSource: source, ...rest } = e;
+    if (typeof name !== 'string' || name === '')
+        return rest;
+    return { ...rest, providerSessionName: name, ...(isNameSource(source) ? { providerSessionNameSource: source } : {}) };
+};
 const isTmuxRunIds = (v) => v === undefined || (Array.isArray(v) && v.every((id) => typeof id === 'string'));
 const readAll = () => {
     try {
@@ -51,7 +59,7 @@ const readAll = () => {
             typeof e.agentKind === 'string' &&
             typeof e.lastSeenAt === 'string' &&
             (e.runId === undefined || typeof e.runId === 'string') &&
-            isTmuxRunIds(e.tmuxRunIds));
+            isTmuxRunIds(e.tmuxRunIds)).map(withReadableName);
     }
     catch {
         return [];
@@ -200,6 +208,12 @@ const rememberSessions = (live, now = Date.now()) => {
         const tmuxRunIds = continued && s.tmuxRunId
             ? [...(prev?.tmuxRunIds ?? []).filter((id) => id !== s.tmuxRunId), s.tmuxRunId].slice(-exports.MAX_TMUX_RUNS_PER_RUN)
             : prev?.tmuxRunIds;
+        // The run's name is the last one read: a sweep that read none (the
+        // agent has not titled it yet, or its record was unreadable) does not
+        // take it away.
+        const named = s.providerSessionName
+            ? { providerSessionName: s.providerSessionName, providerSessionNameSource: s.providerSessionNameSource }
+            : prev;
         byRun.set(key, {
             name: s.name,
             cwd: s.cwd,
@@ -210,6 +224,8 @@ const rememberSessions = (live, now = Date.now()) => {
             ...(startedAt ? { startedAt } : {}),
             ...(agentSessionId ? { agentSessionId } : {}),
             ...(tmuxRunIds?.length ? { tmuxRunIds } : {}),
+            ...(named?.providerSessionName ? { providerSessionName: named.providerSessionName } : {}),
+            ...(named?.providerSessionName && named.providerSessionNameSource ? { providerSessionNameSource: named.providerSessionNameSource } : {}),
             lastSeenAt: seenAt,
         });
     }

package/dist/usage.js

@@ -172,6 +172,10 @@ ${usageAgentLines()}
                                     (cc, codex, …) and the project is this one
                   schedule [list]   show them, with the next run and the last
                                     result (--json for scripts)
+                  schedule edit <id> [--at HH:MM] [--days …] [--every <N>m|<N>h]
+                                    [--prompt <text>] [--max-runtime <N>m|<N>h]
+                                    change one in place; a new time counts
+                                    from the edit, a running session keeps going
                   schedule rm <id>  remove one; a session it already started
                                     keeps running
   sh              Open (or reattach) 'hwip-<project>-sh', a login shell the

package/dist/wrapper.js

@@ -14,6 +14,7 @@ exports.handleShellSession = exports.shellTargets = exports.readShellSessionStat
  */
 const child_process_1 = require("child_process");
 const path_1 = require("path");
+const agent_dirs_js_1 = require("./agent-dirs.js");
 const agents_js_1 = require("./agents.js");
 const tmux_install_js_1 = require("./tmux-install.js");
 const check_update_js_1 = require("./check-update.js");
@@ -530,6 +531,15 @@ const handleAgentSession = async (agent, extra = [], opts = {}, deps = {}) => {
         console.error(missing);
         return 127;
     }
+    // Where this shell finds the agent: a schedule launch, which has only the listener's PATH, looks there too (agent-dirs.ts).
+    const agentFile = (0, agents_js_1.findOnPath)(agent.binary);
+    if (agentFile && !launchedByListener)
+        (0, agent_dirs_js_1.rememberAgentDir)(agentFile);
+    // tmux would create the session anyway and its pane would die at once, leaving the caller a session that is just gone.
+    if (opts.detach && !agentFile) {
+        console.error(`hwip: '${agent.binary}' not found on PATH`);
+        return 127;
+    }
     // Before the listener starts: a refused `--wt` should cost nothing.
     if (opts.worktree) {
         const made = await (0, worktree_js_1.ensureWorktree)({ dir: (0, exports.detectProjectDir)(), name: opts.worktree });

package/package.json

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