specrails-desktop 2.29.0 → 2.29.2

package/server/dist/rail-pr-delivery.js

@@ -17,6 +17,7 @@ async function deliverRailAsPr(git, exec, input) {
             baseBranch: input.integrationBranch,
             title: input.title,
             body: input.body,
+            sourceSha: b.sourceSha,
         });
         return { state: 'delivered', branch: b.branch, pr, ticketIds: [b.ticketId] };
     }
@@ -46,7 +47,7 @@ async function deliverRailAsPr(git, exec, input) {
         return { state: 'assembly-failed', reason: firstLine(add) || 'worktree-add-failed', ticketIds };
     }
     for (const b of succeeded) {
-        const merge = await git.run(['merge', '--no-ff', '--no-edit', b.branch], wt);
+        const merge = await git.run(['merge', '--no-ff', '--no-edit', b.sourceSha ?? b.branch], wt);
         if (merge.code !== 0) {
             // Conflict/failure → abort and tear the batch down cleanly. Ticket branches
             // stay intact for a human. Never leave a half-merged batch.

package/server/dist/rail-pr-store.js

@@ -1,25 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ACTIVE_PR_DECISIONS = exports.TERMINAL_PR_DECISIONS = void 0;
+exports.PrDeliveryGenerationConflict = exports.ACTIVE_PR_DECISIONS = exports.TERMINAL_PR_DECISIONS = void 0;
 exports.isTerminalPrDecision = isTerminalPrDecision;
 exports.createPrDelivery = createPrDelivery;
+exports.createPrDeliveryGeneration = createPrDeliveryGeneration;
+exports.failPrDeliveryAndRestoreSuperseded = failPrDeliveryAndRestoreSuperseded;
 exports.getPrDelivery = getPrDelivery;
 exports.getActivePrDeliveryByRail = getActivePrDeliveryByRail;
 exports.listActivePrDeliveries = listActivePrDeliveries;
+exports.listOriginLinkedPrDeliveries = listOriginLinkedPrDeliveries;
 exports.reconcileFailedBuildingPrDeliveries = reconcileFailedBuildingPrDeliveries;
+exports.boundPrDiagnostic = boundPrDiagnostic;
+exports.boundCleanupWarnings = boundCleanupWarnings;
 exports.transitionDecision = transitionDecision;
+exports.transitionClaimedDecision = transitionClaimedDecision;
+exports.claimPrDeliveryOperation = claimPrDeliveryOperation;
+exports.releasePrDeliveryOperation = releasePrDeliveryOperation;
+exports.clearOrphanedPrDeliveryOperations = clearOrphanedPrDeliveryOperations;
 exports.toPrDeliverySnapshot = toPrDeliverySnapshot;
 exports.toRailPrStateMessage = toRailPrStateMessage;
 exports.toPrDecisionCardEnvelope = toPrDecisionCardEnvelope;
 const ids_1 = require("./ids");
 /** States after which the delivery is closed (no further decision possible). */
-exports.TERMINAL_PR_DECISIONS = new Set(['merged', 'discarded']);
+exports.TERMINAL_PR_DECISIONS = new Set(['completed', 'merged', 'discarded', 'superseded']);
 /** States in which the delivery still awaits (or is executing) a user decision. */
 exports.ACTIVE_PR_DECISIONS = new Set([
     'building',
     'on_review',
+    'no_changes',
     'pr_draft',
     'pr_ready',
+    'pr_closed',
     'implementation_failed',
     'pr_failed',
 ]);
@@ -35,10 +46,87 @@ function createPrDelivery(db, input) {
     const id = input.id ?? (0, ids_1.newId)();
     db.prepare(`INSERT INTO rail_pr_deliveries (
        id, rail_index, loop_id, rail_key, ticket_ids, base_branch,
-       loop_name, origin_surface, origin_conversation_id
-     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.railIndex, input.loopId ?? null, input.railKey, JSON.stringify(input.ticketIds), input.baseBranch, input.loopName, input.originSurface, input.originConversationId ?? null);
+       loop_name, origin_surface, origin_conversation_id,
+       implementation_outcome, delivery_outcome, status_code,
+       is_continuation, supersedes_delivery_id
+     ) 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);
     return getPrDelivery(db, id);
 }
+class PrDeliveryGenerationConflict extends Error {
+    currentId;
+    code = 'PR_DELIVERY_GENERATION_CONFLICT';
+    constructor(currentId) {
+        super(currentId
+            ? `rail already has active PR delivery ${currentId}`
+            : 'expected active PR delivery is no longer current');
+        this.currentId = currentId;
+        this.name = 'PrDeliveryGenerationConflict';
+    }
+}
+exports.PrDeliveryGenerationConflict = PrDeliveryGenerationConflict;
+/** Recheck admission and, for a continuation, replace the prior generation in
+ * one SQLite transaction. The partial unique index is therefore an invariant,
+ * not merely a router convention. Pass null for a genuinely fresh launch. */
+function createPrDeliveryGeneration(db, input, expectedActive) {
+    return db.transaction(() => {
+        const current = getActivePrDeliveryByRail(db, input.railIndex);
+        if (expectedActive === null) {
+            if (current)
+                throw new PrDeliveryGenerationConflict(current.id);
+            return { delivery: createPrDelivery(db, input), superseded: null };
+        }
+        if (!current || current.id !== expectedActive.id || current.decision !== expectedActive.decision ||
+            current.operation_token !== null) {
+            throw new PrDeliveryGenerationConflict(current?.id ?? null);
+        }
+        const previous = {
+            id: current.id,
+            decision: current.decision,
+            statusCode: current.status_code,
+        };
+        const moved = db.prepare(`
+      UPDATE rail_pr_deliveries
+         SET decision = 'superseded', updated_at = datetime('now')
+       WHERE id = ? AND decision = ? AND operation_token IS NULL
+    `).run(current.id, current.decision);
+        if (moved.changes !== 1)
+            throw new PrDeliveryGenerationConflict(current.id);
+        const delivery = createPrDelivery(db, {
+            ...input,
+            // An expected active generation can be replaced either by a verified
+            // continuation or by a fresh lineage after its recorded PR went stale.
+            // Persist the caller's ownership decision in this same transaction so a
+            // crash cannot expose a fresh branch as a borrowed continuation branch.
+            isContinuation: input.isContinuation ?? true,
+            supersedesDeliveryId: current.id,
+        });
+        return { delivery, superseded: previous };
+    })();
+}
+/** Allocation failed after a continuation generation replaced its predecessor:
+ * close the failed generation first (freeing the unique slot), then restore the
+ * exact prior decision/status. A stale/raced row leaves both untouched. */
+function failPrDeliveryAndRestoreSuperseded(db, failedId, previous) {
+    return db.transaction(() => {
+        const failed = db.prepare(`
+      UPDATE rail_pr_deliveries
+         SET decision = 'discarded', status_code = 'delivery_failed',
+             delivery_outcome = 'blocked', updated_at = datetime('now')
+       WHERE id = ? AND decision = 'building'
+    `).run(failedId);
+        if (failed.changes !== 1)
+            return false;
+        const restored = db.prepare(`
+      UPDATE rail_pr_deliveries
+         SET decision = ?, status_code = ?, updated_at = datetime('now')
+       WHERE id = ? AND decision = 'superseded'
+    `).run(previous.decision, previous.statusCode, previous.id);
+        if (restored.changes !== 1)
+            throw new Error(`failed to restore superseded delivery ${previous.id}`);
+        return true;
+    })();
+}
 function getPrDelivery(db, id) {
     return db.prepare('SELECT * FROM rail_pr_deliveries WHERE id = ?').get(id);
 }
@@ -50,7 +138,7 @@ function getPrDelivery(db, id) {
 function getActivePrDeliveryByRail(db, railIndex) {
     return db
         .prepare(`SELECT * FROM rail_pr_deliveries
-       WHERE rail_index = ? AND decision NOT IN ('merged','discarded')
+       WHERE rail_index = ? AND decision NOT IN ('completed','merged','discarded','superseded')
        ORDER BY created_at DESC, rowid DESC LIMIT 1`)
         .get(railIndex);
 }
@@ -58,37 +146,125 @@ function getActivePrDeliveryByRail(db, railIndex) {
 function listActivePrDeliveries(db) {
     return db
         .prepare(`SELECT * FROM rail_pr_deliveries
-       WHERE decision NOT IN ('merged','discarded')
+       WHERE decision NOT IN ('completed','merged','discarded','superseded')
        ORDER BY rail_index, created_at DESC, rowid DESC`)
         .all();
 }
+/** Startup projection source for persisted Agent cards. Terminal rows matter:
+ * a process may die after their SQLite transition but before the conversation
+ * envelope update, leaving an obsolete actionable card pinned forever. */
+function listOriginLinkedPrDeliveries(db) {
+    return db.prepare(`
+    SELECT * FROM rail_pr_deliveries
+     WHERE origin_conversation_id IS NOT NULL
+     ORDER BY created_at ASC, rowid ASC
+  `).all();
+}
 /**
- * Recover implementation cards stranded at `building` after the loop process
- * already settled all associated run ids without a success. This covers server
- * restarts and the settle gap where loop_runs/worktrees mark failure but the
- * PR-delivery row never receives its final card state.
+ * Recover cards stranded between engine completion and delivery settlement.
+ * Callers wait for every known run to finish; startup may additionally close
+ * impossible empty/incomplete generations from the prior process. Hydration
+ * never invokes this reconciler. Successful/uncertain work is NEVER called an
+ * implementation failure and this data-only pass never removes a worktree.
  */
-function reconcileFailedBuildingPrDeliveries(db) {
+function reconcileFailedBuildingPrDeliveries(db, opts = {}) {
     const rows = db
         .prepare(`SELECT * FROM rail_pr_deliveries WHERE decision = 'building' ORDER BY created_at ASC, rowid ASC`)
         .all();
     const reconciled = [];
     for (const row of rows) {
         const runIds = parseJsonArray(row.run_ids ?? '[]');
-        if (runIds.length === 0)
+        if (runIds.length === 0) {
+            if (!opts.startup)
+                continue;
+            if (transitionDecision(db, row.id, 'building', 'pr_failed', {
+                implementationOutcome: 'unknown',
+                deliveryOutcome: 'blocked',
+                statusCode: 'settlement_interrupted',
+                statusDetail: 'The prior process stopped before run allocation became durable.',
+            })) {
+                const updated = getPrDelivery(db, row.id);
+                if (updated)
+                    reconciled.push(updated);
+            }
             continue;
+        }
         const uniqueRunIds = [...new Set(runIds)];
         const placeholders = uniqueRunIds.map(() => '?').join(',');
         const runs = db
             .prepare(`SELECT id, status, final_outcome FROM loop_runs WHERE id IN (${placeholders})`)
             .all(...uniqueRunIds);
-        if (runs.length !== uniqueRunIds.length)
-            continue;
-        if (runs.some((run) => run.status !== 'completed'))
+        if (runs.length !== uniqueRunIds.length || runs.some((run) => run.status !== 'completed')) {
+            if (!opts.startup)
+                continue;
+            if (transitionDecision(db, row.id, 'building', 'pr_failed', {
+                implementationOutcome: 'unknown',
+                deliveryOutcome: 'blocked',
+                statusCode: 'settlement_interrupted',
+                statusDetail: 'The prior process stopped before every implementation unit settled.',
+            })) {
+                const updated = getPrDelivery(db, row.id);
+                if (updated)
+                    reconciled.push(updated);
+            }
             continue;
-        if (runs.some((run) => run.final_outcome === 'success'))
+        }
+        const successfulRunIds = new Set(runs.filter((run) => run.final_outcome === 'success').map((run) => run.id));
+        if (successfulRunIds.size === 0) {
+            if (transitionDecision(db, row.id, 'building', 'implementation_failed', {
+                implementationOutcome: 'failed',
+                deliveryOutcome: 'not_started',
+                statusCode: 'implementation_failed',
+            })) {
+                const updated = getPrDelivery(db, row.id);
+                if (updated)
+                    reconciled.push(updated);
+            }
             continue;
-        if (transitionDecision(db, row.id, 'building', 'implementation_failed')) {
+        }
+        const placeholdersForWorktrees = uniqueRunIds.map(() => '?').join(',');
+        const worktrees = db.prepare(`
+      SELECT id, ticket_id, run_id, branch, merge_state
+        FROM rail_worktrees
+       WHERE run_id IN (${placeholdersForWorktrees})
+       ORDER BY created_at ASC, rowid ASC
+    `).all(...uniqueRunIds);
+        const reconstructed = worktrees.map((worktree) => {
+            const implementationSucceeded = worktree.run_id != null && successfulRunIds.has(worktree.run_id);
+            const deliveryReady = implementationSucceeded && ['built', 'released'].includes(worktree.merge_state);
+            return {
+                ticketId: worktree.ticket_id,
+                branch: worktree.branch,
+                succeeded: deliveryReady,
+                ...(worktree.run_id ? { runId: worktree.run_id } : {}),
+                implementationOutcome: implementationSucceeded ? 'succeeded' : 'failed',
+                deliveryOutcome: deliveryReady ? 'ready' : implementationSucceeded ? 'blocked' : 'not_started',
+                changed: deliveryReady,
+                ...(!deliveryReady && implementationSucceeded ? { failureCode: 'settlement_interrupted' } : {}),
+            };
+        });
+        const readyCount = reconstructed.filter((unit) => unit.succeeded).length;
+        const implementationOutcome = successfulRunIds.size === runs.length
+            ? 'succeeded'
+            : 'partially_succeeded';
+        const canResumeFreshReview = row.is_continuation !== 1 && readyCount > 0;
+        const next = canResumeFreshReview ? 'on_review' : 'pr_failed';
+        const deliveryOutcome = canResumeFreshReview
+            ? (implementationOutcome === 'partially_succeeded' ? 'partial' : 'ready')
+            : 'blocked';
+        const statusCode = canResumeFreshReview
+            ? (implementationOutcome === 'partially_succeeded' ? 'partial_success' : 'ready_for_review')
+            : 'settlement_interrupted';
+        if (transitionDecision(db, row.id, 'building', next, {
+            implementationOutcome,
+            deliveryOutcome,
+            statusCode,
+            statusDetail: canResumeFreshReview
+                ? 'Recovered committed implementation branches after an interrupted settlement.'
+                : 'Implementation completed, but delivery settlement was interrupted before an exact deliverable could be proven.',
+            ...(reconstructed.length > 0 ? { branches: reconstructed } : {}),
+            ...(worktrees.length > 0 ? { worktreeIds: worktrees.map((worktree) => worktree.id) } : {}),
+        })) {
             const updated = getPrDelivery(db, row.id);
             if (updated)
                 reconciled.push(updated);
@@ -107,13 +283,40 @@ const PATCH_COLUMNS = {
     branches: 'branches',
     worktreeIds: 'worktree_ids',
     runIds: 'run_ids',
+    implementationOutcome: 'implementation_outcome',
+    deliveryOutcome: 'delivery_outcome',
+    statusCode: 'status_code',
+    statusDetail: 'status_detail',
+    deliverySha: 'delivery_sha',
+    isContinuation: 'is_continuation',
+    supersedesDeliveryId: 'supersedes_delivery_id',
+    operation: 'operation',
+    operationToken: 'operation_token',
+    operationStartedAtMs: 'operation_started_at_ms',
+    cleanupWarnings: 'cleanup_warnings',
 };
 function patchValue(key, patch) {
     const raw = patch[key];
     if (key === 'branches' || key === 'worktreeIds' || key === 'runIds')
         return JSON.stringify(raw);
+    if (key === 'cleanupWarnings')
+        return JSON.stringify(boundCleanupWarnings(raw));
+    if (key === 'statusDetail')
+        return raw == null ? null : boundPrDiagnostic(String(raw));
+    if (key === 'isContinuation')
+        return raw ? 1 : 0;
     return raw;
 }
+/** Bounded, single-line diagnostics are safe to persist/broadcast as secondary
+ * detail. Primary UI copy always derives from status_code. */
+function boundPrDiagnostic(value, maxLength = 512) {
+    return value.replace(/[\r\n\t\0]+/g, ' ').replace(/\s{2,}/g, ' ').trim().slice(0, maxLength);
+}
+/** Cleanup is best-effort; retain enough unique warnings to be honest without
+ * allowing unbounded command output to inflate every snapshot. */
+function boundCleanupWarnings(values) {
+    return [...new Set(values.map((value) => boundPrDiagnostic(value)).filter(Boolean))].slice(0, 8);
+}
 /**
  * COMPARE-AND-SET decision transition: one atomic
  * `UPDATE … WHERE id = ? AND decision = ?` (no read-modify-write), so two
@@ -132,6 +335,71 @@ function transitionDecision(db, id, expected, next, patch = {}) {
          WHERE id = ? AND decision = ?`)
         .run(next, ...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
+ * worker's final CAS, so it cannot overwrite the newer owner's authoritative
+ * state after eventually returning. */
+function transitionClaimedDecision(db, id, expected, next, operationToken, patch = {}) {
+    if (!operationToken)
+        return false;
+    const keys = Object.keys(patch).filter((key) => patch[key] !== undefined);
+    const patchClause = keys.map((key) => `, ${PATCH_COLUMNS[key]} = ?`).join('');
+    const values = keys.map((key) => patchValue(key, patch));
+    return db.prepare(`
+    UPDATE rail_pr_deliveries
+       SET decision = ?, updated_at = datetime('now')${patchClause}
+     WHERE id = ? AND decision = ? AND operation_token = ?
+  `).run(next, ...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
+ * external work. `expected` remains the visible decision throughout the effect
+ * so the final decision transition keeps its existing CAS contract. */
+function claimPrDeliveryOperation(db, id, expected, operation, token, nowMs = Date.now(), leaseMs = 30 * 60 * 1000) {
+    if (!token)
+        return false;
+    const staleBefore = nowMs - Math.max(1, leaseMs);
+    return db.prepare(`
+    UPDATE rail_pr_deliveries
+       SET operation = ?, operation_token = ?, operation_started_at_ms = ?,
+           updated_at = datetime('now')
+     WHERE id = ? AND decision = ?
+       AND (operation_token IS NULL OR operation_started_at_ms IS NULL OR operation_started_at_ms < ?)
+  `).run(operation, token, nowMs, id, expected, staleBefore).changes > 0;
+}
+/** Release only the caller's lease. Works after a successful decision change,
+ * too, so a handler can use one `finally` without racing a newer operation. */
+function releasePrDeliveryOperation(db, id, token) {
+    return db.prepare(`
+    UPDATE rail_pr_deliveries
+       SET operation = NULL, operation_token = NULL, operation_started_at_ms = NULL,
+           updated_at = datetime('now')
+     WHERE id = ? AND operation_token = ?
+  `).run(id, token).changes > 0;
+}
+/** A process restart proves every persisted decision lease is orphaned: tokens
+ * are process-local capabilities and no prior worker can still complete inside
+ * this process. Clear them while startup admission is closed so reprojected
+ * cards never remain permanently disabled as "Publishing…"/"Discarding…". */
+function clearOrphanedPrDeliveryOperations(db) {
+    return db.prepare(`
+    UPDATE rail_pr_deliveries
+       SET operation = NULL, operation_token = NULL, operation_started_at_ms = NULL,
+           status_code = CASE
+             WHEN decision NOT IN ('completed','merged','discarded','superseded')
+             THEN 'operation_interrupted'
+             ELSE status_code
+           END,
+           status_detail = CASE
+             WHEN decision NOT IN ('completed','merged','discarded','superseded')
+              AND (status_detail IS NULL OR status_detail = '')
+             THEN 'A previous delivery action was interrupted by restart. Its durable evidence was preserved; review the current state and retry.'
+             ELSE status_detail
+           END,
+           updated_at = datetime('now')
+     WHERE operation IS NOT NULL OR operation_token IS NOT NULL OR operation_started_at_ms IS NOT NULL
+  `).run().changes;
+}
 function parseJsonArray(raw) {
     try {
         const parsed = JSON.parse(raw);
@@ -142,6 +410,7 @@ function parseJsonArray(raw) {
     }
 }
 function toPrDeliverySnapshot(row) {
+    const units = parseJsonArray(row.branches);
     return {
         id: row.id,
         railIndex: row.rail_index,
@@ -154,7 +423,17 @@ function toPrDeliverySnapshot(row) {
         prNumber: row.pr_number,
         prState: row.pr_state,
         decision: row.decision,
-        branches: parseJsonArray(row.branches),
+        implementationOutcome: row.implementation_outcome ?? 'unknown',
+        deliveryOutcome: row.delivery_outcome ?? 'unknown',
+        statusCode: row.status_code ?? null,
+        statusDetail: row.status_detail ?? null,
+        deliverySha: row.delivery_sha ?? null,
+        isContinuation: row.is_continuation === 1,
+        supersedesDeliveryId: row.supersedes_delivery_id ?? null,
+        operation: row.operation ?? null,
+        cleanupWarnings: parseJsonArray(row.cleanup_warnings ?? '[]'),
+        branches: units,
+        units,
         loopName: row.loop_name,
         worktreeIds: parseJsonArray(row.worktree_ids),
         runIds: parseJsonArray(row.run_ids ?? '[]'),
@@ -184,6 +463,16 @@ function toRailPrStateMessage(projectId, snap) {
         prNumber: snap.prNumber,
         prState: snap.prState,
         decision: snap.decision,
+        implementationOutcome: snap.implementationOutcome,
+        deliveryOutcome: snap.deliveryOutcome,
+        statusCode: snap.statusCode,
+        statusDetail: snap.statusDetail,
+        deliverySha: snap.deliverySha,
+        isContinuation: snap.isContinuation,
+        supersedesDeliveryId: snap.supersedesDeliveryId,
+        operation: snap.operation,
+        cleanupWarnings: snap.cleanupWarnings,
+        units: snap.units,
         runIds: snap.runIds,
         originConversationId: snap.originConversationId,
     };
@@ -203,6 +492,16 @@ function toPrDecisionCardEnvelope(projectId, snap) {
         baseBranch: snap.baseBranch,
         ticketIds: snap.ticketIds,
         decision: snap.decision,
+        implementationOutcome: snap.implementationOutcome,
+        deliveryOutcome: snap.deliveryOutcome,
+        statusCode: snap.statusCode,
+        statusDetail: snap.statusDetail,
+        deliverySha: snap.deliverySha,
+        isContinuation: snap.isContinuation,
+        supersedesDeliveryId: snap.supersedesDeliveryId,
+        operation: snap.operation,
+        cleanupWarnings: snap.cleanupWarnings,
+        units: snap.units,
         prUrl: snap.prUrl,
         prNumber: snap.prNumber,
         prState: snap.prState,