specrails-desktop 2.64.1 → 2.65.0

package/server/dist/modules/delivery/runtime/rail-pr-store.js

@@ -5,7 +5,11 @@ exports.boundSpecSnapshot = boundSpecSnapshot;
 exports.boundRevisionNote = boundRevisionNote;
 exports.readSpecSnapshot = readSpecSnapshot;
 exports.isTerminalPrDecision = isTerminalPrDecision;
+exports.readLocalStash = readLocalStash;
+exports.setPrDeliveryLocalStash = setPrDeliveryLocalStash;
+exports.listPrDeliveriesWithLocalStash = listPrDeliveriesWithLocalStash;
 exports.createPrDelivery = createPrDelivery;
+exports.getTriageAccuracy = getTriageAccuracy;
 exports.isPreparationFailureRow = isPreparationFailureRow;
 exports.createPrDeliveryGeneration = createPrDeliveryGeneration;
 exports.failPrDeliveryAndRestoreSuperseded = failPrDeliveryAndRestoreSuperseded;
@@ -17,6 +21,7 @@ exports.listTerminalPrDeliveries = listTerminalPrDeliveries;
 exports.getLatestTerminalPrDeliveryTouchingTicketSet = getLatestTerminalPrDeliveryTouchingTicketSet;
 exports.listOriginLinkedPrDeliveries = listOriginLinkedPrDeliveries;
 exports.reconcileFailedBuildingPrDeliveries = reconcileFailedBuildingPrDeliveries;
+exports.lifecycleStamps = lifecycleStamps;
 exports.boundPrDiagnostic = boundPrDiagnostic;
 exports.boundCleanupWarnings = boundCleanupWarnings;
 exports.normalizeSafetyArchives = normalizeSafetyArchives;
@@ -27,6 +32,7 @@ exports.transitionClaimedDecision = transitionClaimedDecision;
 exports.claimPrDeliveryOperation = claimPrDeliveryOperation;
 exports.releasePrDeliveryOperation = releasePrDeliveryOperation;
 exports.clearOrphanedPrDeliveryOperations = clearOrphanedPrDeliveryOperations;
+exports.readDeliveryRiskSummary = readDeliveryRiskSummary;
 exports.updatePrDeliverySettleEvidence = updatePrDeliverySettleEvidence;
 exports.toPrDeliverySnapshot = toPrDeliverySnapshot;
 exports.toRailPrStateMessage = toRailPrStateMessage;
@@ -41,8 +47,11 @@ exports.missionPhaseForDecision = missionPhaseForDecision;
  * decision. Pure data access; the PR plumbing lives in rail-pr-delivery /
  * pr-publisher and the launch wiring in rail-isolated-launch.
  */
+const triage_1 = require("../../specs/domain/triage");
 const pr_follow_up_1 = require("./pr-follow-up");
 const spec_addenda_core_1 = require("../../specs/runtime/spec-addenda-core");
+const review_brief_1 = require("./review-brief");
+const flow_review_outcome_1 = require("./flow-review-outcome");
 const ids_1 = require("../../../ids");
 const multi_repo_execution_store_1 = require("./multi-repo-execution-store");
 /** Defensive per-ticket cap; contract-layer specs run long but bounded. */
@@ -89,6 +98,85 @@ exports.ACTIVE_PR_DECISIONS = new Set([
 function isTerminalPrDecision(s) {
     return exports.TERMINAL_PR_DECISIONS.has(s);
 }
+const RESTORE_STATUSES = new Set(['resolving', 'ready', 'failed', 'brought_back', 'discarded']);
+const strings = (v, max) => Array.isArray(v) ? v.filter((p) => typeof p === 'string').slice(0, max) : [];
+function readRestoreBranch(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const v = raw;
+    if (typeof v.status !== 'string' || !RESTORE_STATUSES.has(v.status) || typeof v.branch !== 'string' || !v.branch)
+        return null;
+    const sha = (x) => typeof x === 'string' && /^[0-9a-f]{40,64}$/i.test(x) ? x : null;
+    const count = (x) => typeof x === 'number' && Number.isFinite(x) ? x : null;
+    return {
+        status: v.status,
+        branch: v.branch,
+        worktreePath: typeof v.worktreePath === 'string' ? v.worktreePath : '',
+        baseSha: sha(v.baseSha),
+        commitSha: sha(v.commitSha),
+        resolvedBy: v.resolvedBy === 'clean' || v.resolvedBy === 'resolver' ? v.resolvedBy : null,
+        managedPaths: strings(v.managedPaths, 50),
+        conflictPaths: strings(v.conflictPaths, 20),
+        files: Array.isArray(v.files)
+            ? v.files.filter((f) => !!f && typeof f.path === 'string')
+                .slice(0, 50).map((f) => ({ path: f.path, added: count(f.added), removed: count(f.removed) }))
+            : [],
+        detail: typeof v.detail === 'string' ? v.detail : null,
+        updatedAt: typeof v.updatedAt === 'string' ? v.updatedAt : '',
+    };
+}
+const LOCAL_STASH_STATES = new Set(['saved', 'restored', 'needs_attention', 'released']);
+function readLocalStash(raw) {
+    if (!raw)
+        return null;
+    try {
+        const value = JSON.parse(raw);
+        if (!value || typeof value.sha !== 'string' || !/^[0-9a-f]{40,64}$/i.test(value.sha))
+            return null;
+        if (typeof value.state !== 'string' || !LOCAL_STASH_STATES.has(value.state))
+            return null;
+        return {
+            sha: value.sha,
+            name: typeof value.name === 'string' ? value.name : '',
+            checkoutPath: typeof value.checkoutPath === 'string' ? value.checkoutPath : '',
+            branch: typeof value.branch === 'string' ? value.branch : '',
+            state: value.state,
+            restoreBranch: typeof value.restoreBranch === 'string' ? value.restoreBranch : null,
+            conflictPaths: Array.isArray(value.conflictPaths) ? value.conflictPaths.filter((p) => typeof p === 'string').slice(0, 20) : [],
+            restore: readRestoreBranch(value.restore),
+            savedAt: typeof value.savedAt === 'string' ? value.savedAt : '',
+            updatedAt: typeof value.updatedAt === 'string' ? value.updatedAt : '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Persist the local-stash record independently of the decision lease, like a
+ * safety archive: it points at the person's own work, so a raced decision CAS
+ * must never be able to lose it. Optionally move `status_code` off/onto
+ * `local_changes_attention` in the same statement (only from `fromStatus`).
+ */
+function setPrDeliveryLocalStash(db, id, record, status) {
+    const value = JSON.stringify({ ...record, conflictPaths: record.conflictPaths.slice(0, 20) });
+    if (status) {
+        db.prepare(`
+      UPDATE rail_pr_deliveries
+         SET status_code = ?, updated_at = ${NEXT_PR_UPDATED_AT_SQL}
+       WHERE id = ? AND status_code = ?
+    `).run(status.to, id, status.from);
+    }
+    return db.prepare(`
+    UPDATE rail_pr_deliveries
+       SET local_stash = ?, updated_at = ${NEXT_PR_UPDATED_AT_SQL}
+     WHERE id = ?
+  `).run(value, id).changes > 0;
+}
+/** Every delivery that still references a stash Specrails must restore or keep. */
+function listPrDeliveriesWithLocalStash(db) {
+    return db.prepare(`SELECT * FROM rail_pr_deliveries WHERE local_stash IS NOT NULL ORDER BY created_at`).all();
+}
 /**
  * Insert a new delivery row for a rail launch. The row starts at
  * decision='building', pr_state='none' with empty branches/worktree_ids —
@@ -101,13 +189,26 @@ function createPrDelivery(db, input) {
        loop_name, origin_surface, origin_conversation_id,
        implementation_outcome, delivery_outcome, status_code,
        is_continuation, supersedes_delivery_id, spec_snapshot,
-       revision_note, revision_of, parent_delivery_id, repository_id, repository_path, follow_up, spec_addenda, launch_config_json
+       revision_note, revision_of, parent_delivery_id, repository_id, repository_path, follow_up, spec_addenda, launch_config_json,
+       recommended_loop, chosen_loop
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', 'pending',
-       'implementation_running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.railIndex, input.loopId ?? null, input.railKey, JSON.stringify(input.ticketIds), input.baseBranch, input.loopName, input.originSurface, input.originConversationId ?? null, input.isContinuation ? 1 : 0, input.supersedesDeliveryId ?? null, input.specSnapshot && input.specSnapshot.length > 0
+       'implementation_running', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.railIndex, input.loopId ?? null, input.railKey, JSON.stringify(input.ticketIds), input.baseBranch, input.loopName, input.originSurface, input.originConversationId ?? null, input.isContinuation ? 1 : 0, input.supersedesDeliveryId ?? null, input.specSnapshot && input.specSnapshot.length > 0
         ? JSON.stringify(boundSpecSnapshot(input.specSnapshot))
-        : null, input.revisionNote ? boundRevisionNote(input.revisionNote) : null, input.revisionOf ?? null, input.parentDeliveryId ?? null, input.repositoryId ?? null, input.repositoryPath ?? null, input.followUp ? JSON.stringify(input.followUp) : null, input.specAddenda && input.specAddenda.length > 0 ? JSON.stringify(input.specAddenda) : null, input.launchConfig ? JSON.stringify(input.launchConfig) : null);
+        : null, input.revisionNote ? boundRevisionNote(input.revisionNote) : null, input.revisionOf ?? null, input.parentDeliveryId ?? null, input.repositoryId ?? null, input.repositoryPath ?? null, input.followUp ? JSON.stringify(input.followUp) : null, input.specAddenda && input.specAddenda.length > 0 ? JSON.stringify(input.specAddenda) : null, input.launchConfig ? JSON.stringify(input.launchConfig) : null, input.loopChoice?.recommendedLoop ?? null, input.loopChoice?.chosenLoop ?? null);
     return getPrDelivery(db, id);
 }
+/**
+ * Triage accuracy for loop economics (launch-triage): over root deliveries
+ * (one per launch) that carried a recommendation, how many launched exactly
+ * the recommended loop. Optional ISO lower bound on `created_at`.
+ */
+function getTriageAccuracy(db, opts = {}) {
+    const rows = db.prepare(`SELECT recommended_loop AS recommendedLoop, chosen_loop AS chosenLoop
+       FROM rail_pr_deliveries
+      WHERE parent_delivery_id IS NULL AND recommended_loop IS NOT NULL
+        ${opts.since ? 'AND created_at >= datetime(?)' : ''}`).all(...(opts.since ? [opts.since] : []));
+    return (0, triage_1.triageAccuracy)(rows);
+}
 /**
  * A delivery that failed BEFORE any repository work was allocated (e.g. `git
  * worktree add` refused): it never ran, so it owns no worktree, branch, commit
@@ -407,6 +508,43 @@ function reconcileFailedBuildingPrDeliveries(db, opts = {}) {
     }
     return reconciled;
 }
+const STAMP_COLUMNS = {
+    onReviewAt: 'on_review_at',
+    decidedAt: 'decided_at',
+    publishedAt: 'published_at',
+    mergedAt: 'merged_at',
+};
+/** Pure: which first-write-wins instants a `expected → next` transition sets.
+ * Entering `on_review` proves reviewability; entering `pr_ready` proves the PR
+ * was published for review; entering `merged` proves the merge. A human
+ * decision is never inferred from a transition (startup recovery may leave
+ * `on_review` automatically) — only decision adapters pass `decidedAt`. */
+function lifecycleStamps(expected, next, patch, nowIso) {
+    const stamps = {};
+    if (next === 'on_review' && expected !== 'on_review')
+        stamps.onReviewAt = nowIso;
+    if (patch.decidedAt)
+        stamps.decidedAt = patch.decidedAt;
+    const published = patch.publishedAt ?? (next === 'pr_ready' && expected !== 'pr_ready' ? nowIso : undefined);
+    if (published)
+        stamps.publishedAt = published;
+    const merged = patch.mergedAt ?? (next === 'merged' && expected !== 'merged' ? nowIso : undefined);
+    if (merged)
+        stamps.mergedAt = merged;
+    return stamps;
+}
+function stampClause(expected, next, patch) {
+    const stamps = lifecycleStamps(expected, next, patch, new Date().toISOString());
+    const keys = Object.keys(stamps);
+    return {
+        clause: keys.map((key) => `, ${STAMP_COLUMNS[key]} = COALESCE(${STAMP_COLUMNS[key]}, ?)`).join(''),
+        values: keys.map((key) => stamps[key]),
+    };
+}
+function patchKeys(patch) {
+    return Object.keys(patch)
+        .filter((key) => key in PATCH_COLUMNS && patch[key] !== undefined);
+}
 // Column allow-list — patch keys are interpolated into the SET clause, so gate
 // them to prevent any future caller injecting SQL via an object key (values
 // are always parameterized). Mirrors loop-runs-store's COUNTER_COLUMNS.
@@ -508,14 +646,15 @@ function appendPrDeliverySafetyArchive(db, id, archive) {
  * always bumped.
  */
 function transitionDecision(db, id, expected, next, patch = {}) {
-    const keys = Object.keys(patch).filter((k) => patch[k] !== undefined);
+    const keys = patchKeys(patch);
     const patchClause = keys.map((k) => `, ${PATCH_COLUMNS[k]} = ?`).join('');
     const values = keys.map((k) => patchValue(k, patch));
+    const stamps = stampClause(expected, next, patch);
     return (db
         .prepare(`UPDATE rail_pr_deliveries
-         SET decision = ?, updated_at = ${NEXT_PR_UPDATED_AT_SQL}${patchClause}
+         SET decision = ?, updated_at = ${NEXT_PR_UPDATED_AT_SQL}${patchClause}${stamps.clause}
          WHERE id = ? AND decision = ?`)
-        .run(next, ...values, id, expected).changes > 0);
+        .run(next, ...values, ...stamps.values, id, expected).changes > 0);
 }
 /** Complete a decision transition only while the caller still owns the lease it
  * claimed before external effects. A reclaimed stale lease invalidates the old
@@ -524,14 +663,15 @@ function transitionDecision(db, id, expected, next, patch = {}) {
 function transitionClaimedDecision(db, id, expected, next, operationToken, patch = {}) {
     if (!operationToken)
         return false;
-    const keys = Object.keys(patch).filter((key) => patch[key] !== undefined);
+    const keys = patchKeys(patch);
     const patchClause = keys.map((key) => `, ${PATCH_COLUMNS[key]} = ?`).join('');
     const values = keys.map((key) => patchValue(key, patch));
+    const stamps = stampClause(expected, next, patch);
     return db.prepare(`
     UPDATE rail_pr_deliveries
-       SET decision = ?, updated_at = ${NEXT_PR_UPDATED_AT_SQL}${patchClause}
+       SET decision = ?, updated_at = ${NEXT_PR_UPDATED_AT_SQL}${patchClause}${stamps.clause}
      WHERE id = ? AND decision = ? AND operation_token = ?
-  `).run(next, ...values, id, expected, operationToken).changes > 0;
+  `).run(next, ...values, ...stamps.values, id, expected, operationToken).changes > 0;
 }
 /** Decision-side Git/GitHub effects must be claimed BEFORE they start. The
  * stale lease is reclaimable after a dead process; a live loser performs zero
@@ -590,6 +730,19 @@ function clearOrphanedPrDeliveryOperations(db) {
      WHERE operation IS NOT NULL OR operation_token IS NOT NULL OR operation_started_at_ms IS NOT NULL
   `).run().changes;
 }
+/** Risk summary of a row's harvested reviewer brief (null when none recorded).
+ *  The substring guard keeps snapshots of brief-less rows from parsing JSON. */
+function readDeliveryRiskSummary(settleEvidence) {
+    if (!settleEvidence || !settleEvidence.includes('"reviewBrief"'))
+        return null;
+    try {
+        const evidence = JSON.parse(settleEvidence);
+        return Array.isArray(evidence?.units) ? (0, review_brief_1.summarizeReviewBriefs)(evidence.units.map((unit) => unit?.reviewBrief)) : null;
+    }
+    catch {
+        return null;
+    }
+}
 function parseJsonArray(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -604,7 +757,11 @@ function updatePrDeliverySettleEvidence(db, id, evidence) {
     return db.prepare('UPDATE rail_pr_deliveries SET settle_evidence = ? WHERE id = ?').run(JSON.stringify(evidence), id).changes > 0;
 }
 function toPrDeliverySnapshot(row) {
-    const units = parseJsonArray(row.branches);
+    const storedUnits = parseJsonArray(row.branches);
+    // A Flow → Spec delivery settled as a generic failure whose evidence shows
+    // requested changes reads exactly like one settled as such today.
+    const legacyFlowReview = (0, flow_review_outcome_1.legacyFlowReviewReclassification)(row, storedUnits);
+    const units = legacyFlowReview?.units ?? storedUnits;
     return {
         ...(row.execution_manifest ? { executionManifest: (0, multi_repo_execution_store_1.readExecutionManifest)(row.execution_manifest), repositoryDeliveries: parseJsonArray(row.repository_deliveries ?? '[]') } : {}),
         id: row.id,
@@ -620,8 +777,8 @@ function toPrDeliverySnapshot(row) {
         decision: row.decision,
         implementationOutcome: row.implementation_outcome ?? 'unknown',
         deliveryOutcome: row.delivery_outcome ?? 'unknown',
-        statusCode: row.status_code ?? null,
-        statusDetail: row.status_detail ?? null,
+        statusCode: legacyFlowReview?.statusCode ?? row.status_code ?? null,
+        statusDetail: legacyFlowReview?.statusDetail ?? row.status_detail ?? null,
         deliverySha: row.delivery_sha ?? null,
         isContinuation: row.is_continuation === 1,
         supersedesDeliveryId: row.supersedes_delivery_id ?? null,
@@ -639,6 +796,20 @@ function toPrDeliverySnapshot(row) {
         originConversationId: row.origin_conversation_id,
         followUp: (0, pr_follow_up_1.readFollowUp)(row.follow_up),
         specAddenda: (0, spec_addenda_core_1.readSpecAddendaSnapshot)(row.spec_addenda),
+        ...(() => { const riskSummary = readDeliveryRiskSummary(row.settle_evidence); return riskSummary ? { riskSummary } : {}; })(),
+        ...(() => { const flowReview = legacyFlowReview?.flowReview ?? (0, flow_review_outcome_1.readFlowReviewOutcome)(row); return flowReview ? { flowReview } : {}; })(),
+        ...(() => {
+            const stash = readLocalStash(row.local_stash);
+            if (!stash)
+                return {};
+            const { checkoutPath: _checkoutPath, restore, ...rest } = stash;
+            const localStash = { ...rest };
+            if (restore) {
+                const { worktreePath: _worktreePath, ...wire } = restore;
+                localStash.restore = wire;
+            }
+            return { localStash };
+        })(),
         createdAt: row.created_at,
         updatedAt: row.updated_at,
     };
@@ -678,6 +849,11 @@ function toRailPrStateMessage(projectId, snap) {
         units: snap.units,
         runIds: snap.runIds,
         originConversationId: snap.originConversationId,
+        ...(snap.riskSummary ? { riskSummary: snap.riskSummary } : {}),
+        ...(snap.flowReview ? { flowReview: snap.flowReview } : {}),
+        ...(snap.localStash ? { localStash: snap.localStash } : {}),
+        loopId: snap.loopId,
+        loopName: snap.loopName || null,
         createdAt: snap.createdAt,
         updatedAt: snap.updatedAt,
     };
@@ -715,6 +891,11 @@ function toPrDecisionCardEnvelope(projectId, snap) {
         prState: snap.prState,
         branch: snap.branch,
         runIds: snap.runIds,
+        ...(snap.riskSummary ? { riskSummary: snap.riskSummary } : {}),
+        ...(snap.flowReview ? { flowReview: snap.flowReview } : {}),
+        ...(snap.localStash ? { localStash: snap.localStash } : {}),
+        loopId: snap.loopId,
+        loopName: snap.loopName || null,
         createdAt: snap.createdAt,
         updatedAt: snap.updatedAt,
         // mission-rail-cards: coarse phase so the card renders the run header