specrails-desktop 2.34.0 → 2.35.0

package/server/dist/rails-router.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.prDeliveryRevisionAllowed = prDeliveryRevisionAllowed;
 exports.createRailsRouter = createRailsRouter;
 const express_1 = require("express");
 const rails_store_1 = require("./rails-store");
@@ -11,6 +12,8 @@ const file_story_1 = require("./file-story");
 const loops_store_1 = require("./loops-store");
 const loop_runs_store_1 = require("./loop-runs-store");
 const providers_1 = require("./providers");
+const runtime_1 = require("./providers/runtime");
+const agent_defaults_1 = require("./agent-defaults");
 const spec_models_1 = require("./spec-models");
 const workspace_resolution_1 = require("./workspace-resolution");
 const loop_factory_1 = require("./loop-factory");
@@ -20,6 +23,8 @@ const loop_graph_1 = require("./loop-graph");
 const rail_isolation_1 = require("./rail-isolation");
 const rail_pr_store_1 = require("./rail-pr-store");
 const loop_effect_1 = require("./loop-effect");
+const review_packet_1 = require("./review-packet");
+const accept_ladder_1 = require("./accept-ladder");
 const rail_pr_decision_1 = require("./rail-pr-decision");
 const active_pr_continuation_1 = require("./active-pr-continuation");
 const rail_isolated_launch_1 = require("./rail-isolated-launch");
@@ -41,6 +46,22 @@ function prDeliveryContinuesTickets(delivery, ticketIds) {
     const requested = new Set(ticketIds);
     return requested.size > 0 && requested.size === covered.size && [...requested].every((id) => covered.has(id));
 }
+/**
+ * Whether a launch may revise an undecided delivery. Deliberately strict:
+ * the named id must BE the rail's active generation, that generation must still
+ * be awaiting a decision (a terminal one is history, not revisable), and the
+ * rail must still carry exactly the delivery's ticket set — a subset would
+ * revise work the user never asked about while leaving the rest undecided.
+ */
+function prDeliveryRevisionAllowed(delivery, revisionOfDeliveryId, ticketIds) {
+    if (delivery.id !== revisionOfDeliveryId)
+        return false;
+    if ((0, rail_pr_store_1.isTerminalPrDecision)(delivery.decision))
+        return false;
+    const covered = new Set(delivery.ticketIds);
+    const requested = new Set(ticketIds);
+    return requested.size > 0 && requested.size === covered.size && [...requested].every((id) => covered.has(id));
+}
 function prDeliveryCheckoutBlock(delivery) {
     if (delivery.deliveryOutcome === 'blocked') {
         return 'delivery is blocked and has no safely checkoutable result';
@@ -381,7 +402,20 @@ function createRailsRouter() {
             return;
         }
         let { mode = 'implement' } = req.body ?? {};
-        const { profileName, aiEngine, model, loopId: rawLoopId, reasoning_effort, originConversationId, originSurface, targetPrNumber } = req.body ?? {};
+        const { profileName, aiEngine, model, loopId: rawLoopId, reasoning_effort, originConversationId, originSurface, targetPrNumber, revisionOfDeliveryId, revisionNote } = req.body ?? {};
+        // Revision launch (nontech-review-experience Wave 3): the user asked for a
+        // change to a delivery that is already awaiting their decision. Shape is
+        // validated here; the narrow guard exemption is enforced below.
+        if (revisionOfDeliveryId !== undefined && revisionOfDeliveryId !== null) {
+            if (typeof revisionOfDeliveryId !== 'string' || !/^[A-Za-z0-9-]{1,64}$/.test(revisionOfDeliveryId)) {
+                res.status(400).json({ error: 'invalid_revision_target', detail: 'revisionOfDeliveryId must be a delivery id' });
+                return;
+            }
+            if (typeof revisionNote !== 'string' || revisionNote.trim().length === 0) {
+                res.status(400).json({ error: 'revision_note_required', detail: 'revisionNote must describe the change to make' });
+                return;
+            }
+        }
         // Explicit target PR (deliver-rail-into-existing-pr): the user names an
         // existing open PR as the delivery destination. Shape-validated here;
         // resolved and verified inside the isolated launch, fail-closed.
@@ -414,6 +448,18 @@ function createRailsRouter() {
                 res.status(404).json({ error: 'Factory loop not found' });
                 return;
             }
+            // The revision loop is meaningless without a revision to apply: its prompt
+            // consumes {{const:REVISION_REQUEST}}, and an unresolved constant renders
+            // as an EMPTY string (loop-constants), so naming it directly would spawn a
+            // run whose central instruction is silently blank. It is reachable by id
+            // (fork/preview resolve it), so the launch door has to refuse it.
+            if (loopId === loop_factory_1.FACTORY_REVISION_LOOP_ID && !revisionOfDeliveryId) {
+                res.status(400).json({
+                    error: 'revision_loop_requires_revision',
+                    detail: 'factory:revision only runs as a revision — pass revisionOfDeliveryId and revisionNote instead of naming the loop',
+                });
+                return;
+            }
             mode = fmode;
         }
         if (!VALID_MODES.has(mode)) {
@@ -429,6 +475,17 @@ function createRailsRouter() {
         if ((0, feature_flags_1.isLoopsEnabled)() && (typeof loopId !== 'string' || !loopId) && mode !== 'loop') {
             loopId = (0, loop_factory_1.factoryLoopForMode)(mode)?.id;
         }
+        // A revision must run the Architect-LESS revision loop, whatever the rail's
+        // stored mode is. Without this every one-sentence tweak would re-run the
+        // full implement pipeline — the exact cost the feature exists to avoid.
+        // An explicit loopId is respected (a caller naming a loop means it).
+        if (revisionOfDeliveryId && (0, feature_flags_1.isLoopsEnabled)() && (typeof loopId !== 'string' || !loopId || (0, loop_factory_1.isFactoryLoopId)(loopId))) {
+            const revisionLoop = (0, loop_factory_1.getFactoryLoop)(loop_factory_1.FACTORY_REVISION_LOOP_ID);
+            if (revisionLoop) {
+                loopId = revisionLoop.id;
+                mode = revisionLoop.mode;
+            }
+        }
         if (mode === 'loop' && !(0, feature_flags_1.isLoopsEnabled)()) {
             res.status(403).json({ error: 'Loops are disabled on this server' });
             return;
@@ -599,7 +656,14 @@ function createRailsRouter() {
                     res.status(400).json({ error: `model is not valid for provider "${loopProvider}"`, allowed: (0, spec_models_1.getModelsForProvider)(loopProvider) });
                     return;
                 }
-                const loopModel = typeof model === 'string' && model ? model : loopAdapter.defaultModel();
+                // Global Specrails Agents defaults (Settings ▸ Specrails Agents): fill
+                // model/effort ONLY when the launch body carries no explicit choice —
+                // dashboard factory launches send neither. Read at launch time, so a
+                // settings change applies to the next launch without restart.
+                const globalAgentDefaults = (0, agent_defaults_1.resolveAgentDefaults)(c.desktopDb, loopProvider);
+                const loopModel = typeof model === 'string' && model
+                    ? model
+                    : (globalAgentDefaults?.pipelineModel ?? loopAdapter.defaultModel());
                 let effort;
                 if (reasoning_effort !== undefined && reasoning_effort !== null) {
                     const allowed = (0, providers_1.reasoningEffortsForModel)(loopAdapter, loopModel);
@@ -613,6 +677,10 @@ function createRailsRouter() {
                     }
                     effort = reasoning_effort;
                 }
+                else if (globalAgentDefaults?.pipelineEffort
+                    && (0, runtime_1.isReasoningEffortValidForModel)(loopAdapter, loopModel, globalAgentDefaults.pipelineEffort)) {
+                    effort = globalAgentDefaults.pipelineEffort;
+                }
                 // The loop's command(s) declare ticket scope + required capabilities.
                 const promptsText = loopGraph.nodes
                     .filter((n) => n.type === 'ai-step')
@@ -634,6 +702,7 @@ function createRailsRouter() {
                 // cards) is diagnosable from the UI, not just the server log.
                 let isolationUnavailableDetail;
                 let continuablePrDelivery = null;
+                let revisionRequest = null;
                 // Read-only vs mutating is DERIVED from the loop's nodes (see loop-effect),
                 // not a user flag — a content-read-only loop (no ai-step/shell) never writes,
                 // so it is not isolated; anything that can write is.
@@ -644,10 +713,32 @@ function createRailsRouter() {
                 if ((0, rail_isolation_1.isRailPrDeliveryEnabled)()) {
                     const pending = (0, rail_pr_store_1.getActivePrDeliveryByRail)(c.db, railIndex);
                     const pendingSnapshot = pending ? (0, rail_pr_store_1.toPrDeliverySnapshot)(pending) : null;
-                    if (pendingSnapshot && !prDeliveryContinuesTickets(pendingSnapshot, rail.ticketIds)) {
+                    // A revision is the ONE launch allowed to proceed against an
+                    // undecided delivery, and only on the exact terms below: the caller
+                    // names that delivery AND covers its full ticket set. Anything else
+                    // would silently append work to branches the user has not judged.
+                    const revisionsEnabled = (0, feature_flags_1.areDeliveryRevisionsEnabled)();
+                    const revisionOfPending = Boolean(revisionsEnabled && pendingSnapshot && revisionOfDeliveryId
+                        && prDeliveryRevisionAllowed(pendingSnapshot, revisionOfDeliveryId, rail.ticketIds));
+                    if (revisionsEnabled && pendingSnapshot && revisionOfDeliveryId && !revisionOfPending) {
+                        res.status(409).json({
+                            error: 'invalid_revision_target',
+                            prDeliveryId: pendingSnapshot.id,
+                            detail: 'a revision must target the rail\'s active delivery and cover all of its specs',
+                        });
+                        return;
+                    }
+                    if (pendingSnapshot && !revisionOfPending && !prDeliveryContinuesTickets(pendingSnapshot, rail.ticketIds)) {
                         res.status(409).json({ error: 'pr_decision_pending', prDeliveryId: pendingSnapshot.id });
                         return;
                     }
+                    if (revisionOfPending && pendingSnapshot) {
+                        revisionRequest = {
+                            ofDeliveryId: pendingSnapshot.id,
+                            decision: pendingSnapshot.decision,
+                            note: revisionNote,
+                        };
+                    }
                     // Explicit target vs an undecided continuable delivery: the slot's
                     // active generation owns its PR. A DIFFERENT explicit target would
                     // append to the undecided branches → 409; the SAME PR is redundant
@@ -720,6 +811,9 @@ function createRailsRouter() {
                                 ...(typeof targetPrNumber === 'number' && !continuablePrDelivery
                                     ? { explicitPrTarget: { prNumber: targetPrNumber } }
                                     : {}),
+                                // Revision of an undecided delivery: the guard above proved the
+                                // exemption, so pass the contract through for supersession.
+                                ...(revisionRequest ? { revision: revisionRequest } : {}),
                             });
                             res.status(202).json({ loopRunIds: ids, railIndex, mode, isolated: true });
                             return;
@@ -999,6 +1093,33 @@ function createRailsRouter() {
         }
         res.json({ ok: true, jobIds: targetJobIds, loopRunIds: targetLoopRunIds, canceled: canceledCount });
     });
+    // GET /rails/pr-deliveries/:id/packet — the plain-language review packet for a
+    // settled delivery: composed server-side from durable rows only (no model
+    // calls, no live-store reads) plus the pre-resolved Accept ladder, so the
+    // client never has to ask the user to choose between git actions. Read-only.
+    router.get('/pr-deliveries/:prDeliveryId/packet', async (req, res) => {
+        if (!(0, feature_flags_1.isReviewPacketEnabled)()) {
+            res.status(404).json({ error: 'Not Found' });
+            return;
+        }
+        const c = ctx(req);
+        const row = (0, rail_pr_store_1.getPrDelivery)(c.db, req.params.prDeliveryId);
+        if (!row) {
+            res.status(404).json({ error: 'Delivery not found' });
+            return;
+        }
+        try {
+            const packet = (0, review_packet_1.composeReviewPacket)({ db: c.db, row });
+            // Capability probes are read-only and offline; a failure degrades to the
+            // confirm-gated local path rather than blocking the packet.
+            const acceptCapability = await (0, accept_ladder_1.resolveAcceptCapability)({ repoDir: c.project.path, exec: pr_publisher_1.defaultExec });
+            res.json({ packet, acceptCapability, snapshot: (0, rail_pr_store_1.toPrDeliverySnapshot)(row) });
+        }
+        catch (err) {
+            console.error('[rails-router] packet composition failed:', err);
+            res.status(500).json({ error: 'packet composition failed', detail: err.message });
+        }
+    });
     // POST /rails/pr-decision — the ONE decision action (safe-pr-review-flow) both
     // surfaces (dashboard rail row + agent-chat card) call on a rail_pr_deliveries
     // row: create-pr | publish | discard/dismiss | poll/reopen | merge-local |

package/server/dist/review-packet.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DRIFT_REVISION_COUNT = exports.DRIFT_COST_SHARE = exports.MAX_VERSION_CHAIN = exports.HUMAN_REVIEW_BAND = void 0;
+exports.selectVariant = selectVariant;
+exports.computeDriftNudges = computeDriftNudges;
+exports.composeReviewPacket = composeReviewPacket;
+exports.packetHasUnsourcedNumericClaim = packetHasUnsourcedNumericClaim;
+const delivery_evidence_1 = require("./delivery-evidence");
+const rail_pr_store_1 = require("./rail-pr-store");
+const pr_body_1 = require("./pr-body");
+const ai_invocations_1 = require("./ai-invocations");
+const TEST_FILE_RE = /(\.test\.|\.spec\.|(^|\/)__tests__\/)/;
+function churnForRuns(db, runIds) {
+    const ids = [...new Set(runIds.filter((id) => typeof id === 'string' && id.length > 0))];
+    if (ids.length === 0)
+        return [];
+    const placeholders = ids.map(() => '?').join(', ');
+    try {
+        return db.prepare(`
+      SELECT job_id, file_path, added_lines, removed_lines
+        FROM file_story_contributions
+       WHERE job_id IN (${placeholders})
+    `).all(...ids);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Variant selection reads ONLY durable outcomes. `no-changes` must win over
+ * `success` (a run that changed nothing has nothing to show), and a mixed batch
+ * is `partial` rather than a success that quietly hides a failed ticket.
+ */
+function selectVariant(row, units) {
+    if (row.decision === 'no_changes' || row.delivery_outcome === 'no_changes' || row.status_code === 'no_changes') {
+        return 'no-changes';
+    }
+    if (row.implementation_outcome === 'failed' || row.decision === 'implementation_failed')
+        return 'failed';
+    const succeeded = units.filter((unit) => unit.implementationOutcome === 'succeeded' || (unit.implementationOutcome == null && unit.succeeded)).length;
+    const failed = units.filter((unit) => unit.implementationOutcome === 'failed' || (unit.implementationOutcome == null && !unit.succeeded)).length;
+    if (row.implementation_outcome === 'partially_succeeded' || row.delivery_outcome === 'partial' || (succeeded > 0 && failed > 0)) {
+        return 'partial';
+    }
+    return 'success';
+}
+function headlineFor(variant, succeeded, total) {
+    switch (variant) {
+        case 'no-changes': return 'headline.noChanges';
+        case 'failed': return succeeded > 0 ? 'headline.failedPartial' : 'headline.failed';
+        case 'partial': return 'headline.partial';
+        default: return total > 1 ? 'headline.successMany' : 'headline.success';
+    }
+}
+/** Reviewer band documented by sr-reviewer's schema: 50-69 ⇒ recommend a human. */
+exports.HUMAN_REVIEW_BAND = { min: 50, max: 69 };
+function buildProof(units, evidence, churn, confidence) {
+    const proof = [];
+    // ── Tier 1: what Specrails measured itself ────────────────────────────────
+    const testFiles = [...new Set(churn.filter((row) => TEST_FILE_RE.test(row.file_path)).map((row) => row.file_path))];
+    const totalFiles = new Set(churn.map((row) => row.file_path)).size;
+    const added = churn.reduce((sum, row) => sum + (row.added_lines || 0), 0);
+    const removed = churn.reduce((sum, row) => sum + (row.removed_lines || 0), 0);
+    if (totalFiles > 0) {
+        proof.push({
+            tier: 'app-verified',
+            code: 'proof.filesChanged',
+            values: { files: totalFiles, added, removed },
+        });
+    }
+    proof.push(testFiles.length > 0
+        ? { tier: 'app-verified', code: 'proof.testFilesChanged', values: { count: testFiles.length } }
+        // The honest negative: silence here would read as "tests fine".
+        : { tier: 'app-verified', code: 'proof.noTestFilesChanged' });
+    const verifiedBranches = units.filter((unit) => unit.finalSha && unit.finalSha !== unit.initialSha).length;
+    if (verifiedBranches > 0) {
+        proof.push({ tier: 'app-verified', code: 'proof.commitsRecorded', values: { branches: verifiedBranches } });
+    }
+    // ── Tier 2: what the agent itself reported ────────────────────────────────
+    const sentinels = (evidence ?? []).filter((unit) => unit.sentinel !== 'absent');
+    if (sentinels.length === 0) {
+        proof.push({ tier: 'ai-reported', code: 'proof.noVerificationReported' });
+    }
+    else {
+        const failed = sentinels.filter((unit) => unit.sentinel === 'fail');
+        if (failed.length > 0) {
+            // Failure leads: a packet must never bury a reported failure under a pass.
+            proof.push({
+                tier: 'ai-reported',
+                code: 'proof.verificationFailed',
+                values: { count: failed.length },
+                ...(failed[0].sentinelDetail ? { rawExcerpt: failed[0].sentinelDetail } : {}),
+            });
+        }
+        const passed = sentinels.filter((unit) => unit.sentinel === 'pass');
+        if (passed.length > 0) {
+            proof.push({ tier: 'ai-reported', code: 'proof.verificationPassed', values: { count: passed.length } });
+        }
+        const tail = sentinels.map((unit) => unit.verifyTail).find((value) => Boolean(value));
+        if (tail)
+            proof.push({ tier: 'ai-reported', code: 'proof.verifyOutput', rawExcerpt: tail });
+    }
+    // ── Tier 3: the reviewer grading its own pipeline ─────────────────────────
+    if (confidence) {
+        if (confidence.overall !== null) {
+            proof.push({
+                tier: 'reviewer-score',
+                code: 'proof.reviewerScore',
+                values: { overall: confidence.overall },
+            });
+        }
+        for (const [aspect, score] of Object.entries(confidence.aspects)) {
+            proof.push({ tier: 'reviewer-score', code: 'proof.reviewerAspect', values: { aspect, score } });
+        }
+    }
+    else {
+        proof.push({ tier: 'reviewer-score', code: 'proof.reviewerScoreUnavailable' });
+    }
+    return proof;
+}
+/**
+ * "What to watch out for" is capped and derived from REAL signals only —
+ * reviewer flags, the human-review band, and a code-changed-without-tests
+ * observation. Confabulated caution would train the user to ignore the section.
+ */
+function buildWatchOut(confidence, churn, variant) {
+    const out = [];
+    if (confidence?.overall !== null && confidence?.overall !== undefined) {
+        if (confidence.overall >= exports.HUMAN_REVIEW_BAND.min && confidence.overall <= exports.HUMAN_REVIEW_BAND.max) {
+            out.push({ tier: 'reviewer-score', code: 'watch.humanReviewRecommended', values: { overall: confidence.overall } });
+        }
+        else if (confidence.overall < exports.HUMAN_REVIEW_BAND.min) {
+            out.push({ tier: 'reviewer-score', code: 'watch.lowConfidence', values: { overall: confidence.overall } });
+        }
+    }
+    for (const flag of (confidence?.flags ?? []).slice(0, 3)) {
+        out.push({ tier: 'reviewer-score', code: 'watch.reviewerFlag', rawExcerpt: flag });
+    }
+    const codeFiles = churn.filter((row) => !TEST_FILE_RE.test(row.file_path));
+    const testFiles = churn.filter((row) => TEST_FILE_RE.test(row.file_path));
+    if (out.length < 3 && variant !== 'no-changes' && codeFiles.length > 0 && testFiles.length === 0) {
+        out.push({ tier: 'app-verified', code: 'watch.noTestsForChangedCode', values: { files: codeFiles.length } });
+    }
+    return out.slice(0, 3);
+}
+/**
+ * Walk the supersession chain back to the original build. Bounded so a corrupted
+ * lineage cannot spin, and tolerant of a missing ancestor (an old row may have
+ * been pruned) — the chain simply starts where the data does.
+ */
+exports.MAX_VERSION_CHAIN = 25;
+function versionChain(db, row) {
+    const chain = [row];
+    const seen = new Set([row.id]);
+    let cursor = row;
+    while (chain.length < exports.MAX_VERSION_CHAIN && cursor.revision_of) {
+        const previous = (0, rail_pr_store_1.getPrDelivery)(db, cursor.revision_of);
+        if (!previous || seen.has(previous.id))
+            break;
+        seen.add(previous.id);
+        chain.push(previous);
+        cursor = previous;
+    }
+    return chain.reverse(); // oldest first: v1 … vN
+}
+/** Fraction of the original build's cost above which revisions are worth flagging. */
+exports.DRIFT_COST_SHARE = 0.5;
+/** Revision count backstop — advisory, never a block. */
+exports.DRIFT_REVISION_COUNT = 3;
+/**
+ * Reshape-the-spec nudges. Every trigger is a real measurement (cumulative cost
+ * vs the original build, churn landing outside the original file set, revision
+ * depth) so the banner can show its own numbers instead of asserting a vibe.
+ * A hard count alone was rejected: it treats a 40-cent typo fix and a nine-dollar
+ * architectural thrash identically.
+ */
+function computeDriftNudges(input) {
+    const nudges = [];
+    const [original, ...revisions] = input.versions;
+    if (revisions.length === 0)
+        return nudges;
+    const originalCost = original?.costUsd ?? null;
+    const revisionCost = revisions.reduce((sum, version) => sum + (version.costUsd ?? 0), 0);
+    if (originalCost !== null && originalCost > 0 && revisionCost > originalCost * exports.DRIFT_COST_SHARE) {
+        nudges.push({
+            code: 'drift.costShare',
+            values: {
+                revisions: revisions.length,
+                revisionCost: revisionCost.toFixed(2),
+                originalCost: originalCost.toFixed(2),
+                share: Math.round((revisionCost / originalCost) * 100),
+            },
+        });
+    }
+    if (input.originalFileSet.size > 0 && input.currentFiles.size > 0) {
+        const outside = [...input.currentFiles].filter((file) => !input.originalFileSet.has(file));
+        if (outside.length * 2 > input.currentFiles.size) {
+            nudges.push({ code: 'drift.outOfScopeChurn', values: { files: outside.length, total: input.currentFiles.size } });
+        }
+    }
+    if (revisions.length >= exports.DRIFT_REVISION_COUNT) {
+        nudges.push({ code: 'drift.revisionCount', values: { revisions: revisions.length } });
+    }
+    return nudges;
+}
+function composeReviewPacket({ db, row }) {
+    const ticketIds = safeParse(row.ticket_ids, []);
+    const units = safeParse(row.branches, []);
+    const runIds = safeParse(row.run_ids, []);
+    const snapshot = (0, rail_pr_store_1.readSpecSnapshot)(row.spec_snapshot);
+    const evidence = (0, delivery_evidence_1.readSettleEvidence)(row.settle_evidence);
+    const churn = churnForRuns(db, runIds);
+    const variant = selectVariant(row, units);
+    const confidence = (evidence?.units ?? [])
+        .map((unit) => unit.confidence)
+        .find((score) => score !== null) ?? null;
+    const sections = ticketIds.map((ticketId) => {
+        const snap = snapshot?.find((entry) => entry.ticketId === ticketId) ?? null;
+        const narrative = (0, pr_body_1.extractSpecNarrative)(snap?.description ?? null);
+        const unitRows = units.filter((unit) => unit.ticketId === ticketId);
+        const unitRunIds = [...new Set(unitRows.map((unit) => unit.runId).filter((id) => Boolean(id)))];
+        // A run that covered several tickets (a batch collapsed into one checkout)
+        // cannot have its files split per ticket: provenance keys them to the run's
+        // primary ticket. Report null rather than repeat delivery totals per section.
+        const sharedRun = unitRunIds.some((runId) => new Set(units.filter((unit) => unit.runId === runId).map((unit) => unit.ticketId)).size > 1);
+        const unitChurn = !sharedRun && unitRunIds.length > 0
+            ? churn.filter((row) => row.job_id != null && unitRunIds.includes(row.job_id))
+            : null;
+        return {
+            ticketId,
+            title: snap?.title ?? null,
+            problem: narrative.problem,
+            solution: narrative.solution,
+            labels: snap?.labels ?? [],
+            implementationOutcome: unitRows[0]?.implementationOutcome ?? null,
+            deliveryOutcome: unitRows[0]?.deliveryOutcome ?? null,
+            changed: unitRows[0]?.changed ?? null,
+            churn: unitChurn === null ? null : {
+                filesTouched: new Set(unitChurn.map((c) => c.file_path)).size,
+                addedLines: unitChurn.reduce((sum, c) => sum + (c.added_lines || 0), 0),
+                removedLines: unitChurn.reduce((sum, c) => sum + (c.removed_lines || 0), 0),
+                testFilesTouched: [...new Set(unitChurn.filter((c) => TEST_FILE_RE.test(c.file_path)).map((c) => c.file_path))],
+            },
+            runIds: unitRunIds,
+        };
+    });
+    const succeededCount = units.length > 0
+        ? units.filter((unit) => unit.implementationOutcome === 'succeeded' || (unit.implementationOutcome == null && unit.succeeded)).length
+        : row.implementation_outcome === 'failed' ? 0 : ticketIds.length;
+    const failedCount = units.length > 0
+        ? units.filter((unit) => unit.implementationOutcome === 'failed' || (unit.implementationOutcome == null && !unit.succeeded)).length
+        : row.implementation_outcome === 'failed' ? ticketIds.length : 0;
+    const costSum = (0, ai_invocations_1.sumInvocationCostForRuns)(db, runIds);
+    const chain = versionChain(db, row);
+    const versions = chain.map((entry, index) => {
+        const entryRunIds = safeParse(entry.run_ids, []);
+        const entryCost = (0, ai_invocations_1.sumInvocationCostForRuns)(db, entryRunIds);
+        return {
+            prDeliveryId: entry.id,
+            version: index + 1,
+            revisionNote: entry.revision_note,
+            decision: entry.decision,
+            costUsd: entryCost?.totalUsd ?? null,
+            costEstimated: entryCost?.estimated ?? false,
+            current: entry.id === row.id,
+        };
+    });
+    const chainCosts = versions.map((version) => version.costUsd).filter((value) => value !== null);
+    // Churn comparison uses the ORIGINAL generation's files as the scope baseline:
+    // a revision touching mostly new files is the honest signal that the spec no
+    // longer describes the work.
+    const originalFiles = chain.length > 1
+        ? new Set(churnForRuns(db, safeParse(chain[0].run_ids, [])).map((entry) => entry.file_path))
+        : new Set();
+    const driftNudges = computeDriftNudges({
+        versions,
+        originalFileSet: originalFiles,
+        currentFiles: new Set(churn.map((entry) => entry.file_path)),
+    });
+    return {
+        schemaVersion: 1,
+        prDeliveryId: row.id,
+        railIndex: row.rail_index,
+        variant,
+        decision: row.decision,
+        statusCode: row.status_code,
+        headlineCode: headlineFor(variant, succeededCount, ticketIds.length),
+        ticketIds,
+        baseBranch: row.base_branch,
+        loopName: row.loop_name,
+        prUrl: row.pr_url,
+        prNumber: row.pr_number,
+        succeededCount,
+        failedCount,
+        totalCount: units.length > 0 ? new Set(units.map((u) => u.ticketId)).size : ticketIds.length,
+        sections,
+        proof: buildProof(units, evidence?.units ?? null, churn, confidence),
+        watchOut: buildWatchOut(confidence, churn, variant),
+        confidence,
+        cost: { totalUsd: costSum?.totalUsd ?? null, estimated: costSum?.estimated ?? false },
+        evidenceUnavailable: evidence === null || evidence.harvest === 'failed',
+        runIds,
+        supersedesDeliveryId: row.supersedes_delivery_id,
+        revisionNote: row.revision_note,
+        versions,
+        chainCostUsd: chainCosts.length > 0 ? chainCosts.reduce((sum, value) => sum + value, 0) : null,
+        chainCostEstimated: versions.some((version) => version.costEstimated),
+        driftNudges,
+    };
+}
+/** Assert-by-construction guard used in tests and by the route: no packet field
+ * may carry a numeric verification claim without a structured source. */
+function packetHasUnsourcedNumericClaim(packet) {
+    return packet.proof.some((item) => item.tier === 'ai-reported'
+        && Object.keys(item.values ?? {}).some((key) => key === 'tests' || key === 'passed' || key === 'failedTests'));
+}
+function safeParse(raw, fallback) {
+    if (!raw)
+        return fallback;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed ?? fallback;
+    }
+    catch {
+        return fallback;
+    }
+}

package/server/dist/revision-seed.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEED_EVIDENCE_CAP = exports.SEED_DIFF_CAP = exports.SEED_SPEC_BODY_CAP = void 0;
+exports.buildRevisionSeed = buildRevisionSeed;
+/** Bounds keep the seed a briefing, not a transcript. */
+exports.SEED_SPEC_BODY_CAP = 4000;
+exports.SEED_DIFF_CAP = 4000;
+exports.SEED_EVIDENCE_CAP = 1200;
+function clamp(value, cap) {
+    const trimmed = value.trim();
+    return trimmed.length <= cap ? trimmed : `${trimmed.slice(0, cap)}\n…(truncated)`;
+}
+/** One-line digest of what the previous run's verification actually reported. */
+function evidenceLine(evidence) {
+    if (!evidence || evidence.units.length === 0)
+        return 'No verification evidence was captured for the previous run.';
+    const failed = evidence.units.filter((unit) => unit.sentinel === 'fail');
+    const passed = evidence.units.filter((unit) => unit.sentinel === 'pass');
+    const parts = [];
+    if (failed.length > 0) {
+        // Failure first: a revision briefing must not bury it behind a pass.
+        const detail = failed.map((unit) => unit.sentinelDetail).find(Boolean);
+        parts.push(`The previous run REPORTED FAILED verification${detail ? ` (${clamp(detail, 200)})` : ''}.`);
+    }
+    if (passed.length > 0)
+        parts.push('The previous run reported its verification passed.');
+    if (parts.length === 0)
+        parts.push('The previous run did not report a verification verdict.');
+    const score = evidence.units.map((unit) => unit.confidence?.overall).find((value) => typeof value === 'number');
+    if (typeof score === 'number')
+        parts.push(`Its reviewer scored the work ${score}/100.`);
+    return parts.join(' ');
+}
+/**
+ * The briefing a revision run is seeded with. Deterministic (same input ⇒ same
+ * text) so it is cache-friendly and testable, and honest: it never claims the
+ * previous run verified anything the evidence does not say.
+ */
+function buildRevisionSeed(input) {
+    const specs = (input.specSnapshot ?? []).length > 0
+        ? (input.specSnapshot ?? []).map((entry) => [
+            `### #${entry.ticketId} ${entry.title ?? '(untitled)'}`,
+            entry.description ? clamp(entry.description, exports.SEED_SPEC_BODY_CAP) : '(no description recorded)',
+        ].join('\n')).join('\n\n')
+        : input.ticketIds.map((id) => `### #${id}\n(spec text was not captured at launch)`).join('\n\n');
+    return [
+        '## Revision briefing',
+        '',
+        `This is revision ${input.revisionNumber} of work that has ALREADY been delivered for the spec(s) below.`,
+        'The code exists on the branch listed here. Do NOT start over, re-plan, or re-implement it.',
+        '',
+        '## What the user asked to change',
+        '',
+        clamp(input.note, exports.SEED_SPEC_BODY_CAP),
+        '',
+        '## The original request (frozen at launch)',
+        '',
+        specs,
+        '',
+        '## Where the existing work lives',
+        '',
+        input.branches.length > 0
+            ? `Branch(es): ${input.branches.join(', ')} (based on ${input.baseBranch}).`
+            : `Base branch: ${input.baseBranch}.`,
+        ...(input.branchDiffSummary
+            ? ['', 'Already changed on that branch:', '', clamp(input.branchDiffSummary, exports.SEED_DIFF_CAP)]
+            : []),
+        '',
+        '## What the previous run reported',
+        '',
+        clamp(evidenceLine(input.evidence), exports.SEED_EVIDENCE_CAP),
+    ].join('\n');
+}