ensemble-review 1.0.35 → 1.0.36

package/dist/review/story-report/manager.js

@@ -1,287 +0,0 @@
-import { and, desc, eq, inArray } from 'drizzle-orm';
-import { STORY_REPORT_MODEL, } from '../../shared/index.js';
-import { config } from '../../config.js';
-import { db, schema } from '../../db/client.js';
-import { loadStorySelection } from '../../db/story-selection.js';
-import { pickReviewNonce } from '../claude-review/prompts.js';
-import { runStoryLabelsToEnd } from '../story-labels/manager.js';
-import { selectionFingerprint } from './fingerprint.js';
-import { storyUntrustedTexts } from './story-detail.js';
-import { validateStoryReport } from './validate.js';
-let labelSeams = null;
-/** Tests inject the label pass's completion/store seams (never a real model call); null restores them. */
-export function setStoryReportLabelSeamsForTests(s) {
-    labelSeams = s;
-}
-const slots = new Map(); // accountId → the one in-flight run
-const runs = new Map(); // report id → its background run (tests await it)
-/** Claim the account's slot. SYNCHRONOUS — call before any await. false = already taken. */
-export function claimStoryReportSlot(accountId) {
-    if (slots.has(accountId))
-        return false;
-    slots.set(accountId, { id: null, abort: new AbortController() });
-    return true;
-}
-export function releaseStoryReportSlot(accountId) {
-    slots.delete(accountId);
-}
-/** The run id holding the account's slot (null while the claim has no row yet, or none). */
-export function storyReportSlotId(accountId) {
-    return slots.get(accountId)?.id ?? null;
-}
-let runnerOverride = null;
-/** Tests inject a fake runner (never a real model call); null restores the SDK runner. */
-export function setStoryReportRunnerForTests(fn) {
-    runnerOverride = fn;
-}
-/** The background run of `id`, for tests to await; undefined when none. */
-export function storyReportRunPromise(id) {
-    return runs.get(id);
-}
-export function storyReportRecordOf(r) {
-    return {
-        id: r.id,
-        workspaceId: r.workspaceId,
-        window: r.windowChoice,
-        range: r.rangeJson,
-        model: r.model,
-        status: r.status,
-        picked: r.pickedJson ?? [],
-        population: r.populationJson,
-        report: r.status === 'succeeded' ? (r.reportJson ?? null) : null,
-        dropped: r.droppedJson ?? null,
-        error: r.error ?? null,
-        costUsd: r.costUsd ?? null,
-        inputTokens: r.inputTokens ?? null,
-        outputTokens: r.outputTokens ?? null,
-        numTurns: r.numTurns ?? null,
-        createdAt: r.createdAt.toISOString(),
-        completedAt: r.completedAt != null ? r.completedAt.toISOString() : null,
-    };
-}
-const t = () => schema.storyReports;
-/** One run by id — this account's only (another account's id → null → 404). */
-export async function loadStoryReport(accountId, id) {
-    const rows = await db
-        .select()
-        .from(t())
-        .where(and(eq(t().accountId, accountId), eq(t().id, id)))
-        .limit(1)
-        .execute();
-    return rows[0] ?? null;
-}
-/** The latest run of any status and the latest SUCCEEDED run for (account, workspace, window). */
-export async function latestStoryReports(accountId, workspaceId, choice) {
-    const where = and(eq(t().accountId, accountId), eq(t().workspaceId, workspaceId), eq(t().windowChoice, choice));
-    const [latest] = await db.select().from(t()).where(where).orderBy(desc(t().createdAt), desc(t().id)).limit(1).execute();
-    const [report] = await db
-        .select()
-        .from(t())
-        .where(and(where, eq(t().status, 'succeeded')))
-        .orderBy(desc(t().createdAt), desc(t().id))
-        .limit(1)
-        .execute();
-    return { latest: latest ?? null, report: report ?? null };
-}
-/** The account's in-flight run (any workspace / window), or null. */
-export async function runningStoryReport(accountId) {
-    const [r] = await db
-        .select({ id: t().id, workspaceId: t().workspaceId, windowChoice: t().windowChoice, status: t().status })
-        .from(t())
-        .where(and(eq(t().accountId, accountId), inArray(t().status, ['queued', 'running'])))
-        .orderBy(desc(t().createdAt), desc(t().id))
-        .limit(1)
-        .execute();
-    return r
-        ? { id: r.id, workspaceId: r.workspaceId, window: r.windowChoice, status: r.status }
-        : null;
-}
-/**
- * Insert the queued row and launch the run in the background. The caller MUST hold the account's
- * slot (`claimStoryReportSlot`); from here the run owns it and releases it when it ends. If the
- * insert throws, the caller still owns the slot and releases it.
- */
-export async function startStoryReport(ctx, a) {
-    const slot = slots.get(a.accountId);
-    if (slot == null)
-        throw new Error('story report: start without a claimed slot');
-    const [row] = (await db
-        .insert(t())
-        .values({
-        accountId: a.accountId,
-        workspaceId: a.workspaceId,
-        windowChoice: a.choice,
-        fromAt: new Date(a.range.from),
-        toAt: new Date(a.range.to),
-        rangeJson: a.range,
-        model: STORY_REPORT_MODEL,
-        status: 'queued',
-        fingerprint: a.fingerprint,
-        pickedJson: a.candidates,
-        populationJson: a.population,
-        createdAt: new Date(),
-    })
-        .returning()
-        .execute());
-    slot.id = row.id;
-    const p = runStoryReport(ctx, row.id, a, slot.abort).finally(() => {
-        runs.delete(row.id);
-        if (slots.get(a.accountId) === slot)
-            slots.delete(a.accountId);
-    });
-    runs.set(row.id, p);
-    return storyReportRecordOf(row);
-}
-/** Map an agent result with no usable report to its error code. */
-export function storyReportFailureOf(res) {
-    if (res.runtimeMissing)
-        return 'runtime';
-    if (res.error != null)
-        return 'failed';
-    if (res.subtype === 'error_max_turns')
-        return 'max_turns';
-    if (res.subtype === 'error_max_budget_usd')
-        return 'budget_exceeded';
-    return 'no_report';
-}
-const windowLabelOf = (range) => range.reporting != null && range.reporting.mode === 'sprint'
-    ? 'sprint so far'
-    : `last ${range.reporting?.days ?? range.days} days`;
-async function finish(id, set, cas) {
-    await db
-        .update(t())
-        .set({ ...set, completedAt: new Date() })
-        .where(cas ? and(eq(t().id, id), inArray(t().status, ['queued', 'running'])) : eq(t().id, id))
-        .execute();
-}
-async function runStoryReport(ctx, id, a, abort) {
-    try {
-        await db
-            .update(t())
-            .set({ status: 'running' })
-            .where(and(eq(t().id, id), eq(t().status, 'queued')))
-            .execute();
-        if (abort.signal.aborted)
-            return; // cancelled before it started; the cancel wrote the row
-        if (ctx.llm.detectAuth().status !== 'ok') {
-            await finish(id, { status: 'failed', error: 'auth' }, true);
-            return;
-        }
-        // THE LABEL PASS (header). Best effort: a failed pass leaves the labels as they were.
-        let labelCostUsd = 0;
-        let sel = { candidates: a.candidates, population: a.population, internalsByKey: a.internalsByKey };
-        try {
-            const pass = await runStoryLabelsToEnd({ ...ctx, db, schema }, {
-                accountId: a.accountId,
-                workspaceId: a.workspaceId,
-                budgetUsd: config.storyLabelBudgetUsd,
-                stories: async () => (await loadStorySelection(a.accountId, a.scope, a.choice, Date.now())).toLabel,
-            }, labelSeams ?? {}, abort.signal);
-            labelCostUsd = pass?.costUsd ?? 0;
-            if (pass != null && pass.labelled > 0 && !abort.signal.aborted) {
-                const fresh = await loadStorySelection(a.accountId, a.scope, a.choice, Date.now());
-                if (fresh.candidates.length > 0) {
-                    sel = { candidates: fresh.candidates, population: fresh.population, internalsByKey: fresh.internalsByKey };
-                    await db
-                        .update(t())
-                        .set({ pickedJson: sel.candidates, populationJson: sel.population, fingerprint: selectionFingerprint(a.choice, sel) })
-                        .where(and(eq(t().id, id), inArray(t().status, ['queued', 'running'])))
-                        .execute();
-                }
-            }
-        }
-        catch (err) {
-            ctx.log.warn({ reportId: id, err: String(err).slice(0, 200) }, 'story report: label pass failed (non-fatal)');
-        }
-        if (abort.signal.aborted) {
-            await finish(id, { status: 'cancelled', costUsd: labelCostUsd > 0 ? labelCostUsd : null }, false);
-            return;
-        }
-        const runner = runnerOverride ?? (await import('./agent.js')).runStoryReportAgent;
-        // The credential ladder is applied to process.env only when no Claude Review run is in flight
-        // (the review chat's rule): two runs mutating the env at once would restore each other's values.
-        const { chatMayApplyAuthEnv } = await import('../claude-review/manager.js');
-        const res = await runner({
-            candidates: sel.candidates,
-            population: sel.population,
-            internalsByKey: sel.internalsByKey,
-            windowLabel: windowLabelOf(a.range),
-            model: STORY_REPORT_MODEL,
-            nonce: pickReviewNonce(storyUntrustedTexts(sel.candidates, sel.internalsByKey)),
-            maxTurns: config.storyReportMaxTurns,
-            maxBudgetUsd: config.storyReportBudgetUsd,
-            applyAuthEnv: chatMayApplyAuthEnv(),
-            abortController: abort,
-        });
-        const usage = {
-            // The row's cost is the whole run's: the agent's plus the label pass's (each recorded apart).
-            costUsd: res.costUsd == null && labelCostUsd === 0 ? res.costUsd : (res.costUsd ?? 0) + labelCostUsd,
-            inputTokens: res.inputTokens,
-            outputTokens: res.outputTokens,
-            numTurns: res.numTurns,
-        };
-        if (res.costUsd != null && res.costUsd > 0) {
-            await ctx
-                .recordAiUsage({
-                accountId: a.accountId,
-                seam: 'agent',
-                feature: 'story_report',
-                model: STORY_REPORT_MODEL,
-                costUsd: res.costUsd,
-                inputTokens: res.inputTokens,
-                outputTokens: res.outputTokens,
-            })
-                .catch((err) => ctx.log.warn({ err }, 'story report: usage record failed'));
-        }
-        if (res.aborted || abort.signal.aborted) {
-            await finish(id, { status: 'cancelled', ...usage }, false);
-            return;
-        }
-        if (res.error != null)
-            ctx.log.warn({ reportId: id, err: res.error }, 'story report: run failed');
-        if (res.submitted === undefined) {
-            await finish(id, { status: 'failed', error: storyReportFailureOf(res), ...usage }, true);
-            return;
-        }
-        const v = validateStoryReport(res.submitted, new Set(sel.candidates.map((c) => c.key)));
-        if (v.dropped.unknownTickets + v.dropped.items + v.dropped.overCap > 0) {
-            ctx.log.info({ reportId: id, dropped: v.dropped }, 'story report: validation removed items');
-        }
-        if (!v.ok) {
-            await finish(id, { status: 'failed', error: 'invalid_report', droppedJson: v.dropped, ...usage }, true);
-            return;
-        }
-        await finish(id, { status: 'succeeded', reportJson: v.report, droppedJson: v.dropped, error: null, ...usage }, true);
-    }
-    catch (err) {
-        ctx.log.warn({ err, reportId: id }, 'story report: run threw');
-        await finish(id, { status: 'failed', error: 'failed' }, true).catch(() => { });
-    }
-}
-/**
- * Cancel this account's run `id`. In flight → abort and write 'cancelled' now; already finished →
- * unchanged. Returns the row after, or null when it is not this account's.
- */
-export async function cancelStoryReport(accountId, id) {
-    const row = await loadStoryReport(accountId, id);
-    if (row == null)
-        return null;
-    if (row.status !== 'queued' && row.status !== 'running')
-        return row;
-    const slot = slots.get(accountId);
-    if (slot?.id === id)
-        slot.abort.abort();
-    await finish(id, { status: 'cancelled' }, true);
-    return loadStoryReport(accountId, id);
-}
-/** Boot sweep: a queued/running row from an earlier process can never finish — mark it interrupted. */
-export async function reconcileStoryReportsOnStartup() {
-    const rows = await db
-        .update(t())
-        .set({ status: 'failed', error: 'interrupted', completedAt: new Date() })
-        .where(inArray(t().status, ['queued', 'running']))
-        .returning({ id: t().id })
-        .execute();
-    return rows.length;
-}
-//# sourceMappingURL=manager.js.map

package/dist/review/story-report/routes.js

@@ -1,154 +0,0 @@
-import { STORY_REPORT_WINDOW_CHOICES, parseStoryReportWindow, } from '../../shared/index.js';
-import { resolveWorkspaceScope } from '../../db/queries.js';
-import { loadStorySelection } from '../../db/story-selection.js';
-import { reportsEntitled } from '../../api/routes/insights.js';
-import { selectionFingerprint } from './fingerprint.js';
-import { cancelStoryReport, claimStoryReportSlot, latestStoryReports, loadStoryReport, releaseStoryReportSlot, runningStoryReport, startStoryReport, storyReportRecordOf, storyReportSlotId, } from './manager.js';
-// THE STORY REPORT'S ROUTES (docs/API.md § Story report; docs/CLAUDE-REVIEW.md § Story report).
-// Registered ONLY through `registerAgenticRoutes` — its explicit `isCloud` check is the cloud
-// guarantee (the routes 404 there). Pro with the rest of Reports: `reportsEntitled` false → 402
-// BEFORE any DB work, identical for every id/workspace (no oracle). The workspace always goes
-// through `resolveWorkspaceScope`: an unknown or another tenant's id degrades to the caller's
-// Default, never a 404, and every response echoes the workspace used.
-//
-//   GET  /api/story-reports?workspace=&window=   picks + figures NOW (code) + stored runs   → read
-//   POST /api/story-reports {workspaceId, window} the ONLY path that runs the model         → ai + ai_hourly
-//        (the run first LABELS the window's stories with no current label — manager.ts)
-//   GET  /api/story-reports/:id                  one run (the SPA polls while in flight)    → read
-//   POST /api/story-reports/:id/cancel           abort; spends nothing                      → read
-const PRO_REQUIRED = { error: 'pro required' };
-const fingerprintOf = (choice, sel) => selectionFingerprint(choice, sel);
-const parseId = (raw) => {
-    const n = typeof raw === 'string' && /^\d+$/.test(raw) ? Number(raw) : NaN;
-    return Number.isSafeInteger(n) && n > 0 ? n : null;
-};
-export function registerStoryReportRoutes(app, ctx) {
-    /** A succeeded run's currency against today's picks for its own workspace + window. */
-    const currencyOf = async (accountId, row) => {
-        if (row.status !== 'succeeded')
-            return null;
-        const scope = await resolveWorkspaceScope(accountId, row.workspaceId);
-        const choice = parseStoryReportWindow(row.windowChoice);
-        const sel = await loadStorySelection(accountId, scope, choice, Date.now());
-        return fingerprintOf(choice, sel) === row.fingerprint ? 'current' : 'stale';
-    };
-    app.get('/api/story-reports', async (req, reply) => {
-        if (!reportsEntitled(req)) {
-            reply.status(402);
-            return PRO_REQUIRED;
-        }
-        const q = req.query;
-        const accountId = ctx.accountIdOf(req);
-        const scope = await resolveWorkspaceScope(accountId, q.workspace);
-        const choice = parseStoryReportWindow(q.window);
-        const sel = await loadStorySelection(accountId, scope, choice, Date.now());
-        const { latest, report } = await latestStoryReports(accountId, scope.workspaceId, choice);
-        return {
-            workspaceId: scope.workspaceId,
-            window: choice,
-            range: sel.range,
-            trackerOn: sel.trackerOn,
-            latest: latest ? storyReportRecordOf(latest) : null,
-            report: report ? storyReportRecordOf(report) : null,
-            currency: report ? (fingerprintOf(choice, sel) === report.fingerprint ? 'current' : 'stale') : null,
-            running: await runningStoryReport(accountId),
-            candidates: sel.candidates,
-            population: sel.population,
-        };
-    });
-    app.post('/api/story-reports', async (req, reply) => {
-        if (!reportsEntitled(req)) {
-            reply.status(402);
-            return PRO_REQUIRED;
-        }
-        const body = (req.body ?? {});
-        if (typeof body.workspaceId !== 'number' ||
-            !Number.isSafeInteger(body.workspaceId) ||
-            typeof body.window !== 'string' ||
-            !STORY_REPORT_WINDOW_CHOICES.includes(body.window)) {
-            reply.status(400);
-            return { error: 'bad_request', message: 'Send a workspaceId and a window (reporting, 30, 60 or 90).' };
-        }
-        const choice = body.window;
-        const accountId = ctx.accountIdOf(req);
-        // ⚠ THE SLOT IS CLAIMED HERE, BEFORE THE FIRST AWAIT — two POSTs cannot both start a run.
-        if (!claimStoryReportSlot(accountId)) {
-            // Name only a run whose row is still queued/running. A CANCELLED run keeps the slot until
-            // its SDK call has actually stopped (the slot also serialises the auth-env mutation, so it
-            // must not be released early) — its row already reads 'cancelled', so naming it would point
-            // the card at a run it no longer shows.
-            const running = await runningStoryReport(accountId);
-            const stopping = running == null && storyReportSlotId(accountId) != null;
-            reply.status(409);
-            return {
-                error: 'busy',
-                message: stopping
-                    ? 'The cancelled story report is still stopping. Try again in a moment.'
-                    : 'A story report is already being written.',
-                ...(running != null ? { runningId: running.id } : {}),
-            };
-        }
-        let handedOff = false;
-        try {
-            const scope = await resolveWorkspaceScope(accountId, body.workspaceId);
-            const sel = await loadStorySelection(accountId, scope, choice, Date.now());
-            if (!sel.trackerOn) {
-                reply.status(400);
-                return { error: 'no_tracker', message: 'This workspace has no issue tracker.' };
-            }
-            // Picks never depend on labels (only their issue fields and the rates do), so no picks means
-            // nothing to report even after a label pass.
-            if (sel.candidates.length === 0) {
-                reply.status(422);
-                return { error: 'no_candidates', message: 'No stories to report on in this window.' };
-            }
-            const record = await startStoryReport(ctx, {
-                accountId,
-                workspaceId: scope.workspaceId,
-                scope,
-                choice,
-                range: sel.range,
-                candidates: sel.candidates,
-                population: sel.population,
-                internalsByKey: sel.internalsByKey,
-                fingerprint: fingerprintOf(choice, sel),
-            });
-            handedOff = true;
-            reply.status(202);
-            return { report: record };
-        }
-        finally {
-            if (!handedOff)
-                releaseStoryReportSlot(accountId);
-        }
-    });
-    app.get('/api/story-reports/:id', async (req, reply) => {
-        if (!reportsEntitled(req)) {
-            reply.status(402);
-            return PRO_REQUIRED;
-        }
-        const id = parseId(req.params.id);
-        const accountId = ctx.accountIdOf(req);
-        const row = id != null ? await loadStoryReport(accountId, id) : null;
-        if (row == null) {
-            reply.status(404);
-            return { error: 'not_found' };
-        }
-        return { report: storyReportRecordOf(row), currency: await currencyOf(accountId, row) };
-    });
-    app.post('/api/story-reports/:id/cancel', async (req, reply) => {
-        if (!reportsEntitled(req)) {
-            reply.status(402);
-            return PRO_REQUIRED;
-        }
-        const id = parseId(req.params.id);
-        const accountId = ctx.accountIdOf(req);
-        const row = id != null ? await cancelStoryReport(accountId, id) : null;
-        if (row == null) {
-            reply.status(404);
-            return { error: 'not_found' };
-        }
-        return { report: storyReportRecordOf(row), currency: await currencyOf(accountId, row) };
-    });
-}
-//# sourceMappingURL=routes.js.map

package/dist/review/story-report/story-detail.js

@@ -1,148 +0,0 @@
-import { STORY_DEPENDENCY_KIND_LABEL, STORY_ISSUES, STORY_ISSUE_BY_ID, STORY_SPEC_GAP_TYPE_LABEL, } from '../../shared/index.js';
-// What the story report's agent READS — the trial harness's (scratchpad haiku/agent-exp.mts)
-// `candidateTable`, `population` and `storyDetail()` verbatim, adapted only to the stored shapes. Pure.
-//
-// ⚠ ALL OF IT IS ATTACKER-AUTHORED TEXT (ticket titles, descriptions and criteria; PR titles; the
-// ticket review's model prose). agent.ts nonce-fences every tool answer built here.
-const COLOR_RE = /\{color[^}]*\}/g;
-/** Drop Jira colour markup, collapse whitespace before a newline, cap. */
-export function stripStoryText(s, cap) {
-    return (s ?? '').replace(COLOR_RE, '').replace(/\s+\n/g, '\n').slice(0, cap);
-}
-/** The prototype's caps on the ticket text `get_story` returns. */
-export const STORY_DETAIL_DESCRIPTION_MAX = 3000;
-export const STORY_DETAIL_AC_MAX = 2500;
-/** "2.4 working days" / "5.0 working hours" — the agent's duration words. */
-export function workingDuration(hours, dayHours) {
-    return hours >= dayHours ? `${(hours / dayHours).toFixed(1)} working days` : `${hours.toFixed(1)} working hours`;
-}
-/** `list_candidates`' table row. */
-export function candidateRow(c, dayHours) {
-    return {
-        key: c.key,
-        title: c.title,
-        url: c.url,
-        group: c.group,
-        whyPicked: c.whyPicked,
-        time: workingDuration(c.workingHours, dayHours),
-        pullRequests: c.pullRequests,
-        linesChanged: c.linesChanged,
-        criteria: c.criteria,
-        criteriaSource: c.criteriaSource,
-        review: c.review
-            ? { alignment: c.review.alignment, met: c.review.met, partlyMet: c.review.partlyMet, notMet: c.review.notMet, missing: c.review.missing }
-            : null,
-        // The three story issues by LABEL (what the agent quotes), each with a state: present (and the
-        // specific detail behind it), false = known absent, null = NOT KNOWN. ⚠ An unread ticket is
-        // `issues: null` and an unlabelled one says null per issue — never `[]` ("avoids all three").
-        ...(c.issues !== undefined ? { issues: candidateIssues(c) } : {}),
-    };
-}
-/** The SPECIFIC detail behind one present issue — which criteria and why, what the story waited on
- *  (who, ticket, status, finished or not), which details the spec leaves out. Ticket-derived strings:
- *  fenced with the rest of the tool answer, and in `storyUntrustedTexts`. */
-export function issueDetailForAgent(i) {
-    switch (i.id) {
-        case 'unclear_done':
-            return i.reasons.includes('no_criteria')
-                ? { noCriteria: true }
-                : { criteria: i.criteria.map((c) => ({ criterion: c.n, reason: c.reason })) };
-        case 'blocked':
-            return {
-                waitsOn: i.blockers.map((b) => ({
-                    what: b.what,
-                    kind: STORY_DEPENDENCY_KIND_LABEL[b.kind],
-                    ticket: b.ticketKey,
-                    owner: b.owner,
-                    status: b.status,
-                    finished: b.resolved,
-                    source: b.source === 'link' ? 'tracker link' : 'named in the ticket text',
-                })),
-            };
-        case 'spec_gaps':
-            return { gaps: i.gaps.map((g) => ({ type: STORY_SPEC_GAP_TYPE_LABEL[g.type], gap: g.text })) };
-    }
-}
-/** One candidate's three issues for the agent; null when the ticket text was never read. Old rows'
- *  retired ids never reach here (the list is STORY_ISSUES, looked up by id). */
-export function candidateIssues(c) {
-    if (c.issues == null)
-        return null;
-    const states = c.issueStates ?? null;
-    return STORY_ISSUES.map((m) => {
-        const hit = c.issues.find((i) => i.id === m.id);
-        if (hit != null)
-            return { issue: m.label, present: true, ...issueDetailForAgent(hit) };
-        // An issue code did not raise is known absent only when its state says so; old rows had no state.
-        return { issue: m.label, present: states != null ? (states[m.id] ?? null) : null };
-    });
-}
-/** `list_candidates`' `wholeWindow` — the raw population with the median as words, as the prototype sent. */
-export function populationForAgent(p) {
-    return {
-        storiesInWindow: p.storiesInWindow,
-        withWrittenCriteria: p.withWrittenCriteria,
-        criteriaOnlyInDescription: p.criteriaOnlyInDescription,
-        noCriteriaFound: p.noCriteriaFound,
-        checkedByTicketReview: p.checkedByTicketReview,
-        checkedAndFullyMet: p.checkedAndFullyMet,
-        checkedWithGaps: p.checkedWithGaps,
-        medianWorkingTime: workingDuration(p.medianWorkingHours ?? 0, p.workingDayHours),
-        // Whole-window, by code: the ONLY issue rates the agent may quote, each in its own unit (`count` of
-        // `of` criteria or stories); no-criteria is `noCriteriaFound`.
-        ...(p.issueRates != null
-            ? {
-                issueRates: p.issueRates.map((r) => ({
-                    measure: STORY_ISSUE_BY_ID[r.id].measureLabel,
-                    count: r.stories,
-                    of: r.of,
-                    unit: r.unit ?? 'stories',
-                })),
-            }
-            : {}),
-    };
-}
-/** `get_story` for one picked key; an unknown key gets the prototype's error object. */
-export function storyDetail(key, byKey) {
-    const s = byKey.get(key);
-    if (!s)
-        return { error: `Unknown ticket ${key}. Use a key from list_candidates.` };
-    const snap = s.review?.snapshot, t = s.ticket;
-    const a = s.review?.assessment;
-    return {
-        key,
-        title: s.row.title,
-        url: s.row.url,
-        description: stripStoryText(snap?.description ?? t?.description, STORY_DETAIL_DESCRIPTION_MAX),
-        acceptanceCriteria: stripStoryText(snap?.acceptanceCriteria ?? t?.acceptanceCriteria, STORY_DETAIL_AC_MAX),
-        review: a
-            ? {
-                summary: a.summary,
-                criteria: a.criteria.map((x) => ({ ref: x.ref, text: x.text, status: x.status, explanation: x.explanation })),
-                missing: a.missing.map((m) => ({ ref: m.ref, title: m.title, explanation: m.explanation })),
-                notRequested: a.notRequested.map((n) => ({ title: n.title })),
-            }
-            : null,
-        pullRequests: [...s.prs.values()].map((p) => ({
-            ref: `${p.repoFullName.split('/')[1]}#${p.number}`,
-            title: p.title,
-            state: p.state,
-            linesChanged: p.additions + p.deletions,
-        })),
-    };
-}
-/** Every untrusted string a tool answer may carry this run — the nonce-collision scan's input. */
-export function storyUntrustedTexts(candidates, byKey) {
-    const out = [];
-    for (const c of candidates) {
-        out.push(c.key, c.title ?? '', c.url ?? '');
-        if (c.issues != null)
-            out.push(JSON.stringify(candidateIssues(c)));
-        const s = byKey.get(c.key);
-        if (s == null)
-            continue;
-        out.push(JSON.stringify(storyDetail(c.key, byKey)));
-    }
-    return out;
-}
-//# sourceMappingURL=story-detail.js.map