@mnemom/mnemom 0.17.3-next.0 → 0.17.3-next.2

package/dist/commands/agent.js

@@ -33,7 +33,8 @@ import { basename, join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { MNEMOM_DIR } from "../lib/config.js";
 import { getAgentByName } from "../lib/api.js";
-import { LEDGER_FILE, appendSessionRecord, toLedgerContract } from "../lib/agent-ledger.js";
+import { LEDGER_FILE, appendSessionRecord, resolveRetentionDays, toLedgerContract, } from "../lib/agent-ledger.js";
+import { loadCliConfig } from "../lib/cli-config.js";
 import { configKeySpec, loadLauncherConfig, writeLauncherConfig } from "../lib/launcher-config.js";
 import { fmt } from "../lib/format.js";
 import { askInput, askYesNo, isInteractive } from "../lib/prompt.js";
@@ -377,7 +378,12 @@ export async function recordSessionLaunch(ctx) {
         contract: toLedgerContract(ctx.envelope?.contract ?? null),
         goal_mode: goalAlignmentMode(ctx.envelope, ctx.goalMode),
         cc_session_id: ctx.ccSessionId ?? null,
-    }, { dir: MNEMOM_DIR, now: () => new Date(), pid: process.pid });
+    }, {
+        dir: MNEMOM_DIR,
+        now: () => new Date(),
+        pid: process.pid,
+        retentionDays: resolveRetentionDays(loadCliConfig().sessions?.retentionDays, process.env),
+    });
     if (!result.ok) {
         say(fmt.warn(`mnemom agent: could not record this session in ~/.mnemom/${LEDGER_FILE} (${result.error}) — launching anyway.`));
     }

package/dist/commands/config.d.ts

@@ -1,30 +1,30 @@
 /**
  * `mnemom config list|get|set|unset` — CLI-wide preferences in
- * ~/.mnemom/config.json. Today: the auto-update keys. (Launcher settings for
+ * ~/.mnemom/config.json: auto-update and local session retention. (Launcher settings for
  * `mnemom agent` stay in `mnemom agent config` / launcher.toml.)
  *
  * Keys are data (CONFIG_KEYS) so list/get/set/unset share one source of truth.
  */
-import { type InstallHint, type UpdatePrefs } from "../lib/update/decide.js";
-import { setUpdatePref } from "../lib/cli-config.js";
+import { type InstallHint } from "../lib/update/decide.js";
+import { setPref, type CliConfig } from "../lib/cli-config.js";
 export interface CliConfigKey {
     key: string;
     describe: string;
     env: string;
     /** Stored value (undefined when unset). */
-    stored(prefs: UpdatePrefs): string | undefined;
+    stored(config: CliConfig): string | undefined;
     /** Value in effect after env + default (`hint` picks the channel default). */
-    effective(prefs: UpdatePrefs, env: Record<string, string | undefined>, hint: InstallHint): string;
+    effective(config: CliConfig, env: Record<string, string | undefined>, hint: InstallHint): string;
     /** Validate + persist; throws with a user-facing message on a bad value. */
-    set(raw: string, persist: typeof setUpdatePref): void;
-    unset(persist: typeof setUpdatePref): void;
+    set(raw: string, persist: typeof setPref): void;
+    unset(persist: typeof setPref): void;
 }
 export declare const CONFIG_KEYS: readonly CliConfigKey[];
 export declare function findKey(key: string): CliConfigKey;
 export interface ConfigDeps {
-    prefs(): UpdatePrefs;
+    config(): CliConfig;
     env: Record<string, string | undefined>;
-    persist: typeof setUpdatePref;
+    persist: typeof setPref;
     log(line: string): void;
     /** Running version + last-followed channel (picks the default channel). */
     hint: InstallHint;

package/dist/commands/config.js

@@ -1,12 +1,13 @@
 /**
  * `mnemom config list|get|set|unset` — CLI-wide preferences in
- * ~/.mnemom/config.json. Today: the auto-update keys. (Launcher settings for
+ * ~/.mnemom/config.json: auto-update and local session retention. (Launcher settings for
  * `mnemom agent` stay in `mnemom agent config` / launcher.toml.)
  *
  * Keys are data (CONFIG_KEYS) so list/get/set/unset share one source of truth.
  */
 import { isUpdateChannel, isUpdateMode, resolveChannel, resolveMode, UPDATE_CHANNELS, UPDATE_MODES, } from "../lib/update/decide.js";
-import { loadCliConfig, setUpdatePref } from "../lib/cli-config.js";
+import { DEFAULT_RETENTION_DAYS, parseRetentionDays, resolveRetentionDays, RETENTION_ENV, } from "../lib/agent-ledger.js";
+import { loadCliConfig, setPref } from "../lib/cli-config.js";
 import { loadUpdateState } from "../lib/update/state.js";
 import { CLI_VERSION } from "../version.js";
 export const CONFIG_KEYS = [
@@ -14,29 +15,43 @@ export const CONFIG_KEYS = [
         key: "update.channel",
         describe: `Release channel for auto-update: ${UPDATE_CHANNELS.join(" | ")} (default: next on a next build, else latest; next requires an invite)`,
         env: "MNEMOM_UPDATE_CHANNEL",
-        stored: (p) => p.channel,
-        effective: (p, env, hint) => resolveChannel(p, env, undefined, hint),
+        stored: (c) => c.update?.channel,
+        effective: (c, env, hint) => resolveChannel(c.update ?? {}, env, undefined, hint),
         set: (raw, persist) => {
             const v = raw.trim();
             if (!isUpdateChannel(v))
                 throw new Error(`update.channel must be one of ${UPDATE_CHANNELS.join(", ")} (got '${raw}').`);
-            persist("channel", v);
+            persist("update", "channel", v);
         },
-        unset: (persist) => persist("channel", undefined),
+        unset: (persist) => persist("update", "channel", undefined),
     },
     {
         key: "update.mode",
         describe: `Auto-update behaviour: ${UPDATE_MODES.join(" | ")}`,
         env: "MNEMOM_UPDATE_MODE",
-        stored: (p) => p.mode,
-        effective: (p, env) => resolveMode(p, env),
+        stored: (c) => c.update?.mode,
+        effective: (c, env) => resolveMode(c.update ?? {}, env),
         set: (raw, persist) => {
             const v = raw.trim();
             if (!isUpdateMode(v))
                 throw new Error(`update.mode must be one of ${UPDATE_MODES.join(", ")} (got '${raw}').`);
-            persist("mode", v);
+            persist("update", "mode", v);
         },
-        unset: (persist) => persist("mode", undefined),
+        unset: (persist) => persist("update", "mode", undefined),
+    },
+    {
+        key: "sessions.retention_days",
+        describe: `Days \`mnemom agent sessions\` keeps a launch in ~/.mnemom/sessions.jsonl (default ${DEFAULT_RETENTION_DAYS}; older ones are removed at the next launch)`,
+        env: RETENTION_ENV,
+        stored: (c) => c.sessions?.retentionDays?.toString(),
+        effective: (c, env) => String(resolveRetentionDays(c.sessions?.retentionDays, env)),
+        set: (raw, persist) => {
+            const days = parseRetentionDays(raw);
+            if (days === null)
+                throw new Error(`sessions.retention_days must be a whole number of days, at least 1 (got '${raw}').`);
+            persist("sessions", "retentionDays", days);
+        },
+        unset: (persist) => persist("sessions", "retentionDays", undefined),
     },
 ];
 export function findKey(key) {
@@ -47,22 +62,22 @@ export function findKey(key) {
 }
 function defaultDeps() {
     return {
-        prefs: () => loadCliConfig().update ?? {},
+        config: loadCliConfig,
         env: process.env,
-        persist: setUpdatePref,
+        persist: setPref,
         log: (line) => console.log(line),
         hint: { current: CLI_VERSION, followed: loadUpdateState().followChannel },
     };
 }
 /** One line per key: `key = effective  (source)  — description`. */
 export function configListCommand(opts = {}, deps = defaultDeps()) {
-    const prefs = deps.prefs();
+    const config = deps.config();
     const rows = CONFIG_KEYS.map((k) => {
-        const stored = k.stored(prefs);
+        const stored = k.stored(config);
         const source = deps.env[k.env] ? `env ${k.env}` : stored !== undefined ? "config" : "default";
         return {
             key: k.key,
-            value: k.effective(prefs, deps.env, deps.hint),
+            value: k.effective(config, deps.env, deps.hint),
             source,
             describe: k.describe,
         };
@@ -75,7 +90,7 @@ export function configListCommand(opts = {}, deps = defaultDeps()) {
         deps.log(`${r.key} = ${r.value}  (${r.source})  — ${r.describe}`);
 }
 export function configGetCommand(key, deps = defaultDeps()) {
-    deps.log(findKey(key).effective(deps.prefs(), deps.env, deps.hint));
+    deps.log(findKey(key).effective(deps.config(), deps.env, deps.hint));
 }
 export function configSetCommand(key, value, deps = defaultDeps()) {
     const spec = findKey(key);

package/dist/index.js

@@ -1898,7 +1898,7 @@ program
     .action((options) => runAction(() => updateCommand(options)));
 const configCmd = program
     .command("config")
-    .description("CLI-wide preferences in ~/.mnemom/config.json (auto-update channel and mode)");
+    .description("CLI-wide preferences in ~/.mnemom/config.json (auto-update, session retention)");
 configCmd
     .command("list")
     .description("Show every setting, its effective value, and where it came from")

package/dist/lib/agent-ledger.d.ts

@@ -9,12 +9,24 @@
  *
  * Writes are best-effort: `appendSessionRecord` never throws — a failure comes
  * back as `{ ok: false, error }` and the caller decides how loudly to warn.
+ *
+ * Retention mirrors Claude Code's `cleanupPeriodDays`: launches older than
+ * `sessions.retention_days` (default 30) are dropped when the next one is
+ * recorded. No count cap — a long retention keeps everything in the window.
  */
 import type { LaunchShape, SealedContract } from "./agent.js";
 /** The ledger's file name under MNEMOM_DIR. */
 export declare const LEDGER_FILE = "sessions.jsonl";
-/** The ledger keeps only the newest this-many launches. */
-export declare const LEDGER_CAP = 200;
+/** Days a launch stays in the ledger when `sessions.retention_days` is unset. */
+export declare const DEFAULT_RETENTION_DAYS = 30;
+export declare const RETENTION_ENV = "MNEMOM_SESSIONS_RETENTION_DAYS";
+/** A retention setting must be a whole number of days, at least 1. */
+export declare function parseRetentionDays(raw: string): number | null;
+/**
+ * Precedence: MNEMOM_SESSIONS_RETENTION_DAYS > config.json > 30. An invalid value from either
+ * source is ignored (config.json can be hand-edited past `mnemom config set`'s validation).
+ */
+export declare function resolveRetentionDays(stored: unknown, env: Record<string, string | undefined>): number;
 /** The sealed-contract fields the ledger keeps (no goal_id — the statement is the identity). */
 export interface SessionRecordContract {
     statement: string;
@@ -76,6 +88,8 @@ export interface LedgerDeps {
     now: () => Date;
     /** The writing process's pid (names the rewrite temp file). */
     pid: number;
+    /** Drop launches older than this many days (default DEFAULT_RETENTION_DAYS). */
+    retentionDays?: number;
 }
 export type AppendResult = {
     ok: true;
@@ -93,11 +107,11 @@ export declare function toLedgerContract(sealed: SealedContract | null): Session
 /** The ledger's path under `dir`. */
 export declare function ledgerPath(dir: string): string;
 /**
- * Append one launch to the ledger, atomically and capped:
+ * Append one launch to the ledger, dropping expired ones:
  *   - `dir` is created 0o700 when missing; the file is created 0o600;
- *   - the new line is appended when the ledger stays within LEDGER_CAP lines,
- *     otherwise the newest LEDGER_CAP lines (this one included) are rewritten
- *     via a temp file + rename, so a reader never sees a torn file.
+ *   - when no launch is older than the retention window the new line is
+ *     appended; otherwise the surviving lines plus this one are rewritten via a
+ *     temp file + rename, so a reader never sees a torn file.
  * Never throws — a failure is returned as `{ ok: false, error }`.
  */
 export declare function appendSessionRecord(input: SessionRecordInput, deps: LedgerDeps): AppendResult;

package/dist/lib/agent-ledger.js

@@ -9,13 +9,36 @@
  *
  * Writes are best-effort: `appendSessionRecord` never throws — a failure comes
  * back as `{ ok: false, error }` and the caller decides how loudly to warn.
+ *
+ * Retention mirrors Claude Code's `cleanupPeriodDays`: launches older than
+ * `sessions.retention_days` (default 30) are dropped when the next one is
+ * recorded. No count cap — a long retention keeps everything in the window.
  */
 import { appendFileSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 /** The ledger's file name under MNEMOM_DIR. */
 export const LEDGER_FILE = "sessions.jsonl";
-/** The ledger keeps only the newest this-many launches. */
-export const LEDGER_CAP = 200;
+/** Days a launch stays in the ledger when `sessions.retention_days` is unset. */
+export const DEFAULT_RETENTION_DAYS = 30;
+export const RETENTION_ENV = "MNEMOM_SESSIONS_RETENTION_DAYS";
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** A retention setting must be a whole number of days, at least 1. */
+export function parseRetentionDays(raw) {
+    const v = raw.trim();
+    if (!/^\d+$/.test(v))
+        return null;
+    const n = Number(v);
+    return Number.isSafeInteger(n) && n >= 1 ? n : null;
+}
+/**
+ * Precedence: MNEMOM_SESSIONS_RETENTION_DAYS > config.json > 30. An invalid value from either
+ * source is ignored (config.json can be hand-edited past `mnemom config set`'s validation).
+ */
+export function resolveRetentionDays(stored, env) {
+    const fromEnv = env[RETENTION_ENV] === undefined ? null : parseRetentionDays(env[RETENTION_ENV]);
+    const fromConfig = typeof stored === "number" && Number.isSafeInteger(stored) && stored >= 1 ? stored : null;
+    return fromEnv ?? fromConfig ?? DEFAULT_RETENTION_DAYS;
+}
 /**
  * Project a sealed contract onto the ledger's contract shape (drops `goal_id`,
  * keeps only defined fields). `null` in, `null` out.
@@ -58,25 +81,43 @@ function readLedgerText(path) {
     }
 }
 /**
- * Append one launch to the ledger, atomically and capped:
+ * True when `line` is a launch that started before `cutoffMs`. A line whose
+ * age can't be read is kept — never delete what we can't date.
+ */
+function isExpired(line, cutoffMs) {
+    try {
+        const startedAt = JSON.parse(line).started_at;
+        if (typeof startedAt !== "string")
+            return false;
+        const t = Date.parse(startedAt);
+        return !Number.isNaN(t) && t < cutoffMs;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Append one launch to the ledger, dropping expired ones:
  *   - `dir` is created 0o700 when missing; the file is created 0o600;
- *   - the new line is appended when the ledger stays within LEDGER_CAP lines,
- *     otherwise the newest LEDGER_CAP lines (this one included) are rewritten
- *     via a temp file + rename, so a reader never sees a torn file.
+ *   - when no launch is older than the retention window the new line is
+ *     appended; otherwise the surviving lines plus this one are rewritten via a
+ *     temp file + rename, so a reader never sees a torn file.
  * Never throws — a failure is returned as `{ ok: false, error }`.
  */
 export function appendSessionRecord(input, deps) {
     const path = ledgerPath(deps.dir);
     try {
-        const record = { v: 1, started_at: deps.now().toISOString(), ...input };
+        const now = deps.now();
+        const record = { v: 1, started_at: now.toISOString(), ...input };
         mkdirSync(deps.dir, { recursive: true, mode: 0o700 });
         const line = `${JSON.stringify(record)}\n`;
         const text = readLedgerText(path);
         const existing = text === null ? [] : nonEmptyLines(text);
-        if (existing.length + 1 > LEDGER_CAP) {
-            const kept = [...existing, JSON.stringify(record)].slice(-LEDGER_CAP);
-            const tmp = join(deps.dir, `.${LEDGER_FILE}.tmp-${deps.pid}-${deps.now().getTime()}`);
-            writeFileSync(tmp, `${kept.join("\n")}\n`, { mode: 0o600 });
+        const cutoff = now.getTime() - (deps.retentionDays ?? DEFAULT_RETENTION_DAYS) * DAY_MS;
+        const kept = existing.filter((l) => !isExpired(l, cutoff));
+        if (kept.length < existing.length) {
+            const tmp = join(deps.dir, `.${LEDGER_FILE}.tmp-${deps.pid}-${now.getTime()}`);
+            writeFileSync(tmp, `${[...kept, JSON.stringify(record)].join("\n")}\n`, { mode: 0o600 });
             renameSync(tmp, path);
         }
         else {

package/dist/lib/cli-config.d.ts

@@ -23,10 +23,20 @@ export interface ActiveOrg {
     slug: string;
     name: string;
 }
+/** Local session-ledger preferences (`mnemom config set sessions.retention_days`). */
+export interface SessionPrefs {
+    retentionDays?: number;
+}
 export interface CliConfig {
     activeOrg?: ActiveOrg;
     /** Auto-update preferences (`mnemom config set update.channel|update.mode`). */
     update?: UpdatePrefs;
+    sessions?: SessionPrefs;
+}
+/** The config.json sections `mnemom config` edits. */
+export interface PrefSections {
+    update: UpdatePrefs;
+    sessions: SessionPrefs;
 }
 /** Load the config; a missing or corrupt file degrades to `{}`. */
 export declare function loadCliConfig(): CliConfig;
@@ -35,7 +45,10 @@ export declare function setActiveOrg(org: ActiveOrg | null): void;
 /** The active org, or undefined when none is set. */
 export declare function getActiveOrg(): ActiveOrg | undefined;
 /**
- * Set (or with `undefined`, clear) one auto-update preference. Validation is
- * the caller's job (commands/config.ts) — this only persists.
+ * Set (or with `undefined`, clear) one preference in a config.json section;
+ * an emptied section is removed. Validation is the caller's job
+ * (commands/config.ts) — this only persists.
  */
+export declare function setPref<S extends keyof PrefSections, K extends keyof PrefSections[S] & string>(section: S, key: K, value: PrefSections[S][K] | undefined): void;
+/** One auto-update preference — `setPref("update", …)`. */
 export declare function setUpdatePref<K extends keyof UpdatePrefs>(key: K, value: UpdatePrefs[K] | undefined): void;

package/dist/lib/cli-config.js

@@ -69,15 +69,18 @@ export function getActiveOrg() {
     return loadCliConfig().activeOrg;
 }
 /**
- * Set (or with `undefined`, clear) one auto-update preference. Validation is
- * the caller's job (commands/config.ts) — this only persists.
+ * Set (or with `undefined`, clear) one preference in a config.json section;
+ * an emptied section is removed. Validation is the caller's job
+ * (commands/config.ts) — this only persists.
  */
-export function setUpdatePref(key, value) {
+export function setPref(section, key, value) {
     const config = loadCliConfig();
-    const update = Object.fromEntries(Object.entries({ ...config.update, [key]: value }).filter(([, v]) => v !== undefined));
-    if (Object.keys(update).length === 0)
-        delete config.update;
-    else
-        config.update = update;
+    const next = Object.fromEntries(Object.entries({ ...config[section], [key]: value }).filter(([, v]) => v !== undefined));
+    // An emptied section becomes undefined, which JSON.stringify omits.
+    config[section] = Object.keys(next).length > 0 ? next : undefined;
     saveCliConfig(config);
 }
+/** One auto-update preference — `setPref("update", …)`. */
+export function setUpdatePref(key, value) {
+    setPref("update", key, value);
+}

package/dist/lib/update/decide.d.ts

@@ -64,6 +64,9 @@ export interface UpdateState {
     method?: InstallMethod;
     /** Channel the last successful update installed from; feeds defaultChannel. */
     followChannel?: UpdateChannel;
+    /** The background worker startup last spawned, while it runs (cleared when it finishes). */
+    workerPid?: number;
+    workerSince?: number;
 }
 export interface UpdatePrefs {
     channel?: UpdateChannel;
@@ -121,6 +124,19 @@ export declare function entitlementFresh(cache: EntitlementCache | undefined, no
  * registry response).
  */
 export declare function pickTarget(tags: DistTags, channel: UpdateChannel): string | undefined;
+/**
+ * Longest a worker lives: it waits for its parent `mnemom` (a whole agent session)
+ * up to this long. A recorded worker older than this is treated as gone, so a
+ * recycled pid can't block updates.
+ */
+export declare const WORKER_MAX_AGE_MS: number;
+/**
+ * A known update is still pending and nothing is working on it: the last worker
+ * recorded `available` but was killed before installing (e.g. while waiting out
+ * a long agent session). Startup respawns one without waiting for the next
+ * scheduled check.
+ */
+export declare function shouldResume(state: UpdateState, current: string, now: number, alive: (pid: number) => boolean): boolean;
 /** Whether the background worker should poll the registry now. */
 export declare function shouldCheck(state: UpdateState, channel: UpdateChannel, now: number): boolean;
 export declare function backoffDelay(failures: number): number;

package/dist/lib/update/decide.js

@@ -115,6 +115,33 @@ export function pickTarget(tags, channel) {
         return next;
     return compareVersions(next, stable) >= 0 ? next : stable;
 }
+/**
+ * Longest a worker lives: it waits for its parent `mnemom` (a whole agent session)
+ * up to this long. A recorded worker older than this is treated as gone, so a
+ * recycled pid can't block updates.
+ */
+export const WORKER_MAX_AGE_MS = 12 * HOUR;
+/**
+ * A known update is still pending and nothing is working on it: the last worker
+ * recorded `available` but was killed before installing (e.g. while waiting out
+ * a long agent session). Startup respawns one without waiting for the next
+ * scheduled check.
+ */
+export function shouldResume(state, current, now, alive) {
+    if (!state.available || !isValidVersion(state.available))
+        return false;
+    if (compareVersions(state.available, current) <= 0)
+        return false;
+    if (state.installBlocked || !canSelfUpdate(state.method ?? "unknown"))
+        return false;
+    if (state.backoffUntil !== undefined && now < state.backoffUntil)
+        return false;
+    const working = state.workerPid !== undefined &&
+        state.workerSince !== undefined &&
+        now - state.workerSince < WORKER_MAX_AGE_MS &&
+        alive(state.workerPid);
+    return !working;
+}
 /** Whether the background worker should poll the registry now. */
 export function shouldCheck(state, channel, now) {
     if (state.backoffUntil !== undefined && now < state.backoffUntil)

package/dist/lib/update/run.d.ts

@@ -29,6 +29,8 @@ export interface RunDeps {
      * `mnemom agent` session). Resolving false skips the install this pass.
      */
     beforeInstall?(): Promise<boolean>;
+    /** The background worker's own pid: it clears its `workerPid` record when done. */
+    pid?: number;
 }
 export interface RunResult {
     /** The channel actually honoured (next falls back to latest when not entitled). */

package/dist/lib/update/run.js

@@ -37,13 +37,17 @@ function failurePatch(state, now, message) {
 export async function runUpdate(deps, settings, opts = {}) {
     const now = deps.now();
     const state = deps.loadState();
+    // Every exit path forgets this worker's record, so startup can tell it's gone.
+    const done = deps.pid !== undefined && state.workerPid === deps.pid
+        ? { workerPid: undefined, workerSince: undefined }
+        : {};
     let tags;
     try {
         tags = await deps.fetchDistTags();
     }
     catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        deps.saveState(failurePatch(state, now, message));
+        deps.saveState({ ...failurePatch(state, now, message), ...done });
         return { channel: settings.channel, channelDowngraded: false, error: message };
     }
     const entitled = settings.channel === "next" ? await resolveEntitlement(deps, state, now) : false;
@@ -71,12 +75,18 @@ export async function runUpdate(deps, settings, opts = {}) {
     };
     const result = { channel, channelDowngraded, method, target, action };
     if (action.kind !== "install") {
-        deps.saveState(base);
+        deps.saveState({ ...base, ...done });
         return result;
     }
-    const proceed = deps.beforeInstall ? await deps.beforeInstall() : true;
-    if (!proceed) {
+    let proceed = true;
+    if (deps.beforeInstall) {
+        // Record what we found BEFORE the (possibly hours-long) wait: if this worker
+        // is killed meanwhile, the next launch still knows an update is pending.
         deps.saveState(base);
+        proceed = await deps.beforeInstall();
+    }
+    if (!proceed) {
+        deps.saveState({ ...base, ...done });
         return { ...result, action: { kind: "notify", version: action.version, reason: "deferred" } };
     }
     const outcome = await deps.install(action.version);
@@ -87,15 +97,20 @@ export async function runUpdate(deps, settings, opts = {}) {
             installBlocked: undefined,
             pending: { from: deps.current, to: action.version, channel },
             followChannel: channel,
+            ...done,
         });
         return { ...result, installed: action.version };
     }
     if (outcome.eacces) {
         // Retrying can't fix permissions — switch to notify-with-instructions.
-        deps.saveState({ ...base, installBlocked: true, lastError: outcome.message });
+        deps.saveState({ ...base, installBlocked: true, lastError: outcome.message, ...done });
     }
     else {
-        deps.saveState({ ...failurePatch(state, now, outcome.message), available: base.available });
+        deps.saveState({
+            ...failurePatch(state, now, outcome.message),
+            available: base.available,
+            ...done,
+        });
     }
     return { ...result, error: outcome.message };
 }

package/dist/lib/update/startup.d.ts

@@ -2,7 +2,8 @@
  * The per-invocation hook, run before commander parses argv. It must cost
  * ~nothing and never fail the user's command:
  *   1. print a one-line stderr notice (completed update, or an available one);
- *   2. if a check is due, spawn the detached worker and return immediately.
+ *   2. if a check is due — or a known update was left uninstalled by a worker
+ *      that died — spawn the detached worker and return immediately.
  * All I/O is injected; `defaultStartupDeps()` wires the real process.
  */
 import { type UpdateChannel, type UpdateMode, type UpdatePrefs, type UpdateState } from "./decide.js";
@@ -18,8 +19,10 @@ export interface StartupDeps {
     saveState(patch: Partial<UpdateState>): void;
     entryPath: string;
     writeErr(line: string): void;
-    spawnWorker(args: [entry: string, channel: UpdateChannel, mode: UpdateMode, parentPid: string]): void;
+    /** Returns the worker's pid (undefined if the spawn failed). */
+    spawnWorker(args: [entry: string, channel: UpdateChannel, mode: UpdateMode, parentPid: string]): number | undefined;
     pid: number;
+    alive(pid: number): boolean;
 }
 export declare function maybeRunUpdateHook(deps: StartupDeps): void;
 /** dist/lib/update/startup.js → dist/update-worker.js */

package/dist/lib/update/startup.js

@@ -2,16 +2,18 @@
  * The per-invocation hook, run before commander parses argv. It must cost
  * ~nothing and never fail the user's command:
  *   1. print a one-line stderr notice (completed update, or an available one);
- *   2. if a check is due, spawn the detached worker and return immediately.
+ *   2. if a check is due — or a known update was left uninstalled by a worker
+ *      that died — spawn the detached worker and return immediately.
  * All I/O is injected; `defaultStartupDeps()` wires the real process.
  */
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { CLI_VERSION } from "../../version.js";
-import { resolveSettings, shouldCheck, startupNotice, } from "./decide.js";
+import { resolveSettings, shouldCheck, shouldResume, startupNotice, } from "./decide.js";
 import { classifyInstall } from "./install-method.js";
 import { loadUpdateState, saveUpdateState } from "./state.js";
 import { entryRealpath, loadUpdatePrefs } from "./system.js";
+import { isAlive } from "./worker.js";
 /** Commands that manage updates themselves, or must stay side-effect free. */
 const SKIP_COMMANDS = new Set(["update", "config"]);
 export function maybeRunUpdateHook(deps) {
@@ -41,11 +43,21 @@ export function maybeRunUpdateHook(deps) {
         }
         if (SKIP_COMMANDS.has(deps.argv[0] ?? ""))
             return;
-        if (!shouldCheck(state, settings.channel, now))
+        const due = shouldCheck(state, settings.channel, now);
+        const resume = !due && settings.mode === "auto" && shouldResume(state, deps.current, now, deps.alive);
+        if (!due && !resume)
             return;
         // Stamp first so a burst of commands doesn't spawn a burst of workers.
-        deps.saveState({ lastCheck: now });
-        deps.spawnWorker([deps.entryPath, settings.channel, settings.mode, String(deps.pid)]);
+        if (due)
+            deps.saveState({ lastCheck: now });
+        const pid = deps.spawnWorker([
+            deps.entryPath,
+            settings.channel,
+            settings.mode,
+            String(deps.pid),
+        ]);
+        if (pid !== undefined)
+            deps.saveState({ workerPid: pid, workerSince: now });
     }
     catch {
         /* the updater never breaks the user's command */
@@ -75,6 +87,8 @@ export function defaultStartupDeps(argv) {
             });
             child.on("error", () => { });
             child.unref();
+            return child.pid;
         },
+        alive: (pid) => isAlive(pid),
     };
 }

package/dist/lib/update/worker.js

@@ -8,7 +8,7 @@
  */
 import { CLI_VERSION } from "../../version.js";
 import { getApiUrl } from "../config.js";
-import { isUpdateChannel, isUpdateMode } from "./decide.js";
+import { isUpdateChannel, isUpdateMode, WORKER_MAX_AGE_MS, } from "./decide.js";
 import { classifyInstall } from "./install-method.js";
 import { fetchChannelEntitlement, fetchDistTags } from "./registry.js";
 import { runUpdate } from "./run.js";
@@ -23,7 +23,7 @@ export function parseWorkerArgs(args) {
 }
 export const PARENT_POLL_MS = 5000;
 /** Give up waiting on a very long session; the next run picks the update up. */
-export const PARENT_WAIT_MAX_MS = 12 * 60 * 60 * 1000;
+export const PARENT_WAIT_MAX_MS = WORKER_MAX_AGE_MS;
 /** `kill(pid, 0)` probes liveness without signalling. EPERM still means alive. */
 export function isAlive(pid, kill = (p, s) => void process.kill(p, s)) {
     try {
@@ -60,6 +60,7 @@ export function realRunDeps(entry, credential) {
         fetchEntitlement: async () => fetchChannelEntitlement(fetch, getApiUrl(), await credential()),
         installMethod: async () => classifyInstall(entry, await npmGlobalRoot()),
         install: (version) => npmInstallGlobal(version),
+        pid: process.pid,
     };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.3-next.0",
+  "version": "0.17.3-next.2",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {