@mnemom/mnemom 0.17.15 → 0.17.16

package/dist/lib/statusline.js

@@ -13,6 +13,15 @@
  * keeps each file's byte offset and each message id's contribution, and a tick reads at
  * most MAX_BYTES_PER_TICK of new bytes (a big resumed session catches up over ticks).
  *
+ * Measured mode (the `measured-savings` experimental feature; the launch sets
+ * MNEMOM_STATUSLINE_MEASURED=1): the gateway measures each request's saving — the stock
+ * request's input cost minus what it billed — and writes it into the response usage as
+ * `mnemom_savings` inside a `usage.iterations` entry, the one place Claude Code keeps an
+ * unknown usage key in its transcript. The counter sums those per message id
+ * ("mnemom saved $X this session", no "~": it is measured) and makes no claim before the
+ * first one arrives. Its state lives in its own file (<session>.measured.json), so the two
+ * modes never share a count.
+ *
  * A user's own statusLine is never replaced: the launch passes it in
  * MNEMOM_STATUSLINE_INNER, it runs with the same stdin, and our segment is appended.
  * Read-only on every transcript; no network. It lives outside lib/first-run because it runs
@@ -30,10 +39,15 @@ export const MAX_BYTES_PER_TICK = 8 * 1024 * 1024;
 export const INNER_ENV = "MNEMOM_STATUSLINE_INNER";
 /** Set to 1 to launch without the counter. */
 export const NO_STATUSLINE_ENV = "MNEMOM_AGENT_NO_STATUSLINE";
+/** The launcher sets this to 1 when the gateway measures the session's saving. */
+export const MEASURED_ENV = "MNEMOM_STATUSLINE_MEASURED";
 export const INNER_TIMEOUT_MS = 2000;
 export function freshState() {
     return { v: 1, files: {}, ids: {}, actual: 0, saved: 0 };
 }
+export function freshMeasuredState() {
+    return { v: 1, files: {}, ids: {}, saved: 0, seen: false };
+}
 /** The main transcript, then its subagent transcripts (sorted). */
 export function sessionFiles(transcriptPath) {
     const dir = join(transcriptPath.replace(/\.jsonl$/, ""), "subagents");
@@ -87,8 +101,12 @@ export function readNewLines(path, offset, maxBytes) {
         closeSync(fd);
     }
 }
-/** Read what is new in the session's files into `st`. A file that shrank resets the count. */
-export function update(st, files, maxBytes = MAX_BYTES_PER_TICK) {
+/**
+ * The incremental read both modes share: each file's new complete lines, within the tick's
+ * byte budget, go to `add` (with the key a record without an id is counted under). A file
+ * that shrank or vanished starts over from `fresh()`.
+ */
+function readSession(st, files, maxBytes, fresh, add) {
     let budget = maxBytes;
     for (const f of files) {
         if (budget <= 0)
@@ -97,38 +115,97 @@ export function update(st, files, maxBytes = MAX_BYTES_PER_TICK) {
         const r = readNewLines(f, from, budget);
         if (r === null) {
             if (from > 0)
-                return update(freshState(), files, maxBytes);
+                return readSession(fresh(), files, maxBytes, fresh, add);
             continue;
         }
         budget -= r.next - from;
         const subagent = f.includes("/subagents/");
-        r.lines.forEach((line, i) => {
-            const p = parseUsageLine(line, subagent);
-            if (!p)
-                return;
-            const key = p.id ?? `anon-${f}-${from}-${i}`;
-            const cost = rowCost(p.row);
-            const saved = ruleRate(origContext(p.row)).screen * cost;
-            const prev = st.ids[key];
-            if (prev) {
-                st.actual -= prev[0];
-                st.saved -= prev[1];
-            }
-            st.ids[key] = [cost, saved];
-            st.actual += cost;
-            st.saved += saved;
-        });
+        r.lines.forEach((line, i) => add(st, line, subagent, `anon-${f}-${from}-${i}`));
         st.files[f] = r.next;
     }
     return st;
 }
+/** Read what is new in the session's files into `st`. A file that shrank resets the count. */
+export function update(st, files, maxBytes = MAX_BYTES_PER_TICK) {
+    return readSession(st, files, maxBytes, freshState, (s, line, subagent, anonKey) => {
+        const p = parseUsageLine(line, subagent);
+        if (!p)
+            return;
+        const key = p.id ?? anonKey;
+        const cost = rowCost(p.row);
+        const saved = ruleRate(origContext(p.row)).screen * cost;
+        const prev = s.ids[key];
+        if (prev) {
+            s.actual -= prev[0];
+            s.saved -= prev[1];
+        }
+        s.ids[key] = [cost, saved];
+        s.actual += cost;
+        s.saved += saved;
+    });
+}
+const SAVINGS = Buffer.from('"mnemom_savings"');
+const ASSISTANT = Buffer.from('"assistant"');
+/** A `usage.iterations` entry's measured saving (`mnemom_savings` v1), or null. */
+export function measuredSaving(entry) {
+    const m = entry?.mnemom_savings;
+    return m?.v === 1 && Number.isFinite(m.saved_usd) ? m.saved_usd : null;
+}
+/**
+ * One transcript line → the gateway's measured saving for its request, or null (not an
+ * assistant record, or no measurement in its `message.usage.iterations`). `id` is the message
+ * id (or record uuid); null when the record carries neither. Claude Code writes one record per
+ * content block, all with the same id and usage, so the id is what dedupes them.
+ */
+export function parseMeasuredLine(line) {
+    if (line.indexOf(SAVINGS) === -1 || line.indexOf(ASSISTANT) === -1)
+        return null;
+    const d = parseJson(line);
+    if (d?.type !== "assistant")
+        return null;
+    const m = d.message;
+    const iterations = m?.usage?.iterations;
+    if (!Array.isArray(iterations))
+        return null;
+    const saved = iterations.map(measuredSaving).find((v) => v !== null);
+    if (saved === undefined)
+        return null;
+    const id = (typeof m?.id === "string" && m.id) || (typeof d.uuid === "string" && d.uuid) || null;
+    return { id, saved };
+}
+/** Measured mode's `update`: sums each request's measured saving, replace-by-id. */
+export function updateMeasured(st, files, maxBytes = MAX_BYTES_PER_TICK) {
+    return readSession(st, files, maxBytes, freshMeasuredState, (s, line, _subagent, anonKey) => {
+        const p = parseMeasuredLine(line);
+        if (!p)
+            return;
+        const key = p.id ?? anonKey;
+        s.saved += p.saved - (s.ids[key] ?? 0);
+        s.ids[key] = p.saved;
+        s.seen = true;
+    });
+}
+/** USD rounded DOWN to the cent and never below 0.00. */
+function cents(usd) {
+    return (Math.max(Math.floor(usd * 100 + 1e-9), 0) / 100).toFixed(2);
+}
 /** The segment, rounded DOWN to the cent and never below $0.00. */
 export function segment(saved) {
-    const cents = Math.max(Math.floor(saved * 100 + 1e-9), 0);
-    return `mnemom saved ~$${(cents / 100).toFixed(2)} this session`;
+    return `mnemom saved ~$${cents(saved)} this session`;
+}
+/** Measured mode's segment: no claim until the gateway has measured something; no "~". */
+export function measuredSegment(st) {
+    return st.seen ? `mnemom saved $${cents(st.saved)} this session` : "mnemom";
+}
+function stateName(sessionId) {
+    return sessionId.replace(/[^A-Za-z0-9_-]/g, "_");
 }
 function statePath(stateDir, sessionId) {
-    return join(stateDir, `${sessionId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
+    return join(stateDir, `${stateName(sessionId)}.json`);
+}
+/** Measured mode's own file: a sanitized id has no ".", so it never collides with statePath. */
+function measuredStatePath(stateDir, sessionId) {
+    return join(stateDir, `${stateName(sessionId)}.measured.json`);
 }
 export function loadState(path) {
     try {
@@ -141,6 +218,18 @@ export function loadState(path) {
     }
     return freshState();
 }
+export function loadMeasuredState(path) {
+    try {
+        const v = parseJson(readFileSync(path, "utf8"));
+        if (v && v.v === 1 && v.files && v.ids && typeof v.seen === "boolean") {
+            return v;
+        }
+    }
+    catch {
+        /* none yet */
+    }
+    return freshMeasuredState();
+}
 export function saveState(path, st) {
     mkdirSync(join(path, ".."), { recursive: true, mode: 0o700 });
     const tmp = `${path}.${process.pid}.tmp`;
@@ -162,6 +251,18 @@ export function runInner(command, input) {
         return "";
     }
 }
+/** Is the counter in measured mode? The launch's MEASURED_ENV, exactly "1". */
+export function measuredMode(env) {
+    return env[MEASURED_ENV] === "1";
+}
+function saveQuietly(path, st) {
+    try {
+        saveState(path, st);
+    }
+    catch {
+        /* an unwritable state dir only means the next tick re-reads */
+    }
+}
 /** Claude Code's status JSON → the one status line. Never throws. */
 export function render(stdin, deps) {
     const innerOut = deps.inner ? (deps.runInner ?? runInner)(deps.inner, stdin) : "";
@@ -170,16 +271,17 @@ export function render(stdin, deps) {
         const d = parseJson(stdin);
         const tp = typeof d?.transcript_path === "string" ? d.transcript_path : null;
         const sid = typeof d?.session_id === "string" && d.session_id ? d.session_id : null;
-        if (tp && sid) {
+        if (tp && sid && deps.measured) {
+            const path = measuredStatePath(deps.stateDir, sid);
+            const st = updateMeasured(loadMeasuredState(path), sessionFiles(tp));
+            seg = measuredSegment(st);
+            saveQuietly(path, st);
+        }
+        else if (tp && sid) {
             const path = statePath(deps.stateDir, sid);
             const st = update(loadState(path), sessionFiles(tp));
             seg = segment(st.saved);
-            try {
-                saveState(path, st);
-            }
-            catch {
-                /* an unwritable state dir only means the next tick re-reads */
-            }
+            saveQuietly(path, st);
         }
     }
     catch {
@@ -219,6 +321,7 @@ const sq = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
 /**
  * Launch args + env that add the counter, or null when it should stay off: the opt-out
  * env, or the user passing their own --settings (two would fight over precedence).
+ * `measured` puts the counter in measured mode (MEASURED_ENV).
  */
 export function statuslineLaunch(o) {
     if (o.env[NO_STATUSLINE_ENV] === "1")
@@ -233,8 +336,8 @@ export function statuslineLaunch(o) {
     };
     if (user?.padding !== undefined)
         statusLine.padding = user.padding;
-    return {
-        args: ["--settings", JSON.stringify({ statusLine })],
-        env: user ? { [INNER_ENV]: user.command } : {},
-    };
+    const env = user ? { [INNER_ENV]: user.command } : {};
+    if (o.measured)
+        env[MEASURED_ENV] = "1";
+    return { args: ["--settings", JSON.stringify({ statusLine })], env };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.15",
+  "version": "0.17.16",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "js-yaml": "^4.3.2",
-    "smol-toml": "^1.8.0"
+    "smol-toml": "^1.9.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",