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

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.0",
+  "version": "0.17.38-next.2",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {
@@ -19,7 +19,7 @@
   },
   "dependencies": {
     "@mnemom/policy-engine": "^0.3.0",
-    "@mnemom/verify": "0.6.2",
+    "@mnemom/verify": "0.6.3",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "js-yaml": "^4.3.2",