@mnemom/mnemom 0.17.38-next.1 → 0.17.38-next.2

package/dist/vendor/shared/org-scan-core/spend/prices.d.ts

@@ -0,0 +1,33 @@
+export type AiTool = "claude_code" | "codex" | "copilot" | "gemini";
+export interface TokenPrice {
+    /** USD per 1M input tokens. */
+    inputPerMTok: number;
+    /** USD per 1M output tokens. */
+    outputPerMTok: number;
+    model: string;
+}
+export interface PriceBand {
+    low: TokenPrice;
+    high: TokenPrice;
+    /** Page the prices were read from. */
+    source: string;
+}
+export declare const PRICES_AS_OF = "2026-10-28";
+export declare const TOOL_PRICES: Record<Exclude<AiTool, "copilot">, PriceBand>;
+/**
+ * GitHub Copilot bills per premium request, not per token
+ * (https://docs.github.com/en/copilot/concepts/billing/copilot-requests),
+ * so it has no token price of its own. Its agent routes to the other vendors' models, so its band is
+ * the union of the other three: cheapest low to dearest high. An assumption, stated here once.
+ */
+export declare function copilotBand(): PriceBand;
+/**
+ * Share of billed tokens that are input (the rest output). Agent loops re-read large context and
+ * write little, so input dominates. An ASSUMPTION used both to turn our known run cost into
+ * tokens-per-line and to price those tokens for each tool; it cancels to first order when the
+ * tool's input/output price ratio matches ours, and is the main source of the range's width.
+ */
+export declare const INPUT_SHARE = 0.9;
+export declare function bandFor(tool: AiTool): PriceBand;
+/** USD per token at the assumed input/output mix. */
+export declare function blendedUsdPerToken(p: TokenPrice): number;

package/dist/vendor/shared/org-scan-core/spend/prices.js

@@ -0,0 +1,58 @@
+// GENERATED from shared/org-scan-core/src/spend/prices.ts by cli/scripts/sync-org-scan-core.mjs; do not edit.
+// MNE-9268: public list prices for the AI coding tools the Tier-3 spend estimator can name.
+// Constants, not magic numbers: every row carries its source page and the date it was read.
+// USD per million tokens (input / output), standard (non-batch) list price. A band is the cheapest
+// and the dearest model a tool's coding agent plausibly runs on, so the estimate is a RANGE.
+// Re-read the pages and bump PRICES_AS_OF when they move; a stale price widens nothing silently,
+// it just shifts the range, which is why the date ships with the estimate's method text.
+export const PRICES_AS_OF = "2026-10-28";
+export const TOOL_PRICES = {
+    claude_code: {
+        source: "https://platform.claude.com/docs/en/about-claude/pricing",
+        low: { model: "Claude Sonnet 5.5", inputPerMTok: 2, outputPerMTok: 10 },
+        high: { model: "Claude Opus 5", inputPerMTok: 5, outputPerMTok: 25 },
+    },
+    codex: {
+        source: "https://developers.openai.com/api/docs/pricing",
+        low: { model: "gpt-5.3-codex (standard)", inputPerMTok: 1.75, outputPerMTok: 14 },
+        high: { model: "gpt-5.3-codex (fast)", inputPerMTok: 3.5, outputPerMTok: 28 },
+    },
+    gemini: {
+        source: "https://ai.google.dev/gemini-api/docs/pricing",
+        // Gemini 3.8 Flash is $0.75/$3.75 through 2026-12-31 and $1.50/$7.50 from 2027-01-01; the
+        // post-promotion price is used so the lower bound does not expire in two months.
+        low: { model: "Gemini 3.8 Flash (from 2027-01-01)", inputPerMTok: 1.5, outputPerMTok: 7.5 },
+        high: { model: "Gemini 3.1 Pro (prompts up to 200k)", inputPerMTok: 2, outputPerMTok: 12 },
+    },
+};
+/**
+ * GitHub Copilot bills per premium request, not per token
+ * (https://docs.github.com/en/copilot/concepts/billing/copilot-requests),
+ * so it has no token price of its own. Its agent routes to the other vendors' models, so its band is
+ * the union of the other three: cheapest low to dearest high. An assumption, stated here once.
+ */
+export function copilotBand() {
+    const bands = Object.values(TOOL_PRICES);
+    const blend = (p) => p.inputPerMTok * INPUT_SHARE + p.outputPerMTok * (1 - INPUT_SHARE);
+    const low = bands.map((b) => b.low).sort((a, b) => blend(a) - blend(b))[0];
+    const high = bands.map((b) => b.high).sort((a, b) => blend(b) - blend(a))[0];
+    return {
+        low,
+        high,
+        source: "union of the claude_code, codex and gemini bands (per-request billing)",
+    };
+}
+/**
+ * Share of billed tokens that are input (the rest output). Agent loops re-read large context and
+ * write little, so input dominates. An ASSUMPTION used both to turn our known run cost into
+ * tokens-per-line and to price those tokens for each tool; it cancels to first order when the
+ * tool's input/output price ratio matches ours, and is the main source of the range's width.
+ */
+export const INPUT_SHARE = 0.9;
+export function bandFor(tool) {
+    return tool === "copilot" ? copilotBand() : TOOL_PRICES[tool];
+}
+/** USD per token at the assumed input/output mix. */
+export function blendedUsdPerToken(p) {
+    return (p.inputPerMTok * INPUT_SHARE + p.outputPerMTok * (1 - INPUT_SHARE)) / 1_000_000;
+}

package/dist/vendor/shared/org-scan-core/spend/spend-estimate.d.ts

@@ -0,0 +1,30 @@
+import { type AiTool } from "./prices.js";
+import { type TokenRate } from "./token-rate.js";
+/** AI-assisted PRs needed before a range is worth printing. */
+export declare const MIN_AI_PRS = 10;
+/** Per-PR input. `markText` is commit messages / PR body, read for tool marks and dropped. */
+export interface SpendPrInput {
+    additions: number;
+    deletions: number;
+    markText: string;
+    /** Tools already detected inside the PR source (so the body never leaves it). Wins over markText. */
+    tools?: AiTool[];
+}
+export type NoSpendReason = "too_few_ai_prs" | "no_rate" | "invalid_input";
+export type SpendEstimate = {
+    kind: "range";
+    lowUsd: number;
+    highUsd: number;
+    aiPrs: number;
+    scannedPrs: number;
+    byTool: Partial<Record<AiTool, number>>;
+    /** One line, labelled estimate, passes claim-lint. */
+    line: string;
+} | {
+    kind: "none";
+    reason: NoSpendReason;
+    aiPrs: number;
+    scannedPrs: number;
+    line: string;
+};
+export declare function estimateSpend(prs: unknown, rate?: TokenRate | null): SpendEstimate;

package/dist/vendor/shared/org-scan-core/spend/spend-estimate.js

@@ -0,0 +1,71 @@
+// GENERATED from shared/org-scan-core/src/spend/spend-estimate.ts by cli/scripts/sync-org-scan-core.mjs; do not edit.
+// MNE-9268: Tier-3 spend RANGE estimator. Pure and in-memory: takes per-PR counts and mark text, returns
+// one labelled estimate line or an explicit "no estimate". Nothing is stored, fetched or logged.
+//
+// No line is produced when there are too few AI-assisted PRs to price (MIN_AI_PRS). That is a
+// data-sufficiency threshold on the evidence behind the range, nothing to do with how large a
+// reporting cohort is. Default-OFF behind ORG_SCAN_MODE via estimateSpendIfEnabled.
+import { AI_TOOLS, detectAiTools } from "./ai-tool-detect.js";
+import { PRICES_AS_OF, bandFor, blendedUsdPerToken } from "./prices.js";
+import { DERIVED_TOKEN_RATE } from "./token-rate.js";
+/** AI-assisted PRs needed before a range is worth printing. */
+export const MIN_AI_PRS = 10;
+/** Fixed strings only: a failure never carries input or an error message into the output. */
+const NONE_LINES = {
+    too_few_ai_prs: "No spend estimate: too few AI-assisted PRs in this scan to price a range.",
+    no_rate: "No spend estimate: the cost reference data is not sufficient to price a range.",
+    invalid_input: "No spend estimate: the PR counts could not be read.",
+};
+const isCount = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0;
+function none(reason, aiPrs, scannedPrs) {
+    return { kind: "none", reason, aiPrs, scannedPrs, line: NONE_LINES[reason] };
+}
+function validPr(p) {
+    if (typeof p !== "object" || p === null)
+        return false;
+    const o = p;
+    return (isCount(o.additions) &&
+        isCount(o.deletions) &&
+        typeof o.markText === "string" &&
+        (o.tools === undefined ||
+            (Array.isArray(o.tools) && o.tools.every((t) => AI_TOOLS.includes(t)))));
+}
+/** Two significant figures so the range does not claim precision it lacks ($2.4, not $2; 0 stays $0). */
+function usd(n) {
+    return `$${n.toLocaleString("en-US", { maximumSignificantDigits: 2 })}`;
+}
+export function estimateSpend(prs, rate = DERIVED_TOKEN_RATE) {
+    if (!Array.isArray(prs))
+        return none("invalid_input", 0, 0);
+    const scanned = prs.length;
+    if (!prs.every(validPr))
+        return none("invalid_input", 0, scanned);
+    let aiPrs = 0;
+    let low = 0;
+    let high = 0;
+    const byTool = {};
+    for (const p of prs) {
+        const tools = p.tools ?? detectAiTools(p.markText);
+        if (tools.length === 0)
+            continue;
+        aiPrs += 1;
+        for (const t of tools)
+            byTool[t] = (byTool[t] ?? 0) + 1;
+        if (!rate)
+            continue;
+        const lines = p.additions + p.deletions;
+        // A PR carrying several marks is priced once, across the widest band of the tools named.
+        const bands = tools.map(bandFor);
+        const lo = Math.min(...bands.map((b) => blendedUsdPerToken(b.low)));
+        const hi = Math.max(...bands.map((b) => blendedUsdPerToken(b.high)));
+        low += lines * rate.low * lo;
+        high += lines * rate.high * hi;
+    }
+    if (aiPrs < MIN_AI_PRS)
+        return none("too_few_ai_prs", aiPrs, scanned);
+    if (!rate)
+        return none("no_rate", aiPrs, scanned);
+    const line = `Estimate, AI tool spend: ${usd(low)} to ${usd(high)} across ${aiPrs} AI-assisted PRs ` +
+        `(public list prices as of ${PRICES_AS_OF} times a tokens-per-line rate from our own agents' PRs; not billing data).`;
+    return { kind: "range", lowUsd: low, highUsd: high, aiPrs, scannedPrs: scanned, byTool, line };
+}

package/dist/vendor/shared/org-scan-core/spend/spend-select.d.ts

@@ -0,0 +1,16 @@
+import type { SpendEstimate } from "./spend-estimate.js";
+export type SpendTier = 1 | 2 | 3;
+export interface SpendSelection {
+    /** null when the evidence is too thin: print nothing. */
+    tier: SpendTier | null;
+    line: string | null;
+    /** May this line leave the machine in a share payload? Never for a self-reported figure. */
+    shareable: boolean;
+}
+export declare function selectSpend(i: {
+    measuredUsd?: number;
+    /** Fraction of measured tokens from requests over 200k context; shown only with a measured figure. */
+    over200kShare?: number | null;
+    selfReportedUsd?: number | null;
+    estimate: SpendEstimate;
+}): SpendSelection;

package/dist/vendor/shared/org-scan-core/spend/spend-select.js

@@ -0,0 +1,26 @@
+const usd = (n) => `$${n.toLocaleString("en-US", { maximumFractionDigits: 2 })}`;
+const isUsd = (n) => typeof n === "number" && Number.isFinite(n) && n > 0;
+const pct = (f) => `${Math.round(f * 100)}%`;
+const isShare = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 && n <= 1;
+export function selectSpend(i) {
+    if (isUsd(i.measuredUsd)) {
+        return {
+            tier: 1,
+            line: `Tier 1, measured: ${usd(i.measuredUsd)} of Anthropic usage over the period${isShare(i.over200kShare)
+                ? ` (${pct(i.over200kShare)} of tokens in requests over 200k context)`
+                : ""}.`,
+            shareable: true,
+        };
+    }
+    if (isUsd(i.selfReportedUsd)) {
+        return {
+            tier: 2,
+            line: `Tier 2, self-reported: about ${usd(i.selfReportedUsd)} a month (given by you; not verified, not sent, not saved).`,
+            shareable: false,
+        };
+    }
+    if (i.estimate.kind === "range") {
+        return { tier: 3, line: `Tier 3, ${i.estimate.line}`, shareable: true };
+    }
+    return { tier: null, line: null, shareable: false };
+}

package/dist/vendor/shared/org-scan-core/spend/token-rate.d.ts

@@ -0,0 +1,30 @@
+/** Rows needed before the rate is trusted at all (data sufficiency, not a group size). */
+export declare const MIN_CORPUS_ROWS = 5;
+export interface CostRowShape {
+    repo: string;
+    pr: number;
+    additions: number;
+    deletions: number;
+    cost_usd: number;
+    runs: number;
+    models: string[];
+}
+export interface TokenRate {
+    /** Price-equivalent tokens per changed (added + deleted) line: 25th percentile. */
+    low: number;
+    median: number;
+    /** 75th percentile. */
+    high: number;
+    rows: number;
+}
+/** Linear-interpolated quantile of a sorted array. */
+export declare function quantile(sorted: number[], q: number): number;
+/**
+ * Derive the rate from corpus rows: per-row tokens/line, then the 25th, 50th and 75th percentile.
+ * Rows that fail validation are dropped (not repaired); fewer than MIN_CORPUS_ROWS valid rows
+ * returns null, never a rate built on a handful.
+ */
+export declare function deriveTokenRate(rows: unknown): TokenRate | null;
+export declare const CORPUS_AS_OF: string;
+/** The shipped rate: derived once from the committed fixture. */
+export declare const DERIVED_TOKEN_RATE: TokenRate | null;

package/dist/vendor/shared/org-scan-core/spend/token-rate.js

@@ -0,0 +1,55 @@
+// GENERATED from shared/org-scan-core/src/spend/token-rate.ts by cli/scripts/sync-org-scan-core.mjs; do not edit.
+// MNE-9268: tokens-per-changed-line and its spread, DERIVED from our own agents' PRs whose run cost is
+// known (cost-corpus.v1.json, built by build-cost-corpus.mjs from the ADW "Run cost" PR comments).
+// Nothing here is a typed-in rate: change the fixture and the rate moves, and token-rate.test.ts pins
+// the derivation. Tokens are price-equivalent: cost / (our model's blended list price per token).
+import rawCorpus from "./cost-corpus.v1.js";
+import { TOOL_PRICES, blendedUsdPerToken } from "./prices.js";
+/** Rows needed before the rate is trusted at all (data sufficiency, not a group size). */
+export const MIN_CORPUS_ROWS = 5;
+/** Our agents ran on Sonnet-family models in every corpus row; price their tokens as that. */
+const BASIS_USD_PER_TOKEN = blendedUsdPerToken(TOOL_PRICES.claude_code.low);
+const isCount = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0;
+function validRow(r) {
+    if (typeof r !== "object" || r === null)
+        return false;
+    const o = r;
+    return (isCount(o.additions) &&
+        isCount(o.deletions) &&
+        o.additions + o.deletions > 0 &&
+        isCount(o.cost_usd) &&
+        o.cost_usd > 0);
+}
+/** Linear-interpolated quantile of a sorted array. */
+export function quantile(sorted, q) {
+    if (sorted.length === 0)
+        return NaN;
+    const pos = (sorted.length - 1) * q;
+    const lo = Math.floor(pos);
+    const hi = Math.ceil(pos);
+    return sorted[lo] + (sorted[hi] - sorted[lo]) * (pos - lo);
+}
+/**
+ * Derive the rate from corpus rows: per-row tokens/line, then the 25th, 50th and 75th percentile.
+ * Rows that fail validation are dropped (not repaired); fewer than MIN_CORPUS_ROWS valid rows
+ * returns null, never a rate built on a handful.
+ */
+export function deriveTokenRate(rows) {
+    if (!Array.isArray(rows))
+        return null;
+    const per = rows
+        .filter(validRow)
+        .map((r) => r.cost_usd / (r.additions + r.deletions) / BASIS_USD_PER_TOKEN)
+        .sort((a, b) => a - b);
+    if (per.length < MIN_CORPUS_ROWS)
+        return null;
+    return {
+        low: quantile(per, 0.25),
+        median: quantile(per, 0.5),
+        high: quantile(per, 0.75),
+        rows: per.length,
+    };
+}
+export const CORPUS_AS_OF = rawCorpus.as_of;
+/** The shipped rate: derived once from the committed fixture. */
+export const DERIVED_TOKEN_RATE = deriveTokenRate(rawCorpus.rows);

package/package.json

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