@mnemom/mnemom 0.17.4 → 0.17.5

package/dist/lib/first-run/index.d.ts

@@ -3,6 +3,11 @@
  * backtest the user's last 30 days of Claude Code sessions on this machine and show what
  * Mnemom would have saved. `mnemom agent --first-run` shows it again at any time.
  *
+ * Every session in the window is priced (operator 2026-10-02: "count all sessions"),
+ * including ones that already ran through Mnemom: their transcripts hold the full,
+ * unfolded context the client sent. Only copies of one session are dropped. The governed
+ * classification is still run, for the audit counts only.
+ *
  * Privacy: READ-ONLY on ~/.claude and every transcript; no network call anywhere in this
  * module tree; only token counts, model ids, timestamps and Claude Code's own limit
  * records are read. Writes only the offer state file and a local audit (both 0600,
@@ -13,6 +18,7 @@
  * Enter / y shows the screen and records acceptance; n skips until the next launch;
  * never stops asking. A non-interactive launch is never asked and writes nothing.
  */
+import { type ScopeResult, type Session } from "./scope.js";
 import { type Audit, type Variation } from "./screen.js";
 export declare const STATE_FILE = "first-run.json";
 export declare const AUDIT_FILE = "first-run-audit.json";
@@ -51,6 +57,20 @@ export interface FirstRunResult {
 }
 /** Scan, classify, price and build the screen. Read-only on every transcript. */
 export declare function computeFirstRun(opts?: ScanOptions): FirstRunResult;
+/**
+ * The sessions the screen prices: every session in the window, one per session id (an
+ * ungoverned copy first), none without a parent transcript.
+ */
+export declare function pricedSessions(scope: ScopeResult): Array<{
+    s: Session;
+    viaMnemom: boolean;
+}>;
+/**
+ * Proof a session ran through Mnemom: `mnemom agent` recorded it in the launch ledger.
+ * Every other governed signal (an Agent-SDK host, a text marker, a time window) only
+ * means it may have, so those sessions are not said to have been saved on.
+ */
+export declare const LEDGER_SIGNALS: Set<string>;
 /** The screen's hard budget: a regression in buildScreen's line dropping must fail loudly. */
 export declare function assertScreenBudget(lines: readonly string[]): void;
 /** A transcript's mtime (ms), 0 when it vanished since discovery (it then sorts first). */

package/dist/lib/first-run/index.js

@@ -3,6 +3,11 @@
  * backtest the user's last 30 days of Claude Code sessions on this machine and show what
  * Mnemom would have saved. `mnemom agent --first-run` shows it again at any time.
  *
+ * Every session in the window is priced (operator 2026-10-02: "count all sessions"),
+ * including ones that already ran through Mnemom: their transcripts hold the full,
+ * unfolded context the client sent. Only copies of one session are dropped. The governed
+ * classification is still run, for the audit counts only.
+ *
  * Privacy: READ-ONLY on ~/.claude and every transcript; no network call anywhere in this
  * module tree; only token counts, model ids, timestamps and Claude Code's own limit
  * records are read. Writes only the offer state file and a local audit (both 0600,
@@ -95,8 +100,8 @@ export function computeFirstRun(opts = {}) {
     const counts = {
         sessions_total: scope.sessions.size,
         sessions_recent: scope.inWindow,
-        excluded_governed_or_doubt: scope.excluded.size,
-        kept: scope.kept.size,
+        governed_or_doubt: scope.excluded.size,
+        ungoverned: scope.kept.size,
     };
     for (const sigs of scope.excluded.values()) {
         for (const s of sigs)
@@ -104,10 +109,11 @@ export function computeFirstRun(opts = {}) {
     }
     // Oldest first, so a message copied into a later (resumed / forked) transcript is billed
     // once, to its origin.
-    const ordered = [...scope.kept.values()]
-        .map((s) => ({ s, m: mtimeOf(s.top) }))
-        .sort((a, b) => a.m - b.m)
-        .map((x) => x.s);
+    const priced = pricedSessions(scope);
+    counts.priced = priced.length;
+    const ordered = priced
+        .map((x) => ({ ...x, m: mtimeOf(x.s.top) }))
+        .sort((a, b) => a.m - b.m);
     const seen = new Set();
     const shapes = new Map();
     const sessions = [];
@@ -117,7 +123,7 @@ export function computeFirstRun(opts = {}) {
     // their subscription (lib/subscription-login.ts), so only they get the usage sentence.
     let orgLogin = false;
     const seatInputs = new Map();
-    ordered.forEach((s, i) => {
+    ordered.forEach(({ s, viaMnemom }, i) => {
         if (i % 25 === 0)
             opts.progress?.(`pricing sessions ${i + 1}/${ordered.length}`);
         const paths = [s.top, ...[...s.subs].sort()];
@@ -154,6 +160,7 @@ export function computeFirstRun(opts = {}) {
             end,
             actual: e.actual,
             saved: e.saved,
+            viaMnemom,
         };
         sessions.push(sc);
         if (cls === "subscription_org")
@@ -178,6 +185,27 @@ export function computeFirstRun(opts = {}) {
     };
     return { lines, audit, variation, counts, seconds: (Date.now() - t0) / 1000 };
 }
+/**
+ * The sessions the screen prices: every session in the window, one per session id (an
+ * ungoverned copy first), none without a parent transcript.
+ */
+export function pricedSessions(scope) {
+    const out = new Map();
+    for (const key of [...scope.kept.keys(), ...scope.excluded.keys()]) {
+        const s = scope.sessions.get(key);
+        if (!s.top || out.has(s.sid))
+            continue;
+        const sigs = scope.excluded.get(key) ?? [];
+        out.set(s.sid, { s, viaMnemom: sigs.some((x) => LEDGER_SIGNALS.has(x)) });
+    }
+    return [...out.values()];
+}
+/**
+ * Proof a session ran through Mnemom: `mnemom agent` recorded it in the launch ledger.
+ * Every other governed signal (an Agent-SDK host, a text marker, a time window) only
+ * means it may have, so those sessions are not said to have been saved on.
+ */
+export const LEDGER_SIGNALS = new Set(["registry_cc_id", "registry_conv_id"]);
 /** The screen's hard budget: a regression in buildScreen's line dropping must fail loudly. */
 export function assertScreenBudget(lines) {
     if (lines.length > MAX_LINES || lines.some((l) => l.length > WIDTH)) {

package/dist/lib/first-run/scope.d.ts

@@ -2,10 +2,13 @@
  * Which local Claude Code sessions the first-run look may count, and how each was billed.
  *
  * Operator rulings (2026-09-30 / 2026-10-01), binding:
- *   - The ONLY exclusion is "governed" (already ran through Mnemom); when in doubt,
- *     exclude. A headless `claude -p` session (entrypoint sdk-cli) is excluded: the env of
- *     the script that launched it (ANTHROPIC_BASE_URL, a proxy) is never recorded.
- *   - Sessions are discovered in ~/.claude/projects and every ~/.claude-*\/projects.
+ *   - "Governed" (already ran through Mnemom, or in doubt) is classified here and
+ *     recorded in the audit; since 2026-10-02 it no longer removes a session from the
+ *     priced set (index.ts pricedSessions: every session is counted). A headless
+ *     `claude -p` session (entrypoint sdk-cli) is marked: the env of the script that
+ *     launched it (ANTHROPIC_BASE_URL, a proxy) is never recorded.
+ *   - Sessions are discovered in ~/.claude/projects, every ~/.claude-*\/projects, and
+ *     $CLAUDE_CONFIG_DIR/projects wherever it points (a Console login often lives there).
  *   - Dollars are shown for API-billed sessions; Team / Enterprise subscription sessions
  *     (the plans `mnemom agent --auth subscription` supports) are in scope as usage-limit
  *     headroom with a clearly labelled list-price equivalent. Pro / Max are not supported
@@ -37,8 +40,11 @@ export interface ScopeResult {
     kept: Map<string, Session>;
     excluded: Map<string, string[]>;
 }
-/** ~/.claude/projects and ~/.claude-*\/projects that exist (realpath, de-duplicated). */
-export declare function defaultProjectRoots(home?: string): string[];
+/**
+ * ~/.claude/projects, ~/.claude-*\/projects and $CLAUDE_CONFIG_DIR/projects that exist
+ * (realpath, de-duplicated). CLAUDE_CONFIG_DIR can point anywhere, not only ~/.claude-*.
+ */
+export declare function defaultProjectRoots(home?: string, env?: Record<string, string | undefined>): string[];
 /** Every top-level transcript and subagent transcript under the roots, grouped by session. */
 export declare function discover(roots: readonly string[]): Map<string, Session>;
 export interface ClassifyOptions {

package/dist/lib/first-run/scope.js

@@ -2,10 +2,13 @@
  * Which local Claude Code sessions the first-run look may count, and how each was billed.
  *
  * Operator rulings (2026-09-30 / 2026-10-01), binding:
- *   - The ONLY exclusion is "governed" (already ran through Mnemom); when in doubt,
- *     exclude. A headless `claude -p` session (entrypoint sdk-cli) is excluded: the env of
- *     the script that launched it (ANTHROPIC_BASE_URL, a proxy) is never recorded.
- *   - Sessions are discovered in ~/.claude/projects and every ~/.claude-*\/projects.
+ *   - "Governed" (already ran through Mnemom, or in doubt) is classified here and
+ *     recorded in the audit; since 2026-10-02 it no longer removes a session from the
+ *     priced set (index.ts pricedSessions: every session is counted). A headless
+ *     `claude -p` session (entrypoint sdk-cli) is marked: the env of the script that
+ *     launched it (ANTHROPIC_BASE_URL, a proxy) is never recorded.
+ *   - Sessions are discovered in ~/.claude/projects, every ~/.claude-*\/projects, and
+ *     $CLAUDE_CONFIG_DIR/projects wherever it points (a Console login often lives there).
  *   - Dollars are shown for API-billed sessions; Team / Enterprise subscription sessions
  *     (the plans `mnemom agent --auth subscription` supports) are in scope as usage-limit
  *     headroom with a clearly labelled list-price equivalent. Pro / Max are not supported
@@ -44,8 +47,11 @@ function list(dir) {
         return [];
     }
 }
-/** ~/.claude/projects and ~/.claude-*\/projects that exist (realpath, de-duplicated). */
-export function defaultProjectRoots(home = homedir()) {
+/**
+ * ~/.claude/projects, ~/.claude-*\/projects and $CLAUDE_CONFIG_DIR/projects that exist
+ * (realpath, de-duplicated). CLAUDE_CONFIG_DIR can point anywhere, not only ~/.claude-*.
+ */
+export function defaultProjectRoots(home = homedir(), env = process.env) {
     const out = [];
     const add = (p) => {
         const rp = realOrNull(p);
@@ -57,6 +63,9 @@ export function defaultProjectRoots(home = homedir()) {
         if (d.startsWith(".claude-"))
             add(join(home, d, "projects"));
     }
+    const configDir = (env.CLAUDE_CONFIG_DIR ?? "").trim();
+    if (configDir)
+        add(join(configDir, "projects"));
     return out;
 }
 /** Every top-level transcript and subagent transcript under the roots, grouped by session. */

package/dist/lib/first-run/screen.d.ts

@@ -8,7 +8,9 @@
  * two lines make the same claim:
  *   A  saving   the shown saving is >= $5 and >= 5%: the usage at API prices, with Mnemom,
  *               the saving, the biggest session; plus ONE subscription sentence for a Team /
- *               Enterprise subscriber whose usage cut rounds to >= 5%.
+ *               Enterprise subscriber whose usage cut rounds to >= 5%. Where sessions ran
+ *               through Mnemom (launch ledger), that part is said to be SAVED: what it
+ *               saved you, and what it would have saved on the rest (operator 2026-10-02).
  *   B  small    >= $5 of usage at API prices but a smaller saving: the usage, the honest
  *               "wouldn't have changed that much" line, and the forward line.
  *   C  none     too little history: the forward line only.
@@ -64,6 +66,8 @@ export interface SessionCost {
     end: number;
     actual: number;
     saved: number;
+    /** The launch ledger proves it ran through Mnemom: its saving is said to be SAVED. */
+    viaMnemom?: boolean;
 }
 /** A Team / Enterprise subscriber's usage, at API prices (local evidence only). */
 export interface SubUsage {

package/dist/lib/first-run/screen.js

@@ -8,7 +8,9 @@
  * two lines make the same claim:
  *   A  saving   the shown saving is >= $5 and >= 5%: the usage at API prices, with Mnemom,
  *               the saving, the biggest session; plus ONE subscription sentence for a Team /
- *               Enterprise subscriber whose usage cut rounds to >= 5%.
+ *               Enterprise subscriber whose usage cut rounds to >= 5%. Where sessions ran
+ *               through Mnemom (launch ledger), that part is said to be SAVED: what it
+ *               saved you, and what it would have saved on the rest (operator 2026-10-02).
  *   B  small    >= $5 of usage at API prices but a smaller saving: the usage, the honest
  *               "wouldn't have changed that much" line, and the forward line.
  *   C  none     too little history: the forward line only.
@@ -160,11 +162,33 @@ export function buildScreen(inp) {
     L.push("");
     if (variation === "A") {
         A("spent_usd", { shown: a, raw: actual, method: SPENT_METHOD });
-        A("saved_usd", { shown: s, raw: saved, method: SAVED_METHOD });
-        A("with_mnemom_usd", { shown: e, raw: actual - saved, method: "spent shown - saved shown" });
         A("saved_pct", { shown: p, raw: (100 * saved) / actual, method: "rounded DOWN to 5s" });
-        L.push(...wrap(`At API prices that usage cost about ${usd(a)}. With Mnemom: about ${usd(e)}.`));
-        L.push(...wrap(`That's about ${usd(s)} less (${p}%), and you don't change how you work.`));
+        const viaRaw = ses.reduce((t, r) => t + (r.viaMnemom ? r.saved : 0), 0);
+        const via = sig2(viaRaw);
+        const rest = sig2(saved - viaRaw);
+        if (via < 1) {
+            A("saved_usd", { shown: s, raw: saved, method: SAVED_METHOD });
+            A("with_mnemom_usd", { shown: e, raw: actual - saved, method: "spent shown - saved shown" });
+            L.push(...wrap(`At API prices that usage cost about ${usd(a)}. With Mnemom: about ${usd(e)}.`));
+            L.push(...wrap(`That's about ${usd(s)} less (${p}%), and you don't change how you work.`));
+        }
+        else {
+            const m = `${SAVED_METHOD}; sessions the launch ledger shows ran through Mnemom`;
+            A("saved_via_mnemom_usd", { shown: via, raw: viaRaw, method: m });
+            L.push(...wrap(`At API prices that usage comes to about ${usd(a)} without Mnemom.`));
+            if (rest < 1) {
+                L.push(...wrap(`Mnemom saved you about ${usd(via)} of it (${p}%), and you didn't change how you work.`));
+            }
+            else {
+                A("saved_rest_usd", {
+                    shown: rest,
+                    raw: saved - viaRaw,
+                    method: `${SAVED_METHOD}; the rest`,
+                });
+                L.push(...wrap(`Mnemom saved you about ${usd(via)} of it, and would have saved about ${usd(rest)} ` +
+                    "more on the sessions that didn't run through it."));
+            }
+        }
         // A has a saving, so the session with the largest saving exists and saved something.
         const big = ses.reduce((m, r) => (r.saved > m.saved ? r : m));
         const [ba, , be] = pair(big.actual, big.saved);
@@ -179,7 +203,9 @@ export function buildScreen(inp) {
             method: "its cost shown - its saving (2 sig figs DOWN)",
         });
         const where = big.label ? `${big.label} on ${day(big.end)}` : `on ${day(big.end)}`;
-        L.push(...wrap(`Your biggest session, ${where}: ${usd(ba)}, with Mnemom about ${usd(be)}.`));
+        L.push(...wrap(big.viaMnemom
+            ? `Your biggest session, ${where}: ${usd(ba)} without Mnemom, about ${usd(be)} with it.`
+            : `Your biggest session, ${where}: ${usd(ba)}, with Mnemom about ${usd(be)}.`));
         L.push(...subLines(inp.sub, A));
     }
     else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.4",
+  "version": "0.17.5",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {