@mnemom/mnemom 0.17.31 → 0.17.32-next.1

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

@@ -15,8 +15,13 @@
  *            for entitled callers (internal cohort, staff, `cli_next` invite —
  *            GET /v1/cli/channel-entitlement); otherwise it behaves as latest.
  *
- * Never downgrades automatically: switching next → latest while ahead of latest
- * keeps the current build until latest overtakes it (`mnemom update --force`).
+ * Never downgrades on its own, with one exception: a moved tag. Switching
+ * next → latest while ahead of latest keeps the current build until latest
+ * overtakes it (`mnemom update --force`). But when the channel pointed at the
+ * running build on the last check and now points lower, the tag was moved back
+ * (a bad release rolled back by hand: OIDC publishing can't move a tag, a
+ * person can), and the next check follows it down. A build the channel never
+ * pointed at (a dev build, a newer local install) is never downgraded.
  */
 export type UpdateChannel = "latest" | "next";
 export type UpdateMode = "auto" | "notify" | "off";
@@ -64,6 +69,13 @@ export interface UpdateState {
     method?: InstallMethod;
     /** Channel the last successful update installed from; feeds defaultChannel. */
     followChannel?: UpdateChannel;
+    /** What the channel pointed at on the last check; detects a tag moved back. */
+    channelTarget?: {
+        channel: UpdateChannel;
+        version: string;
+    };
+    /** `available` is the channel's tag moved back below the running build. */
+    movedBack?: boolean;
     /** The background worker startup last spawned, while it runs (cleared when it finishes). */
     workerPid?: number;
     workerSince?: number;
@@ -124,6 +136,11 @@ export declare function entitlementFresh(cache: EntitlementCache | undefined, no
  * registry response).
  */
 export declare function pickTarget(tags: DistTags, channel: UpdateChannel): string | undefined;
+/**
+ * The channel's tag was moved back off the running build: on the last check it
+ * pointed at `current`, and now it points at an older version.
+ */
+export declare function tagMovedBack(previous: UpdateState["channelTarget"], channel: UpdateChannel, current: string, target: string | undefined): boolean;
 /**
  * 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
@@ -155,7 +172,8 @@ export type UpdateAction = {
 /**
  * The single decision: given where the registry is and how we're installed,
  * install / notify / do nothing. `force` (explicit `mnemom update --force`)
- * permits a downgrade to the channel's target.
+ * permits a downgrade to the channel's target; `followMovedTag` (see
+ * tagMovedBack) permits one to the version the channel's tag was moved back to.
  */
 export declare function decide(input: {
     current: string;
@@ -164,6 +182,7 @@ export declare function decide(input: {
     method: InstallMethod;
     installBlocked?: boolean;
     force?: boolean;
+    followMovedTag?: boolean;
 }): UpdateAction;
 /** The command a human should run to upgrade, for the given install method. */
 export declare function manualUpgradeCommand(method: InstallMethod, version: string): string;

package/dist/lib/update/decide.js

@@ -15,8 +15,13 @@
  *            for entitled callers (internal cohort, staff, `cli_next` invite —
  *            GET /v1/cli/channel-entitlement); otherwise it behaves as latest.
  *
- * Never downgrades automatically: switching next → latest while ahead of latest
- * keeps the current build until latest overtakes it (`mnemom update --force`).
+ * Never downgrades on its own, with one exception: a moved tag. Switching
+ * next → latest while ahead of latest keeps the current build until latest
+ * overtakes it (`mnemom update --force`). But when the channel pointed at the
+ * running build on the last check and now points lower, the tag was moved back
+ * (a bad release rolled back by hand: OIDC publishing can't move a tag, a
+ * person can), and the next check follows it down. A build the channel never
+ * pointed at (a dev build, a newer local install) is never downgraded.
  */
 import { compareVersions, isPrerelease, isValidVersion } from "./semver.js";
 export const UPDATE_CHANNELS = ["latest", "next"];
@@ -115,6 +120,24 @@ export function pickTarget(tags, channel) {
         return next;
     return compareVersions(next, stable) >= 0 ? next : stable;
 }
+/**
+ * The channel's tag was moved back off the running build: on the last check it
+ * pointed at `current`, and now it points at an older version.
+ */
+export function tagMovedBack(previous, channel, current, target) {
+    return (previous !== undefined &&
+        previous.channel === channel &&
+        previous.version === current &&
+        target !== undefined &&
+        compareVersions(target, current) < 0);
+}
+/** `state.available` is something to act on: newer, or the tag moved back to it. */
+function actionable(state, current) {
+    if (!state.available || !isValidVersion(state.available))
+        return false;
+    const cmp = compareVersions(state.available, current);
+    return cmp > 0 || (state.movedBack === true && cmp < 0);
+}
 /**
  * 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
@@ -128,9 +151,7 @@ export const WORKER_MAX_AGE_MS = 12 * HOUR;
  * scheduled check.
  */
 export function shouldResume(state, current, now, alive) {
-    if (!state.available || !isValidVersion(state.available))
-        return false;
-    if (compareVersions(state.available, current) <= 0)
+    if (!actionable(state, current))
         return false;
     if (state.installBlocked || !canSelfUpdate(state.method ?? "unknown"))
         return false;
@@ -160,10 +181,11 @@ export function canSelfUpdate(method) {
 /**
  * The single decision: given where the registry is and how we're installed,
  * install / notify / do nothing. `force` (explicit `mnemom update --force`)
- * permits a downgrade to the channel's target.
+ * permits a downgrade to the channel's target; `followMovedTag` (see
+ * tagMovedBack) permits one to the version the channel's tag was moved back to.
  */
 export function decide(input) {
-    const { current, target, mode, method, installBlocked, force } = input;
+    const { current, target, mode, method, installBlocked, force, followMovedTag } = input;
     if (mode === "off")
         return { kind: "noop", reason: "updates are off" };
     if (!target)
@@ -171,7 +193,7 @@ export function decide(input) {
     const cmp = compareVersions(target, current);
     if (cmp === 0)
         return { kind: "noop", reason: "already on the newest version" };
-    if (cmp < 0 && !force)
+    if (cmp < 0 && !force && !followMovedTag)
         return { kind: "noop", reason: "current build is newer than the channel" };
     if (!canSelfUpdate(method)) {
         return { kind: "notify", version: target, reason: `installed via ${method}` };
@@ -215,9 +237,7 @@ export function startupNotice(input) {
             patch: { pending: undefined },
         };
     }
-    if (mode === "off" || !state.available || !isValidVersion(state.available))
-        return null;
-    if (compareVersions(state.available, current) <= 0)
+    if (mode === "off" || !actionable(state, current))
         return null;
     // In auto mode with a working self-update, the worker installs it — stay quiet.
     if (mode === "auto" && canSelfUpdate(method) && !state.installBlocked)
@@ -229,8 +249,11 @@ export function startupNotice(input) {
         : state.installBlocked
             ? ` — the global npm prefix isn't writable; run: ${manualUpgradeCommand(method, state.available)} (see https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally)`
             : " — run: mnemom update";
+    const what = state.movedBack
+        ? `mnemom ${current} was withdrawn; the channel is back on ${state.available}`
+        : `mnemom ${state.available} is available (you have ${current})`;
     return {
-        message: `mnemom ${state.available} is available (you have ${current})${cmd}`,
+        message: `${what}${cmd}`,
         patch: { lastNotified: now },
     };
 }

package/dist/lib/update/doctor.js

@@ -46,7 +46,11 @@ export function updateDoctorRow(input) {
             hint: "it retries automatically with backoff; `mnemom update` retries now",
         };
     }
-    const pending = state.available ? `, ${state.available} available` : "";
+    const pending = !state.available
+        ? ""
+        : state.movedBack
+            ? `, withdrawn: the channel is back on ${state.available}`
+            : `, ${state.available} available`;
     return {
         mark: "ok",
         text: `auto-update: ${settings.mode} on ${settings.channel} (v${current}${pending})`,

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

@@ -42,6 +42,8 @@ export interface RunResult {
     action?: UpdateAction;
     installed?: string;
     error?: string;
+    /** The channel's tag moved back below the running build (a withdrawn release). */
+    movedBack?: boolean;
 }
 /**
  * Resolve the `next` entitlement: a fresh cache wins; otherwise ask the API.

package/dist/lib/update/run.js

@@ -5,7 +5,7 @@
  * (maybe) install → persist state. Never throws; failures become state
  * (backoff) and a result the caller may print.
  */
-import { backoffDelay, decide, effectiveChannel, entitlementFresh, pickTarget, } from "./decide.js";
+import { backoffDelay, decide, effectiveChannel, entitlementFresh, pickTarget, tagMovedBack, } from "./decide.js";
 import { compareVersions } from "./semver.js";
 /**
  * Resolve the `next` entitlement: a fresh cache wins; otherwise ask the API.
@@ -55,6 +55,7 @@ export async function runUpdate(deps, settings, opts = {}) {
     const channelDowngraded = channel !== settings.channel;
     const target = pickTarget(tags, channel);
     const method = await deps.installMethod();
+    const movedBack = tagMovedBack(state.channelTarget, channel, deps.current, target);
     const action = decide({
         current: deps.current,
         target,
@@ -63,17 +64,30 @@ export async function runUpdate(deps, settings, opts = {}) {
         // An explicit `mnemom update` retries even after an EACCES (the user may have fixed it).
         installBlocked: opts.foreground ? false : state.installBlocked,
         force: opts.force,
+        followMovedTag: movedBack,
     });
     const newer = target !== undefined && compareVersions(target, deps.current) > 0;
     const base = {
         lastCheck: now,
         method,
-        available: newer ? target : undefined,
+        available: newer || movedBack ? target : undefined,
+        movedBack: movedBack || undefined,
+        // A moved-back tag keeps the old record until it is followed, so a deferred
+        // or notify-only pass doesn't forget the move on the next check; an empty
+        // answer from the registry keeps it too.
+        ...(movedBack || target === undefined ? {} : { channelTarget: { channel, version: target } }),
         failures: undefined,
         backoffUntil: undefined,
         lastError: undefined,
     };
-    const result = { channel, channelDowngraded, method, target, action };
+    const result = {
+        channel,
+        channelDowngraded,
+        method,
+        target,
+        action,
+        ...(movedBack ? { movedBack: true } : {}),
+    };
     if (action.kind !== "install") {
         deps.saveState({ ...base, ...done });
         return result;
@@ -94,9 +108,11 @@ export async function runUpdate(deps, settings, opts = {}) {
         deps.saveState({
             ...base,
             available: undefined,
+            movedBack: undefined,
             installBlocked: undefined,
             pending: { from: deps.current, to: action.version, channel },
             followChannel: channel,
+            channelTarget: { channel, version: action.version },
             ...done,
         });
         return { ...result, installed: action.version };
@@ -106,11 +122,9 @@ export async function runUpdate(deps, settings, opts = {}) {
         deps.saveState({ ...base, installBlocked: true, lastError: outcome.message, ...done });
     }
     else {
-        deps.saveState({
-            ...failurePatch(state, now, outcome.message),
-            available: base.available,
-            ...done,
-        });
+        // Keep the moved-tag record: startup reads `movedBack` to notify and resume,
+        // and a moved-back tag must stay remembered until it is followed.
+        deps.saveState({ ...base, ...failurePatch(state, now, outcome.message), ...done });
     }
     return { ...result, error: outcome.message };
 }

package/package.json

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