@hwip/cli 0.1.4 → 0.1.6

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;
 }
@@ -80,8 +89,9 @@ export declare const runKey: (name: string, agentKind: string, runId?: string) =
 /** Sessions this machine has seen, newest first, expired ones dropped. */
 export declare const knownSessions: (now?: number) => KnownSession[];
 /** One remembered session, or null when this machine never saw that name.
- *  The newest run under that name — which is the one a bare resume means. */
-export declare const recallSession: (name: string, now?: number) => KnownSession | null;
+ *  The newest run under that name — which is the one a bare resume means.
+ *  With `runId`, that run of the name and nothing else (Q46). */
+export declare const recallSession: (name: string, now?: number, runId?: string) => KnownSession | null;
 /**
  * One specific run: the newest under this name that ran THIS agent.
  *
@@ -90,8 +100,12 @@ export declare const recallSession: (name: string, now?: number) => KnownSession
  * which row was tapped and says so; this is how that answer is honoured.
  * Null when this machine never saw that agent under that name — the caller
  * decides whether to fall back to the newest run or refuse.
+ *
+ * With `runId`, that run of the name and nothing else (docs/session-runs.md
+ * Q46): the earlier-runs fold asks for one conversation, and the newest run is
+ * a different one.
  */
-export declare const recallRun: (name: string, agentKind: string, now?: number) => KnownSession | null;
+export declare const recallRun: (name: string, agentKind: string, now?: number, runId?: string) => KnownSession | null;
 /** tmux sessions remembered per run: an `exit` and `-c` every few minutes all day stays a short list. */
 export declare const MAX_TMUX_RUNS_PER_RUN = 10;
 /**
@@ -138,6 +152,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 [];
@@ -96,9 +104,12 @@ const knownSessions = (now = Date.now()) => readAll()
     .filter((e) => now - Date.parse(e.lastSeenAt) < exports.KNOWN_SESSION_TTL_MS)
     .sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt));
 exports.knownSessions = knownSessions;
+/** No run asked for, or that run. */
+const ofRun = (e, runId) => runId === undefined || e.runId === runId;
 /** One remembered session, or null when this machine never saw that name.
- *  The newest run under that name — which is the one a bare resume means. */
-const recallSession = (name, now = Date.now()) => (0, exports.knownSessions)(now).find((e) => e.name === name) ?? null;
+ *  The newest run under that name — which is the one a bare resume means.
+ *  With `runId`, that run of the name and nothing else (Q46). */
+const recallSession = (name, now = Date.now(), runId) => (0, exports.knownSessions)(now).find((e) => e.name === name && ofRun(e, runId)) ?? null;
 exports.recallSession = recallSession;
 /**
  * One specific run: the newest under this name that ran THIS agent.
@@ -108,8 +119,12 @@ exports.recallSession = recallSession;
  * which row was tapped and says so; this is how that answer is honoured.
  * Null when this machine never saw that agent under that name — the caller
  * decides whether to fall back to the newest run or refuse.
+ *
+ * With `runId`, that run of the name and nothing else (docs/session-runs.md
+ * Q46): the earlier-runs fold asks for one conversation, and the newest run is
+ * a different one.
  */
-const recallRun = (name, agentKind, now = Date.now()) => (0, exports.knownSessions)(now).find((e) => e.name === name && e.agentKind === agentKind) ?? null;
+const recallRun = (name, agentKind, now = Date.now(), runId) => (0, exports.knownSessions)(now).find((e) => e.name === name && e.agentKind === agentKind && ofRun(e, runId)) ?? null;
 exports.recallRun = recallRun;
 /** tmux sessions remembered per run: an `exit` and `-c` every few minutes all day stays a short list. */
 exports.MAX_TMUX_RUNS_PER_RUN = 10;
@@ -200,6 +215,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 +231,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.d.ts

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

package/dist/wrapper.js

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