@mnemom/mnemom 0.17.3-next.0 → 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,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/package.json

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