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

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.1",
+  "version": "0.17.3-next.2",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {