codehere 1.0.1 → 1.0.3

package/dist/infrastructure/context/write-pass-resolver.js

@@ -1,106 +0,0 @@
-/**
- * Write-pass target resolver · v0.9 S6 part B.
- *
- * Turns a W-PASS target like `linear://INFRA-247` into a concrete
- * HTTPS request the daemon can fire on the user's behalf, AFTER the
- * user has approved the payload. The resolver layer mirrors the
- * context-source registry · same scheme namespace, opposite direction
- * (read vs write).
- *
- * Resolved request shape:
- *   - url      · absolute HTTPS
- *   - method   · same as the intent (POST/PUT/PATCH/DELETE)
- *   - headers  · auth + content-type · loaded from ctx.config[scheme]
- *   - body     · JSON-stringified payload
- *
- * Tests pass a fake httpRequest · production uses node's fetch. Same
- * seam as context-source so adapters look symmetric.
- *
- * S6 ships ONE resolver (Linear) to prove the shape. github + figma +
- * drawio + notion follow in subsequent slices · each is a self-contained
- * function in this file, so adding one is a copy-paste-modify, not an
- * architectural change.
- */
-import { gradeDomain, hostOf } from '../../application/use-cases/domain-trust.js';
-export class WritePassResolveError extends Error {
-    code;
-    constructor(code, message) {
-        super(`[w-pass resolve] ${code}: ${message}`);
-        this.code = code;
-    }
-}
-/**
- * Resolve an intent + effective payload into a concrete HTTP request.
- * Throws WritePassResolveError if the scheme isn't supported OR auth
- * is missing · the daemon turns those into a 4xx response BEFORE
- * touching the network.
- */
-export function resolveWriteRequest(intent, effectivePayload, config) {
-    const m = intent.target.match(/^([a-z][a-z0-9+.-]*):\/\/(.+)$/);
-    if (!m) {
-        throw new WritePassResolveError('invalid_target', `bad URL: ${intent.target}`);
-    }
-    const scheme = m[1];
-    const rest = m[2];
-    const built = scheme === 'linear'
-        ? resolveLinear(rest, intent.method, effectivePayload, config.linear)
-        : scheme === 'github'
-            ? resolveGitHub(rest, intent.method, effectivePayload, config.github)
-            : null;
-    if (built) {
-        return { ...built, trust: gradeDomain(hostOf(built.url)) };
-    }
-    throw new WritePassResolveError('unsupported_scheme', `no W-PASS resolver for "${scheme}" yet · supported in S6: linear, github`);
-}
-/* ──────────────────────────────────────────────────────────────────────── */
-/* Linear                                                                    */
-/* ──────────────────────────────────────────────────────────────────────── */
-function resolveLinear(rest, method, payload, cfg) {
-    const auth = cfg?.oauth?.accessToken ? `Bearer ${cfg.oauth.accessToken}` : cfg?.apiKey;
-    if (!auth) {
-        throw new WritePassResolveError('auth_missing', 'no Linear apiKey or OAuth token in config["linear"] · agent cannot write without explicit credentials');
-    }
-    // Linear's API is GraphQL · we send mutations via POST. The agent's
-    // intent.payload is expected to be { query, variables } or { mutation, variables }.
-    // We pass it through verbatim · the human saw + approved it.
-    const endpoint = cfg?.endpoint ?? 'https://api.linear.app/graphql';
-    return {
-        url: endpoint,
-        // Linear writes always POST (it's GraphQL) · intent.method is recorded
-        // for audit but doesn't change the transport. We log a one-line audit
-        // hint when method != POST so the user sees the mediation.
-        method: 'POST',
-        headers: {
-            Authorization: auth,
-            'Content-Type': 'application/json',
-            'X-Codehere-Mediated': 'w-pass',
-            'X-Codehere-Original-Method': method,
-            'X-Codehere-Identifier': rest,
-        },
-        body: JSON.stringify(payload),
-    };
-}
-/* ──────────────────────────────────────────────────────────────────────── */
-/* GitHub                                                                    */
-/* ──────────────────────────────────────────────────────────────────────── */
-function resolveGitHub(rest, method, payload, cfg) {
-    if (!cfg?.token) {
-        throw new WritePassResolveError('auth_missing', 'no GitHub token in config["github"] · public-by-URL is READ only · writes need an explicit PAT');
-    }
-    // rest is e.g. owner/repo/issues/42/comments or owner/repo/issues/42
-    const endpoint = cfg.endpoint ?? 'https://api.github.com';
-    return {
-        url: `${endpoint}/repos/${rest}`,
-        method,
-        headers: {
-            Authorization: `Bearer ${cfg.token}`,
-            Accept: 'application/vnd.github+json',
-            'X-GitHub-Api-Version': '2022-11-28',
-            'Content-Type': 'application/json',
-            'User-Agent': 'codehere/0.9 w-pass',
-            'X-Codehere-Mediated': 'w-pass',
-        },
-        body: JSON.stringify(payload),
-    };
-}
-//# sourceMappingURL=write-pass-resolver.js.map

package/dist/infrastructure/cost/budget-config.js

@@ -1,114 +0,0 @@
-import { writeFileAtomic } from '../storage/atomic-write.js';
-/**
- * v0.6 S3 slice 2 — daily spend budget config.
- *
- * Reads ~/.codehere/budget.yaml. The pre-spawn check in /api/task compares
- * computeSpendToday().totalUsd against `daily_usd`; over-budget refuses with
- * a friendly message instead of silently spawning another paid call.
- *
- * Why this is the v1 promise · claim_market_position v3 lists "cost-bounded
- * execution" as one of the few capture-strategy edges still possibly open.
- * Slice 1 surfaced spend; slice 2 enforces it. Together they make the edge
- * demonstrable in 60 seconds: set a $1 budget, spawn until you hit it,
- * watch codehere refuse the next spawn.
- *
- * Schema (~/.codehere/budget.yaml):
- *
- *   daily_usd: 5.00      # null / omitted = no budget enforcement
- *   warn_at_pct: 70      # default 70 — chip turns yellow at 70%
- *
- * Single-file, hand-editable, plain YAML. Per claim_user_persona HIGH:
- * non-technical users can edit it directly. Per overconfidence-guard:
- * the budget is a USER ceiling, not a codehere guarantee — we can't
- * see the actual provider invoice in real time.
- */
-import { existsSync, mkdirSync, readFileSync } from 'fs';
-import { dirname, join } from 'path';
-import { homedir } from 'os';
-const DEFAULT_CONFIG = {
-    dailyUsd: null,
-    warnAtPct: 70,
-};
-function configFile() {
-    return join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'budget.yaml');
-}
-/** Parse a tiny subset of YAML — `key: value` pairs, # comments, blank lines.
- *  No nesting, no lists, no multi-line. Same approach as permissions-config:
- *  keep the dependency surface zero, schema simple. */
-function parseYaml(content) {
-    const out = {};
-    for (const rawLine of content.split('\n')) {
-        const line = rawLine.replace(/#.*$/, '').trim();
-        if (!line)
-            continue;
-        const colonIdx = line.indexOf(':');
-        if (colonIdx === -1)
-            continue;
-        const key = line.slice(0, colonIdx).trim();
-        const val = line.slice(colonIdx + 1).trim();
-        if (key)
-            out[key] = val;
-    }
-    return out;
-}
-/** Read the budget config from disk. Missing file or parse failure → defaults
- *  (no enforcement). Best-effort: never throws — a corrupt file should not
- *  break the spawn path. */
-export function loadBudget() {
-    const path = configFile();
-    if (!existsSync(path))
-        return { ...DEFAULT_CONFIG };
-    try {
-        const raw = readFileSync(path, 'utf-8');
-        const parsed = parseYaml(raw);
-        const cfg = { ...DEFAULT_CONFIG };
-        if ('daily_usd' in parsed) {
-            const n = Number(parsed.daily_usd);
-            cfg.dailyUsd = Number.isFinite(n) && n > 0 ? n : null;
-        }
-        if ('warn_at_pct' in parsed) {
-            const n = Number(parsed.warn_at_pct);
-            cfg.warnAtPct = Number.isFinite(n) && n > 0 && n <= 100 ? n : DEFAULT_CONFIG.warnAtPct;
-        }
-        return cfg;
-    }
-    catch {
-        return { ...DEFAULT_CONFIG };
-    }
-}
-/** Persist the budget config. Creates ~/.codehere/ if missing. Comments
- *  in the emitted YAML help a non-technical user edit it later. */
-export function saveBudget(cfg) {
-    const path = configFile();
-    const dir = dirname(path);
-    if (!existsSync(dir))
-        mkdirSync(dir, { recursive: true });
-    const lines = [
-        '# codehere daily-spend budget. Edit by hand or via `codehere budget set <amount>`.',
-        "# daily_usd: hard ceiling for today's estimated spend. Set to a number to enable.",
-        '# Leave commented out / omit to disable budget enforcement entirely.',
-    ];
-    if (cfg.dailyUsd !== null) {
-        lines.push(`daily_usd: ${cfg.dailyUsd}`);
-    }
-    else {
-        lines.push('# daily_usd: 5.00');
-    }
-    lines.push(`warn_at_pct: ${cfg.warnAtPct}`);
-    lines.push('');
-    writeFileAtomic(path, lines.join('\n'));
-}
-/** True when today's estimated spend has hit or exceeded the daily ceiling.
- *  Returns false when no budget is set (no enforcement). */
-export function isOverBudget(spentTodayUsd, cfg = loadBudget()) {
-    if (cfg.dailyUsd === null)
-        return false;
-    return spentTodayUsd >= cfg.dailyUsd;
-}
-/** Percentage of today's budget consumed (0-100, or null when no budget set). */
-export function budgetUsedPct(spentTodayUsd, cfg = loadBudget()) {
-    if (cfg.dailyUsd === null || cfg.dailyUsd === 0)
-        return null;
-    return Math.min(100, Math.round((spentTodayUsd / cfg.dailyUsd) * 100));
-}
-//# sourceMappingURL=budget-config.js.map

package/dist/infrastructure/cost/cost-router.js

@@ -1,97 +0,0 @@
-/**
- * Cost Router
- *
- * Given a trust score and task complexity, recommends the cheapest model
- * that's safe to use. The 42x cost difference between Haiku and Opus means
- * routing decisions have real financial impact at scale.
- *
- * Model tiers (approximate $/M output tokens, 2026):
- *   fast tier    (claude-haiku-4-5)   $1.25   — cheap, good for simple tasks
- *   balanced tier (claude-sonnet-4-6) $15.00  — good for most tasks
- *   max tier     (claude-fable-5)     $50.00  — strongest (Anthropic's current flagship,
- *                                              Mythos-class; 1M ctx); use sparingly
- *
- * Routing logic:
- *   trust >= 90, simple task  → fast tier      (60x cheaper than max tier)
- *   trust >= 75, any task     → balanced tier  (5x cheaper than max tier)
- *   trust < 75, or critical   → balanced tier with human review flag
- *   critical findings present → block before reaching model
- */
-export const MODEL_COSTS = {
-    haiku: 1.25,
-    sonnet: 15.0,
-    opus: 50.0,
-};
-// NB: the `opus` key is the internal name for the MAX / strongest tier. Its model
-// is now Claude Fable 5 (Anthropic's current flagship, released 2026-06-09 —
-// stronger than Opus 4.8, which it falls back to on high-risk queries). User-facing
-// surfaces show the tier label ("max tier") + this modelId, so the key name is
-// internal-only.
-const MODEL_IDS = {
-    haiku: 'claude-haiku-4-5-20251001',
-    sonnet: 'claude-sonnet-4-6',
-    opus: 'claude-fable-5',
-};
-const TIER_LABELS = {
-    haiku: 'fast tier',
-    sonnet: 'balanced tier',
-    opus: 'max tier',
-};
-function savingsLabel(chosen) {
-    if (chosen === 'opus')
-        return 'max tier (baseline)';
-    const ratio = MODEL_COSTS.opus / MODEL_COSTS[chosen];
-    return `${TIER_LABELS[chosen]} · ${Math.round(ratio)}x cheaper than max tier`;
-}
-/**
- * Recommend the optimal model for a given trust score and task complexity.
- */
-export function recommendModel(trustScore, complexity = 'standard', criticalFindings = 0) {
-    // Critical findings → require human review regardless of model
-    if (criticalFindings > 0) {
-        return {
-            model: 'sonnet',
-            modelId: MODEL_IDS.sonnet,
-            reason: `${criticalFindings} critical finding${criticalFindings !== 1 ? 's' : ''} — human review required before applying any edit`,
-            costPer1MTokens: MODEL_COSTS.sonnet,
-            savingsVsOpus: savingsLabel('sonnet'),
-            humanReview: true,
-        };
-    }
-    // High-trust simple tasks → Haiku
-    if (trustScore >= 90 && complexity === 'simple') {
-        return {
-            model: 'haiku',
-            modelId: MODEL_IDS.haiku,
-            reason: `Trust ${trustScore}/100 · simple task — safe for fastest, cheapest model`,
-            costPer1MTokens: MODEL_COSTS.haiku,
-            savingsVsOpus: savingsLabel('haiku'),
-            humanReview: false,
-        };
-    }
-    // Good trust, standard task → Sonnet
-    if (trustScore >= 75) {
-        return {
-            model: 'sonnet',
-            modelId: MODEL_IDS.sonnet,
-            reason: `Trust ${trustScore}/100 · ${complexity} task — Sonnet is the right balance`,
-            costPer1MTokens: MODEL_COSTS.sonnet,
-            savingsVsOpus: savingsLabel('sonnet'),
-            humanReview: false,
-        };
-    }
-    // Low trust → Sonnet with human review
-    return {
-        model: 'sonnet',
-        modelId: MODEL_IDS.sonnet,
-        reason: `Trust ${trustScore}/100 — lower confidence; recommend reviewing the output`,
-        costPer1MTokens: MODEL_COSTS.sonnet,
-        savingsVsOpus: savingsLabel('sonnet'),
-        humanReview: true,
-    };
-}
-// MED #29 (atomic audit) · estimateMonthlySavings deleted: a pure projection
-// with zero production callers whose output ("~83% savings") had been quoted
-// as a shipped outcome. The honest claim now lives in PRODUCT_STATE (🟡,
-// projection); the budget gate carries the cost-bounded pillar.
-//# sourceMappingURL=cost-router.js.map

package/dist/infrastructure/cost/spend-aggregator.js

@@ -1,222 +0,0 @@
-/**
- * v0.6 S3 slice 1 — spend-today aggregator.
- *
- * Reads ~/.codehere/sessions.jsonl (the same append-only log session-persistence
- * writes), filters completed records to today (local timezone), and estimates
- * dollar spend per agent based on token usage × per-tier output-rate ceilings.
- *
- * Why · claim_market_position v3 lists "cost-bounded execution" as one of the
- * few capture-strategy edges still possibly open. Demonstrating cost awareness
- * starts here: surface what the user has actually spent today across all spawned
- * agents, then (slice 2) enforce a per-day ceiling.
- *
- * Why estimates not exact · codehere doesn't see provider invoices. Adapters
- * report token counts via TaskArtifacts.usage; we multiply by published tier
- * ceilings. Per feedback_overconfidence_guard.md, copy frames this as
- * "estimate" and points to vendor dashboards as authoritative.
- *
- * Cost table · output-tier ceilings (input is rougher; we use a 5x ratio).
- * All values 2026 published rates. When a model isn't surfaced in usage,
- * default to the agent's typical tier.
- */
-import { existsSync, readFileSync } from 'fs';
-import { homedir } from 'os';
-import { basename, join } from 'path';
-/** Resolved at call time, not module load, so test setups that swap $HOME
- *  after import still get a fresh path on each invocation. */
-function sessionsFile() {
-    return join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'sessions.jsonl');
-}
-/** USD per million OUTPUT tokens at the agent's typical 2026 tier. Input is
- *  estimated at 1/5 of output rate (Anthropic + OpenAI both publish ~5x
- *  output:input ratios on their flagship coding tiers). Cache reads ~1/10
- *  of input. Free-tier agents → 0.
- *
- *  Conservative-ceiling philosophy: better to over-estimate spend than
- *  under-promise and miss a real bill. */
-export const COST_PER_M_OUTPUT_TOKENS_USD = {
-    'claude-code': 15.0, // Sonnet 4.6 baseline
-    codex: 10.0, // GPT-5 / codex baseline
-    aider: 15.0, // typically Sonnet
-    gemini: 0, // free tier (Google AI Studio)
-    opencode: 0, // typically free local / NIM-routed
-    conductor: 15.0, // routes to Claude Code by default
-};
-const INPUT_RATE_RATIO = 0.2; // input ≈ 1/5 of output
-const CACHE_READ_RATIO = 0.1; // cache reads ≈ 1/10 of input (so 1/50 output)
-/** Per-MODEL published rates (USD per million tokens), 2026. Matched by substring
- *  so version suffixes resolve (claude-opus-4-x, gpt-5-codex, gemini-2.5-pro).
- *  This is what makes an Opus run cost more than a Haiku run instead of one flat
- *  per-agent tier, and prices a paid model even when the agent's default is free.
- *  Still an estimate, not an invoice — see the file header. */
-const MODEL_RATES = [
-    // Anthropic — verified against platform.claude.com rate card (2026-07). Standard
-    // (post-introductory) rates; Sonnet 5's Aug-2026 intro price is lower, so the
-    // standard rate keeps the estimate conservative rather than under-billing.
-    { match: /fable|mythos/i, inputUsd: 10, outputUsd: 50 }, // Claude 5 flagship tier
-    { match: /opus/i, inputUsd: 5, outputUsd: 25 },
-    { match: /sonnet/i, inputUsd: 3, outputUsd: 15 },
-    { match: /haiku/i, inputUsd: 1, outputUsd: 5 },
-    { match: /gpt-5|codex/i, inputUsd: 1.25, outputUsd: 10 },
-    { match: /gemini.*(2\.5.*pro|1\.5.*pro|-pro)/i, inputUsd: 1.25, outputUsd: 10 }, // paid Gemini Pro tiers
-];
-/** Self-hosted / local backends cost nothing per token — never bill them at a
- *  cloud tier just because the agent (e.g. aider) usually runs on a paid model. */
-const LOCAL_MODEL = /(?:^|[/:])(?:ollama(?:_chat)?|lmstudio|lm-studio|llama[._-]?cpp|local)\b/i;
-export function modelRate(model) {
-    if (!model)
-        return undefined;
-    for (const r of MODEL_RATES)
-        if (r.match.test(model))
-            return { inputUsd: r.inputUsd, outputUsd: r.outputUsd };
-    return undefined;
-}
-/**
- * Estimate dollar cost for one session's token usage. Per-model rates when the
- * adapter surfaced the real model (accurate input AND output); otherwise the
- * agent's typical output tier (input ≈ 1/5). Returns 0 when neither is priced.
- */
-export function estimateCostUsd(agent, usage) {
-    if (!usage)
-        return 0;
-    const tokens = {
-        input: Math.max(0, usage.inputTokens || 0),
-        output: Math.max(0, usage.outputTokens || 0),
-        cacheRead: Math.max(0, usage.cacheReadTokens || 0),
-        cacheCreate: Math.max(0, usage.cacheCreationTokens || 0),
-    };
-    // Local/self-hosted models are free to call — don't bill them at cloud rates.
-    // EXCEPT ollama's `:cloud`-tagged models: no local weights, proxied to Ollama's
-    // billed cloud — "ollama/glm-5.2:cloud" must NOT be recorded as $0.
-    if (usage.model && LOCAL_MODEL.test(usage.model) && !/:cloud$/i.test(usage.model))
-        return 0;
-    // Per-model when the real model is known — also prices a paid model whose agent
-    // default tier is 0 (closes the gemini/opencode $0-on-a-paid-backend hole).
-    const mr = modelRate(usage.model);
-    if (mr) {
-        return ((tokens.input / 1_000_000) * mr.inputUsd +
-            (tokens.output / 1_000_000) * mr.outputUsd +
-            (tokens.cacheRead / 1_000_000) * (mr.inputUsd * CACHE_READ_RATIO) +
-            (tokens.cacheCreate / 1_000_000) * mr.inputUsd);
-    }
-    // Fallback: the agent's typical tier. No regression for sessions without a model.
-    const outputRate = COST_PER_M_OUTPUT_TOKENS_USD[agent];
-    if (outputRate === undefined || outputRate === 0)
-        return 0;
-    const inputRate = outputRate * INPUT_RATE_RATIO;
-    return ((tokens.input / 1_000_000) * inputRate +
-        (tokens.output / 1_000_000) * outputRate +
-        (tokens.cacheRead / 1_000_000) * (inputRate * CACHE_READ_RATIO) +
-        (tokens.cacheCreate / 1_000_000) * inputRate);
-}
-/** Return the millisecond timestamp for the start of "today" in local time. */
-function startOfTodayLocalMs(now = new Date()) {
-    const d = new Date(now);
-    d.setHours(0, 0, 0, 0);
-    return d.getTime();
-}
-/**
- * Walk sessions.jsonl, sum estimated USD spend for sessions whose
- * `completedAt` falls within today (local). Best-effort: missing file =
- * empty report; parse errors per-line ignored. Pairs spawned + completed
- * by id so we know which agent spent what.
- */
-export function computeSpendToday(now = new Date()) {
-    const cutoff = startOfTodayLocalMs(now);
-    const empty = {
-        totalUsd: 0,
-        tokens: { input: 0, output: 0, cache: 0 },
-        sessionCount: 0,
-        byAgent: {},
-        byProject: {},
-        practice: { usd: 0, sessions: 0 },
-        windowStartedAt: cutoff,
-    };
-    if (!existsSync(sessionsFile()))
-        return empty;
-    let content;
-    try {
-        content = readFileSync(sessionsFile(), 'utf-8');
-    }
-    catch {
-        return empty;
-    }
-    // Pair spawned (carries agent + cwd + mockRun) with completed (carries usage + completedAt).
-    const spawnedAgent = new Map();
-    const spawnedProject = new Map();
-    const spawnedMock = new Set();
-    const completedById = new Map();
-    const report = { ...empty, byAgent: {}, byProject: {}, practice: { usd: 0, sessions: 0 } };
-    for (const line of content.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        let rec;
-        try {
-            rec = JSON.parse(trimmed);
-        }
-        catch {
-            continue;
-        }
-        if (rec.t === 'spawned' && rec.id && rec.agent) {
-            spawnedAgent.set(rec.id, rec.agent);
-            if (rec.cwd)
-                spawnedProject.set(rec.id, basename(rec.cwd));
-            if (rec.mockRun === true)
-                spawnedMock.add(rec.id);
-            continue;
-        }
-        if (rec.t !== 'completed' || !rec.id)
-            continue;
-        if (typeof rec.completedAt !== 'number' || rec.completedAt < cutoff)
-            continue;
-        if (!spawnedAgent.has(rec.id))
-            continue;
-        // ONE session = ONE count: a session legitimately carries MULTIPLE
-        // completed rows (the exit handler writes one, the async test-observation
-        // re-persists a corrected one — loadRecent dedups by id, later wins).
-        // Summing every row DOUBLED cost + session counts on the team record
-        // (found live 2026-07-07: 2 real runs read as 4 sessions / 2x spend).
-        // Same semantics as the reader: keep the LAST row per id.
-        completedById.set(rec.id, rec);
-    }
-    for (const [id, rec] of completedById) {
-        const agent = spawnedAgent.get(id);
-        const usage = rec.artifacts?.usage;
-        const usd = estimateCostUsd(agent, usage);
-        // Practice runs divert to their own bucket — a mock's fabricated "cost"
-        // never joins the real totals, the by-* breakdowns, or the budget's view.
-        if (spawnedMock.has(id)) {
-            report.practice.usd += usd;
-            report.practice.sessions += 1;
-            continue;
-        }
-        report.sessionCount += 1;
-        if (usage) {
-            report.tokens.input += usage.inputTokens || 0;
-            report.tokens.output += usage.outputTokens || 0;
-            report.tokens.cache += (usage.cacheReadTokens || 0) + (usage.cacheCreationTokens || 0);
-        }
-        report.totalUsd += usd;
-        const cur = report.byAgent[agent] || { usd: 0, sessions: 0 };
-        cur.usd += usd;
-        cur.sessions += 1;
-        report.byAgent[agent] = cur;
-        const project = spawnedProject.get(id) || 'unknown';
-        const pcur = report.byProject[project] || { usd: 0, sessions: 0 };
-        pcur.usd += usd;
-        pcur.sessions += 1;
-        report.byProject[project] = pcur;
-    }
-    // Round totals to 4 decimals (1/100 of a cent) — final display rounds to 2.
-    report.totalUsd = Math.round(report.totalUsd * 10_000) / 10_000;
-    for (const k of Object.keys(report.byAgent)) {
-        report.byAgent[k].usd = Math.round(report.byAgent[k].usd * 10_000) / 10_000;
-    }
-    for (const k of Object.keys(report.byProject)) {
-        report.byProject[k].usd = Math.round(report.byProject[k].usd * 10_000) / 10_000;
-    }
-    report.practice.usd = Math.round(report.practice.usd * 10_000) / 10_000;
-    return report;
-}
-//# sourceMappingURL=spend-aggregator.js.map