@mnemom/mnemom 0.17.31 → 0.17.32-next.1

package/dist/lib/statusline-feed.js

@@ -0,0 +1,68 @@
+/**
+ * The launcher side of the fed status line (W1.4, decision 14), prerelease only.
+ *
+ * The local base-URL proxy records the gateway's `x-mnemom-lineage-key` for this session in
+ * its record-state file (the one the conduct receipt reads). While Claude Code runs, the launcher reads Record's accumulator totals for that
+ * lineage every few seconds and writes them to the feed file the status-line bin reads
+ * (lib/statusline.ts). The bin never touches the network.
+ *
+ * Fail open everywhere: no lineage yet, a dark route (404), a non-billing role (403) or any
+ * error leaves the feed as it was, so the status line stays "mnemom" until fed.
+ */
+import { renameSync, writeFileSync } from "node:fs";
+import { getRecordTotals } from "./api.js";
+import { readRecordState } from "./conduct-receipt.js";
+import { LINEAGE_KEY_RE, MMU_RE } from "./statusline.js";
+/** How often the launcher re-reads the totals. */
+export const FEED_INTERVAL_MS = 10_000;
+/**
+ * The lineage key the proxy recorded, or null when there is none (yet) or it is not the
+ * gateway's `cid:`/`cr:` shape (the proxy's own check is looser; this read is exact).
+ */
+export function readLineage(path) {
+    const key = readRecordState(path).lineageKey;
+    return key && LINEAGE_KEY_RE.test(key) ? key : null;
+}
+/** One poll: read the lineage, fetch its totals, write the feed. Never throws. */
+export async function feedOnce(o) {
+    const key = readLineage(o.recordStateFile);
+    if (!key)
+        return false;
+    try {
+        const totals = await (o.fetchTotals ?? getRecordTotals)(o.orgId, key);
+        if (!totals || totals.lineage_key !== key)
+            return false;
+        // Persist only amounts the bin would render: a malformed reply never replaces a good feed.
+        const mu = totals.mu_charged_mmu;
+        if (typeof totals.model_cost_mmu !== "string" || !MMU_RE.test(totals.model_cost_mmu)) {
+            return false;
+        }
+        if (mu !== null && (typeof mu !== "string" || !MMU_RE.test(mu)))
+            return false;
+        const tmp = `${o.feedFile}.tmp`;
+        writeFileSync(tmp, JSON.stringify({
+            model_cost_mmu: totals.model_cost_mmu,
+            mu_charged_mmu: totals.mu_charged_mmu,
+        }));
+        renameSync(tmp, o.feedFile);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Poll until stopped. The timer is unref'd, so it never holds the launcher open. */
+export function startFeed(o) {
+    let running = false;
+    const tick = () => {
+        if (running)
+            return;
+        running = true;
+        void feedOnce(o).finally(() => {
+            running = false;
+        });
+    };
+    const timer = setInterval(tick, o.intervalMs ?? FEED_INTERVAL_MS);
+    timer.unref();
+    return () => clearInterval(timer);
+}

package/dist/lib/statusline.d.ts

@@ -1,108 +1,61 @@
 /**
- * The `mnemom agent` status-bar savings counter: a Claude Code statusLine command that
- * prints "mnemom saved ~$X this session".
+ * The `mnemom agent` status-bar segment: a Claude Code statusLine command that prints
+ * "mnemom", after the user's own status line when they have one.
  *
- * The number is the first-run look's estimator (first-run/backtest.ts), applied live to this
- * session's own transcript: each request priced at API list prices, times the empirical
- * curve's lower-bound saving rate for its original context. So the counter and the
- * first-run screen always agree, and it rounds DOWN to the cent.
+ * The segment never says "saved" and never shows an estimate (decision 14). The old
+ * "mnemom saved ~$X this session" counter priced the transcript with the first-run look's
+ * benchmark estimate; it is gone on every channel, stable included.
  *
- * Claude Code runs the command on every status update with its status JSON on stdin
- * (session_id, transcript_path, …). It must be fast, so the transcript is read
- * incrementally: per session, a state file (~/.mnemom/statusline/<session>.json, 0600)
- * 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.
+ * On a prerelease (`next`) launch the segment is fed: the launcher writes this session's
+ * measured model cost and μ from Record's accumulator to the file named in
+ * MNEMOM_STATUSLINE_FEED (lib/statusline-feed.ts), and the segment reads
+ * "mnemom · $0.42 · 1.70 μ". Until that file holds valid totals it is only "mnemom".
+ * Stable launches set no feed, so stable is only "mnemom".
  *
  * 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
- * the user's own statusLine command, and the first-run code is held to spawning nothing.
+ * No transcript reads and no network: the only file read is the feed.
  */
-export declare const STATE_DIR = "statusline";
-export declare const MAX_BYTES_PER_TICK: number;
 /** The launcher passes the user's own statusLine command here. */
 export declare const INNER_ENV = "MNEMOM_STATUSLINE_INNER";
-/** Set to 1 to launch without the counter. */
+/** Set to 1 to launch without the segment. */
 export declare const NO_STATUSLINE_ENV = "MNEMOM_AGENT_NO_STATUSLINE";
-/** The launcher sets this to 1 when the gateway measures the session's saving. */
-export declare const MEASURED_ENV = "MNEMOM_STATUSLINE_MEASURED";
 export declare const INNER_TIMEOUT_MS = 2000;
-export interface SessionState {
-    v: 1;
-    /** Byte offset read so far, per transcript file. */
-    files: Record<string, number>;
-    /** Per message id: [list-price cost, saving]. A re-written id replaces its old share. */
-    ids: Record<string, [number, number]>;
-    actual: number;
-    saved: number;
-}
-export declare function freshState(): SessionState;
-/** Measured mode's state (<session>.measured.json). */
-export interface MeasuredState {
-    v: 1;
-    files: Record<string, number>;
-    /** Per message id: the gateway's measured saving (USD). A re-written id replaces its old share. */
-    ids: Record<string, number>;
-    saved: number;
-    /** Has any record carried a measurement yet? Until then the segment makes no claim. */
-    seen: boolean;
-}
-export declare function freshMeasuredState(): MeasuredState;
-/** The main transcript, then its subagent transcripts (sorted). */
-export declare function sessionFiles(transcriptPath: string): string[];
-/**
- * The complete lines of `path` from `offset`, at most `maxBytes` of them, and the offset
- * after the last complete line. null: the file is unreadable or shorter than `offset`.
- */
-export declare function readNewLines(path: string, offset: number, maxBytes: number): {
-    lines: Buffer[];
-    next: number;
-} | null;
-/** Read what is new in the session's files into `st`. A file that shrank resets the count. */
-export declare function update(st: SessionState, files: string[], maxBytes?: number): SessionState;
-/** A `usage.iterations` entry's measured saving (`mnemom_savings` v1), or null. */
-export declare function measuredSaving(entry: unknown): number | null;
+/** What the segment says until it is fed. */
+export declare const SEGMENT = "mnemom";
+/** The launcher names the feed file here (prerelease launches only). */
+export declare const FEED_ENV = "MNEMOM_STATUSLINE_FEED";
 /**
- * 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.
+ * The gateway's per-conversation lineage key (deriveLineageKey): `cid:` or `cr:` + 16 hex.
+ * base-url-proxy.mjs (a standalone script) keeps its own copy; a test pins the two equal.
  */
-export declare function parseMeasuredLine(line: Buffer): {
-    id: string | null;
-    saved: number;
-} | null;
-/** Measured mode's `update`: sums each request's measured saving, replace-by-id. */
-export declare function updateMeasured(st: MeasuredState, files: string[], maxBytes?: number): MeasuredState;
-/** The segment, rounded DOWN to the cent and never below $0.00. */
-export declare function segment(saved: number): string;
-/** Measured mode's segment: no claim until the gateway has measured something; no "~". */
-export declare function measuredSegment(st: MeasuredState): string;
-export declare function loadState(path: string): SessionState;
-export declare function loadMeasuredState(path: string): MeasuredState;
-export declare function saveState(path: string, st: SessionState | MeasuredState): void;
+export declare const LINEAGE_KEY_RE: RegExp;
+/** A millimu amount as the record route returns it: a decimal string, no sign, no leading 0. */
+export declare const MMU_RE: RegExp;
+export interface FedTotals {
+    /** Integer millimu (1 μ = 1¢ = 1000 mmu), decimal string. */
+    model_cost_mmu: string;
+    /** null: no billing row yet, shown "μ not charged" (OD-9). */
+    mu_charged_mmu: string | null;
+}
+/** The feed file's totals, or null when it is absent or anything in it is off. */
+export declare function readFeed(path: string): FedTotals | null;
+/** Model cost in dollars: 1000 mmu = 1 μ = 1¢. Under half a cent reads "<$0.01", never "$0.00". */
+export declare function formatCost(mmu: string): string;
+/** μ charged, two places; null (no billing row) reads "μ not charged" (OD-9). */
+export declare function formatMu(mmu: string | null): string;
+/** The segment for these totals: "mnemom · $0.42 · 1.70 μ". */
+export declare function fedSegment(t: FedTotals): string;
 /** Run the user's own statusLine command with the same stdin; its first line, or "". */
 export declare function runInner(command: string, input: string): string;
 export interface RenderDeps {
-    stateDir: string;
     inner?: string;
-    /** Measured mode (`measuredMode`): the gateway's measured saving, not the estimate. */
-    measured?: boolean;
     runInner?: (command: string, input: string) => string;
+    /** The feed file (FEED_ENV); absent on stable, so the segment is only "mnemom". */
+    feed?: string;
 }
-/** Is the counter in measured mode? The launch's MEASURED_ENV, exactly "1". */
-export declare function measuredMode(env: NodeJS.ProcessEnv): boolean;
 /** Claude Code's status JSON → the one status line. Never throws. */
-export declare function render(stdin: string, deps: RenderDeps): string;
+export declare function render(stdin: string, deps?: RenderDeps): string;
 export interface UserStatusLine {
     command: string;
     padding?: number;
@@ -113,9 +66,8 @@ export interface UserStatusLine {
  */
 export declare function userStatusLine(cwd: string, configDir: string): UserStatusLine | null;
 /**
- * Launch args + env that add the counter, or null when it should stay off: the opt-out
+ * Launch args + env that add the segment, 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 declare function statuslineLaunch(o: {
     passthrough: readonly string[];
@@ -124,7 +76,6 @@ export declare function statuslineLaunch(o: {
     home?: string;
     node: string;
     bin: string;
-    measured?: boolean;
 }): {
     args: string[];
     env: Record<string, string>;

package/dist/lib/statusline.js

@@ -1,240 +1,82 @@
 /**
- * The `mnemom agent` status-bar savings counter: a Claude Code statusLine command that
- * prints "mnemom saved ~$X this session".
+ * The `mnemom agent` status-bar segment: a Claude Code statusLine command that prints
+ * "mnemom", after the user's own status line when they have one.
  *
- * The number is the first-run look's estimator (first-run/backtest.ts), applied live to this
- * session's own transcript: each request priced at API list prices, times the empirical
- * curve's lower-bound saving rate for its original context. So the counter and the
- * first-run screen always agree, and it rounds DOWN to the cent.
+ * The segment never says "saved" and never shows an estimate (decision 14). The old
+ * "mnemom saved ~$X this session" counter priced the transcript with the first-run look's
+ * benchmark estimate; it is gone on every channel, stable included.
  *
- * Claude Code runs the command on every status update with its status JSON on stdin
- * (session_id, transcript_path, …). It must be fast, so the transcript is read
- * incrementally: per session, a state file (~/.mnemom/statusline/<session>.json, 0600)
- * 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.
+ * On a prerelease (`next`) launch the segment is fed: the launcher writes this session's
+ * measured model cost and μ from Record's accumulator to the file named in
+ * MNEMOM_STATUSLINE_FEED (lib/statusline-feed.ts), and the segment reads
+ * "mnemom · $0.42 · 1.70 μ". Until that file holds valid totals it is only "mnemom".
+ * Stable launches set no feed, so stable is only "mnemom".
  *
  * 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
- * the user's own statusLine command, and the first-run code is held to spawning nothing.
+ * No transcript reads and no network: the only file read is the feed.
  */
 import { execSync } from "node:child_process";
-import { closeSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, writeFileSync, } from "node:fs";
+import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { origContext, parseUsageLine, rowCost, ruleRate } from "./first-run/backtest.js";
 import { parseJson } from "./first-run/lines.js";
-export const STATE_DIR = "statusline";
-export const MAX_BYTES_PER_TICK = 8 * 1024 * 1024;
 /** The launcher passes the user's own statusLine command here. */
 export const INNER_ENV = "MNEMOM_STATUSLINE_INNER";
-/** Set to 1 to launch without the counter. */
+/** Set to 1 to launch without the segment. */
 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");
-    let subs = [];
-    try {
-        subs = readdirSync(dir)
-            .filter((f) => f.endsWith(".jsonl"))
-            .sort()
-            .map((f) => join(dir, f));
-    }
-    catch {
-        /* no subagents */
-    }
-    return [transcriptPath, ...subs];
-}
+/** What the segment says until it is fed. */
+export const SEGMENT = "mnemom";
+/** The launcher names the feed file here (prerelease launches only). */
+export const FEED_ENV = "MNEMOM_STATUSLINE_FEED";
 /**
- * The complete lines of `path` from `offset`, at most `maxBytes` of them, and the offset
- * after the last complete line. null: the file is unreadable or shorter than `offset`.
+ * The gateway's per-conversation lineage key (deriveLineageKey): `cid:` or `cr:` + 16 hex.
+ * base-url-proxy.mjs (a standalone script) keeps its own copy; a test pins the two equal.
  */
-export function readNewLines(path, offset, maxBytes) {
-    let fd;
+export const LINEAGE_KEY_RE = /^(cid|cr):[0-9a-f]{16}$/;
+/** A millimu amount as the record route returns it: a decimal string, no sign, no leading 0. */
+export const MMU_RE = /^(0|[1-9][0-9]{0,18})$/;
+/** The feed file's totals, or null when it is absent or anything in it is off. */
+export function readFeed(path) {
     try {
-        fd = openSync(path, "r");
+        const d = parseJson(readFileSync(path, "utf8"));
+        if (!d)
+            return null;
+        const cost = d.model_cost_mmu;
+        const mu = d.mu_charged_mmu;
+        if (typeof cost !== "string" || !MMU_RE.test(cost))
+            return null;
+        if (mu !== null && (typeof mu !== "string" || !MMU_RE.test(mu)))
+            return null;
+        return { model_cost_mmu: cost, mu_charged_mmu: mu };
     }
     catch {
         return null;
     }
-    try {
-        const size = fstatSync(fd).size;
-        if (size < offset)
-            return null;
-        const n = Math.min(size - offset, maxBytes);
-        if (n <= 0)
-            return { lines: [], next: offset };
-        const buf = Buffer.allocUnsafe(n);
-        const got = readSync(fd, buf, 0, n, offset);
-        const view = buf.subarray(0, got);
-        const last = view.lastIndexOf(0x0a);
-        // One line longer than the whole budget: skip past it rather than stall forever.
-        if (last === -1)
-            return { lines: [], next: got === maxBytes ? offset + got : offset };
-        const lines = [];
-        let start = 0;
-        for (let nl = view.indexOf(0x0a); nl !== -1 && nl <= last; nl = view.indexOf(0x0a, start)) {
-            lines.push(view.subarray(start, nl));
-            start = nl + 1;
-        }
-        return { lines, next: offset + last + 1 };
-    }
-    finally {
-        closeSync(fd);
-    }
-}
-/**
- * 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)
-            break;
-        const from = st.files[f] ?? 0;
-        const r = readNewLines(f, from, budget);
-        if (r === null) {
-            if (from > 0)
-                return readSession(fresh(), files, maxBytes, fresh, add);
-            continue;
-        }
-        budget -= r.next - from;
-        const subagent = f.includes("/subagents/");
-        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;
-    });
+/** `n / 10^scale` rounded half up, as a decimal with `places` digits, in BigInt (never a float). */
+function fixed(mmu, divisor, places) {
+    const v = (BigInt(mmu) * 10n ** BigInt(places) * 2n + divisor) / (2n * divisor);
+    const s = v.toString().padStart(places + 1, "0");
+    return `${s.slice(0, -places)}.${s.slice(-places)}`;
 }
-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 };
+/** Model cost in dollars: 1000 mmu = 1 μ = 1¢. Under half a cent reads "<$0.01", never "$0.00". */
+export function formatCost(mmu) {
+    const big = BigInt(mmu);
+    if (big > 0n && big < 500n)
+        return "<$0.01";
+    return `$${fixed(mmu, 100000n, 2)}`;
 }
-/** 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;
-    });
+/** μ charged, two places; null (no billing row) reads "μ not charged" (OD-9). */
+export function formatMu(mmu) {
+    if (mmu === null)
+        return "μ not charged";
+    return `${fixed(mmu, 1000n, 2)} μ`;
 }
-/** 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) {
-    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, `${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 {
-        const v = parseJson(readFileSync(path, "utf8"));
-        if (v && v.v === 1 && v.files && v.ids)
-            return v;
-    }
-    catch {
-        /* none yet */
-    }
-    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`;
-    writeFileSync(tmp, JSON.stringify(st), { mode: 0o600 });
-    renameSync(tmp, path);
+/** The segment for these totals: "mnemom · $0.42 · 1.70 μ". */
+export function fedSegment(t) {
+    return `${SEGMENT} · ${formatCost(t.model_cost_mmu)} · ${formatMu(t.mu_charged_mmu)}`;
 }
 /** Run the user's own statusLine command with the same stdin; its first line, or "". */
 export function runInner(command, input) {
@@ -251,43 +93,12 @@ 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) {
+export function render(stdin, deps = {}) {
     const innerOut = deps.inner ? (deps.runInner ?? runInner)(deps.inner, stdin) : "";
-    let seg = "mnemom";
-    try {
-        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 && 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);
-            saveQuietly(path, st);
-        }
-    }
-    catch {
-        /* the counter never breaks the status bar */
-    }
-    return innerOut ? `${innerOut} · ${seg}` : seg;
+    const totals = deps.feed ? readFeed(deps.feed) : null;
+    const segment = totals ? fedSegment(totals) : SEGMENT;
+    return innerOut ? `${innerOut} · ${segment}` : segment;
 }
 /**
  * The statusLine Claude Code would use without us: the first settings file (highest
@@ -319,9 +130,8 @@ export function userStatusLine(cwd, configDir) {
 }
 const sq = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
 /**
- * Launch args + env that add the counter, or null when it should stay off: the opt-out
+ * Launch args + env that add the segment, 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")
@@ -337,8 +147,6 @@ export function statuslineLaunch(o) {
     if (user?.padding !== undefined)
         statusLine.padding = user.padding;
     const env = user ? { [INNER_ENV]: user.command } : {};
-    if (o.measured)
-        env[MEASURED_ENV] = "1";
     // `settings` is the same layer as `args`, for a caller that merges it with its own (Claude Code
     // keeps only the last --settings it is given).
     return { args: ["--settings", JSON.stringify({ statusLine })], env, settings: { statusLine } };