specrails-desktop 2.49.2 → 2.51.0

package/server/dist/project-router-tickets.js

@@ -57,6 +57,7 @@ const spec_models_1 = require("./spec-models");
 const provider_selection_1 = require("./provider-selection");
 const ticket_store_1 = require("./ticket-store");
 const explore_draft_title_1 = require("./explore-draft-title");
+const spec_addenda_1 = require("./spec-addenda");
 const cli_prompt_1 = require("./util/cli-prompt");
 const transient_children_1 = require("./transient-children");
 const process_admission_1 = require("./process-admission");
@@ -1535,6 +1536,228 @@ function registerTicketsRoutes(deps) {
             res.status(500).json({ error: 'Failed to create ticket' });
         }
     });
+    // ── Spec addenda (spec-addenda) ─────────────────────────────────────────
+    // Structured iteration notes attached to a spec WITHOUT touching its
+    // description. CRUD here; the launch doors claim them (open → in_flight),
+    // the completion chokepoints settle them, a discarded delivery reopens them.
+    // Never a Jira write-back: addenda are local-only guidance for the run.
+    const ADDENDUM_ID_RE = /^[A-Za-z0-9-]{1,64}$/;
+    const addendaTicketId = (req, res) => {
+        const ticketId = req.params.id;
+        if (!/^\d+$/.test(ticketId)) {
+            res.status(400).json({ error: 'Invalid ticket ID' });
+            return null;
+        }
+        return ticketId;
+    };
+    const addendumId = (req, res) => {
+        const id = req.params.addendumId;
+        if (!ADDENDUM_ID_RE.test(id)) {
+            res.status(400).json({ error: 'Invalid addendum ID' });
+            return null;
+        }
+        return id;
+    };
+    const broadcastTicket = (req, ticket, revision) => {
+        const { broadcast, ticketWatcher } = ctx(req);
+        ticketWatcher.notifyDesktopWrite(revision);
+        const msg = { type: 'ticket_updated', ticket: ticket, projectId: ctx(req).project.id, timestamp: new Date().toISOString() };
+        broadcast(msg);
+    };
+    const addendumEditFailure = (res, failure) => {
+        if (failure === 'not_found') {
+            res.status(404).json({ error: 'addendum_not_found' });
+            return;
+        }
+        if (failure === 'in_flight') {
+            res.status(409).json({ error: 'addendum_in_flight', detail: 'the addendum is frozen inside a running job; wait for it to settle' });
+            return;
+        }
+        res.status(409).json({ error: 'addendum_applied', detail: 'an applied addendum is history; reopen it or add a new one' });
+    };
+    // GET /:projectId/tickets/:id/addenda — list a spec's addenda
+    router.get('/:projectId/tickets/:id/addenda', (req, res) => {
+        const ticketId = addendaTicketId(req, res);
+        if (!ticketId)
+            return;
+        try {
+            const store = (0, ticket_store_1.readStore)(ticketPath(req));
+            const ticket = store.tickets[ticketId];
+            if (!ticket) {
+                res.status(404).json({ error: 'Ticket not found' });
+                return;
+            }
+            res.json({ addenda: (0, spec_addenda_1.readSpecAddenda)(ticket.addenda), revision: store.revision });
+        }
+        catch (err) {
+            console.error('[project-router] addenda list error:', err);
+            res.status(500).json({ error: 'Failed to read addenda' });
+        }
+    });
+    // POST /:projectId/tickets/:id/addenda — add an addendum { kind?, title?, body, originConversationId? }
+    router.post('/:projectId/tickets/:id/addenda', (req, res) => {
+        const ticketId = addendaTicketId(req, res);
+        if (!ticketId)
+            return;
+        let input;
+        try {
+            input = (0, spec_addenda_1.parseSpecAddendumInput)(req.body ?? {});
+        }
+        catch (err) {
+            if (err instanceof spec_addenda_1.SpecAddendumValidationError) {
+                res.status(400).json({ error: 'invalid_addendum', code: err.code, detail: err.message });
+                return;
+            }
+            throw err;
+        }
+        const createdBy = typeof req.body?.createdBy === 'string' && /^[a-z-]{1,32}$/.test(req.body.createdBy) ? req.body.createdBy : 'user';
+        const originConversationId = typeof req.body?.originConversationId === 'string' && /^[A-Za-z0-9-]{1,64}$/.test(req.body.originConversationId) ? req.body.originConversationId : null;
+        try {
+            let created;
+            let updated;
+            let capError = null;
+            const store = (0, ticket_store_1.mutateStore)(ticketPath(req), (s) => {
+                const ticket = s.tickets[ticketId];
+                if (!ticket)
+                    return;
+                try {
+                    created = (0, spec_addenda_1.appendSpecAddendum)(ticket, (0, spec_addenda_1.buildSpecAddendum)(input, { createdBy, originConversationId }));
+                    updated = ticket;
+                }
+                catch (err) {
+                    if (err instanceof spec_addenda_1.SpecAddendumValidationError) {
+                        capError = err;
+                        return;
+                    }
+                    throw err;
+                }
+            });
+            if (capError) {
+                const e = capError;
+                res.status(400).json({ error: 'invalid_addendum', code: e.code, detail: e.message });
+                return;
+            }
+            if (!updated || !created) {
+                res.status(404).json({ error: 'Ticket not found' });
+                return;
+            }
+            broadcastTicket(req, updated, store.revision);
+            res.status(201).json({ addendum: created, ticket: updated, revision: store.revision });
+        }
+        catch (err) {
+            console.error('[project-router] addendum create error:', err);
+            res.status(500).json({ error: 'Failed to add addendum' });
+        }
+    });
+    // PATCH /:projectId/tickets/:id/addenda/:addendumId — edit content and/or move status (open|dismissed);
+    // `force: true` releases an in-flight claim whose run vanished (user escape hatch)
+    router.patch('/:projectId/tickets/:id/addenda/:addendumId', (req, res) => {
+        const ticketId = addendaTicketId(req, res);
+        if (!ticketId)
+            return;
+        const aid = addendumId(req, res);
+        if (!aid)
+            return;
+        const body = req.body ?? {};
+        const wantsContent = body.kind !== undefined || body.title !== undefined || body.body !== undefined;
+        const status = body.status;
+        if (status !== undefined && status !== 'open' && status !== 'dismissed') {
+            res.status(400).json({ error: 'invalid_addendum', code: 'invalid_status', detail: 'status must be open or dismissed' });
+            return;
+        }
+        if (!wantsContent && status === undefined) {
+            res.status(400).json({ error: 'invalid_addendum', code: 'not_object', detail: 'nothing to change' });
+            return;
+        }
+        try {
+            let result = 'not_found';
+            let updated;
+            let validation = null;
+            const store = (0, ticket_store_1.mutateStore)(ticketPath(req), (s) => {
+                const ticket = s.tickets[ticketId];
+                if (!ticket)
+                    return;
+                updated = ticket;
+                if (wantsContent) {
+                    const current = (0, spec_addenda_1.readSpecAddenda)(ticket.addenda).find((a) => a.id === aid);
+                    if (!current) {
+                        result = 'not_found';
+                        return;
+                    }
+                    let input;
+                    try {
+                        input = (0, spec_addenda_1.parseSpecAddendumInput)({ kind: body.kind ?? current.kind, title: body.title ?? current.title, body: body.body ?? current.body });
+                    }
+                    catch (err) {
+                        if (err instanceof spec_addenda_1.SpecAddendumValidationError) {
+                            validation = err;
+                            return;
+                        }
+                        throw err;
+                    }
+                    result = (0, spec_addenda_1.editSpecAddendum)(ticket, aid, input);
+                    if (typeof result === 'string')
+                        return;
+                }
+                if (status !== undefined)
+                    result = (0, spec_addenda_1.setSpecAddendumStatus)(ticket, aid, status, undefined, { force: body.force === true });
+            });
+            if (validation) {
+                const e = validation;
+                res.status(400).json({ error: 'invalid_addendum', code: e.code, detail: e.message });
+                return;
+            }
+            if (!updated) {
+                res.status(404).json({ error: 'Ticket not found' });
+                return;
+            }
+            if (typeof result === 'string') {
+                addendumEditFailure(res, result);
+                return;
+            }
+            broadcastTicket(req, updated, store.revision);
+            res.json({ addendum: result, ticket: updated, revision: store.revision });
+        }
+        catch (err) {
+            console.error('[project-router] addendum update error:', err);
+            res.status(500).json({ error: 'Failed to update addendum' });
+        }
+    });
+    // DELETE /:projectId/tickets/:id/addenda/:addendumId — remove (never while in flight)
+    router.delete('/:projectId/tickets/:id/addenda/:addendumId', (req, res) => {
+        const ticketId = addendaTicketId(req, res);
+        if (!ticketId)
+            return;
+        const aid = addendumId(req, res);
+        if (!aid)
+            return;
+        try {
+            let result = 'not_found';
+            let updated;
+            const store = (0, ticket_store_1.mutateStore)(ticketPath(req), (s) => {
+                const ticket = s.tickets[ticketId];
+                if (!ticket)
+                    return;
+                updated = ticket;
+                result = (0, spec_addenda_1.removeSpecAddendum)(ticket, aid);
+            });
+            if (!updated) {
+                res.status(404).json({ error: 'Ticket not found' });
+                return;
+            }
+            const outcome = result;
+            if (outcome !== true) {
+                addendumEditFailure(res, outcome);
+                return;
+            }
+            broadcastTicket(req, updated, store.revision);
+            res.json({ ok: true, ticket: updated, revision: store.revision });
+        }
+        catch (err) {
+            console.error('[project-router] addendum delete error:', err);
+            res.status(500).json({ error: 'Failed to delete addendum' });
+        }
+    });
     // PATCH /:projectId/tickets/:id — Update ticket fields
     router.patch('/:projectId/tickets/:id', (req, res) => {
         const ticketId = req.params.id;

package/server/dist/queue-manager.js

@@ -33,6 +33,7 @@ const db_1 = require("./db");
 const interactive_job_session_1 = require("./interactive-job-session");
 const attachment_manager_1 = require("./attachment-manager");
 const ticket_store_1 = require("./ticket-store");
+const spec_addenda_1 = require("./spec-addenda");
 const binary_probe_1 = require("./binary-probe");
 const workspace_manager_1 = require("./workspace-manager");
 const claude_trust_1 = require("./claude-trust");
@@ -1481,6 +1482,29 @@ class QueueManager {
             return '';
         }
     }
+    /**
+     * Spec addenda briefing for a job (spec-addenda): claims (idempotently, keyed
+     * on the job id) the open addenda of every ticket the command references and
+     * renders the deterministic briefing. Best-effort: an unreadable store ⇒ ''.
+     */
+    _buildSpecAddendaBriefing(command, jobId) {
+        if (!this._cwd)
+            return '';
+        const ticketIds = this._extractTicketIds(command);
+        if (ticketIds.length === 0)
+            return '';
+        try {
+            const claimed = (0, spec_addenda_1.claimSpecAddendaForRun)(this._resolveTicketsPath(), ticketIds, jobId);
+            if (claimed.store && this._projectId) {
+                (0, spec_addenda_1.broadcastSpecAddendaChange)((msg) => this._broadcast(msg), this._projectId, claimed);
+            }
+            return claimed.briefing;
+        }
+        catch (err) {
+            console.warn(`[queue-manager] failed to build spec addenda briefing: ${err.message}`);
+            return '';
+        }
+    }
     /**
      * Build the Claude prompt for an Freestyle job. Freestyle does NOT invoke
      * a slash command: it sends the resolved pre-prompt followed by the full spec
@@ -2270,9 +2294,18 @@ class QueueManager {
         // prompt. The server route rejects adapters that do not advertise
         // `freestyle` before this point.
         // (`isFreestyle` itself is resolved above, before the systemAppend build.)
-        const railPrompt = isFreestyle
+        let railPrompt = isFreestyle
             ? this._buildFreestylePrompt(commandToRun)
             : (0, runtime_1.formatProviderCommand)(adapter, commandToRun, execution.cwd);
+        // Spec addenda (spec-addenda): every ticket-referencing job carries the
+        // specs' open addenda as a briefing APPENDED after the command (so it rides
+        // as command arguments for CLI providers, plain text for freestyle/runner).
+        // Read + claimed at SPAWN time from the store — restart-durable, and the
+        // same path the loop engine takes, so implement/SDD Quick/freestyle/legacy
+        // all see the identical text.
+        const addendaBriefing = this._buildSpecAddendaBriefing(commandToRun, jobId);
+        if (addendaBriefing)
+            railPrompt = `${railPrompt}\n\n${addendaBriefing}`;
         // Per-job model override (consumed once) takes precedence — used by the
         // freestyle model picker so the user can choose haiku/sonnet/opus per launch.
         const modelOverride = this._jobModelSelection.get(jobId);

package/server/dist/rail-isolated-launch.js

@@ -88,6 +88,8 @@ const loop_executors_1 = require("./loop-executors");
 const worktree_overlay_1 = require("./worktree-overlay");
 const worktree_node_modules_1 = require("./worktree-node-modules");
 const revision_seed_1 = require("./revision-seed");
+const pr_follow_up_1 = require("./pr-follow-up");
+const spec_addenda_1 = require("./spec-addenda");
 const workspace_resolution_1 = require("./workspace-resolution");
 const feature_flags_1 = require("./feature-flags");
 const file_provenance_1 = require("./file-provenance");
@@ -432,6 +434,12 @@ async function launchIsolatedRail(input, io = {}) {
             REVISION_REQUEST: buildRevisionSeedForLaunch(ctx.db, input.revision, ticketIds),
         }
         : (0, loop_constants_1.loadConstantMap)(ctx.desktopDb);
+    // Spec addenda (spec-addenda): the iteration notes the specs carry are
+    // planned ONCE at launch entry (frozen on the delivery row below), then
+    // claimed per allocated unit with that unit's run id and rendered into the
+    // briefing every AI step of the run receives.
+    const addendaStorePath = (0, spec_addenda_1.ticketStorePathForProject)(ctx.project);
+    const addendaPlan = (0, spec_addenda_1.planSpecAddendaAt)(addendaStorePath, ticketIds);
     // Capture the PR-delivery mode ONCE at launch entry so a mid-flight env flip
     // can never split one launch across the two delivery paths.
     const prMode = Boolean(input.repositoryExecution) || (0, rail_isolation_1.isRailPrDeliveryEnabled)();
@@ -720,6 +728,8 @@ async function launchIsolatedRail(input, io = {}) {
                         : null,
                     specSnapshot: buildSpecSnapshot(ctx, ticketIds),
                     ...(input.revision ? { revisionNote: input.revision.note, revisionOf: input.revision.ofDeliveryId } : {}),
+                    ...(input.followUp ? { followUp: input.followUp } : {}),
+                    ...(addendaPlan.length > 0 ? { specAddenda: (0, spec_addenda_1.snapshotSpecAddenda)(addendaPlan) } : {}),
                 }, input.requiredPrContinuation
                     ? { id: input.requiredPrContinuation.deliveryId, decision: input.requiredPrContinuation.decision }
                     // A revision replaces the generation it revises, atomically, so the rail
@@ -1219,6 +1229,10 @@ async function launchIsolatedRail(input, io = {}) {
             requiresTerminalIntent: true,
         });
         const spec = ctx.getTicketSpec(a.ticketId);
+        const claimedAddenda = (0, spec_addenda_1.claimSpecAddendaForRun)(addendaStorePath, a.ticketIds, a.runId, {
+            plan: addendaPlan.filter((e) => a.ticketIds.includes(e.ticketId)),
+        });
+        (0, spec_addenda_1.broadcastSpecAddendaChange)((msg) => ctx.broadcast(msg), ctx.project.id, claimedAddenda);
         const enginePromise = ctx.loopRunManager.run({
             runtimeProviderOverride: input.runtimeProviderOverride,
             runId: a.runId, loopId, loopName, graph: loopGraph, projectId: ctx.project.id,
@@ -1240,6 +1254,8 @@ async function launchIsolatedRail(input, io = {}) {
             deferTerminalOutcome: true,
             constants, provider, model, effort, ...(deciderEngine ? { deciderEngine } : {}),
             profileName: input.profileName,
+            ...(input.followUp ? { followUp: { id: input.followUp.id, version: input.followUp.version, hash: input.followUp.hash, briefing: (0, pr_follow_up_1.renderFollowUpBriefing)(input.followUp, { prNumber: launchContinuation?.prNumber ?? input.explicitPrTarget?.prNumber ?? null, ticketIds }) } } : {}),
+            ...(claimedAddenda.briefing ? { addenda: { ids: claimedAddenda.snapshot.map((e) => e.id), briefing: claimedAddenda.briefing } } : {}),
         });
         runPromises.push(settleAllocatedRun(a, enginePromise));
         try {

package/server/dist/rail-launch-parser.js

@@ -19,6 +19,7 @@ exports.coerceRailLaunchProposal = coerceRailLaunchProposal;
 exports.extractRailLaunchProposals = extractRailLaunchProposals;
 exports.looksLikeRailLaunch = looksLikeRailLaunch;
 const json_tolerant_1 = require("./json-tolerant");
+const pr_follow_up_scope_1 = require("./pr-follow-up-scope");
 exports.RAIL_LAUNCH_FENCE = 'rail-launch';
 exports.RAIL_LAUNCH_PROPOSAL_VERSION = 1;
 exports.RAIL_LAUNCH_MODES = ['implement', 'batch-implement', 'freestyle', 'loop'];
@@ -97,9 +98,20 @@ function coerceRailLaunchProposal(value) {
             baseBranch: optString(value.baseBranch, 200),
             railName: optString(value.railName ?? value.name, 80),
             rationale: optString(value.rationale ?? value.reason ?? value.why, 400),
+            followUp: coerceFollowUp(value.followUp),
         },
     };
 }
+function coerceFollowUp(value) {
+    if (value === undefined || value === null)
+        return null;
+    try {
+        return (0, pr_follow_up_scope_1.parseFollowUpInput)(value);
+    }
+    catch {
+        return null;
+    }
+}
 function tidy(body) {
     return body.replace(/\n{3,}/g, '\n\n').trim();
 }

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

@@ -162,7 +162,13 @@ async function executePrDecision(deps, input) {
         return { status: 404, body: { error: 'Unknown prDeliveryId' } };
     if (row.parent_delivery_id && deps.repositoryChildOf !== row.parent_delivery_id)
         return { status: 409, body: { error: 'repository_delivery_requires_parent', parentDeliveryId: row.parent_delivery_id } };
-    if (!row.parent_delivery_id && row.execution_manifest) {
+    // A manifest alone does not make a repository GROUP: a launch that failed
+    // before allocating a single repository delivery persists the parent with
+    // its manifest and zero children (observed: `git worktree add` refused
+    // because the PR branch was checked out in the main clone). Routing that
+    // parent into the group path 404'd on "no repositories" — which the UI read
+    // as "already resolved" — and left the rail pinned at pending_decision.
+    if (!row.parent_delivery_id && row.execution_manifest && (0, rail_pr_store_1.hasRepositoryDeliveries)(deps.db, row.id)) {
         const { executeRepositoryGroupDecision } = await Promise.resolve().then(() => __importStar(require('./multi-repo-delivery')));
         return executeRepositoryGroupDecision(deps, input);
     }
@@ -1525,6 +1531,16 @@ async function runDiscard(deps, row, opts = { removeNeedsReview: true }) {
     // borrows the PR/ticket lifecycle. Per-unit ownership below independently
     // prevents deletion of borrowed/pre-existing head refs for fresh replacements.
     const preserveExternalReview = row.is_continuation === 1;
+    // A preparation failure never ran: no worktree, no branch, no commit, no PR.
+    // Discarding it only closes the attempt and frees the rail — the spec keeps
+    // the status it had (typically on_review from a still-open earlier PR), the
+    // backlog/Jira are not told about a delivery that never existed, and no
+    // resource cleanup can be owed. Distinct from implementation_failed, which
+    // did run and did move the ticket.
+    const preparationFailure = row.decision === 'pr_failed' &&
+        row.implementation_outcome === 'failed' &&
+        !row.pr_url && !row.delivery_sha && !preserveExternalReview &&
+        snap.branches.length === 0 && snap.worktreeIds.length === 0;
     const cleanupWarnings = [];
     // A continuation borrows an existing PR/head. Discarding its local iteration
     // may remove Specrails' worktree, but never closes or deletes borrowed review
@@ -1620,7 +1636,7 @@ async function runDiscard(deps, row, opts = { removeNeedsReview: true }) {
         statusCode: cleanupWarnings.length > 0 ? 'cleanup_incomplete' : 'discarded',
         cleanupWarnings,
     };
-    const conflict = preserveExternalReview
+    const conflict = preserveExternalReview || preparationFailure
         ? casTransition(deps, row, 'discarded', terminalPatch)
         : casTransitionWithTicketEffect(deps, row, 'discarded', terminalPatch, {
             deliveryId: row.id,
@@ -1634,7 +1650,7 @@ async function runDiscard(deps, row, opts = { removeNeedsReview: true }) {
     if (conflict)
         return conflict;
     pauseChainsOnDiscard(deps, row);
-    if (!preserveExternalReview)
+    if (!preserveExternalReview && !preparationFailure)
         applyTerminalTicketEffect(deps, row, 'discarded', cleanupWarnings);
     finalizeTransition(deps, row.id);
     return {
@@ -1643,6 +1659,7 @@ async function runDiscard(deps, row, opts = { removeNeedsReview: true }) {
             ok: true,
             decision: 'discarded',
             ...(cleanupWarnings.length > 0 ? { cleanupWarnings } : {}),
+            ...(preparationFailure ? { preparationFailure: true } : {}),
             ...(preserveExternalReview ? { preservedBorrowedReview: true, preservedExternalReview: true } : {}),
         },
     };

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

@@ -6,10 +6,12 @@ exports.boundRevisionNote = boundRevisionNote;
 exports.readSpecSnapshot = readSpecSnapshot;
 exports.isTerminalPrDecision = isTerminalPrDecision;
 exports.createPrDelivery = createPrDelivery;
+exports.isPreparationFailureRow = isPreparationFailureRow;
 exports.createPrDeliveryGeneration = createPrDeliveryGeneration;
 exports.failPrDeliveryAndRestoreSuperseded = failPrDeliveryAndRestoreSuperseded;
 exports.getPrDelivery = getPrDelivery;
 exports.getActivePrDeliveryByRail = getActivePrDeliveryByRail;
+exports.hasRepositoryDeliveries = hasRepositoryDeliveries;
 exports.listActivePrDeliveries = listActivePrDeliveries;
 exports.listTerminalPrDeliveries = listTerminalPrDeliveries;
 exports.getLatestTerminalPrDeliveryTouchingTicketSet = getLatestTerminalPrDeliveryTouchingTicketSet;
@@ -30,6 +32,17 @@ exports.toPrDeliverySnapshot = toPrDeliverySnapshot;
 exports.toRailPrStateMessage = toRailPrStateMessage;
 exports.toPrDecisionCardEnvelope = toPrDecisionCardEnvelope;
 exports.missionPhaseForDecision = missionPhaseForDecision;
+/**
+ * CRUD for the `rail_pr_deliveries` ledger (migration 36) — one row per isolated
+ * rail LAUNCH tracking the ask-first PR decision lifecycle. This is the single
+ * authoritative server-side state both decision surfaces (the rail row on the
+ * dashboard and the launching agent-chat conversation) read and write, so the
+ * two surfaces never desync and a refresh/restart never loses a pending
+ * decision. Pure data access; the PR plumbing lives in rail-pr-delivery /
+ * pr-publisher and the launch wiring in rail-isolated-launch.
+ */
+const pr_follow_up_1 = require("./pr-follow-up");
+const spec_addenda_core_1 = require("./spec-addenda-core");
 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. */
@@ -88,13 +101,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
+       revision_note, revision_of, parent_delivery_id, repository_id, repository_path, follow_up, spec_addenda
      ) 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);
+        : 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);
     return getPrDelivery(db, id);
 }
+/**
+ * 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
+ * or PR. Shared by the discard path (no ticket/Jira effect) and the launch
+ * route (a relaunch closes it instead of reporting `pr_decision_pending`).
+ */
+function isPreparationFailureRow(row) {
+    if (row.decision !== 'pr_failed' || row.implementation_outcome !== 'failed')
+        return false;
+    if (row.pr_url || row.delivery_sha || row.is_continuation)
+        return false;
+    return parseJsonArray(row.branches ?? '[]').length === 0 && parseJsonArray(row.worktree_ids ?? '[]').length === 0;
+}
 class PrDeliveryGenerationConflict extends Error {
     currentId;
     code = 'PR_DELIVERY_GENERATION_CONFLICT';
@@ -203,6 +229,15 @@ function getActivePrDeliveryByRail(db, railIndex) {
         .get(railIndex);
 }
 /** Every non-terminal delivery — hydrates the GET /rails prDeliveries snapshot. */
+/** True when a delivery group has at least one per-repository child row. A
+ * parent that carries an execution manifest but no children is a launch that
+ * failed BEFORE any repository delivery was allocated (worktree add refused,
+ * DB setup error…) — it must be decided as an ordinary single row, not routed
+ * to the per-repository group machinery, which has nothing to act on. */
+function hasRepositoryDeliveries(db, parentId) {
+    const row = db.prepare('SELECT 1 AS present FROM rail_pr_deliveries WHERE parent_delivery_id = ? LIMIT 1').get(parentId);
+    return Boolean(row);
+}
 function listActivePrDeliveries(db) {
     return db
         .prepare(`SELECT * FROM rail_pr_deliveries
@@ -597,6 +632,8 @@ function toPrDeliverySnapshot(row) {
         runIds: parseJsonArray(row.run_ids ?? '[]'),
         originSurface: row.origin_surface,
         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),
         createdAt: row.created_at,
         updatedAt: row.updated_at,
     };

package/server/dist/rail-pr-ticket-effects.js

@@ -6,6 +6,7 @@ exports.replayPendingRailPrTicketEffects = replayPendingRailPrTicketEffects;
 exports.replayRailPrTicketEffectsUntilSettled = replayRailPrTicketEffectsUntilSettled;
 const rail_pr_store_1 = require("./rail-pr-store");
 const ticket_store_1 = require("./ticket-store");
+const spec_addenda_1 = require("./spec-addenda");
 const workspace_resolution_1 = require("./workspace-resolution");
 /** Commit the terminal decision and its external ticket-file intent together. */
 function transitionClaimedDecisionWithTicketEffect(db, id, expected, next, operationToken, patch, effect) {
@@ -151,6 +152,16 @@ function selectAppliedTicketIds(db, deliveryId, candidateIds, causalOwners, tick
     }
     return parseTicketIds(durable.applied_ticket_ids);
 }
+/** The frozen addenda snapshot a delivery was launched with (null when none / unreadable). */
+function deliveryAddendaSnapshot(db, deliveryId) {
+    try {
+        const row = db.prepare(`SELECT spec_addenda FROM rail_pr_deliveries WHERE id = ?`).get(deliveryId);
+        return (0, spec_addenda_1.readSpecAddendaSnapshot)(row?.spec_addenda ?? null);
+    }
+    catch {
+        return null;
+    }
+}
 /** Apply one pending row idempotently. Only tickets still parked at on_review
  * move. The selected ids and each boundary phase are durable, so replay after
  * the JSON write still hands the original ids to Jira; completion is recorded
@@ -173,6 +184,10 @@ function applyRailPrTicketEffect(deps, deliveryId) {
     try {
         if (!row.tickets_applied_at) {
             const now = new Date().toISOString();
+            // A discard (→ todo) destroys the work the delivery's addenda were applied
+            // by: reopen exactly those (from the delivery's frozen snapshot) so the
+            // next launch carries them again. Read before the lock; malformed ⇒ none.
+            const reopenAddenda = row.target_status === 'todo' ? deliveryAddendaSnapshot(deps.db, deliveryId) : null;
             store = (0, ticket_store_1.mutateStore)(resolveTicketFile(deps), (current) => {
                 appliedTicketIds = selectAppliedTicketIds(deps.db, deliveryId, ticketIds, causalOwners, current.tickets);
                 for (const ticketId of appliedTicketIds) {
@@ -183,6 +198,12 @@ function applyRailPrTicketEffect(deps, deliveryId) {
                     ticket.updated_at = now;
                     changedTicketIds.push(ticketId);
                 }
+                if (reopenAddenda) {
+                    for (const ticketId of (0, spec_addenda_1.reopenSpecAddenda)(current, reopenAddenda, now)) {
+                        if (!changedTicketIds.includes(ticketId))
+                            changedTicketIds.push(ticketId);
+                    }
+                }
             });
             deps.db.prepare(`
         UPDATE rail_pr_ticket_effects