@mnemom/mnemom 0.17.31 → 0.17.32-next.0

package/dist/lib/experimental.js

@@ -75,7 +75,7 @@ export const EXPERIMENTAL_FEATURES = [
     {
         // No flag, launcher.toml key or env of its own: `mnemom experimental enable` is the switch.
         id: "measured-savings",
-        summary: "The status bar shows the saving the gateway measured on this session instead of the benchmark estimate",
+        summary: "The gateway measures each request's saving into the response usage (the status bar never shows it)",
         since: "0.17.16",
         gates: {
             flags: [],
@@ -84,6 +84,29 @@ export const EXPERIMENTAL_FEATURES = [
             env: [],
         },
     },
+    {
+        // No flag, launcher.toml key or env of its own: `mnemom experimental enable` is the switch.
+        id: "record",
+        summary: "Print the conduct receipt at exit: the session's measured model cost and μ, or the record link",
+        since: "0.17.32",
+        gates: {
+            flags: [],
+            configKeys: [],
+            commands: [],
+            env: [],
+        },
+    },
+    {
+        id: "fuel",
+        summary: "The fuel step: `mnemom agent fuel <file>` seals a batch of job contracts with one confirmation and commits them to the repo",
+        since: "0.17.32",
+        gates: {
+            flags: [],
+            configKeys: [],
+            commands: ["mnemom agent fuel"],
+            env: [],
+        },
+    },
 ];
 export const EXPERIMENTAL_IDS = EXPERIMENTAL_FEATURES.map((f) => f.id);
 export const EXPERIMENTAL_ENV = "MNEMOM_EXPERIMENTAL";
@@ -126,6 +149,17 @@ export function resolveExperimental(opts) {
         unknown: stored.filter((t) => !isExperimentalId(t)),
     };
 }
+/**
+ * Features a prerelease (`-next.N`) build makes available without `mnemom experimental
+ * enable`: door one's T16 turns implicit goals on by default on `next` (decisions 12 and
+ * 22), so its flag, its launcher.toml value and `mnemom agent goal` are not refused there.
+ * Stable is unchanged.
+ */
+export const PRERELEASE_AVAILABLE = ["implicit"];
+/** The features whose flags, keys and commands are usable: the enabled ones, plus PRERELEASE_AVAILABLE on a prerelease. */
+export function availableFeatures(enabled, prerelease) {
+    return normalize(prerelease ? [...enabled, ...PRERELEASE_AVAILABLE] : enabled);
+}
 /** The one-line stderr notice for a launch with experimental features on; null when none are. */
 export function experimentalNotice(enabled) {
     if (enabled.length === 0)

package/dist/lib/oauth.d.ts

@@ -42,7 +42,8 @@ export interface AuthServerMetadata {
 }
 /**
  * Fetch (and process-cache) the AS metadata document. We resolve it relative to
- * the active API base URL so staging/local point at their own AS.
+ * the active API base URL so local (and any non-default `Environment`) points
+ * at its own AS.
  */
 export declare function discover(): Promise<AuthServerMetadata>;
 /** Reset the process-level discovery cache (used by tests). */

package/dist/lib/oauth.js

@@ -117,7 +117,8 @@ async function oauthFetch(what, url, init = {}) {
 let cachedMetadata = null;
 /**
  * Fetch (and process-cache) the AS metadata document. We resolve it relative to
- * the active API base URL so staging/local point at their own AS.
+ * the active API base URL so local (and any non-default `Environment`) points
+ * at its own AS.
  */
 export async function discover() {
     if (cachedMetadata)

package/dist/lib/statusline-bin.d.ts

@@ -1,5 +1,5 @@
 /**
- * Entry for the `mnemom agent` status-bar counter (lib/statusline.ts). Claude Code runs it
- * on every status update, so it imports only the counter — not the whole CLI.
+ * Entry for the `mnemom agent` status-bar segment (lib/statusline.ts). Claude Code runs it
+ * on every status update, so it imports only the segment — not the whole CLI.
  */
 export {};

package/dist/lib/statusline-bin.js

@@ -1,17 +1,14 @@
 /**
- * Entry for the `mnemom agent` status-bar counter (lib/statusline.ts). Claude Code runs it
- * on every status update, so it imports only the counter — not the whole CLI.
+ * Entry for the `mnemom agent` status-bar segment (lib/statusline.ts). Claude Code runs it
+ * on every status update, so it imports only the segment — not the whole CLI.
  */
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { INNER_ENV, measuredMode, render } from "./statusline.js";
+import { FEED_ENV, INNER_ENV, render } from "./statusline.js";
 const chunks = [];
 process.stdin.on("data", (c) => chunks.push(c));
 process.stdin.on("end", () => {
     const line = render(Buffer.concat(chunks).toString("utf8"), {
-        stateDir: join(homedir(), ".mnemom", "statusline"),
         inner: process.env[INNER_ENV] || undefined,
-        measured: measuredMode(process.env),
+        feed: process.env[FEED_ENV] || undefined,
     });
     process.stdout.write(`${line}\n`);
 });

package/dist/lib/statusline-feed.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 { type RecordTotals } from "./api.js";
+/** How often the launcher re-reads the totals. */
+export declare const FEED_INTERVAL_MS = 10000;
+export interface FeedOptions {
+    /** The proxy's record-state JSON (MNEMOM_AGENT_BU_RECORD_STATE), carrying `lineage_key`. */
+    recordStateFile: string;
+    /** Read by the status-line bin (MNEMOM_STATUSLINE_FEED). */
+    feedFile: string;
+    orgId: string;
+    intervalMs?: number;
+    /** Test seam; the real read is getRecordTotals (throws on any non-200). */
+    fetchTotals?: (orgId: string, lineageKey: string) => Promise<RecordTotals | null>;
+}
+/**
+ * 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 declare function readLineage(path: string): string | null;
+/** One poll: read the lineage, fetch its totals, write the feed. Never throws. */
+export declare function feedOnce(o: FeedOptions): Promise<boolean>;
+/** Poll until stopped. The timer is unref'd, so it never holds the launcher open. */
+export declare function startFeed(o: FeedOptions): () => void;

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>;