@mnemom/mnemom 0.17.2 → 0.17.3-next.1

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,31 +1,33 @@
 /**
  * `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 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;
-    /** Value in effect after env + default. */
-    effective(prefs: UpdatePrefs, env: Record<string, string | undefined>): string;
+    stored(config: CliConfig): string | undefined;
+    /** Value in effect after env + default (`hint` picks the channel default). */
+    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;
 }
 /** One line per key: `key = effective  (source)  — description`. */
 export declare function configListCommand(opts?: {

package/dist/commands/config.js

@@ -1,40 +1,57 @@
 /**
  * `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 = [
     {
         key: "update.channel",
-        describe: `Release channel for auto-update: ${UPDATE_CHANNELS.join(" | ")} (next requires an invite)`,
+        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) => resolveChannel(p, env),
+        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) {
@@ -45,19 +62,25 @@ 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), source, describe: k.describe };
+        return {
+            key: k.key,
+            value: k.effective(config, deps.env, deps.hint),
+            source,
+            describe: k.describe,
+        };
     });
     if (opts.json) {
         deps.log(JSON.stringify(rows, null, 2));
@@ -67,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.log(findKey(key).effective(deps.config(), deps.env, deps.hint));
 }
 export function configSetCommand(key, value, deps = defaultDeps()) {
     const spec = findKey(key);

package/dist/commands/update.d.ts

@@ -6,7 +6,7 @@
  * command is consent). `--check` never installs; `--force` permits a downgrade
  * to the channel's version (e.g. leaving next for latest).
  */
-import { type ResolvedSettings } from "../lib/update/decide.js";
+import { type InstallHint, type ResolvedSettings } from "../lib/update/decide.js";
 import { type RunDeps, type RunResult } from "../lib/update/run.js";
 export declare const NEXT_NOT_ENTITLED_HINT: string;
 export interface UpdateOptions {
@@ -16,7 +16,7 @@ export interface UpdateOptions {
     json?: boolean;
 }
 /** Validate flags → the settings for this foreground pass, or an error message. */
-export declare function foregroundSettings(opts: UpdateOptions, prefs?: import("../lib/update/decide.js").UpdatePrefs, env?: Record<string, string | undefined>): ResolvedSettings | string;
+export declare function foregroundSettings(opts: UpdateOptions, prefs?: import("../lib/update/decide.js").UpdatePrefs, env?: Record<string, string | undefined>, hint?: InstallHint): ResolvedSettings | string;
 /** Human-readable report of one pass. Pure, for testing. */
 export declare function formatUpdateResult(result: RunResult, current: string): string[];
 /** Exit status: non-zero only when something actually failed. */

package/dist/commands/update.js

@@ -10,17 +10,17 @@ import chalk from "chalk";
 import { CLI_VERSION } from "../version.js";
 import { canSelfUpdate, isUpdateChannel, manualUpgradeCommand, resolveChannel, UPDATE_CHANNELS, } from "../lib/update/decide.js";
 import { runUpdate } from "../lib/update/run.js";
-import { acquireLock } from "../lib/update/state.js";
+import { acquireLock, loadUpdateState } from "../lib/update/state.js";
 import { entryRealpath, foregroundCredential, loadUpdatePrefs } from "../lib/update/system.js";
 import { realRunDeps } from "../lib/update/worker.js";
 export const NEXT_NOT_ENTITLED_HINT = "The next channel is available to invited accounts. Ask your Mnemom contact for an invite " +
     "(and make sure you're logged in: mnemom login). Using latest for now.";
 /** Validate flags → the settings for this foreground pass, or an error message. */
-export function foregroundSettings(opts, prefs = loadUpdatePrefs(), env = process.env) {
+export function foregroundSettings(opts, prefs = loadUpdatePrefs(), env = process.env, hint = { current: CLI_VERSION, followed: loadUpdateState().followChannel }) {
     if (opts.channel !== undefined && !isUpdateChannel(opts.channel)) {
         return `--channel must be one of ${UPDATE_CHANNELS.join(", ")} (got '${opts.channel}').`;
     }
-    const channel = resolveChannel(prefs, env, opts.channel);
+    const channel = resolveChannel(prefs, env, opts.channel, hint);
     return { channel, mode: opts.check ? "notify" : "auto" };
 }
 /** Human-readable report of one pass. Pure, for testing. */

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

@@ -62,6 +62,8 @@ export interface UpdateState {
     entitlement?: EntitlementCache;
     /** Install method the worker last detected (startup can't afford `npm root -g`). */
     method?: InstallMethod;
+    /** Channel the last successful update installed from; feeds defaultChannel. */
+    followChannel?: UpdateChannel;
 }
 export interface UpdatePrefs {
     channel?: UpdateChannel;
@@ -75,8 +77,23 @@ export interface ResolvedSettings {
 }
 export declare function isUpdateChannel(v: unknown): v is UpdateChannel;
 export declare function isUpdateMode(v: unknown): v is UpdateMode;
-/** Channel precedence: flag > MNEMOM_UPDATE_CHANNEL > config.json > latest. */
-export declare function resolveChannel(prefs: UpdatePrefs, env: Record<string, string | undefined>, flag?: UpdateChannel): UpdateChannel;
+/** What the unconfigured default is derived from. */
+export interface InstallHint {
+    /** The running CLI version. */
+    current?: string;
+    /** The channel the last successful update installed from (update state). */
+    followed?: UpdateChannel;
+}
+/**
+ * The channel when nothing is configured: `next` if this build was installed
+ * from `@next` (a prerelease, e.g. a Mnemom Code invite) or the updater last
+ * installed from `next` — the latter keeps a `next` follower on `next` after
+ * `latest` overtakes it and they land on a stable build. Otherwise `latest`.
+ * The entitlement check still applies to a defaulted `next`.
+ */
+export declare function defaultChannel(hint?: InstallHint): UpdateChannel;
+/** Channel precedence: flag > MNEMOM_UPDATE_CHANNEL > config.json > defaultChannel(hint). */
+export declare function resolveChannel(prefs: UpdatePrefs, env: Record<string, string | undefined>, flag?: UpdateChannel, hint?: InstallHint): UpdateChannel;
 /** Mode precedence: flag > MNEMOM_UPDATE_MODE > config.json > auto. */
 export declare function resolveMode(prefs: UpdatePrefs, env: Record<string, string | undefined>, flag?: UpdateMode): UpdateMode;
 /**
@@ -91,6 +108,8 @@ export declare function resolveSettings(input: {
     env: Record<string, string | undefined>;
     isTTY: boolean;
     flags?: UpdatePrefs;
+    /** Picks the default channel when none is configured. */
+    hint?: InstallHint;
 }): ResolvedSettings;
 /** The channel actually honoured: `next` requires a positive entitlement. */
 export declare function effectiveChannel(requested: UpdateChannel, entitledToNext: boolean): UpdateChannel;

package/dist/lib/update/decide.js

@@ -45,10 +45,24 @@ export function isUpdateMode(v) {
 function truthyEnv(v) {
     return v !== undefined && v !== "" && v !== "0" && v.toLowerCase() !== "false";
 }
-/** Channel precedence: flag > MNEMOM_UPDATE_CHANNEL > config.json > latest. */
-export function resolveChannel(prefs, env, flag) {
+/**
+ * The channel when nothing is configured: `next` if this build was installed
+ * from `@next` (a prerelease, e.g. a Mnemom Code invite) or the updater last
+ * installed from `next` — the latter keeps a `next` follower on `next` after
+ * `latest` overtakes it and they land on a stable build. Otherwise `latest`.
+ * The entitlement check still applies to a defaulted `next`.
+ */
+export function defaultChannel(hint = {}) {
+    const onPrerelease = hint.current !== undefined && isPrerelease(hint.current);
+    return onPrerelease || hint.followed === "next" ? "next" : "latest";
+}
+/** Channel precedence: flag > MNEMOM_UPDATE_CHANNEL > config.json > defaultChannel(hint). */
+export function resolveChannel(prefs, env, flag, hint) {
     const fromEnv = env.MNEMOM_UPDATE_CHANNEL;
-    return flag ?? (isUpdateChannel(fromEnv) ? fromEnv : undefined) ?? prefs.channel ?? "latest";
+    return (flag ??
+        (isUpdateChannel(fromEnv) ? fromEnv : undefined) ??
+        prefs.channel ??
+        defaultChannel(hint));
 }
 /** Mode precedence: flag > MNEMOM_UPDATE_MODE > config.json > auto. */
 export function resolveMode(prefs, env, flag) {
@@ -63,8 +77,8 @@ export function resolveMode(prefs, env, flag) {
  * every command.
  */
 export function resolveSettings(input) {
-    const { prefs, env, isTTY, flags } = input;
-    const channel = resolveChannel(prefs, env, flags?.channel);
+    const { prefs, env, isTTY, flags, hint } = input;
+    const channel = resolveChannel(prefs, env, flags?.channel, hint);
     const mode = resolveMode(prefs, env, flags?.mode);
     if (truthyEnv(env.MNEMOM_DISABLE_AUTOUPDATE)) {
         return { channel, mode: "off", offReason: "MNEMOM_DISABLE_AUTOUPDATE is set" };

package/dist/lib/update/doctor.js

@@ -53,11 +53,13 @@ export function updateDoctorRow(input) {
     };
 }
 export async function probeUpdateStatus() {
+    const state = loadUpdateState();
     const settings = resolveSettings({
         prefs: loadUpdatePrefs(),
         env: process.env,
         isTTY: process.stdout.isTTY === true,
+        hint: { current: CLI_VERSION, followed: state.followChannel },
     });
     const method = classifyInstall(entryRealpath(process.argv[1]), await npmGlobalRoot());
-    return updateDoctorRow({ current: CLI_VERSION, settings, method, state: loadUpdateState() });
+    return updateDoctorRow({ current: CLI_VERSION, settings, method, state });
 }

package/dist/lib/update/min-version.js

@@ -6,9 +6,10 @@
  */
 import { spawnSync } from "node:child_process";
 import { canSelfUpdate, PACKAGE_NAME, resolveSettings, } from "./decide.js";
+import { CLI_VERSION } from "../../version.js";
 import { classifyInstall } from "./install-method.js";
 import { isValidVersion, isPrerelease } from "./semver.js";
-import { acquireLock } from "./state.js";
+import { acquireLock, loadUpdateState } from "./state.js";
 import { entryRealpath, loadUpdatePrefs, npmInvocation } from "./system.js";
 /**
  * Returns true when the CLI was upgraded. Only in `auto` mode — `notify` means
@@ -54,6 +55,7 @@ export function defaultFloorUpgradeDeps() {
             prefs: loadUpdatePrefs(),
             env: process.env,
             isTTY: process.stdout.isTTY === true,
+            hint: { current: CLI_VERSION, followed: loadUpdateState().followChannel },
         }),
         method: () => {
             const root = spawnNpmSync(inv, ["root", "-g"], { timeout: 15_000 });

package/dist/lib/update/run.js

@@ -86,6 +86,7 @@ export async function runUpdate(deps, settings, opts = {}) {
             available: undefined,
             installBlocked: undefined,
             pending: { from: deps.current, to: action.version, channel },
+            followChannel: channel,
         });
         return { ...result, installed: action.version };
     }

package/dist/lib/update/startup.js

@@ -16,13 +16,18 @@ import { entryRealpath, loadUpdatePrefs } from "./system.js";
 const SKIP_COMMANDS = new Set(["update", "config"]);
 export function maybeRunUpdateHook(deps) {
     try {
-        const settings = resolveSettings({ prefs: deps.prefs(), env: deps.env, isTTY: deps.stdoutTTY });
+        const state = deps.loadState();
+        const settings = resolveSettings({
+            prefs: deps.prefs(),
+            env: deps.env,
+            isTTY: deps.stdoutTTY,
+            hint: { current: deps.current, followed: state.followChannel },
+        });
         if (settings.mode === "off")
             return;
         if (classifyInstall(deps.entryPath, undefined) === "dev")
             return;
         const now = deps.now();
-        const state = deps.loadState();
         const notice = startupNotice({
             current: deps.current,
             state,

package/package.json

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