specrails-desktop 2.64.2 → 2.65.0

package/server/dist/mobile/mobile-ws.js

@@ -14,6 +14,15 @@ const HEARTBEAT_MS = 30_000;
 const LOG_FLUSH_MS = 250;
 const LOG_LINE_MAX = 2048;
 const LOG_BATCH_MAX = 60;
+/**
+ * Events that can change what waits for the person (the "Needs you" inbox).
+ * They reach a companion that subscribed to the `inbox` topic as a bare
+ * `inbox.changed` nudge (no payload): the phone re-reads `GET /v1/inbox`.
+ */
+const INBOX_NUDGE_TYPES = new Set([
+    'rail.pr_state', 'rail.job_completed', 'rail.job_stopped', 'job.stuck', 'jira.outbox_changed',
+    'loop.run_paused', 'loop.run_resumed', 'loop.run_stopped', 'loop.run_completed',
+]);
 function topicFor(type) {
     switch (type) {
         case 'agent_stream':
@@ -33,8 +42,7 @@ function topicFor(type) {
         case 'agent_pr_decision':
         case 'background_process.started':
         case 'background_process.updated':
-        case 'background_process.exited':
-        case 'background_process.preview_targets': return 'missions';
+        case 'background_process.exited': return 'missions';
         case 'queue': return 'queue';
         case 'phase': return 'phase';
         case 'ticket_created':
@@ -244,6 +252,8 @@ class MobileWsBridge {
     }
     /** Fan a single bus message out to matching sockets. */
     dispatch(msg) {
+        if (INBOX_NUDGE_TYPES.has(msg.type))
+            this.nudgeInbox(msg);
         const topic = topicFor(msg.type);
         if (!topic)
             return;
@@ -254,8 +264,7 @@ class MobileWsBridge {
                     continue;
                 const value = msg;
                 const process = value.process;
-                const cid = typeof value.conversationId === 'string' ? value.conversationId
-                    : typeof value.chatId === 'string' ? value.chatId : process?.chatId;
+                const cid = typeof value.conversationId === 'string' ? value.conversationId : process?.chatId;
                 const projectId = cid ? this._missionProjectFor(cid) : null;
                 if (!projectId || !s.projects.has(projectId))
                     continue;
@@ -312,6 +321,20 @@ class MobileWsBridge {
             }
         }
     }
+    /** `inbox.changed` to devices on the `inbox` topic that may see the project. */
+    nudgeInbox(msg) {
+        const projectId = msg.projectId;
+        if (!projectId)
+            return;
+        for (const s of this._socks) {
+            if (!s.topics.has('inbox') || !s.projects.has(projectId))
+                continue;
+            const allowed = this._allowedProjectsFor(s.deviceId);
+            if (allowed !== null && !allowed.has(projectId))
+                continue;
+            this.send(s, { type: 'inbox.changed', projectId, reason: msg.type });
+        }
+    }
     bufferLog(s, jobId, line) {
         const buf = s.logBuf.get(jobId) ?? [];
         if (buf.length >= LOG_BATCH_MAX) {

package/server/dist/modules/accounting/runtime/ai-invocations.js

@@ -20,6 +20,8 @@ const ALLOWED_SURFACES = new Set([
     'proposal',
     'agent-studio',
     'setup',
+    'flow',
+    'triage',
 ]);
 class InvalidSurfaceError extends Error {
     surface;
@@ -104,6 +106,8 @@ function getTicketSpendingSummary(db, ticketId) {
         proposal: { count: 0, costUsd: 0, unpricedCount: 0 },
         'agent-studio': { count: 0, costUsd: 0, unpricedCount: 0 },
         setup: { count: 0, costUsd: 0, unpricedCount: 0 },
+        flow: { count: 0, costUsd: 0, unpricedCount: 0 },
+        triage: { count: 0, costUsd: 0, unpricedCount: 0 },
     };
     let totalCostUsd = 0;
     let estimatedCostUsd = 0;

package/server/dist/modules/accounting/runtime/decision-times.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quantile = quantile;
+exports.aggregateDecisionTimes = aggregateDecisionTimes;
+exports.getDecisionTimes = getDecisionTimes;
+const spending_1 = require("./spending");
+/** Decisions in which the delivery still waits for a human decision. */
+const AWAITING_DECISION = new Set(['on_review']);
+/** Decisions from which a merge can still happen. */
+const AWAITING_MERGE = new Set(['on_review', 'pr_draft', 'pr_ready', 'pr_closed', 'pr_failed']);
+/** Decisions that prove a review happened, even on a legacy row without stamps. */
+const PAST_REVIEW = new Set(['pr_draft', 'pr_ready', 'pr_closed', 'merged']);
+/** Linear-interpolated quantile (R type 7) of an ascending array; null when empty. */
+function quantile(sorted, q) {
+    if (sorted.length === 0)
+        return null;
+    const position = (sorted.length - 1) * Math.min(1, Math.max(0, q));
+    const lower = Math.floor(position);
+    const upper = Math.ceil(position);
+    return Math.round(sorted[lower] + (sorted[upper] - sorted[lower]) * (position - lower));
+}
+function intervalMs(start, end) {
+    if (!start || !end)
+        return null;
+    const ms = Date.parse(end) - Date.parse(start);
+    return Number.isFinite(ms) && ms >= 0 ? ms : null;
+}
+function stats(durations, pending, unknown) {
+    const sorted = [...durations].sort((a, b) => a - b);
+    return { measured: sorted.length, pending, unknown, medianMs: quantile(sorted, 0.5), p90Ms: quantile(sorted, 0.9) };
+}
+/** Pure, null-safe aggregation of delivery rows into decision/merge timings. */
+function aggregateDecisionTimes(rows) {
+    const decision = [];
+    const merge = [];
+    let decisionPending = 0, decisionUnknown = 0, mergePending = 0, mergeUnknown = 0;
+    let deliveries = 0;
+    for (const row of rows) {
+        // `decided_at` alone does not prove a review: acknowledging no-changes or
+        // discarding a failed preparation is a decision on a never-reviewable row.
+        const reviewed = row.on_review_at != null || row.merged_at != null || PAST_REVIEW.has(row.decision);
+        if (!reviewed)
+            continue;
+        deliveries++;
+        const toDecision = intervalMs(row.on_review_at, row.decided_at);
+        if (toDecision != null)
+            decision.push(toDecision);
+        else if (row.on_review_at && !row.decided_at && AWAITING_DECISION.has(row.decision))
+            decisionPending++;
+        else
+            decisionUnknown++;
+        const toMerge = intervalMs(row.on_review_at, row.merged_at);
+        if (toMerge != null)
+            merge.push(toMerge);
+        else if (row.merged_at || row.decision === 'merged')
+            mergeUnknown++;
+        else if (AWAITING_MERGE.has(row.decision)) {
+            if (row.on_review_at)
+                mergePending++;
+            else
+                mergeUnknown++;
+        }
+        // discarded / completed / superseded never merge: neither pending nor unknown.
+    }
+    return {
+        deliveries,
+        toDecision: stats(decision, decisionPending, decisionUnknown),
+        toMerge: stats(merge, mergePending, mergeUnknown),
+    };
+}
+/** Per-project and per-loop decision timings for deliveries reviewed in the window. */
+function getDecisionTimes(db, filters, now = new Date()) {
+    const range = (0, spending_1.resolveRange)(filters, now);
+    const rows = db.prepare(`
+    SELECT loop_id, loop_name, decision, on_review_at, decided_at, merged_at
+      FROM rail_pr_deliveries
+     WHERE parent_delivery_id IS NULL
+       AND julianday(COALESCE(on_review_at, created_at)) >= julianday(?)
+       AND julianday(COALESCE(on_review_at, created_at)) <= julianday(?)
+     ORDER BY created_at
+  `).all(range.from, range.to);
+    const loops = new Map();
+    for (const row of rows) {
+        const key = row.loop_id ?? `name:${row.loop_name}`;
+        const group = loops.get(key) ?? { loopId: row.loop_id, loopName: row.loop_name, rows: [] };
+        if (row.loop_name)
+            group.loopName = row.loop_name;
+        group.rows.push(row);
+        loops.set(key, group);
+    }
+    const byLoop = [...loops.values()]
+        .map(({ loopId, loopName, rows: loopRows }) => ({ loopId, loopName, ...aggregateDecisionTimes(loopRows) }))
+        .filter((group) => group.deliveries > 0)
+        .sort((a, b) => b.deliveries - a.deliveries || a.loopName.localeCompare(b.loopName));
+    return {
+        period: filters.period ?? '30d',
+        from: range.from,
+        to: range.to,
+        project: aggregateDecisionTimes(rows),
+        byLoop,
+    };
+}

package/server/dist/modules/accounting/runtime/loop-economics.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requirementsFromSettleEvidence = requirementsFromSettleEvidence;
+exports.isDelivered = isDelivered;
+exports.summarizeInvocationCost = summarizeInvocationCost;
+exports.countLoopRounds = countLoopRounds;
+exports.aggregateLoopEconomics = aggregateLoopEconomics;
+exports.getLoopEconomics = getLoopEconomics;
+exports.listRecentDeliveries = listRecentDeliveries;
+const decision_times_1 = require("./decision-times");
+const spending_1 = require("./spending");
+// ─── Pure helpers ────────────────────────────────────────────────────────────
+/** Decisions that prove the delivery reached review. */
+const PAST_REVIEW = new Set(['on_review', 'pr_draft', 'pr_ready', 'pr_closed', 'merged', 'superseded']);
+const SUCCEEDED = new Set(['succeeded', 'partially_succeeded']);
+const REVIEW_NODES = new Set(['reviewer', 'review']);
+const FIXER_NODES = new Set(['fixer', 'fix']);
+const round6 = (value) => Math.round(value * 1e6) / 1e6;
+/**
+ * Requirements demonstrated by one delivery, summed over its units' spec
+ * traces (Core `specTrace: 1`). Null when the evidence carries no trace —
+ * unknown, never zero. Tolerant of malformed JSON.
+ */
+function requirementsFromSettleEvidence(raw) {
+    if (!raw || !raw.includes('"specTrace"'))
+        return null;
+    try {
+        const evidence = JSON.parse(raw);
+        let demonstrated = 0, total = 0, traced = 0;
+        for (const unit of Array.isArray(evidence.units) ? evidence.units : []) {
+            const trace = unit?.specTrace;
+            if (!trace || !Array.isArray(trace.demonstrated))
+                continue;
+            traced++;
+            demonstrated += trace.demonstrated.length;
+            total += typeof trace.requirements === 'number' && Number.isSafeInteger(trace.requirements) && trace.requirements >= 0 ? Math.max(trace.requirements, trace.demonstrated.length) : trace.demonstrated.length;
+        }
+        return traced ? { demonstrated, total } : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** A delivery counts as delivered once it reached `on_review` or beyond. */
+function isDelivered(row) {
+    if (row.on_review_at || row.merged_at || PAST_REVIEW.has(row.decision))
+        return true;
+    // Legacy rows (pre-migration 72) carry no instants: a discarded delivery
+    // whose implementation succeeded was reviewable when it was discarded.
+    return row.decision === 'discarded' && SUCCEEDED.has(row.implementation_outcome ?? '');
+}
+/** Sum invocation rows keeping unknown (null) cost distinguishable from $0. */
+function summarizeInvocationCost(rows) {
+    let authoritative = 0, estimated = 0, priced = 0, unpriced = 0;
+    for (const row of rows) {
+        if (row.total_cost_usd == null || !Number.isFinite(row.total_cost_usd)) {
+            unpriced++;
+            continue;
+        }
+        priced++;
+        if (row.total_cost_usd_estimated === 1)
+            estimated += row.total_cost_usd;
+        else
+            authoritative += row.total_cost_usd;
+    }
+    return {
+        invocations: rows.length,
+        pricedInvocations: priced,
+        unpricedInvocations: unpriced,
+        costUsd: priced ? round6(authoritative + estimated) : null,
+        authoritativeUsd: priced ? round6(authoritative) : null,
+        estimatedUsd: priced ? round6(estimated) : null,
+    };
+}
+/**
+ * Count review / fixer rounds from `loop_step` rows. Automatic stall retries
+ * (`attempt >= 2`) re-run the same step and are not new rounds. Returns null
+ * when there are no step rows at all (unknown, not zero).
+ */
+function countLoopRounds(steps) {
+    if (steps.length === 0)
+        return null;
+    let review = 0, fixer = 0;
+    for (const step of steps) {
+        if (step.attempt != null && step.attempt >= 2)
+            continue;
+        const node = String(step.node_id ?? '').toLowerCase();
+        if (REVIEW_NODES.has(node))
+            review++;
+        else if (FIXER_NODES.has(node))
+            fixer++;
+    }
+    return { review, fixer };
+}
+function emptyGroup(tracked) {
+    return {
+        hasData: false,
+        delivered: 0, merged: 0, discarded: 0, superseded: 0, onReview: 0,
+        discardRate: null,
+        cost: { pricedDeliveries: 0, unpricedDeliveries: 0, incompleteDeliveries: 0, totalUsd: null, authoritativeUsd: null, estimatedUsd: null, avgCostUsd: null, estimatedShare: null },
+        decisionTimes: (0, decision_times_1.aggregateDecisionTimes)([]),
+        rounds: { measuredDeliveries: 0, reviewRounds: 0, fixerRounds: 0, reviewPerDelivery: null, fixerPerDelivery: null },
+        escapedDefects: tracked ? 0 : null,
+        requirementsDemonstrated: null,
+        triageAccuracy: null,
+    };
+}
+/**
+ * Aggregate already-joined deliveries of one group. Only delivered rows count;
+ * `regressionTracked` is false while no ticket in the project uses
+ * `regressionOf`, which keeps escaped defects null instead of a fake zero.
+ */
+function aggregateLoopEconomics(deliveries, regressionTracked) {
+    const delivered = deliveries.filter((d) => isDelivered(d.row));
+    const group = emptyGroup(regressionTracked);
+    if (delivered.length === 0)
+        return group;
+    let total = 0, authoritative = 0, estimated = 0;
+    for (const d of delivered) {
+        group.delivered++;
+        if (d.row.decision === 'merged' || d.row.merged_at)
+            group.merged++;
+        else if (d.row.decision === 'discarded')
+            group.discarded++;
+        else if (d.row.decision === 'superseded')
+            group.superseded++;
+        else if (d.row.decision === 'on_review')
+            group.onReview++;
+        if (d.cost.costUsd == null)
+            group.cost.unpricedDeliveries++;
+        else {
+            group.cost.pricedDeliveries++;
+            if (d.cost.unpricedInvocations > 0)
+                group.cost.incompleteDeliveries++;
+            total += d.cost.costUsd;
+            authoritative += d.cost.authoritativeUsd ?? 0;
+            estimated += d.cost.estimatedUsd ?? 0;
+        }
+        if (d.rounds) {
+            group.rounds.measuredDeliveries++;
+            group.rounds.reviewRounds += d.rounds.review;
+            group.rounds.fixerRounds += d.rounds.fixer;
+        }
+        if (regressionTracked)
+            group.escapedDefects = (group.escapedDefects ?? 0) + d.escapedDefects;
+        if (d.requirements) {
+            const current = group.requirementsDemonstrated ?? { demonstrated: 0, total: 0, deliveries: 0 };
+            group.requirementsDemonstrated = { demonstrated: current.demonstrated + d.requirements.demonstrated, total: current.total + d.requirements.total, deliveries: current.deliveries + 1 };
+        }
+    }
+    group.hasData = true;
+    group.discardRate = round6(group.discarded / group.delivered);
+    if (group.cost.pricedDeliveries > 0) {
+        group.cost.totalUsd = round6(total);
+        group.cost.authoritativeUsd = round6(authoritative);
+        group.cost.estimatedUsd = round6(estimated);
+        group.cost.avgCostUsd = round6(total / group.cost.pricedDeliveries);
+        group.cost.estimatedShare = total > 0 ? round6(estimated / total) : null;
+    }
+    if (group.rounds.measuredDeliveries > 0) {
+        group.rounds.reviewPerDelivery = round6(group.rounds.reviewRounds / group.rounds.measuredDeliveries);
+        group.rounds.fixerPerDelivery = round6(group.rounds.fixerRounds / group.rounds.measuredDeliveries);
+    }
+    group.decisionTimes = (0, decision_times_1.aggregateDecisionTimes)(delivered.map((d) => d.row));
+    return group;
+}
+// ─── Effectful queries ───────────────────────────────────────────────────────
+function parseRunIds(text) {
+    try {
+        const value = JSON.parse(text ?? '[]');
+        return Array.isArray(value) ? [...new Set(value.filter((id) => typeof id === 'string' && id.length > 0))] : [];
+    }
+    catch {
+        return [];
+    }
+}
+function escapeLikePattern(value) {
+    return value.replace(/[\\%_]/g, (ch) => `\\${ch}`);
+}
+/** Same attribution rule as `sumInvocationCostForRuns`, keeping unpriced rows. */
+function invocationsForRuns(db, runIds) {
+    if (runIds.length === 0)
+        return [];
+    const placeholders = runIds.map(() => '?').join(', ');
+    const merge = runIds.map(() => `surface_ref_id LIKE ? ESCAPE '\\'`).join(' OR ');
+    return db.prepare(`SELECT total_cost_usd, total_cost_usd_estimated FROM ai_invocations
+      WHERE loop_run_id IN (${placeholders}) OR surface_ref_id IN (${placeholders}) OR ${merge}`).all(...runIds, ...runIds, ...runIds.map((id) => `${escapeLikePattern(id)}:merge:%`));
+}
+function stepsForRuns(db, runIds) {
+    if (runIds.length === 0)
+        return [];
+    const placeholders = runIds.map(() => '?').join(', ');
+    return db.prepare(`SELECT CASE WHEN json_valid(payload) THEN json_extract(payload, '$.nodeId') END AS node_id,
+            CASE WHEN json_valid(payload) THEN json_extract(payload, '$.attempt') END AS attempt
+       FROM events
+      WHERE event_type = 'loop_step' AND job_id IN (${placeholders})`).all(...runIds);
+}
+/** Per-project and per-loop economics for deliveries reviewed in the window. */
+function getLoopEconomics(db, filters, options = {}) {
+    const range = (0, spending_1.resolveRange)(filters, options.now ?? new Date());
+    const rows = db.prepare(`
+    SELECT id, loop_id, loop_name, decision, on_review_at, decided_at, merged_at, run_ids, implementation_outcome, settle_evidence
+      FROM rail_pr_deliveries
+     WHERE parent_delivery_id IS NULL
+       AND julianday(COALESCE(on_review_at, created_at)) >= julianday(?)
+       AND julianday(COALESCE(on_review_at, created_at)) <= julianday(?)
+     ORDER BY created_at
+  `).all(range.from, range.to);
+    const links = options.regressionLinks ?? [];
+    const tracked = links.length > 0;
+    // Links may name a repository child; count them through the parent.
+    const parentOf = new Map();
+    if (tracked) {
+        for (const child of db.prepare('SELECT id, parent_delivery_id FROM rail_pr_deliveries WHERE parent_delivery_id IS NOT NULL').all()) {
+            parentOf.set(child.id, child.parent_delivery_id);
+        }
+    }
+    const defects = new Map();
+    for (const link of links) {
+        const id = parentOf.get(link.deliveryId) ?? link.deliveryId;
+        defects.set(id, (defects.get(id) ?? 0) + 1);
+    }
+    const joined = rows.map((row) => {
+        if (!isDelivered(row))
+            return { row, cost: summarizeInvocationCost([]), rounds: null, escapedDefects: 0 };
+        const runIds = parseRunIds(row.run_ids);
+        return {
+            row,
+            cost: summarizeInvocationCost(invocationsForRuns(db, runIds)),
+            rounds: countLoopRounds(stepsForRuns(db, runIds)),
+            escapedDefects: defects.get(row.id) ?? 0,
+            requirements: requirementsFromSettleEvidence(row.settle_evidence),
+        };
+    });
+    const loops = new Map();
+    for (const item of joined) {
+        const key = item.row.loop_id ?? `name:${item.row.loop_name}`;
+        const group = loops.get(key) ?? { loopId: item.row.loop_id, loopName: item.row.loop_name, items: [] };
+        if (item.row.loop_name)
+            group.loopName = item.row.loop_name;
+        group.items.push(item);
+        loops.set(key, group);
+    }
+    for (const loop of options.knownLoops ?? []) {
+        if (!loops.has(loop.id))
+            loops.set(loop.id, { loopId: loop.id, loopName: loop.name, items: [] });
+    }
+    const byLoop = [...loops.values()]
+        .map(({ loopId, loopName, items }) => ({ loopId, loopName, ...aggregateLoopEconomics(items, tracked) }))
+        .sort((a, b) => Number(b.hasData) - Number(a.hasData) || b.delivered - a.delivered || a.loopName.localeCompare(b.loopName));
+    return {
+        period: filters.period ?? '30d',
+        from: range.from,
+        to: range.to,
+        sources: {
+            escapedDefects: tracked ? 'tracked' : 'untracked',
+            requirementsDemonstrated: joined.some((item) => item.requirements) ? 'measured' : 'unavailable',
+            triageAccuracy: 'unavailable',
+        },
+        project: aggregateLoopEconomics(joined, tracked),
+        byLoop,
+    };
+}
+/** Recent delivered parent deliveries — the `regressionOf` picker source. */
+function listRecentDeliveries(db, limit = 50) {
+    const capped = Math.min(200, Math.max(1, Math.trunc(limit) || 50));
+    const rows = db.prepare(`
+    SELECT id, loop_id, loop_name, decision, on_review_at, merged_at, implementation_outcome, ticket_ids, created_at
+      FROM rail_pr_deliveries
+     WHERE parent_delivery_id IS NULL
+     ORDER BY COALESCE(on_review_at, created_at) DESC
+     LIMIT ?
+  `).all(capped * 4);
+    return rows.filter(isDelivered).slice(0, capped).map((row) => {
+        let ticketIds = [];
+        try {
+            const parsed = JSON.parse(row.ticket_ids);
+            if (Array.isArray(parsed))
+                ticketIds = parsed.filter((n) => Number.isInteger(n));
+        }
+        catch { /* malformed legacy value: no tickets */ }
+        return { id: row.id, loopId: row.loop_id, loopName: row.loop_name, decision: row.decision, ticketIds, createdAt: row.created_at };
+    });
+}

package/server/dist/modules/accounting/runtime/spending.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRange = resolveRange;
 exports.getSpending = getSpending;
 exports.summariseExplorePrompt = summariseExplorePrompt;
 exports.getInvocations = getInvocations;
@@ -14,7 +15,7 @@ exports.getAgentMissionSpending = getAgentMissionSpending;
 // the headline regardless.
 const ALL_SURFACES = [
     'job', 'quick-spec', 'explore-spec', 'ai-edit', 'smash', 'file-summary', 'loop',
-    'chat-sidebar', 'spec-launcher', 'proposal', 'agent-studio', 'setup',
+    'chat-sidebar', 'spec-launcher', 'proposal', 'agent-studio', 'setup', 'flow', 'triage',
 ];
 /** Fresh zeroed per-surface bucket covering every Surface, so aggregation
  *  writes (`bySurface[r.surface]`) can never index an undefined key. */
@@ -737,7 +738,9 @@ function getAgentMissionSpending(desktopDb, projectId, filters) {
       COALESCE(SUM(CASE WHEN total_cost_usd_estimated = 1 THEN total_cost_usd ELSE 0 END), 0) AS estimated,
       COUNT(*) AS turns,
       COALESCE(SUM(tokens_in), 0) AS tokensIn,
-      COALESCE(SUM(tokens_out), 0) AS tokensOut
+      COALESCE(SUM(tokens_out), 0) AS tokensOut,
+      COALESCE(SUM(CASE WHEN surface = 'flow' THEN total_cost_usd ELSE 0 END), 0) AS flowTotal,
+      COALESCE(SUM(CASE WHEN surface = 'flow' THEN 1 ELSE 0 END), 0) AS flowTurns
     FROM agent_invocations
     WHERE project_id = ? AND started_at >= ? AND started_at <= ?
   `).get(projectId, range.from, range.to);
@@ -769,6 +772,8 @@ function getAgentMissionSpending(desktopDb, projectId, filters) {
             turns: summaryRow.turns,
             tokensIn: summaryRow.tokensIn,
             tokensOut: summaryRow.tokensOut,
+            flowCostUsd: summaryRow.flowTotal,
+            flowTurns: summaryRow.flowTurns,
         },
         topConversations,
     };

package/server/dist/modules/accounting/runtime/what-if.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WHAT_IF_MAX_DAYS = exports.WHAT_IF_DEFAULT_DAYS = void 0;
+exports.listPricedModels = listPricedModels;
+exports.hasPricing = hasPricing;
+exports.clampDays = clampDays;
+exports.computeWhatIf = computeWhatIf;
+const pricing_1 = require("./pricing");
+exports.WHAT_IF_DEFAULT_DAYS = 30;
+exports.WHAT_IF_MAX_DAYS = 365;
+/** Round once, at the end: summing per-invocation cents would zero out many small calls. */
+const toUsd = (usd) => Math.round(usd * 100) / 100;
+function listPricedModels() {
+    return Object.keys(pricing_1.PRICING).map((key) => {
+        const at = key.indexOf(':');
+        return { provider: key.slice(0, at), model: key.slice(at + 1) };
+    });
+}
+function hasPricing(ref) {
+    return (0, pricing_1.resolvePriceEntry)(ref.provider, ref.model) !== undefined;
+}
+const SELECT = `SELECT COALESCE(provider, 'claude') AS provider, model, tokens_in, tokens_out, tokens_cache_read, tokens_cache_create, total_cost_usd
+  FROM ai_invocations WHERE project_id = ? AND started_at >= ? AND model IS NOT NULL AND model != ''`;
+function clampDays(raw) {
+    const value = typeof raw === 'string' ? parseInt(raw, 10) : typeof raw === 'number' ? Math.trunc(raw) : NaN;
+    return Number.isFinite(value) && value >= 1 ? Math.min(value, exports.WHAT_IF_MAX_DAYS) : exports.WHAT_IF_DEFAULT_DAYS;
+}
+function computeWhatIf(db, projectId, days, pair, now = new Date()) {
+    const since = new Date(now.getTime() - days * 86_400_000).toISOString();
+    const rows = db.prepare(SELECT).all(projectId, since);
+    const buckets = new Map();
+    for (const row of rows) {
+        const key = `${row.provider}:${row.model}`;
+        const bucket = buckets.get(key) ?? { provider: row.provider, model: row.model, invocations: 0, recordedUsd: null, priced: hasPricing({ provider: row.provider, model: row.model }), cost: 0, anyCost: false };
+        bucket.invocations++;
+        if (row.total_cost_usd != null) {
+            bucket.cost += row.total_cost_usd;
+            bucket.anyCost = true;
+        }
+        buckets.set(key, bucket);
+    }
+    const sources = [...buckets.values()]
+        .map(({ cost, anyCost, ...rest }) => ({ ...rest, recordedUsd: anyCost ? toUsd(cost) : null }))
+        .sort((a, b) => (b.recordedUsd ?? 0) - (a.recordedUsd ?? 0) || b.invocations - a.invocations);
+    let result = null;
+    if (pair) {
+        const { from, to } = pair;
+        const mine = rows.filter((row) => row.provider === from.provider && row.model === from.model);
+        const tokens = { in: 0, out: 0, cacheRead: 0, cacheCreate: 0 };
+        let current = 0, whatIf = 0, repriced = 0, recorded = 0, anyRecorded = false;
+        for (const row of mine) {
+            if (row.total_cost_usd != null) {
+                recorded += row.total_cost_usd;
+                anyRecorded = true;
+            }
+            const usage = { tokens_in: row.tokens_in ?? 0, tokens_out: row.tokens_out ?? 0, tokens_cache_read: row.tokens_cache_read ?? 0, tokens_cache_create: row.tokens_cache_create ?? 0 };
+            tokens.in += usage.tokens_in;
+            tokens.out += usage.tokens_out;
+            tokens.cacheRead += usage.tokens_cache_read;
+            tokens.cacheCreate += usage.tokens_cache_create;
+            // Per invocation: a long-context tier depends on THAT request's prompt size.
+            const was = (0, pricing_1.estimateCostUsd)(from.provider, from.model, usage);
+            const would = (0, pricing_1.estimateCostUsd)(to.provider, to.model, usage);
+            if (was === null || would === null)
+                continue;
+            current += was;
+            whatIf += would;
+            repriced++;
+        }
+        const fromPriced = hasPricing(from);
+        const toPriced = hasPricing(to);
+        const noPricing = !toPriced ? { side: 'to', ...to } : !fromPriced ? { side: 'from', ...from } : null;
+        result = {
+            from, to, days,
+            invocations: mine.length,
+            repriced,
+            skipped: mine.length - repriced,
+            tokens,
+            recordedUsd: anyRecorded ? toUsd(recorded) : null,
+            estimateCurrentUsd: noPricing ? null : toUsd(current),
+            estimateWhatIfUsd: noPricing ? null : toUsd(whatIf),
+            deltaUsd: noPricing ? null : toUsd(whatIf - current),
+            noPricing,
+        };
+    }
+    return { days, sources, targets: listPricedModels(), result };
+}