specrails-desktop 2.64.1 → 2.65.0

package/server/dist/modules/specs/domain/handoff.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeCost = summarizeCost;
+exports.redactModel = redactModel;
+exports.renderHandoffMarkdown = renderHandoffMarkdown;
+exports.escapeHtml = escapeHtml;
+exports.renderHandoffHtml = renderHandoffHtml;
+// ─── Cost ────────────────────────────────────────────────────────────────────
+function summarizeCost(rows, planProviders) {
+    const by = new Map();
+    for (const row of rows) {
+        const provider = row.provider ?? 'unknown';
+        let entry = by.get(provider);
+        if (!entry) {
+            entry = { provider, runs: 0, mode: planProviders.has(provider) ? 'turns' : 'dollars', billedUsd: null, estimatedUsd: null, unpricedRuns: 0, turns: null };
+            by.set(provider, entry);
+        }
+        entry.runs += 1;
+        if (row.turns !== null)
+            entry.turns = (entry.turns ?? 0) + row.turns;
+        if (entry.mode === 'turns')
+            continue;
+        if (row.costUsd === null) {
+            entry.unpricedRuns += 1;
+            continue;
+        }
+        if (row.estimated)
+            entry.estimatedUsd = (entry.estimatedUsd ?? 0) + row.costUsd;
+        else
+            entry.billedUsd = (entry.billedUsd ?? 0) + row.costUsd;
+    }
+    return [...by.values()].sort((a, b) => (a.provider < b.provider ? -1 : 1));
+}
+/** Redact every string of the model. Returns the clean model and how many strings changed. */
+function redactModel(model, redact) {
+    let redactions = 0;
+    const walk = (value) => {
+        if (typeof value === 'string') {
+            const next = redact(value);
+            if (next !== value)
+                redactions += 1;
+            return next;
+        }
+        if (Array.isArray(value))
+            return value.map(walk);
+        if (value && typeof value === 'object') {
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, walk(v)]));
+        }
+        return value;
+    };
+    return { model: walk(model), redactions };
+}
+// ─── Rendering helpers ───────────────────────────────────────────────────────
+function usd(value) {
+    return `$${value.toFixed(value >= 1 ? 2 : 4)}`;
+}
+function day(iso) {
+    return iso.slice(0, 10);
+}
+function verdictLabel(l, verdict) {
+    return verdict === 'approved' ? l.verdictApproved : verdict === 'changes_requested' ? l.verdictChangesRequested : verdict === 'failed' ? l.verdictFailed : l.verdictRecorded;
+}
+function decisionLabel(l, kind) {
+    switch (kind) {
+        case 'change-request': return l.decisionAddendum;
+        case 'clarification': return l.decisionClarification;
+        case 'constraint': return l.decisionConstraint;
+        case 'review-feedback': return l.decisionReview;
+        default: return l.decisionVerdict;
+    }
+}
+function costLines(l, cost) {
+    const lines = [];
+    for (const c of cost) {
+        if (c.mode === 'turns') {
+            lines.push(`${c.provider}: ${c.turns ?? 0} ${l.turns} · ${c.runs} ${l.runs} (${l.planNote})`);
+            continue;
+        }
+        const parts = [];
+        if (c.billedUsd !== null)
+            parts.push(`${l.billed}: ${usd(c.billedUsd)}`);
+        if (c.estimatedUsd !== null)
+            parts.push(`${l.estimated}: ~${usd(c.estimatedUsd)}`);
+        if (c.unpricedRuns > 0)
+            parts.push(`${c.unpricedRuns} ${l.unpricedNote}`);
+        if (c.turns !== null)
+            parts.push(`${c.turns} ${l.turns}`);
+        lines.push(`${c.provider} (${c.runs} ${l.runs}): ${parts.join(' · ') || '—'}`);
+    }
+    return lines;
+}
+function diffLine(l, d) {
+    if (!d.diff.available)
+        return l.diffUnavailable;
+    return `${d.diff.files} ${l.files} · +${d.diff.additions} / −${d.diff.deletions}`;
+}
+function deliveryHead(l, d) {
+    const bits = [d.loop || d.id];
+    if (d.prNumber)
+        bits.push(`${l.pr} #${d.prNumber}`);
+    if (d.branch)
+        bits.push(`${l.branch} \`${d.branch}\``);
+    return bits.join(' · ');
+}
+function fence(text) {
+    return text.replace(/\r\n/g, '\n').trim();
+}
+function renderHandoffMarkdown(model, l, variant) {
+    const { spec } = model;
+    const out = [];
+    if (variant === 'full') {
+        out.push(`# ${l.document}: #${spec.id} ${spec.title}`, '');
+        const meta = [`${l.status}: ${spec.status}`];
+        if (spec.priority)
+            meta.push(`${l.priority}: ${spec.priority}`);
+        if (spec.jiraKey)
+            meta.push(spec.jiraKey);
+        if (spec.labels.length > 0)
+            meta.push(`${l.labels}: ${spec.labels.join(', ')}`);
+        out.push(meta.join(' · '), '');
+    }
+    out.push(`## ${l.summary}`, '');
+    out.push(spec.summary ? fence(spec.summary) : fence(spec.description).split('\n').slice(0, variant === 'pr' ? 6 : 12).join('\n'), '');
+    if (variant === 'full') {
+        out.push(`## ${l.request}`, '', fence(spec.description) || '—', '');
+        if (spec.nonGoals)
+            out.push(`**${l.outOfScope}**`, '', fence(spec.nonGoals), '');
+    }
+    out.push(`## ${l.changes}`, '');
+    if (model.deliveries.length === 0)
+        out.push(l.noChanges, '');
+    for (const d of model.deliveries.slice(0, variant === 'pr' ? 3 : 20)) {
+        out.push(`- **${deliveryHead(l, d)}** — ${diffLine(l, d)}${d.prUrl ? ` — ${d.prUrl}` : ''}`);
+        if (variant === 'full' && d.diff.available) {
+            for (const f of d.diff.top)
+                out.push(`  - \`${f.path}\` (${f.status}${f.additions !== null ? `, +${f.additions}/−${f.deletions ?? 0}` : ''})`);
+        }
+    }
+    if (model.deliveries.length > 0)
+        out.push('');
+    const decisions = variant === 'pr' ? model.decisions.slice(0, 5) : model.decisions;
+    out.push(`## ${l.decisions}`, '');
+    if (decisions.length === 0)
+        out.push(l.noDecisions, '');
+    for (const d of decisions) {
+        const head = `- **${decisionLabel(l, d.kind)}** (${day(d.at)}): ${d.title}`;
+        out.push(head);
+        if (variant === 'full' && d.body)
+            for (const line of fence(d.body).split('\n').slice(0, 8))
+                out.push(`  > ${line}`);
+    }
+    if (decisions.length > 0)
+        out.push('');
+    const review = model.deliveries.find((d) => d.review)?.review ?? null;
+    out.push(`## ${l.verification}`, '');
+    out.push(review ? `${verdictLabel(l, review.verdict)}${review.findings > 0 ? ` · ${review.findings}` : ''}` : l.noReview, '');
+    out.push(`## ${l.cost}`, '');
+    const costs = costLines(l, model.cost);
+    if (costs.length === 0)
+        out.push(l.noCost);
+    for (const line of costs)
+        out.push(`- ${line}`);
+    out.push('');
+    out.push(`## ${l.followUps}`, '');
+    const { openAddenda, unresolvedFindings } = model.followUps;
+    if (openAddenda.length === 0 && unresolvedFindings.length === 0)
+        out.push(l.noFollowUps);
+    if (openAddenda.length > 0) {
+        out.push(`**${l.openAddenda}**`);
+        for (const a of openAddenda)
+            out.push(`- [ ] ${a.title} (${a.kind}, ${a.status})`);
+    }
+    if (unresolvedFindings.length > 0) {
+        out.push(`**${l.unresolvedFindings}**`);
+        for (const f of unresolvedFindings.slice(0, variant === 'pr' ? 8 : 40))
+            out.push(`- [ ] ${f.text}${f.location ? ` (\`${f.location}\`)` : ''}`);
+    }
+    out.push('', '---', `${l.attribution} · ${l.generated} ${day(model.generatedAt)}`, '');
+    return out.join('\n');
+}
+// ─── HTML ────────────────────────────────────────────────────────────────────
+function escapeHtml(text) {
+    return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+}
+const HTML_STYLE = `
+:root{color-scheme:light dark;--bg:#fff;--fg:#1c1d21;--muted:#5d6068;--line:#dcdde2;--card:#f6f6f8;--ok:#1f7a3d;--warn:#9a5b00}
+@media (prefers-color-scheme:dark){:root{--bg:#16171a;--fg:#ececef;--muted:#a0a3ab;--line:#2d2f35;--card:#1d1e22;--ok:#58c07a;--warn:#e0a24a}}
+body{margin:0;background:var(--bg);color:var(--fg);font:15px/1.55 system-ui,-apple-system,"Segoe UI",sans-serif}
+main{max-width:46rem;margin:0 auto;padding:2rem 1.25rem 4rem}
+h1{font-size:1.5rem;line-height:1.25;margin:0 0 .5rem}h2{font-size:1.05rem;margin:2rem 0 .6rem;padding-top:1rem;border-top:1px solid var(--line)}
+.meta{color:var(--muted);font-size:.85rem}pre.spec{white-space:pre-wrap;background:var(--card);border:1px solid var(--line);border-radius:8px;padding:.75rem 1rem;font:inherit}
+ul{padding-left:1.2rem}li{margin:.25rem 0}blockquote{margin:.25rem 0 .5rem;padding-left:.75rem;border-left:3px solid var(--line);color:var(--muted)}
+code{background:var(--card);padding:.05rem .3rem;border-radius:4px;font-size:.85em}.ok{color:var(--ok)}.warn{color:var(--warn)}footer{margin-top:3rem;color:var(--muted);font-size:.8rem}
+@media print{body{font-size:12px}}
+`.replace(/\n/g, '');
+function renderHandoffHtml(model, l, locale) {
+    const e = escapeHtml;
+    const { spec } = model;
+    const body = [];
+    body.push(`<h1>${e(l.document)}: #${spec.id} ${e(spec.title)}</h1>`);
+    const meta = [`${e(l.status)}: ${e(spec.status)}`];
+    if (spec.priority)
+        meta.push(`${e(l.priority)}: ${e(spec.priority)}`);
+    if (spec.jiraKey)
+        meta.push(e(spec.jiraKey));
+    if (spec.labels.length > 0)
+        meta.push(`${e(l.labels)}: ${e(spec.labels.join(', '))}`);
+    body.push(`<p class="meta">${meta.join(' · ')}</p>`);
+    if (spec.summary)
+        body.push(`<h2>${e(l.summary)}</h2><p>${e(spec.summary)}</p>`);
+    body.push(`<h2>${e(l.request)}</h2><pre class="spec">${e(fence(spec.description) || '—')}</pre>`);
+    if (spec.nonGoals)
+        body.push(`<p><strong>${e(l.outOfScope)}</strong></p><pre class="spec">${e(fence(spec.nonGoals))}</pre>`);
+    body.push(`<h2>${e(l.changes)}</h2>`);
+    if (model.deliveries.length === 0)
+        body.push(`<p>${e(l.noChanges)}</p>`);
+    else {
+        body.push('<ul>');
+        for (const d of model.deliveries) {
+            const link = d.prUrl && /^https?:\/\//i.test(d.prUrl) ? ` — <a href="${e(d.prUrl)}" rel="noopener noreferrer">${e(d.prUrl)}</a>` : '';
+            body.push(`<li><strong>${e(deliveryHead(l, d).replace(/`/g, ''))}</strong> — ${e(diffLine(l, d))}${link}`);
+            if (d.diff.available && d.diff.top.length > 0) {
+                body.push('<ul>');
+                for (const f of d.diff.top)
+                    body.push(`<li><code>${e(f.path)}</code> (${e(f.status)}${f.additions !== null ? `, +${f.additions}/−${f.deletions ?? 0}` : ''})</li>`);
+                body.push('</ul>');
+            }
+            body.push('</li>');
+        }
+        body.push('</ul>');
+    }
+    body.push(`<h2>${e(l.decisions)}</h2>`);
+    if (model.decisions.length === 0)
+        body.push(`<p>${e(l.noDecisions)}</p>`);
+    else {
+        body.push('<ul>');
+        for (const d of model.decisions) {
+            body.push(`<li><strong>${e(decisionLabel(l, d.kind))}</strong> (${e(day(d.at))}): ${e(d.title)}${d.body ? `<blockquote>${e(fence(d.body).split('\n').slice(0, 8).join('\n')).replace(/\n/g, '<br>')}</blockquote>` : ''}</li>`);
+        }
+        body.push('</ul>');
+    }
+    const review = model.deliveries.find((d) => d.review)?.review ?? null;
+    body.push(`<h2>${e(l.verification)}</h2><p>${review ? `<span class="${review.verdict === 'approved' ? 'ok' : 'warn'}">${e(verdictLabel(l, review.verdict))}</span>${review.findings > 0 ? ` · ${review.findings}` : ''}` : e(l.noReview)}</p>`);
+    body.push(`<h2>${e(l.cost)}</h2>`);
+    const costs = costLines(l, model.cost);
+    if (costs.length === 0)
+        body.push(`<p>${e(l.noCost)}</p>`);
+    else
+        body.push(`<ul>${costs.map((line) => `<li>${e(line)}</li>`).join('')}</ul>`);
+    body.push(`<h2>${e(l.followUps)}</h2>`);
+    const { openAddenda, unresolvedFindings } = model.followUps;
+    if (openAddenda.length === 0 && unresolvedFindings.length === 0)
+        body.push(`<p>${e(l.noFollowUps)}</p>`);
+    if (openAddenda.length > 0)
+        body.push(`<p><strong>${e(l.openAddenda)}</strong></p><ul>${openAddenda.map((a) => `<li>${e(a.title)} (${e(a.kind)}, ${e(a.status)})</li>`).join('')}</ul>`);
+    if (unresolvedFindings.length > 0)
+        body.push(`<p><strong>${e(l.unresolvedFindings)}</strong></p><ul>${unresolvedFindings.slice(0, 40).map((f) => `<li>${e(f.text)}${f.location ? ` (<code>${e(f.location)}</code>)` : ''}</li>`).join('')}</ul>`);
+    body.push(`<footer>${e(l.attribution)} · ${e(l.generated)} ${e(day(model.generatedAt))}</footer>`);
+    return `<!doctype html><html lang="${e(locale)}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><meta name="referrer" content="no-referrer"><title>${e(l.document)} #${spec.id} ${e(spec.title)}</title><style>${HTML_STYLE}</style></head><body><main>${body.join('')}</main></body></html>`;
+}

package/server/dist/modules/specs/domain/non-goals.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Ticket non-goals ("Out of scope", feedback-2026-10 task 3.2).
+ *
+ * Pure rules for the optional top-level ticket field `nonGoals: string[]`:
+ * validation and bounds, extraction of a generated spec's `## Out of Scope`
+ * section into the field, and the rendering every launch door appends to the
+ * description so agents keep seeing the non-goals once they live in their own
+ * field. Zero imports (the architecture test pins domain files to none).
+ *
+ * The field is Desktop-owned and additive: the ticket store stays at schema
+ * 1.5 because Core ignores unknown ticket fields. The Contract Layer is not
+ * involved: it reads and appends to `description` exactly as before.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NON_GOAL_MAX_CHARS = exports.NON_GOALS_MAX_ITEMS = void 0;
+exports.validateNonGoals = validateNonGoals;
+exports.normalizeNonGoals = normalizeNonGoals;
+exports.parseNonGoalsText = parseNonGoalsText;
+exports.extractOutOfScopeSection = extractOutOfScopeSection;
+exports.renderNonGoalsSection = renderNonGoalsSection;
+exports.descriptionWithNonGoals = descriptionWithNonGoals;
+exports.NON_GOALS_MAX_ITEMS = 20;
+exports.NON_GOAL_MAX_CHARS = 300;
+/** Matches the `## Out of Scope` heading (also `Non-Goals` / `Out-of-scope`). */
+const SECTION_HEADING = /^##\s*(?:out[\s-]+of[\s-]+scope|non[\s-]?goals)\s*$/i;
+/** One non-goal line without list markers, trimmed; null when empty. */
+function cleanItem(raw) {
+    const text = raw.replace(/^\s*(?:[-*+•]|\d+[.)])\s+/, '').replace(/\s+/g, ' ').trim();
+    return text ? text.slice(0, exports.NON_GOAL_MAX_CHARS) : null;
+}
+/**
+ * Validate a caller-supplied `nonGoals` value (HTTP, MCP). `null` clears the
+ * field (an empty list); strings are cleaned of list markers, blanks dropped,
+ * duplicates collapsed, each item and the list capped.
+ */
+function validateNonGoals(value) {
+    if (value === null)
+        return { ok: true, nonGoals: [] };
+    if (!Array.isArray(value) || !value.every((item) => typeof item === 'string')) {
+        return { ok: false, error: 'nonGoals must be an array of strings' };
+    }
+    return { ok: true, nonGoals: normalizeNonGoals(value) };
+}
+/** Tolerant normalization used on read: never throws, never invents. */
+function normalizeNonGoals(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const item of value) {
+        if (typeof item !== 'string')
+            continue;
+        const cleaned = cleanItem(item);
+        if (cleaned && !out.includes(cleaned))
+            out.push(cleaned);
+        if (out.length >= exports.NON_GOALS_MAX_ITEMS)
+            break;
+    }
+    return out;
+}
+/** Split free text (the modal's textarea) into non-goals, one per line. */
+function parseNonGoalsText(text) {
+    return normalizeNonGoals(text.replace(/\r\n?/g, '\n').split('\n'));
+}
+/**
+ * Pull the `## Out of Scope` section out of a markdown spec body. Returns the
+ * description without that section and its bullet lines as non-goals. A body
+ * without the section is returned unchanged with no non-goals. Only the first
+ * section is moved; the section ends at the next `#`/`##` heading.
+ */
+function extractOutOfScopeSection(markdown) {
+    const lines = markdown.replace(/\r\n?/g, '\n').split('\n');
+    const start = lines.findIndex((line) => SECTION_HEADING.test(line.trim()));
+    if (start < 0)
+        return { description: markdown, nonGoals: [] };
+    let end = start + 1;
+    while (end < lines.length && !/^#{1,2}\s/.test(lines[end]))
+        end++;
+    const nonGoals = normalizeNonGoals(lines.slice(start + 1, end).filter((line) => line.trim().length > 0));
+    const rest = [...lines.slice(0, start), ...lines.slice(end)].join('\n').replace(/\n{3,}/g, '\n\n').trim();
+    return { description: rest, nonGoals };
+}
+/** The `## Out of Scope` block rendered from non-goals ('' when none). */
+function renderNonGoalsSection(nonGoals) {
+    const items = normalizeNonGoals(nonGoals ?? []);
+    return items.length ? `## Out of Scope\n${items.map((item) => `- ${item}`).join('\n')}` : '';
+}
+/**
+ * The description an agent receives: the stored description plus the
+ * non-goals as an `## Out of Scope` section, unless the description already
+ * carries one (older specs, hand-written sections) — never duplicated.
+ */
+function descriptionWithNonGoals(description, nonGoals) {
+    const body = description ?? '';
+    const section = renderNonGoalsSection(nonGoals);
+    if (!section)
+        return body;
+    if (body.split('\n').some((line) => SECTION_HEADING.test(line.trim())))
+        return body;
+    return body.trim() ? `${body.trimEnd()}\n\n${section}` : section;
+}

package/server/dist/modules/specs/domain/timeline.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * Spec lifecycle timeline: pure vocabulary and rules.
+ *
+ * The timeline is a projection (no store of its own) over the spec, its
+ * addenda, the missions and runs that touched it, the agent actions audit,
+ * the PR deliveries and the reviewer's findings. This file owns the entry
+ * shape, ordering, kind filtering, cursor pagination and the cost folding
+ * rules. Reading the sources is the runtime adapter's job.
+ *
+ * Cost semantics (kept from the accounting module): a provider-reported cost
+ * is `billed`; a cost derived from the pricing table is `estimated`; a run the
+ * provider reported no cost for is simply absent, never zero. The two are
+ * never summed into one undifferentiated figure.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMELINE_MAX_ITEMS = exports.TIMELINE_MAX_LIMIT = exports.TIMELINE_DEFAULT_LIMIT = exports.TIMELINE_KINDS = void 0;
+exports.isTimelineKind = isTimelineKind;
+exports.compareTimelineEntries = compareTimelineEntries;
+exports.sortTimeline = sortTimeline;
+exports.parseKinds = parseKinds;
+exports.parseLimit = parseLimit;
+exports.encodeCursor = encodeCursor;
+exports.decodeCursor = decodeCursor;
+exports.emptyKindCounts = emptyKindCounts;
+exports.pageTimeline = pageTimeline;
+exports.foldCost = foldCost;
+exports.formatLocation = formatLocation;
+exports.utc = utc;
+exports.oneLine = oneLine;
+exports.TIMELINE_KINDS = ['spec_edit', 'addendum', 'mission_turn', 'job', 'phase', 'audit', 'pr_event', 'review'];
+function isTimelineKind(value) {
+    return typeof value === 'string' && exports.TIMELINE_KINDS.includes(value);
+}
+exports.TIMELINE_DEFAULT_LIMIT = 50;
+exports.TIMELINE_MAX_LIMIT = 200;
+exports.TIMELINE_MAX_ITEMS = 12;
+/** Newest first; ties broken by id so a cursor is stable. */
+function compareTimelineEntries(a, b) {
+    if (a.at !== b.at)
+        return a.at < b.at ? 1 : -1;
+    return a.id < b.id ? 1 : a.id > b.id ? -1 : 0;
+}
+function sortTimeline(entries) {
+    return [...entries].sort(compareTimelineEntries);
+}
+function parseKinds(raw) {
+    if (raw === undefined || raw === '')
+        return [];
+    if (typeof raw !== 'string')
+        return null;
+    const kinds = [];
+    for (const part of raw.split(',')) {
+        const value = part.trim();
+        if (!value)
+            continue;
+        if (!isTimelineKind(value))
+            return null;
+        if (!kinds.includes(value))
+            kinds.push(value);
+    }
+    return kinds;
+}
+function parseLimit(raw) {
+    if (raw === undefined || raw === '')
+        return exports.TIMELINE_DEFAULT_LIMIT;
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 1)
+        return null;
+    return Math.min(n, exports.TIMELINE_MAX_LIMIT);
+}
+/** Opaque cursor: the last delivered (at, id). Returns null for a malformed one. */
+function encodeCursor(entry) {
+    return Buffer.from(JSON.stringify([entry.at, entry.id]), 'utf8').toString('base64url');
+}
+function decodeCursor(raw) {
+    if (typeof raw !== 'string' || !raw || raw.length > 600)
+        return null;
+    try {
+        const parsed = JSON.parse(Buffer.from(raw, 'base64url').toString('utf8'));
+        if (!Array.isArray(parsed) || typeof parsed[0] !== 'string' || typeof parsed[1] !== 'string')
+            return null;
+        return { at: parsed[0], id: parsed[1] };
+    }
+    catch {
+        return null;
+    }
+}
+function emptyKindCounts() {
+    return { spec_edit: 0, addendum: 0, mission_turn: 0, job: 0, phase: 0, audit: 0, pr_event: 0, review: 0 };
+}
+/** Filter by kind, then page after the cursor. `all` must already be sorted newest first. */
+function pageTimeline(all, options) {
+    const counts = emptyKindCounts();
+    for (const entry of all)
+        counts[entry.kind] += 1;
+    const wanted = options.kinds.length > 0 ? new Set(options.kinds) : null;
+    let visible = wanted ? all.filter((entry) => wanted.has(entry.kind)) : [...all];
+    const { cursor } = options;
+    if (cursor)
+        visible = visible.filter((entry) => entry.at < cursor.at || (entry.at === cursor.at && entry.id < cursor.id));
+    const entries = visible.slice(0, options.limit);
+    const last = entries[entries.length - 1];
+    return {
+        entries,
+        nextCursor: last && visible.length > entries.length ? encodeCursor(last) : null,
+        counts,
+        total: all.length,
+    };
+}
+function foldCost(rows) {
+    let total = 0;
+    let estimated = 0;
+    let priced = 0;
+    let turns = 0;
+    let turnsKnown = false;
+    for (const row of rows) {
+        if (row.costUsd !== null) {
+            priced += 1;
+            total += row.costUsd;
+            if (row.estimated)
+                estimated += row.costUsd;
+        }
+        if (row.turns !== null) {
+            turns += row.turns;
+            turnsKnown = true;
+        }
+    }
+    const out = { turns: turnsKnown ? turns : null };
+    if (priced > 0) {
+        out.costUsd = total;
+        out.costKind = estimated > 0 ? 'estimated' : 'billed';
+        if (estimated > 0)
+            out.costEstimatedUsd = estimated;
+    }
+    return out;
+}
+/** `a/b.ts:12-14` style anchor of a finding. */
+function formatLocation(location) {
+    if (!location)
+        return null;
+    if (location.line === undefined)
+        return location.path;
+    return location.endLine !== undefined && location.endLine !== location.line
+        ? `${location.path}:${location.line}-${location.endLine}`
+        : `${location.path}:${location.line}`;
+}
+/**
+ * SQLite `datetime('now')` yields `YYYY-MM-DD HH:MM:SS` with no zone, and a
+ * browser reads that as LOCAL time. The value is UTC, so give it an ISO `T…Z`
+ * form before it is compared, sorted or sent to a client. Values that already
+ * carry a zone pass through untouched.
+ */
+function utc(value) {
+    return typeof value === 'string' && /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(value) ? `${value.replace(' ', 'T')}Z` : value;
+}
+function oneLine(value, max = 240) {
+    if (typeof value !== 'string')
+        return null;
+    const flat = value.replace(/\s+/g, ' ').trim();
+    if (!flat)
+        return null;
+    return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}