segreant 0.1.0 → 0.2.0

package/dist/dashboard/web/app/core/api.js

@@ -49,7 +49,24 @@ async function request(path, init) {
     }
     if (!response.ok) {
         const detail = await response.text().catch(() => '');
-        throw new ApiError(detail.slice(0, 400) || `${response.status} ${response.statusText}`, response.status, path);
+        // Show the human message, never the raw JSON envelope. The dashboard's own
+        // routes answer `{ error: "sentence" }`; some answer `{ error: { message } }`.
+        // Only the second was read, so every refusal from a dashboard route, an
+        // allocation or billing write included, reached the screen as raw JSON.
+        let human = null;
+        try {
+            const parsed = JSON.parse(detail);
+            const error = typeof parsed === 'object' && parsed !== null && 'error' in parsed ? parsed.error : undefined;
+            if (typeof error === 'string' && error.trim())
+                human = error;
+            else if (typeof error === 'object' && error !== null && typeof error.message === 'string') {
+                human = error.message;
+            }
+        }
+        catch {
+            // Not JSON: keep the text fallback below.
+        }
+        throw new ApiError(human ?? (detail.slice(0, 400) || `${response.status} ${response.statusText}`), response.status, path);
     }
     const payload = await response.json();
     // The generic type gives the compiler a view of what the caller consumes;
@@ -86,6 +103,13 @@ export const api = {
     overview: (range, signal) => request(`${routePath('overview')}?range=${encodeURIComponent(range)}`, signal ? { signal } : undefined),
     billing: () => request(routePath('billing')),
     allocation: () => request(routePath('allocation')),
+    /** One calendar month, `YYYY-MM`; the four claims side by side, never summed. */
+    statement: (month) => request(month ? `${routePath('statement')}?month=${encodeURIComponent(month)}` : routePath('statement')),
+    /** The Workbench: the range's sessions, buckets by model, and what their commits came to. */
+    sessions: (range, signal) => request(`${routePath('sessions')}?range=${encodeURIComponent(range)}`, signal ? { signal } : undefined),
+    /** A download link, not a fetch: the browser saves the month's CSV. */
+    statementCsvHref: (month) => `${routePath('statement-csv')}?month=${encodeURIComponent(month)}`,
+    allocationRunCsvHref: (allocationRunId) => `${routePath('allocation-run-csv')}?id=${encodeURIComponent(allocationRunId)}`,
     economic: (range = '30d', options = {}) => {
         const params = new URLSearchParams(range === 'all' ? { all: '1' } : { days: '30' });
         if (options.targetCurrency !== undefined)
@@ -107,8 +131,20 @@ export const api = {
     importers: () => request(routePath('importers')),
     /** GET /api/scan is the dry run: it detects and reports, and imports nothing. */
     scan: () => request(routePath('scan')),
+    pricingUnknown: () => request(routePath('pricing-unknown')),
     /** Mutating calls are grouped so every write in the GUI is greppable in one place. */
     write: {
+        pricingDeclare: (body) => request(routePath('pricing-declare'), { method: 'POST', body: JSON.stringify(body) }),
+        pricingUnset: (model) => request(routePath('pricing-unset'), { method: 'POST', body: JSON.stringify({ model }) }),
+        reprice: (apply) => request(routePath('reprice'), { method: 'POST', body: JSON.stringify({ apply }) }),
+        /**
+         * Month close: `scope`, `import`, `adopt`, `reconcile`. Without `apply: true`
+         * every op is a preview and writes nothing. An import carries the file's raw
+         * bytes in base64, so its digest is the one the CLI computes for the file.
+         */
+        billing: (body) => request(routePath('billing-write'), { method: 'POST', body: JSON.stringify(body) }),
+        /** Cost centres, rules and runs. A run with `apply: false` is a preview and records nothing. */
+        allocation: (body) => request(routePath('allocation-write'), { method: 'POST', body: JSON.stringify(body) }),
         outcome: (input, apply) => request(routePath('outcome-record'), { method: 'POST', body: JSON.stringify({ ...input, apply }) }),
         settings: (patch) => request(routePath('settings-update'), { method: 'POST', body: JSON.stringify(patch) }),
         clearProposals: () => request(routePath('clear-proposals'), { method: 'POST' }),

package/dist/dashboard/web/app/core/chain.js

@@ -15,8 +15,8 @@
  * zero.
  */
 import { api } from './api.js';
-import { buildClaimLayers } from './claimLayers.js';
-export async function loadChain(range) {
+import { buildClaimLayers, chainIsSampleData } from './claimLayers.js';
+export async function loadChainState(range) {
     const [overview, billing, allocation, value] = await Promise.allSettled([
         api.overview(range),
         api.billing(),
@@ -24,10 +24,17 @@ export async function loadChain(range) {
         api.value(),
     ]);
     const ok = (r) => (r.status === 'fulfilled' ? r.value : null);
-    return buildClaimLayers({
+    const inputs = {
         overview: ok(overview),
         billing: ok(billing),
         allocation: ok(allocation),
         value: ok(value),
-    }, range);
+    };
+    return {
+        layers: buildClaimLayers(inputs, range),
+        demo: chainIsSampleData(inputs),
+    };
+}
+export async function loadChain(range) {
+    return (await loadChainState(range)).layers;
 }

package/dist/dashboard/web/app/core/claimLayers.js

@@ -25,19 +25,120 @@
  * server, no sockets, and no ledger. Every `null` input here means "that
  * endpoint did not answer", and each layer degrades on its own.
  */
+import { periodWords } from './periodWords.js';
 import { projectRenderedAxes, unreachableSupport } from './claimTypes.js';
 /**
  * Freshness is either a real recorded instant or the words "not established".
  * It is never `new Date()` — a timestamp invented at render time would report
  * the age of the screen as the age of the evidence.
  */
-const iso = (ms) => typeof ms === 'number' ? new Date(ms).toISOString() : 'not established';
+const iso = (ms) => typeof ms === 'number' && Number.isFinite(ms) && ms > 0 && ms <= 8.64e15
+    ? new Date(ms).toISOString() : 'not established';
+/**
+ * Whether any payload behind the spine is seeded sample data. The spine shows
+ * four money figures before any view's own demo banner; on a phone that banner
+ * sat a full screen below them, so sample dollars filled the first screen with
+ * nothing saying they were samples. A payload that failed to load says nothing.
+ */
+export function chainIsSampleData(input) {
+    return Object.values(input).some((p) => p?.demo === true);
+}
+const money = (n) => `$${n.toFixed(2)}`;
+/** "gpt-6.1-sol, codex-auto-review and 1 more". */
+function modelsOf(c) {
+    const names = c.models.map((m) => m.model);
+    return names.length <= 2 ? names.join(', ') : `${names.slice(0, 2).join(', ')} and ${names.length - 2} more`;
+}
+/**
+ * The Metered band's basis line. It used to read "priced from a rate card" for
+ * every total, including amounts a tool reported and models priced at the
+ * generic fallback rate; the inspector then called matched rows "not
+ * estimated" (H003). All local cost is an estimate of a bill; what varies is
+ * how each part was priced, and that is what this says.
+ */
+export function meteredBasisLine(basis) {
+    if (!basis || basis.cohorts.length === 0)
+        return 'no recorded requests in this period';
+    switch (basis.headline) {
+        case 'sample_cost': return 'sample data, priced from the price list';
+        case 'tool_reported_cost': return 'amounts the tools reported, not verified';
+        case 'list_cost': {
+            const line = basis.cohorts.some((c) => c.id === 'list_family')
+                ? "list prices (some models at the nearest model's price)"
+                : "list prices: each model's own published price";
+            // A model marked free is priced by its operator's declaration, not by a
+            // published price, so a mixed total names it (PR #146 review).
+            const free = basis.cohorts.find((c) => c.id === 'user_free');
+            return free ? `${line}; no charge on models you marked free (${modelsOf(free)})` : line;
+        }
+        default: {
+            const weak = basis.cohorts.filter((c) => (c.id === 'fallback' || c.id === 'tool_reported' || c.id === 'unrecorded') && c.costUsd >= 0.005);
+            // A declared price IS the model's own rate, the one its operator set, so
+            // it is named on its own rather than counted as "priced without" a rate
+            // (PR #146 review). It still makes the total an estimate: it is not a
+            // published list price.
+            const declared = basis.cohorts.find((c) => c.id === 'user_declared');
+            // With no weak or declared part, the "estimated" headline comes from the
+            // mix itself (sample rows beside priced ones, or unpriced requests). It
+            // used to print "0% priced without the model's own rate ()".
+            if (weak.length === 0 && !declared) {
+                if (basis.cohorts.some((c) => c.id === 'demo'))
+                    return 'mostly sample data, priced from the price list';
+                // No rate card priced any of it: every charged request is on a model the
+                // user marked free (PR #146 review). It used to read "API list price".
+                if (basis.cohorts.some((c) => c.id === 'user_free') && !basis.cohorts.some((c) => c.id === 'list_exact' || c.id === 'list_family')) {
+                    return basis.cohorts.some((c) => c.id === 'unpriced')
+                        ? 'no charge on models you marked free; some requests have no price'
+                        : 'no charge: every request is on a model you marked free';
+                }
+                if (basis.cohorts.some((c) => c.id === 'unpriced'))
+                    return 'list prices; some requests have no price';
+                return "API list price from the rate card";
+            }
+            const pct = (usd) => (basis.totalUsd > 0 ? Math.round((usd / basis.totalUsd) * 100) : 0);
+            const parts = [];
+            if (weak.length > 0)
+                parts.push(`${pct(weak.reduce((s, c) => s + c.costUsd, 0))}% priced without the model's own rate (${weak.map((c) => c.label).join(', ')})`);
+            if (declared)
+                parts.push(`${pct(declared.costUsd)}% at prices you set`);
+            return `estimated: ${parts.join('; ')}`;
+        }
+    }
+}
+/** Share of the dollar total priced by a guess (nearest model or generic rate), 0..1. */
+export function guessedShare(basis) {
+    if (!basis || basis.totalUsd <= 0)
+        return 0;
+    const guessed = basis.cohorts.filter((c) => c.id === 'fallback' || c.id === 'list_family').reduce((s, c) => s + c.costUsd, 0);
+    return guessed / basis.totalUsd;
+}
+/** Below this share a guess cannot change what the total says; above it, say where to fix it. */
+export const GUESSED_SHARE_NEXT_STEP = 0.05;
+/** Every part of the total, one clause each, for the inspector. */
+export function meteredBasisParts(basis) {
+    if (!basis || basis.cohorts.length === 0)
+        return 'no recorded requests in this period';
+    return basis.cohorts.map((c) => {
+        if (c.id === 'unpriced')
+            return `${c.requests} request(s) not priced (${modelsOf(c)})`;
+        if (c.id === 'not_sent')
+            return `${c.requests} request(s) refused before reaching the provider (no charge)`;
+        if (c.id === 'user_free')
+            return `${c.requests} request(s) on models you marked free (${modelsOf(c)})`;
+        if (c.id === 'tool_reported' && c.costUsd < 0.005)
+            return `${c.requests} request(s) the tool reported at no charge (${modelsOf(c)})`;
+        const which = c.id === 'list_exact' || c.id === 'demo' || c.id === 'tool_reported' ? '' : ` (${modelsOf(c)})`;
+        return `${money(c.costUsd)} ${c.label}${which}`;
+    }).join(' · ');
+}
 export function buildClaimLayers(input, range) {
+    // Each claim names its own window; only Metered follows the chosen period.
     const { overview: o, billing: b, allocation: a, value: v } = input;
     const estimatedShare = o?.pricing.estimatedSpendShare ?? null;
     const metered = {
         id: 'metered',
-        label: 'Metered',
+        label: 'List cost (estimate)',
+        period: periodWords(range),
         claim: 'what we observed',
         valueUsd: o?.summary.costUsd ?? null,
         // Metered is the one layer whose figure IS the claim: if the ledger read,
@@ -47,26 +148,36 @@ export function buildClaimLayers(input, range) {
         support: o?.claimSupport ?? unreachableSupport('withheld_unsupported'),
         basis: o === null
             ? 'could not read the ledger'
-            : 'counted from requests, priced from a rate card',
-        nextStep: o === null ? 'Check that Segreant is running.' : undefined,
+            : meteredBasisLine(o.pricing.basis),
+        nextStep: o === null
+            ? 'Check that Segreant is running.'
+            : guessedShare(o.pricing.basis) >= GUESSED_SHARE_NEXT_STEP
+                ? `${Math.round(guessedShare(o.pricing.basis) * 100)}% is priced by a guess. Give those models a price under Data, then re-price.`
+                : undefined,
         inspection: {
             provenance: 'local request ledger + recorded pricing basis',
             scope: o ? `${range}; ${o.summary.requests} recorded request(s)` : range,
             freshness: o?.generatedAt ?? 'not established',
             coverage: o?.claimSupport?.note
-                ?? (estimatedShare === null
-                    ? 'pricing coverage unavailable'
-                    : `${Math.round((1 - estimatedShare) * 100)}% of spend priced from a matched rate card, not estimated`),
+                ?? (o?.pricing.basis
+                    ? meteredBasisParts(o.pricing.basis)
+                    : estimatedShare === null
+                        ? 'pricing coverage unavailable'
+                        : `${Math.round((1 - estimatedShare) * 100)}% of spend priced at the model's own card rate; all of it is a list-price estimate`),
             // The distinction the whole product is built on, stated where someone is
             // most likely to reach for the metered figure as if it were the bill.
             enforceability: 'observation claim; local caps can govern future in-path requests, but metered cost does not become billed cost',
             evidenceSource: 'local request ledger',
-            assumptions: ['Rate-card cost is an estimate unless provider billing evidence establishes a billed amount.'],
+            assumptions: ['Every local amount is an estimate of a bill: list price is what the use would cost at published API rates, with no plan, discount, credit or tax.'],
             missingEvidence: o === null
                 ? ['a readable local ledger']
-                : estimatedShare !== null && estimatedShare > 0
-                    ? ['exact rate-card matches for the estimated rows']
-                    : [],
+                : [
+                    ...(o.pricing.basis?.cohorts ?? []).flatMap((c) => c.id === 'fallback' ? [`a model rate for ${modelsOf(c)} (if the card has learned it since, segreant reprice previews the new price)`]
+                        : c.id === 'tool_reported' ? ['verification of the tool-reported amounts']
+                            : c.id === 'unrecorded' ? ['the pricing basis of rows recorded before it was kept']
+                                : []),
+                    ...(o.pricing.basis ? [] : estimatedShare !== null && estimatedShare > 0 ? ['exact price-list matches for the estimated rows'] : []),
+                ],
         },
     };
     // Billed is established only by a recorded reconciliation run. Holding
@@ -81,7 +192,8 @@ export function buildClaimLayers(input, range) {
     const billedNote = b?.claimSupport?.note ?? null;
     const billed = {
         id: 'billed',
-        label: 'Billed',
+        period: 'latest invoice comparison',
+        label: 'Billed cost',
         claim: 'what the provider charged',
         valueUsd: null,
         // Holding provider records and having reconciled them are different states,
@@ -92,25 +204,29 @@ export function buildClaimLayers(input, range) {
         // The band deliberately carries no dollar in any branch: this is an evidence
         // claim about whether a comparison happened, not a second cost figure.
         support: b?.claimSupport ?? unreachableSupport('not_a_money_claim'),
-        basis: billedNote
-            // A reconciliation whose provider snapshots contradicted each other is not
-            // a reconciliation that established anything, and saying "reconciled" here
-            // while the axis says `conflicted` is the disagreement this line exists to
-            // avoid.
-            ? `reconciled against a provider report, but ${billedNote}`
-            : runs > 0
-                ? 'reconciled against a provider report, with a residual'
-                : b && b.summary.recordCount > 0
-                    ? `${b.summary.recordCount} provider records held, none reconciled yet`
-                    : 'no provider bill has been compared against this ledger',
+        basis: b === null
+            ? 'could not read the billing report'
+            : billedNote
+                // A reconciliation whose provider snapshots contradicted each other is not
+                // a reconciliation that established anything, and saying "reconciled" here
+                // while the axis says `conflicted` is the disagreement this line exists to
+                // avoid.
+                ? `compared with your invoice, but ${billedNote}`
+                : runs > 0
+                    ? 'compared with your invoice; see Close for the difference'
+                    : b && b.summary.recordCount > 0
+                        ? `${b.summary.recordCount} billing records from your provider, not compared yet`
+                        : 'no invoice imported',
         // A contradiction with no next action leaves an operator looking at a
         // problem they are not told how to work on. Resolving a disagreement is a
         // different task from collecting more evidence, so it gets its own sentence.
-        nextStep: b?.claimSupport && projectRenderedAxes(b.claimSupport.profile).epistemic === 'conflicted'
-            ? 'Re-observe the disagreeing days before relying on this reconciliation.'
-            : runs > 0
-                ? undefined
-                : 'Check readiness in Evidence before spending a credential on it.',
+        nextStep: b === null
+            ? 'Check that Segreant is running, then retry the billing report.'
+            : b?.claimSupport && projectRenderedAxes(b.claimSupport.profile).epistemic === 'conflicted'
+                ? 'Re-observe the disagreeing days before relying on this reconciliation.'
+                : runs > 0
+                    ? undefined
+                    : 'Import one under Close to see billed cost beside list cost.',
         inspection: {
             provenance: latestRun?.result.providerSourceKind
                 ?? (b && b.summary.recordCount > 0 ? 'operator-supplied provider evidence, unreconciled' : 'none'),
@@ -134,7 +250,8 @@ export function buildClaimLayers(input, range) {
     const centres = Array.isArray(a?.costCentres) ? a.costCentres.length : 0;
     const allocated = {
         id: 'allocated',
-        label: 'Allocated',
+        period: 'latest cost split',
+        label: 'Allocated cost',
         claim: 'whose cost it is',
         valueUsd: null,
         // Cost centres defined with no run recorded is partial coverage of a claim
@@ -143,12 +260,16 @@ export function buildClaimLayers(input, range) {
         // Showback: the claim is whose cost it is, not how much, so the band never
         // carries a dollar.
         support: a?.claimSupport ?? unreachableSupport('not_a_money_claim'),
-        basis: allocRuns > 0
-            ? 'apportioned by recorded rules — showback only'
-            : centres > 0
-                ? `${centres} cost centre${centres === 1 ? '' : 's'} defined, no allocation recorded`
-                : 'no cost centres and no rules yet',
-        nextStep: allocRuns > 0 ? undefined : 'Define a cost centre, then run an allocation.',
+        basis: a === null
+            ? 'could not read the allocation report'
+            : allocRuns > 0
+                ? 'split by your rules, for reporting (not a bill)'
+                : centres > 0
+                    ? `${centres} cost centre${centres === 1 ? '' : 's'} set up, nothing split yet`
+                    : 'no cost split set up yet',
+        nextStep: a === null
+            ? 'Check that Segreant is running, then retry the allocation report.'
+            : allocRuns > 0 ? undefined : 'Set up a cost centre, then split the spend under Allocate.',
         inspection: {
             provenance: a?.basis ?? 'no allocation basis recorded',
             scope: a
@@ -203,7 +324,8 @@ export function buildClaimLayers(input, range) {
     const valued = ret?.basis === 'usd' && typeof ret.manualEquivalentValueUsd === 'number';
     const realized = {
         id: 'realized',
-        label: 'Realized',
+        period: 'outcomes on record',
+        label: 'Value (kept work)',
         claim: 'what it produced',
         valueUsd: valued ? (ret?.manualEquivalentValueUsd ?? null) : null,
         // THE CASE THE OLD BOOLEAN COLLAPSED (AII-014). `realizedUnits > 0 && valued`
@@ -219,16 +341,20 @@ export function buildClaimLayers(input, range) {
         // produced nothing" — an inference from a missing input, in the band whose
         // entire job is to keep realized value distinct from the three cost claims.
         support: v?.claimSupport ?? unreachableSupport('withheld_unsupported'),
-        basis: realizedUnits === 0
-            ? 'no work units have matured into verified outcomes'
-            : valued
-                ? `${realizedUnits} of ${matured?.units ?? 0} matured units shipped and survived; manual-equivalent value, net of rework`
-                : `${realizedUnits} of ${matured?.units ?? 0} units matured, but no labour rate is set to price what they produced`,
-        nextStep: realizedUnits === 0
-            ? 'Connect a repository so outcomes can be observed.'
-            : valued
-                ? undefined
-                : 'Set a labour rate so realized work can be priced.',
+        basis: v === null
+            ? 'could not read the outcome report'
+            : realizedUnits === 0
+                ? 'no finished work old enough to judge yet'
+                : valued
+                    ? `${realizedUnits} of ${matured?.units ?? 0} finished pieces of work kept; valued at what the work would cost by hand, less rework`
+                    : `${realizedUnits} of ${matured?.units ?? 0} finished pieces of work kept, but no hourly rate is set to value them`,
+        nextStep: v === null
+            ? 'Check that Segreant is running, then retry the outcome report.'
+            : realizedUnits === 0
+                ? 'Connect a repository so Segreant can see which work you kept.'
+                : valued
+                    ? undefined
+                    : 'Set an hourly rate to put a dollar value on kept work.',
         inspection: {
             provenance: v?.valueSource ?? 'no outcome source established',
             scope: v?.projectScoped === true
@@ -253,11 +379,13 @@ export function buildClaimLayers(input, range) {
                 ? 'repository history + recorded outcome signals'
                 : (v?.valueSource ?? 'none'),
             assumptions: v?.roi?.notes ? [...v.roi.notes] : [],
-            missingEvidence: realizedUnits === 0
-                ? ['matured outcome evidence']
-                : valued
-                    ? []
-                    : ['a labour rate, so realized work can be priced'],
+            missingEvidence: v === null
+                ? ['a readable outcome report']
+                : realizedUnits === 0
+                    ? ['matured outcome evidence']
+                    : valued
+                        ? []
+                        : ['a labour rate, so realized work can be priced'],
         },
     };
     return [metered, billed, allocated, realized];

package/dist/dashboard/web/app/core/claimTypes.js

@@ -182,6 +182,36 @@ export function claimIsUnevidenced(layer) {
 export function claimShowsFigure(layer) {
     return layer.support.figure === 'shown';
 }
+/**
+ * What is complete when a claim names no missing evidence. Scoped to THIS
+ * claim's own standard. An empty `missingEvidence` list means the claim is
+ * complete as stated, not that the claim family is complete or that the figure
+ * is a measured outcome: "Nothing is missing" read as blanket completeness on
+ * a Realized claim that also says "impact uninstrumented" (H018).
+ */
+export function claimCompletionLine(layer, precise) {
+    if (layer.id === 'realized') {
+        return precise
+            ? 'No further evidence is required for this claim as stated: an estimated manual-equivalent value of work that shipped and survived.'
+            : 'Nothing more is needed for this claim as stated: an estimated manual-equivalent value of work that shipped and survived.';
+    }
+    return precise
+        ? 'No further evidence is required for this claim at its stated basis.'
+        : 'Nothing more is needed for this claim at its stated basis.';
+}
+/**
+ * The Realized claim is shown with its basis, and that basis is a value
+ * estimate. A causal or business-value claim needs evidence this layer does
+ * not carry, so the inspector names that gap whether or not `missingEvidence`
+ * is empty. The payload has no structured impact-instrumentation flag (impact
+ * appears only as free-text `roi.notes`), so the line is shown for every
+ * Realized claim rather than conditioned on a flag that does not exist.
+ */
+export function claimStrongerClaimLine(layer) {
+    if (layer.id !== 'realized')
+        return null;
+    return 'A causal or business-value claim would also need independent outcome evidence (impact instrumentation), which this claim does not establish.';
+}
 /**
  * Supported, but no figure because something needed to price it is missing.
  * The case the old boolean reported as "not established", which reads to an

package/dist/dashboard/web/app/core/fmt.js

@@ -86,6 +86,23 @@ export function pct(value, digits = 1) {
         return '—';
     return `${(value * 100).toFixed(digits)}%`;
 }
+/**
+ * A part of a whole, as a percentage. A part that is not zero never prints as
+ * 0%, and a part short of the whole never prints as 100%: either rounding would
+ * state something the figures do not. At the default precision those show as
+ * "<1%" and ">99%".
+ */
+export function share(fraction, digits = 0) {
+    if (fraction === null || fraction === undefined || Number.isNaN(fraction))
+        return '—';
+    const step = 10 ** -digits;
+    const percent = fraction * 100;
+    if (fraction > 0 && percent < step / 2)
+        return `<${step.toFixed(digits)}%`;
+    if (fraction < 1 && percent >= 100 - step / 2)
+        return `>${(100 - step).toFixed(digits)}%`;
+    return pct(fraction, digits);
+}
 export function dateTime(ms) {
     if (!ms)
         return '—';
@@ -93,10 +110,10 @@ export function dateTime(ms) {
         year: 'numeric', month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit',
     });
 }
-export function date(ms) {
+export function date(ms, timeZone) {
     if (!ms)
         return '—';
-    return new Date(ms).toLocaleDateString(undefined, { year: 'numeric', month: 'short', day: 'numeric' });
+    return new Date(ms).toLocaleDateString(undefined, { year: 'numeric', month: 'short', day: 'numeric', ...(timeZone ? { timeZone } : {}) });
 }
 export function relative(ms) {
     if (!ms)

package/dist/dashboard/web/app/core/generated-contract.js

@@ -18,9 +18,19 @@ export const DASHBOARD_API_CONTRACTS = [
     { id: 'scan', path: '/api/scan', methods: ['GET', 'POST'], localOnly: ['POST'], responseType: 'ScanPayload', browserBinding: ['modern-api', 'classic'] },
     { id: 'overview', path: '/api/overview', methods: ['GET', 'HEAD'], localOnly: [], responseType: 'Overview', browserBinding: ['modern-api', 'classic'] },
     { id: 'billing', path: '/api/billing', methods: ['GET'], localOnly: [], responseType: 'BillingPayload', browserBinding: ['modern-api', 'classic'] },
+    { id: 'statement', path: '/api/statement', methods: ['GET', 'HEAD'], localOnly: [], responseType: 'StatementPayload', browserBinding: ['modern-api'] },
+    { id: 'sessions', path: '/api/sessions', methods: ['GET', 'HEAD'], localOnly: [], responseType: 'SessionsPayload', browserBinding: ['modern-api'] },
+    { id: 'statement-csv', path: '/api/statement.csv', methods: ['GET', 'HEAD'], localOnly: [], responseType: 'text/csv', browserBinding: ['modern-api'] },
     { id: 'allocation', path: '/api/allocation', methods: ['GET'], localOnly: [], responseType: 'AllocationPayload', browserBinding: ['modern-api', 'classic'] },
+    { id: 'allocation-write', path: '/api/allocation/write', methods: ['POST'], localOnly: ['POST'], responseType: 'AllocationWritePayload', browserBinding: ['modern-api'] },
+    { id: 'allocation-run-csv', path: '/api/allocation/run.csv', methods: ['GET', 'HEAD'], localOnly: [], responseType: 'text/csv', browserBinding: ['modern-api'] },
+    { id: 'billing-write', path: '/api/billing/write', methods: ['POST'], localOnly: ['POST'], responseType: 'BillingWritePayload', browserBinding: ['modern-api'] },
     { id: 'economic', path: '/api/economic', methods: ['GET', 'HEAD'], localOnly: [], responseType: 'EconomicPayload', browserBinding: ['modern-api'] },
     { id: 'pricing', path: '/api/pricing', methods: ['GET', 'HEAD'], localOnly: [], responseType: 'PricingPayload', browserBinding: [] },
+    { id: 'pricing-unknown', path: '/api/pricing/unknown', methods: ['GET'], localOnly: [], responseType: 'UnknownPricingPayload', browserBinding: ['modern-api'] },
+    { id: 'pricing-declare', path: '/api/pricing/declare', methods: ['POST'], localOnly: ['POST'], responseType: 'PricingDeclarePayload', browserBinding: ['modern-api'] },
+    { id: 'pricing-unset', path: '/api/pricing/unset', methods: ['POST'], localOnly: ['POST'], responseType: 'PricingUnsetPayload', browserBinding: ['modern-api'] },
+    { id: 'reprice', path: '/api/reprice', methods: ['POST'], localOnly: ['POST'], responseType: 'RepricePayload', browserBinding: ['modern-api'] },
     { id: 'export-csv', path: '/api/export.csv', methods: ['GET', 'HEAD'], localOnly: [], responseType: 'text/csv', browserBinding: ['classic', 'actions'] },
     { id: 'realization', path: '/api/realization', methods: ['GET', 'HEAD'], localOnly: [], responseType: 'RealizationPayload', browserBinding: [] },
     { id: 'guide', path: '/api/guide', methods: ['GET', 'HEAD'], localOnly: [], responseType: 'GuidePayload', browserBinding: ['modern-api', 'classic'] },
@@ -59,21 +69,31 @@ export const DASHBOARD_PAYLOAD_CONTRACTS = [
     { routeId: 'scan', method: 'GET', contentType: 'json', responseType: 'ScanPayload', required: [field('ok', 'boolean'), field('tools', 'array'), field('otherApps', 'array'), field('roots', 'array'), field('repoCount', 'number'), field('reposWithSpend', 'number'), field('hitBudget', 'boolean'), field('dirsVisited', 'number'), field('unreadableDirs', 'number'), field('diff', 'object')] },
     { routeId: 'scan', method: 'POST', contentType: 'json', responseType: 'ScanSetupPayload', required: [field('ok', 'boolean'), field('totalNew', 'number'), field('imported', 'object'), field('correlated', 'number'), field('discovered', 'array')] },
     { routeId: 'overview', method: 'GET', contentType: 'json', responseType: 'Overview', required: [field('claimSupport', 'object'), field('range', 'string'), field('demo', 'boolean'), field('generatedAt', 'string'), field('budget', 'object'), field('summary', 'object'), field('pricing', 'object'), field('byModel', 'array'), field('byProject', 'array'), field('attributionEvidence', 'array'), field('byUser', 'array'), field('bySource', 'array'), field('characterization', 'object'), field('dimensions', 'array'), field('series', 'array'), field('recent', 'array'), field('alerts', 'array'), field('alertCoverage', 'object')] },
+    { routeId: 'statement', method: 'GET', contentType: 'json', responseType: 'StatementPayload', required: [field('demo', 'boolean'), field('generatedAt', 'string'), field('month', 'string'), field('period', 'object'), field('metered', 'object'), field('billed', 'object'), field('allocated', 'object'), field('realized', 'object'), field('close', 'object')] },
+    { routeId: 'sessions', method: 'GET', contentType: 'json', responseType: 'SessionsPayload', required: [field('demo', 'boolean'), field('generatedAt', 'string'), field('range', 'string'), field('window', 'object'), field('totals', 'object'), field('models', 'array'), field('buckets', 'array'), field('sessions', 'array'), field('sessionLimit', 'number'), field('sessionsOmitted', 'number'), field('outcomes', 'object')] },
     { routeId: 'billing', method: 'GET', contentType: 'json', responseType: 'BillingPayload', required: [field('claimSupport', 'object'), field('demo', 'boolean'), field('generatedAt', 'string'), field('evidence', 'object'), field('summary', 'object'), field('imports', 'array'), field('kernel', 'object'), field('readiness', 'object'), field('mapping', 'object'), field('directOpenAiCosts', 'object'), field('reconciliation', 'object')] },
     { routeId: 'allocation', method: 'GET', contentType: 'json', responseType: 'AllocationPayload', required: [field('claimSupport', 'object'), field('demo', 'boolean'), field('generatedAt', 'string'), field('kind', 'string'), field('trust', 'string'), field('basis', 'string'), field('excludedFrom', 'array'), field('costCentres', 'array'), field('rules', 'array'), field('runs', 'array'), field('reconciliation', 'object')] },
+    { routeId: 'allocation-write', method: 'POST', contentType: 'json', responseType: 'AllocationWritePayload', required: [field('ok', 'boolean'), field('op', 'string'), field('applied', 'boolean')] },
+    { routeId: 'billing-write', method: 'POST', contentType: 'json', responseType: 'BillingWritePayload', required: [field('ok', 'boolean'), field('op', 'string'), field('applied', 'boolean')] },
     { routeId: 'economic', method: 'GET', contentType: 'json', responseType: 'EconomicPayload', required: [field('kind', 'string'), field('schemaVersion', 'number'), field('demo', 'boolean'), field('window', 'object'), field('translation', 'object', true), field('projection', 'object'), field('periodClose', 'object')] },
     { routeId: 'pricing', method: 'GET', contentType: 'json', responseType: 'PricingPayload', required: [field('demo', 'boolean'), field('generatedAt', 'string'), field('window', 'object'), field('activeRateCard', 'object'), field('total', 'object'), field('provenance', 'array'), field('boundary', 'string')] },
+    { routeId: 'pricing-unknown', method: 'GET', contentType: 'json', responseType: 'UnknownPricingPayload', required: [field('models', 'array'), field('boundary', 'string'), field('demo', 'boolean')] },
+    { routeId: 'pricing-declare', method: 'POST', contentType: 'json', responseType: 'PricingDeclarePayload', required: [field('ok', 'boolean'), field('model', 'string'), field('price', 'object')] },
+    { routeId: 'pricing-unset', method: 'POST', contentType: 'json', responseType: 'PricingUnsetPayload', required: [field('ok', 'boolean'), field('model', 'string'), field('removed', 'boolean')] },
+    { routeId: 'reprice', method: 'POST', contentType: 'json', responseType: 'RepricePayload', required: [field('applied', 'boolean'), field('demo', 'boolean'), field('estimatedRows', 'number'), field('repriceable', 'number'), field('stillEstimated', 'number'), field('totalBeforeUsd', 'number'), field('totalAfterUsd', 'number'), field('byModel', 'array'), field('realizationSync', 'object', true)] },
     { routeId: 'export-csv', method: 'GET', contentType: 'text', responseType: 'text/csv', required: [] },
+    { routeId: 'statement-csv', method: 'GET', contentType: 'text', responseType: 'text/csv', required: [] },
+    { routeId: 'allocation-run-csv', method: 'GET', contentType: 'text', responseType: 'text/csv', required: [] },
     { routeId: 'realization', method: 'GET', contentType: 'json', responseType: 'RealizationPayload', required: [field('available', 'boolean'), field('repo', 'string')] },
     { routeId: 'guide', method: 'GET', contentType: 'json', responseType: 'GuidePayload', required: [field('stage', 'string'), field('headline', 'string'), field('steps', 'array'), field('next', 'object'), field('hint', 'object', true)] },
     { routeId: 'judge', method: 'POST', contentType: 'json', responseType: 'JudgePayload', required: [] },
     { routeId: 'kernel', method: 'GET', contentType: 'json', responseType: 'KernelNodePayload', required: [field('found', 'boolean'), field('id', 'string'), field('asOf', 'string', true), field('node', 'object', true)] },
-    { routeId: 'value', method: 'GET', contentType: 'json', responseType: 'ValuePayload', required: [field('claimSupport', 'object'), field('demo', 'boolean'), field('gitRepo', 'boolean'), field('valueSource', 'string', true), field('repo', 'string'), field('generatedAt', 'string'), field('realization', 'object', true), field('roi', 'object', true), field('frontier', 'object', true), field('budget', 'object', true), field('allocation', 'object', true), field('projects', 'array'), field('projectAllocation', 'object', true), field('usage', 'object', true), field('selfReported', 'object'), field('team', 'object', true), field('drift', 'object', true), field('reclaimed', 'object', true)] },
+    { routeId: 'value', method: 'GET', contentType: 'json', responseType: 'ValuePayload', required: [field('claimSupport', 'object'), field('demo', 'boolean'), field('gitRepo', 'boolean'), field('valueSource', 'string', true), field('repo', 'string'), field('generatedAt', 'string'), field('realization', 'object', true), field('roi', 'object', true), field('frontier', 'object', true), field('budget', 'object', true), field('allocation', 'object', true), field('projects', 'array', true), field('projectAllocation', 'object', true), field('usage', 'object', true), field('selfReported', 'object'), field('team', 'object', true), field('drift', 'object', true), field('reclaimed', 'object', true)] },
     { routeId: 'market', method: 'GET', contentType: 'json', responseType: 'MarketPayload', required: [field('status', 'string'), field('categories', 'array'), field('boundary', 'array'), field('cacheErrors', 'array')] },
     { routeId: 'outcome-record', method: 'POST', contentType: 'json', responseType: 'OutcomeRecordPayload', required: [field('apply', 'boolean'), field('basis', 'string'), field('event', 'object'), field('matchedRequests', 'number'), field('matchedCostUsd', 'number', true), field('linkStatus', 'string')] },
     { routeId: 'causal', method: 'GET', contentType: 'json', responseType: 'CausalPayload', required: [field('demo', 'boolean'), field('generatedAt', 'string'), field('studies', 'array'), field('study', 'object', true), field('causalEvidence', 'string'), field('boundary', 'string')] },
-    { routeId: 'settings', method: 'GET', contentType: 'json', responseType: 'SettingsSnapshot', required: [field('version', 'string'), field('home', 'string'), field('configPath', 'string'), field('dbPath', 'string'), field('proxyPort', 'number'), field('dashboardPort', 'number'), field('retentionDays', 'number'), field('proposalRetentionDays', 'number'), field('metadataOnly', 'boolean'), field('features', 'object'), field('budget', 'object'), field('enforcement', 'object'), field('egress', 'object'), field('connections', 'array')] },
-    { routeId: 'settings-update', method: 'POST', contentType: 'json', responseType: 'SettingsSnapshot', required: [field('version', 'string'), field('home', 'string'), field('configPath', 'string'), field('dbPath', 'string'), field('proxyPort', 'number'), field('dashboardPort', 'number'), field('retentionDays', 'number'), field('proposalRetentionDays', 'number'), field('metadataOnly', 'boolean'), field('features', 'object'), field('budget', 'object'), field('enforcement', 'object'), field('egress', 'object'), field('connections', 'array')] },
+    { routeId: 'settings', method: 'GET', contentType: 'json', responseType: 'SettingsSnapshot', required: [field('version', 'string'), field('home', 'string'), field('configPath', 'string'), field('dbPath', 'string'), field('proxyPort', 'number'), field('dashboardPort', 'number'), field('retentionDays', 'number'), field('proposalRetentionDays', 'number'), field('metadataOnly', 'boolean'), field('demo', 'boolean'), field('features', 'object'), field('budget', 'object'), field('enforcement', 'object'), field('egress', 'object'), field('connections', 'array')] },
+    { routeId: 'settings-update', method: 'POST', contentType: 'json', responseType: 'SettingsSnapshot', required: [field('version', 'string'), field('home', 'string'), field('configPath', 'string'), field('dbPath', 'string'), field('proxyPort', 'number'), field('dashboardPort', 'number'), field('retentionDays', 'number'), field('proposalRetentionDays', 'number'), field('metadataOnly', 'boolean'), field('demo', 'boolean'), field('features', 'object'), field('budget', 'object'), field('enforcement', 'object'), field('egress', 'object'), field('connections', 'array')] },
     { routeId: 'clear-proposals', method: 'POST', contentType: 'json', responseType: 'ClearProposalsPayload', required: [field('ok', 'boolean'), field('removed', 'number')] },
 ];
 export function dashboardPayloadContract(routeId, method) {