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

package/dist/lib/scan/report-email.js

@@ -12,102 +12,9 @@
  * Every failure has a fixed name and fixed text. The server's body, the thrown value and the
  * credential never reach the terminal.
  */
-import { randomUUID } from "node:crypto";
 import { MnemomApiError, postApi } from "../api.js";
-import { buildCostPerPr } from "./cost-per-pr.js";
-export const REPORT_SCHEMA_VERSION = "org-scan-report/1";
-export const ESTIMATE_NAME = "automatable_work_share";
-export const METHOD_URL = "https://www.mnemom.ai/org-scan-method";
-const cents = (usd) => Math.max(0, Math.round(usd * 100));
-/**
- * Maps the local scan onto the route's closed report shape. Team totals stay empty (they come only from
- * Anthropic usage, which the local scan does not carry). The estimate is the share of examined merged
- * PRs that finished with every CI check passing. `figure` (tier 3 range) is included only when the CLI
- * itself would let that line leave the machine (`sendSpendRange`).
- */
-export function buildEmailReport(result, o) {
-    const { totals, coverage } = result;
-    const value = totals.examined > 0 ? Math.round((totals.ciGreen / totals.examined) * 1000) / 10 : 0;
-    const scope = coverage.complete
-        ? "every merged pull request in the period"
-        : "a capped sample (not every merged pull request in the period)";
-    const unit = `percent of merged pull requests examined (${totals.examined} of ${totals.prs}, ${scope}) ` +
-        `that finished with all CI checks passing; an estimate from pull request metadata, not a measured share`;
-    const byTool = result.spend.kind === "range"
-        ? Object.entries(result.spend.byTool)
-            .filter(([, n]) => typeof n === "number" && n > 0)
-            .map(([tool, count]) => ({ tool, count: count }))
-        : [];
-    // Only a scan that read every merged PR in the period gives an average that means anything.
-    const exhaustive = coverage.complete && coverage.prsSkippedLarge === 0 && coverage.prsUnreadable === 0;
-    const cost = buildCostPerPr(result.prSizes, o.period ?? { start: coverage.windowStart, end: coverage.windowEnd }, o.costSpend ?? null, exhaustive);
-    const byRepo = repoRows(result);
-    return {
-        schema_version: REPORT_SCHEMA_VERSION,
-        org_id: o.orgId,
-        scan_id: o.scanId ?? randomUUID(),
-        // The span the scan actually examined (coverage), never the requested period: with no --period
-        // that defaults to today..today, which is not what was read.
-        period: { start: coverage.windowStart, end: coverage.windowEnd },
-        generated_at: new Date(o.now()).toISOString(),
-        measured: {
-            teams: [],
-            summary: {
-                pr_count: totals.prs,
-                revert_count: totals.reverts,
-                automatable_count: totals.ciGreen,
-                examined_count: totals.examined,
-                tokens_total: 0,
-            },
-            spend: {
-                source: "pr_estimate",
-                ...(o.sendSpendRange && result.spend.kind === "range"
-                    ? {
-                        figure: {
-                            low_cents: cents(result.spend.lowUsd),
-                            high_cents: cents(result.spend.highUsd),
-                        },
-                    }
-                    : {}),
-                ...(o.sendSpendRange && byTool.length > 0 ? { ai_prs_by_tool: byTool } : {}),
-            },
-        },
-        estimate: { name: ESTIMATE_NAME, value, unit, method_url: METHOD_URL },
-        ...cost,
-        ...(byRepo.length > 0 ? { by_repo: byRepo } : {}),
-    };
-}
-const MAX_REPOS = 500;
-const REPO_NAME = /^[A-Za-z0-9._-]{1,100}\/[A-Za-z0-9._-]{1,100}$/;
-/** The per-repo rows for the report: valid names only, each once (any case), busiest first, at most 500. */
-function repoRows(result) {
-    const seen = new Set();
-    return [...result.byRepo]
-        .sort((a, b) => b.prs - a.prs || a.repo.localeCompare(b.repo))
-        .filter((r) => {
-        const k = r.repo.toLowerCase();
-        if (!REPO_NAME.test(r.repo) || seen.has(k))
-            return false;
-        seen.add(k);
-        return true;
-    })
-        .slice(0, MAX_REPOS)
-        .map((r) => ({
-        repo: r.repo,
-        pr_count: r.prs,
-        revert_count: r.reverts,
-        automatable_count: r.ciGreen,
-        examined_count: r.examined,
-    }));
-}
-export function buildEmailBody(report, level, complete, extraEmails = []) {
-    return {
-        report,
-        share_level: level,
-        coverage: { complete },
-        ...(extraEmails.length > 0 ? { emails: extraEmails } : {}),
-    };
-}
+// The report body is built by the shared core (MNE-9752), so the Mnemom-side run sends the same report.
+export { REPORT_SCHEMA_VERSION, ESTIMATE_NAME, METHOD_URL, buildEmailReport, buildEmailBody, } from "../../vendor/shared/org-scan-core/report-build.js";
 const FAILURE_TEXT = {
     presend_check_failed: "the report failed Mnemom's pre-send checks, so no email was sent.",
     email_not_sent: "Mnemom could not send the email.",
@@ -119,10 +26,26 @@ const FAILURE_TEXT = {
     emails_rejected: "an address you added was not accepted. Add up to 10 valid email addresses.",
     email_domain_not_allowed: "an address you added is not on your organization's email domain. Add addresses on your own domain or mnemom.ai.",
     admins_not_found: "Mnemom could not look up your org admins, so no email was sent. Try again in a moment.",
+    scan_limit_reached: "the scan limit was reached, so no email was sent.",
     network_error: "Mnemom could not be reached.",
     unexpected_response: "Mnemom answered in an unexpected way.",
 };
-export const failureMessage = (f) => `Your report was NOT emailed: ${f}. ${FAILURE_TEXT[f]}`;
+/** How long to wait, in plain words (rounded up to whole seconds, minutes or hours). */
+export function retryWait(ms) {
+    const s = Math.max(1, Math.ceil(ms / 1000));
+    if (s < 60)
+        return `${s} second${s === 1 ? "" : "s"}`;
+    const m = Math.ceil(s / 60);
+    if (m < 120)
+        return `${m} minute${m === 1 ? "" : "s"}`;
+    const h = Math.ceil(m / 60);
+    return `${h} hour${h === 1 ? "" : "s"}`;
+}
+export const failureMessage = (f, retryAfterMs) => f === "scan_limit_reached"
+    ? `Your report was NOT emailed: ${f}. ${FAILURE_TEXT[f]} ${retryAfterMs !== undefined
+        ? `Try again in about ${retryWait(retryAfterMs)}.`
+        : "Try again later."}`
+    : `Your report was NOT emailed: ${f}. ${FAILURE_TEXT[f]}`;
 export const DRY_RUN_MSG = "Report email is in dry-run on this environment; nothing was sent.";
 export const UNAVAILABLE_MSG = "Report email is not available for this org yet; nothing was sent.";
 export class ReportEmailError extends Error {
@@ -139,6 +62,8 @@ function classifyStatus(status) {
         return "not_signed_in";
     if (status === 403)
         return "not_a_member";
+    if (status === 429)
+        return "scan_limit_reached";
     if (status === 422)
         return "presend_check_failed";
     if (status === 502)
@@ -199,7 +124,10 @@ export async function sendReportEmail(orgId, body, deps = {}) {
                 return { status: "failed", reason: "admins_not_found" };
             if (e.effectiveStatus >= 400 && e.effectiveStatus < 500 && /runner/i.test(e.code ?? ""))
                 return { status: "failed", reason: "runner_not_emailed" };
-            return { status: "failed", reason: classifyStatus(e.effectiveStatus) };
+            const reason = classifyStatus(e.effectiveStatus);
+            return reason === "scan_limit_reached" && e.retryAfterMs !== undefined
+                ? { status: "failed", reason, retryAfterMs: e.retryAfterMs }
+                : { status: "failed", reason };
         }
         return { status: "failed", reason: "network_error" };
     }

package/dist/lib/scan/scan.d.ts

@@ -1,69 +1 @@
-/**
- * Local capped scan core. Port of the window path of runCappedScan (mnemom-api capped-scan.ts, PR #4208)
- * plus the spend estimate (#4222). Everything outside is injected (credential, PR source, clock), so the
- * core touches no network or disk, and the report exists only in memory.
- */
-import { type GitHubCredential } from "./credential.js";
-import { type ScanCaps, type StopReason } from "./caps.js";
-import { type FailureReason } from "./failure.js";
-import { type PrSource } from "./pr-source.js";
-import type { PrSize } from "./cost-per-pr.js";
-import { type SpendEstimate } from "./spend/spend-estimate.js";
-export interface ScanInput {
-    repos: string[];
-    /** Inclusive dates, YYYY-MM-DD. */
-    period: {
-        start: string;
-        end: string;
-    };
-}
-export interface ScanDeps {
-    credential: GitHubCredential;
-    prs?: PrSource;
-    fetchImpl?: typeof fetch;
-    now?: () => number;
-    caps?: Partial<ScanCaps>;
-}
-export interface Coverage {
-    complete: boolean;
-    stoppedBy: StopReason | null;
-    prsExamined: number;
-    prsSkippedLarge: number;
-    prsUnreadable: number;
-    reposRead: number;
-    reposTotal: number;
-    reads: number;
-    windowStart: string;
-    windowEnd: string;
-    /** Set only when the window held more merged PRs than the quota and an even sample was taken. */
-    windowSampledFrom?: number;
-}
-export interface RepoTotals {
-    repo: string;
-    prs: number;
-    reverts: number;
-    ciGreen: number;
-    /** PRs read and counted (not reverts, not skipped); the per-repo base of the CI-green share. */
-    examined: number;
-}
-export interface ScanResult {
-    coverage: Coverage;
-    totals: {
-        prs: number;
-        reverts: number;
-        ciGreen: number;
-        examined: number;
-    };
-    byRepo: RepoTotals[];
-    spend: SpendEstimate;
-    /** Every merged PR read in full (reverts and unreadable/oversize PRs excluded): merge day and size. In memory only. */
-    prSizes: PrSize[];
-}
-export type ScanOutcome = {
-    status: "done";
-    result: ScanResult;
-} | {
-    status: "withheld";
-    reason: FailureReason;
-};
-export declare function runLocalScan(deps: ScanDeps, input: ScanInput): Promise<ScanOutcome>;
+export * from "../../vendor/shared/org-scan-core/scan.js";

package/dist/lib/scan/scan.js

@@ -1,195 +1,2 @@
-/**
- * Local capped scan core. Port of the window path of runCappedScan (mnemom-api capped-scan.ts, PR #4208)
- * plus the spend estimate (#4222). Everything outside is injected (credential, PR source, clock), so the
- * core touches no network or disk, and the report exists only in memory.
- */
-import { assertReadOnlyCredential, isValidRepoSlug } from "./credential.js";
-import { Budget, COVERAGE_MONTHS, evenSample, monthsBefore, sanitiseCaps, } from "./caps.js";
-import { classifyFailure } from "./failure.js";
-import { createGithubPrSource } from "./pr-source.js";
-import { estimateSpend } from "./spend/spend-estimate.js";
-const validDay = (d) => typeof d === "string" &&
-    /^\d{4}-\d{2}-\d{2}$/.test(d) &&
-    !Number.isNaN(Date.parse(`${d}T00:00:00Z`));
-export async function runLocalScan(deps, input) {
-    if (!validDay(input.period.start) ||
-        !validDay(input.period.end) ||
-        input.repos.length === 0 ||
-        !input.repos.every(isValidRepoSlug)) {
-        return { status: "withheld", reason: "invalid_input" };
-    }
-    try {
-        await assertReadOnlyCredential(deps.credential);
-    }
-    catch (e) {
-        return { status: "withheld", reason: classifyFailure(e) };
-    }
-    const prs = deps.prs ?? createGithubPrSource({ credential: deps.credential, fetchImpl: deps.fetchImpl });
-    const now = deps.now ?? Date.now;
-    const caps = sanitiseCaps(deps.caps ?? {});
-    const budget = new Budget(caps, now, now());
-    let stoppedBy = null;
-    const stop = (r) => {
-        if (r && !stoppedBy)
-            stoppedBy = r;
-        return stoppedBy !== null;
-    };
-    const periodStart = input.period.start;
-    const windowStart = periodStart < monthsBefore(input.period.end, COVERAGE_MONTHS)
-        ? periodStart
-        : monthsBefore(input.period.end, COVERAGE_MONTHS);
-    const endDay = input.period.end;
-    const pool = [];
-    let reposRead = 0;
-    let listingCut = false;
-    try {
-        for (const repo of input.repos) {
-            if (stoppedBy !== null || stop(budget.block()))
-                break;
-            reposRead += 1;
-            let cursor = null;
-            const days = [];
-            let oldestUpdated = "9999-99-99";
-            do {
-                if (stop(budget.block()))
-                    break;
-                // Listing may use at most half the read budget, so it never starves the reads of the PRs it found.
-                if (budget.reads * 2 > caps.maxReads) {
-                    listingCut = true;
-                    break;
-                }
-                budget.charge(1);
-                const page = await prs.indexMerged(repo, cursor, budget.room() + 1);
-                budget.charge((Number.isFinite(page.reads) && page.reads >= 1 ? page.reads : 1) - 1);
-                const overrun = budget.overrun();
-                if (overrun) {
-                    stop(overrun);
-                    break;
-                }
-                for (const item of page.items) {
-                    pool.push({ repo, item });
-                    days.push(item.mergedDay);
-                    if (item.updatedDay < oldestUpdated)
-                        oldestUpdated = item.updatedDay;
-                }
-                cursor = page.next;
-                // Newest-activity first: once a seen PR was last touched before D, no later page holds a PR
-                // merged on or after D. Stop when D is both the window start and the merge day of this repo's
-                // maxPrs-th newest merged PR.
-                const kth = days.length >= caps.maxPrs ? [...days].sort().reverse()[caps.maxPrs - 1] : null;
-                if (kth !== null && oldestUpdated < (kth < windowStart ? kth : windowStart))
-                    break;
-            } while (cursor !== null && stoppedBy === null);
-            if (listingCut) {
-                if (cursor === null && days.length === 0)
-                    reposRead -= 1;
-                break;
-            }
-        }
-        // Newest first, ties by repo then number: the same pool always gives the same sample.
-        for (let i = pool.length - 1; i >= 0; i--)
-            if (pool[i].item.mergedDay > endDay)
-                pool.splice(i, 1);
-        pool.sort((a, b) => (a.item.mergedDay === b.item.mergedDay
-            ? 0
-            : a.item.mergedDay < b.item.mergedDay
-                ? 1
-                : -1) ||
-            (a.repo < b.repo ? -1 : a.repo > b.repo ? 1 : 0) ||
-            b.item.number - a.item.number);
-        const inWindow = pool.filter((p) => p.item.mergedDay >= windowStart);
-        const sampled = inWindow.length > caps.maxPrs;
-        const chosen = sampled ? evenSample(inWindow, caps.maxPrs) : pool.slice(0, caps.maxPrs);
-        const byRepo = new Map();
-        const bucket = (repo) => {
-            let b = byRepo.get(repo);
-            if (!b)
-                byRepo.set(repo, (b = { repo, prs: 0, reverts: 0, ciGreen: 0, examined: 0 }));
-            return b;
-        };
-        const totals = { prs: 0, reverts: 0, ciGreen: 0, examined: 0 };
-        const spendInputs = [];
-        const prSizes = [];
-        let skippedLarge = 0;
-        let unreadable = 0;
-        for (const { repo, item } of chosen) {
-            // A revert PR is never a candidate: counted from the listing, never read.
-            if (item.reverted) {
-                totals.prs += 1;
-                totals.reverts += 1;
-                bucket(repo).prs += 1;
-                bucket(repo).reverts += 1;
-                continue;
-            }
-            if (stop(budget.block(2)))
-                break;
-            budget.charge(1);
-            const res = await prs.readPr(repo, item, budget.room() + 1);
-            budget.charge((Number.isFinite(res.reads) && res.reads >= 1 ? res.reads : 1) - 1);
-            const overrun = budget.overrun();
-            if (overrun) {
-                stop(overrun);
-                break;
-            }
-            const rec = res.pr;
-            if (!rec) {
-                unreadable += 1;
-                continue;
-            }
-            if (rec.additions + rec.deletions > caps.maxPrSizeLines) {
-                skippedLarge += 1;
-                continue;
-            }
-            totals.prs += 1;
-            totals.examined += 1;
-            bucket(repo).examined += 1;
-            bucket(repo).prs += 1;
-            if (rec.ci === "success") {
-                totals.ciGreen += 1;
-                bucket(repo).ciGreen += 1;
-            }
-            prSizes.push({
-                mergedDay: item.mergedDay,
-                lines: rec.additions + rec.deletions,
-                aiAssisted: (rec.tools?.length ?? 0) > 0,
-            });
-            spendInputs.push({
-                additions: rec.additions,
-                deletions: rec.deletions,
-                markText: "",
-                tools: rec.tools,
-            });
-        }
-        const coverage = {
-            complete: stoppedBy === null &&
-                !listingCut &&
-                unreadable === 0 &&
-                reposRead === input.repos.length &&
-                !sampled,
-            stoppedBy: stoppedBy ?? (listingCut ? "read-cap" : null),
-            prsExamined: totals.examined,
-            prsSkippedLarge: skippedLarge,
-            prsUnreadable: unreadable,
-            reposRead,
-            reposTotal: input.repos.length,
-            reads: budget.reads,
-            windowStart,
-            windowEnd: endDay,
-            ...(sampled ? { windowSampledFrom: inWindow.length } : {}),
-        };
-        return {
-            status: "done",
-            result: {
-                coverage,
-                totals,
-                byRepo: [...byRepo.values()],
-                spend: estimateSpend(spendInputs),
-                prSizes,
-            },
-        };
-    }
-    catch (e) {
-        // Reads only; the raw error is dropped and a fixed reason returned.
-        return { status: "withheld", reason: classifyFailure(e) };
-    }
-}
+// Moved to shared/org-scan-core (MNE-9752); vendored at cli/src/vendor/shared/org-scan-core. Re-exported so CLI imports stay put.
+export * from "../../vendor/shared/org-scan-core/scan.js";

package/dist/lib/scan/share.d.ts

@@ -1,5 +1,7 @@
 import type { ScanResult } from "./scan.js";
-export type ShareLevel = "full" | "analytics" | "none";
+import type { ShareLevel } from "../../vendor/shared/org-scan-core/report-build.js";
+/** Defined in the shared core (MNE-9752); re-exported for the CLI's callers. */
+export type { ShareLevel };
 /** The level preselected at the prompt (Enter picks it). */
 export declare const DEFAULT_SHARE_LEVEL: ShareLevel;
 export declare const SHARE_OPTIONS: ReadonlyArray<{

package/dist/lib/scan/spend/ai-tool-detect.d.ts

@@ -1,6 +1 @@
-import type { AiTool } from "./prices.js";
-/** Upper bound on text scanned per PR, so one huge body cannot dominate a scan. The TAIL is kept: trailers and "generated with" footers sit at the end. */
-export declare const MAX_MARK_TEXT = 20000;
-export declare const AI_TOOLS: AiTool[];
-/** Tools whose mark appears in the text, in a fixed order. Non-string input yields none. */
-export declare function detectAiTools(markText: unknown): AiTool[];
+export * from "../../../vendor/shared/org-scan-core/spend/ai-tool-detect.js";

package/dist/lib/scan/spend/ai-tool-detect.js

@@ -1,18 +1,2 @@
-/** Upper bound on text scanned per PR, so one huge body cannot dominate a scan. The TAIL is kept: trailers and "generated with" footers sit at the end. */
-export const MAX_MARK_TEXT = 20_000;
-const TRAILER = String.raw `^[ \t>*-]*co-authored-by:[^\n]*?`;
-const GEN = String.raw `generated (?:with|by|using)[^\n]{0,24}?`;
-const MARKS = {
-    claude_code: new RegExp(`${TRAILER}(?:\\bclaude\\b|noreply@anthropic\\.com)|${GEN}\\bclaude code\\b`, "im"),
-    codex: new RegExp(`${TRAILER}\\bcodex\\b|${GEN}\\bcodex\\b`, "im"),
-    copilot: new RegExp(`${TRAILER}\\bcopilot\\b|${GEN}\\bgithub copilot\\b`, "im"),
-    gemini: new RegExp(`${TRAILER}\\bgemini\\b|${GEN}\\bgemini(?: cli)?\\b`, "im"),
-};
-export const AI_TOOLS = Object.keys(MARKS);
-/** Tools whose mark appears in the text, in a fixed order. Non-string input yields none. */
-export function detectAiTools(markText) {
-    if (typeof markText !== "string" || markText.length === 0)
-        return [];
-    const text = markText.length > MAX_MARK_TEXT ? markText.slice(-MAX_MARK_TEXT) : markText;
-    return AI_TOOLS.filter((t) => MARKS[t].test(text));
-}
+// Moved to shared/org-scan-core (MNE-9752); vendored at cli/src/vendor/shared/org-scan-core. Re-exported so CLI imports stay put.
+export * from "../../../vendor/shared/org-scan-core/spend/ai-tool-detect.js";

package/dist/lib/scan/spend/anthropic-usage.d.ts

@@ -1,76 +1 @@
-export declare const ANTHROPIC_ADMIN_ORIGIN = "https://api.anthropic.com";
-export declare const ADMIN_KEY_ENV = "ANTHROPIC_ADMIN_KEY";
-/** The only paths a usage credential is ever sent to (design T18: fenced to report endpoints). */
-export declare const REPORT_PATHS: readonly string[];
-/** The fence, as one exported check so it is directly testable. Throws AnthropicUsageError for any other path. */
-export declare function assertReportPath(path: string): void;
-/** The exact auth header to send; same shape as mnemom-api src/org-scan/usage/credential-source.ts. */
-export type AnthropicAuthHeader = {
-    header: "x-api-key";
-    value: string;
-} | {
-    header: "authorization";
-    value: string;
-};
-export declare const DEFAULT_MAX_PAGES = 20;
-/** One shared deadline for a request including its retries (not N x timeout). */
-export declare const DEFAULT_TIMEOUT_MS = 15000;
-export declare const DEFAULT_MAX_RETRIES = 2;
-/** Shape check only; the key is never echoed, even on a mismatch. */
-export declare const isAdminKeyShape: (k: unknown) => k is string;
-export type UsageFailure = "key_invalid" | "key_refused" | "token_refused" | "rate_limited" | "timeout" | "network" | "upstream" | "malformed" | "too_large";
-/** Fixed sentence for a failure reason. */
-export declare const usageFailureText: (r: UsageFailure) => string;
-/** Carries only a reason tag. Its message is the fixed sentence: nothing upstream can reach it. */
-export declare class AnthropicUsageError extends Error {
-    readonly reason: UsageFailure;
-    constructor(reason: UsageFailure);
-}
-export type ContextWindow = "0-200k" | "200k-1M";
-export interface UsageRow {
-    tokens: number;
-    contextWindow: ContextWindow | null;
-}
-export interface Page<R> {
-    rows: R[];
-    truncated: boolean;
-    pages: number;
-}
-export interface CostRow {
-    /** Cents, as Anthropic returns it (a decimal string). */
-    cents: number;
-    currency: string;
-}
-export interface AnthropicUsageDeps {
-    fetchImpl?: typeof fetch;
-    sleep?: (ms: number) => Promise<void>;
-    maxPages?: number;
-    timeoutMs?: number;
-    maxRetries?: number;
-}
-export declare function parseUsageRow(raw: unknown): UsageRow;
-export declare function parseCostRow(raw: unknown): CostRow;
-/** Buckets are UTC-aligned: floor so a mid-day start reads the whole bucket it falls in. */
-export declare function alignStartingAt(startingAt: string): string;
-export interface MeasuredUsage {
-    /** Whole-org cost over the period, in USD. */
-    usd: number;
-    /** Fraction in [0, 1] of tokens from requests in the 200k-1M context window; null with no tokens. */
-    over200kShare: number | null;
-}
-/**
- * The same two reads mnemom-api made: usage grouped by context_window (the exact >200k share) and cost
- * (total spend). The key is shape-checked before any call so a regular API key never leaves the machine.
- * Throws AnthropicUsageError only. A walk stopped by the page cap is an error, never a short total.
- */
-export declare function fetchMeasuredUsage(key: string | undefined, period: {
-    start: string;
-    end: string;
-}, deps?: AnthropicUsageDeps): Promise<MeasuredUsage>;
-/** A WIF access token as the bearer for the two report reads. Printable ASCII only, else key_invalid. */
-export declare function bearerAuth(token: string): AnthropicAuthHeader;
-/** The two reads with an already-resolved credential (pasted key or WIF bearer). Throws AnthropicUsageError only. */
-export declare function fetchMeasuredUsageWithAuth(auth: AnthropicAuthHeader, period: {
-    start: string;
-    end: string;
-}, deps?: AnthropicUsageDeps): Promise<MeasuredUsage>;
+export * from "../../../vendor/shared/org-scan-core/spend/anthropic-usage.js";