specrails-desktop 2.24.1 → 2.24.2

package/server/dist/active-pr-continuation.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveActivePrContinuationTargets = resolveActivePrContinuationTargets;
+const jira_db_1 = require("./jira/jira-db");
+const rail_pr_store_1 = require("./rail-pr-store");
+const integration_branch_1 = require("./integration-branch");
+function parsePrNumber(prUrl) {
+    if (!prUrl)
+        return null;
+    const m = /\/pull\/(\d+)/.exec(prUrl);
+    return m ? parseInt(m[1], 10) : null;
+}
+function normalizedText(v) {
+    return typeof v === 'string' ? v.toLowerCase() : '';
+}
+function words(v) {
+    return normalizedText(v)
+        .replace(/[^a-z0-9]+/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length >= 4);
+}
+function ticketRefs(db, ticketId, spec) {
+    const refs = new Set([`#${ticketId}`, `[${ticketId}]`, `ticket ${ticketId}`, `spec ${ticketId}`]);
+    let jiraKey = spec?.jira_key ?? null;
+    try {
+        const link = (0, jira_db_1.getLinkByLocalId)(db, ticketId);
+        if (link && !link.tombstoned && link.jiraKey)
+            jiraKey = link.jiraKey;
+    }
+    catch {
+        /* tolerated */
+    }
+    if (jiraKey?.trim())
+        refs.add(jiraKey.trim());
+    return [...refs];
+}
+function hasJiraRef(db, ticketId, spec) {
+    if (spec?.jira_key?.trim())
+        return true;
+    try {
+        const link = (0, jira_db_1.getLinkByLocalId)(db, ticketId);
+        return Boolean(link && !link.tombstoned && link.jiraKey);
+    }
+    catch {
+        return false;
+    }
+}
+function prMatchKind(db, ticketId, spec, pr) {
+    const haystack = `${pr.title ?? ''}\n${pr.body ?? ''}\n${pr.headRefName ?? ''}`.toLowerCase();
+    for (const ref of ticketRefs(db, ticketId, spec)) {
+        const needle = ref.toLowerCase();
+        if (needle.startsWith('#') || needle.startsWith('[')) {
+            if (haystack.includes(needle))
+                return 'explicit-ref';
+        }
+        else if (new RegExp(`(^|[^a-z0-9])${needle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}([^a-z0-9]|$)`, 'i').test(haystack)) {
+            return 'explicit-ref';
+        }
+    }
+    const titleWords = words(spec?.title);
+    if (titleWords.length < 3)
+        return null;
+    const prWords = new Set(words(`${pr.title ?? ''} ${pr.body ?? ''}`));
+    const hits = titleWords.filter((w) => prWords.has(w)).length;
+    return hits >= Math.max(3, Math.ceil(titleWords.length * 0.7)) ? 'title-similarity' : null;
+}
+function canProbeGithubForContinuation(db, ticketId, spec) {
+    if (spec?.status === 'on_review')
+        return true;
+    // Jira review can materialize as in_progress when the project has not mapped
+    // its exact Review status to Specrails on_review. In that fallback, require a
+    // Jira-linked ticket and later only accept explicit PR references.
+    return spec?.status === 'in_progress' && hasJiraRef(db, ticketId, spec);
+}
+function matchAllowedForTicket(spec, kind) {
+    if (spec?.status === 'on_review')
+        return true;
+    return kind === 'explicit-ref';
+}
+async function localBranchExists(git, repoDir, branch) {
+    const r = await git.run(['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`], repoDir);
+    return r.code === 0;
+}
+async function remoteBranchExists(git, repoDir, branch) {
+    const r = await git.run(['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${branch}`], repoDir);
+    return r.code === 0;
+}
+async function materializeTarget(git, repoDir, fetchOk, ticketId, branch, baseBranch, prUrl, prNumber, isDraft, source) {
+    const head = branch?.trim();
+    const base = baseBranch?.trim();
+    if (!head || !base || head === base)
+        return null;
+    if (!(0, integration_branch_1.isValidBranchName)(head) || !(0, integration_branch_1.isValidBranchName)(base))
+        return null;
+    if (await localBranchExists(git, repoDir, head)) {
+        return { ticketId, branch: head, baseBranch: base, prUrl, prNumber, isDraft, source };
+    }
+    if (fetchOk && await remoteBranchExists(git, repoDir, head)) {
+        return { ticketId, branch: head, baseBranch: base, baseRef: `origin/${head}`, prUrl, prNumber, isDraft, source };
+    }
+    return null;
+}
+function internalDeliveryTargets(db, ticketIds) {
+    const wanted = new Set(ticketIds);
+    const out = new Map();
+    for (const row of (0, rail_pr_store_1.listActivePrDeliveries)(db)) {
+        const snap = (0, rail_pr_store_1.toPrDeliverySnapshot)(row);
+        if (!snap.prUrl || !snap.branch)
+            continue;
+        for (const ticketId of snap.ticketIds) {
+            if (!wanted.has(ticketId) || out.has(ticketId))
+                continue;
+            out.set(ticketId, {
+                ticketId,
+                branch: snap.branch,
+                baseBranch: snap.baseBranch,
+                prUrl: snap.prUrl,
+                prNumber: snap.prNumber,
+                isDraft: snap.decision === 'pr_draft',
+                source: 'rail-pr-delivery',
+            });
+        }
+    }
+    return out;
+}
+async function listOpenPrs(exec, repoDir) {
+    const r = await exec.run('gh', ['pr', 'list', '--state', 'open', '--json', 'number,title,body,headRefName,baseRefName,url,isDraft'], repoDir);
+    if (r.code !== 0)
+        return [];
+    try {
+        const parsed = JSON.parse(r.stdout);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Detects tickets whose next implementation pass should continue an already
+ * open PR branch instead of creating fresh work from the integration branch.
+ * It is intentionally fail-open: no gh, no auth, ambiguous branch state, or no
+ * confident PR match all return no target, preserving the normal new-work flow.
+ */
+async function resolveActivePrContinuationTargets(input) {
+    const out = new Map();
+    const internal = internalDeliveryTargets(input.db, input.ticketIds);
+    for (const [ticketId, target] of internal) {
+        const materialized = await materializeTarget(input.git, input.repoDir, input.fetchOk, ticketId, target.branch, target.baseBranch, target.prUrl, target.prNumber, target.isDraft, 'rail-pr-delivery');
+        if (materialized)
+            out.set(ticketId, materialized);
+    }
+    const remaining = input.ticketIds.filter((id) => !out.has(id));
+    const candidateIds = remaining.filter((id) => canProbeGithubForContinuation(input.db, id, input.getTicketSpec(id)));
+    if (candidateIds.length === 0)
+        return out;
+    const openPrs = await listOpenPrs(input.exec, input.repoDir);
+    for (const ticketId of candidateIds) {
+        const spec = input.getTicketSpec(ticketId);
+        const matches = openPrs.filter((pr) => {
+            const kind = prMatchKind(input.db, ticketId, spec, pr);
+            return kind ? matchAllowedForTicket(spec, kind) : false;
+        });
+        if (matches.length !== 1)
+            continue;
+        const pr = matches[0];
+        const materialized = await materializeTarget(input.git, input.repoDir, input.fetchOk, ticketId, pr.headRefName, pr.baseRefName || input.integrationBranch, pr.url ?? null, typeof pr.number === 'number' ? pr.number : parsePrNumber(pr.url), typeof pr.isDraft === 'boolean' ? pr.isDraft : null, 'github-open-pr');
+        if (materialized)
+            out.set(ticketId, materialized);
+    }
+    return out;
+}

package/server/dist/agent-operator-prompt.js

@@ -324,6 +324,13 @@ summary later.
 - Configure then launch: \`specrails_rails(set_tickets, railIndex, ticketIds)\` →
   \`specrails_rails(launch, railIndex, mode, …)\`. Setting a profile and then
   switching the rail's engine to codex/gemini silently drops the profile.
+- When relaunching an \`on_review\` spec that already has an OPEN GitHub PR,
+  \`launch\` automatically tries to continue that PR's head branch (matched by
+  Jira key / spec id / title) instead of starting from the integration branch.
+  Jira-linked \`in_progress\` specs can also continue an open PR when the match
+  is explicit, covering Jira projects whose Review status has not been mapped to
+  Specrails \`on_review\`. You do NOT need to know or pass the branch name. If
+  there is no confident open PR match, the normal new-work flow is preserved.
 - Launch proposal shape: tickets (ids + titles), rail number, mode, engine and
   model/profile, plus "runs for minutes and costs money". Wait for yes.
 - **Parallel launches are safe and normal.** Every rail launch runs its work in
@@ -362,6 +369,8 @@ summary later.
   folder is not a git repo; \`no-commits\` = git repo with no initial commit;
   \`error\` = isolation failed, relay the detail), and — for no-git/no-commits —
   that \`git init\` + one commit (no GitHub remote needed) unlocks the PR flow.
+  In no-git/no-commits projects, there is also no active-PR continuation because
+  there is no branch graph to continue.
   When isolation IS available (no such field), the card WILL appear on settle.
 - **After an ISOLATED rail settles, the DECISION belongs to the user, in the
   app's UI** (the PR card in this chat and the rail header show the same

package/server/dist/docs-router.js

@@ -95,13 +95,78 @@ function langDir(guideRoot, lang) {
 }
 // ─── Category configuration ─────────────────────────────────────────────────
 const CATEGORY_LABELS = {
-    'getting-started': 'Getting started',
-    specs: 'Specs',
-    pipeline: 'Pipeline',
-    agents: 'Agents',
-    insights: 'Insights',
-    integrations: 'Integrations',
-    settings: 'Settings',
+    en: {
+        'getting-started': 'Getting started',
+        specs: 'Specs',
+        pipeline: 'Pipeline',
+        agents: 'Agents',
+        insights: 'Insights',
+        integrations: 'Integrations',
+        settings: 'Settings',
+    },
+    es: {
+        'getting-started': 'Primeros pasos',
+        specs: 'Specs',
+        pipeline: 'Pipeline',
+        agents: 'Agentes',
+        insights: 'Insights',
+        integrations: 'Integraciones',
+        settings: 'Ajustes',
+    },
+    fr: {
+        'getting-started': 'Bien démarrer',
+        specs: 'Specs',
+        pipeline: 'Pipeline',
+        agents: 'Agents',
+        insights: 'Insights',
+        integrations: 'Intégrations',
+        settings: 'Réglages',
+    },
+    de: {
+        'getting-started': 'Erste Schritte',
+        specs: 'Specs',
+        pipeline: 'Pipeline',
+        agents: 'Agenten',
+        insights: 'Insights',
+        integrations: 'Integrationen',
+        settings: 'Einstellungen',
+    },
+    pt: {
+        'getting-started': 'Primeiros passos',
+        specs: 'Specs',
+        pipeline: 'Pipeline',
+        agents: 'Agentes',
+        insights: 'Insights',
+        integrations: 'Integrações',
+        settings: 'Definições',
+    },
+    it: {
+        'getting-started': 'Primi passi',
+        specs: 'Spec',
+        pipeline: 'Pipeline',
+        agents: 'Agenti',
+        insights: 'Insights',
+        integrations: 'Integrazioni',
+        settings: 'Impostazioni',
+    },
+    zh: {
+        'getting-started': '入门',
+        specs: '规格',
+        pipeline: '流水线',
+        agents: '代理',
+        insights: '洞察',
+        integrations: '集成',
+        settings: '设置',
+    },
+    ja: {
+        'getting-started': 'はじめに',
+        specs: 'スペック',
+        pipeline: 'パイプライン',
+        agents: 'エージェント',
+        insights: 'インサイト',
+        integrations: '連携',
+        settings: '設定',
+    },
 };
 /**
  * Preferred display order. Categories not in this list come after, alphabetically.
@@ -119,8 +184,8 @@ const CATEGORY_ORDER = [
 function slugToTitle(slug) {
     return slug.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
 }
-function categoryLabel(slug) {
-    return CATEGORY_LABELS[slug] ?? slugToTitle(slug);
+function categoryLabel(slug, lang) {
+    return CATEGORY_LABELS[lang]?.[slug] ?? CATEGORY_LABELS[DEFAULT_LANG]?.[slug] ?? slugToTitle(slug);
 }
 function extractTitle(content, slug) {
     const match = content.match(/^#\s+(.+)$/m);
@@ -190,7 +255,7 @@ function buildCategories(guideRoot, lang) {
             return { title, slug: meta.slug };
         });
         if (docs.length > 0) {
-            categories.push({ name: categoryLabel(cat), slug: cat, docs });
+            categories.push({ name: categoryLabel(cat, lang), slug: cat, docs });
         }
     }
     return categories.sort((a, b) => categoryRank(a.slug) - categoryRank(b.slug) || a.slug.localeCompare(b.slug));

package/server/dist/jira/jira-adf.js

@@ -12,6 +12,7 @@ exports.bodyForDeployment = bodyForDeployment;
 exports.commentMarker = commentMarker;
 exports.discardCommentMarker = discardCommentMarker;
 exports.prMergedCommentMarker = prMergedCommentMarker;
+exports.railReviewCommentMarker = railReviewCommentMarker;
 exports.bodyContainsMarker = bodyContainsMarker;
 exports.commentHasMarker = commentHasMarker;
 exports.adfToText = adfToText;
@@ -62,6 +63,13 @@ function discardCommentMarker(ticketId, nonce) {
 function prMergedCommentMarker(refId, ticketId) {
     return `[specrails:pr-merged=${refId}:ticket=${ticketId}]`;
 }
+/**
+ * Idempotency marker for the "ready for review" comment posted when an isolated
+ * rail parks a Jira-linked ticket on_review awaiting the PR decision.
+ */
+function railReviewCommentMarker(refId, ticketId) {
+    return `[specrails:rail-review=${refId}:ticket=${ticketId}]`;
+}
 /** True when an ADF doc or wiki string already contains the given marker. */
 function bodyContainsMarker(body, marker) {
     if (typeof body === 'string')

package/server/dist/jira/jira-sync-manager.js

@@ -13,6 +13,7 @@ exports.JiraSyncManager = void 0;
 exports.backoffMs = backoffMs;
 exports.formatJqlDate = formatJqlDate;
 exports.buildCompletionComment = buildCompletionComment;
+exports.buildRailReviewComment = buildRailReviewComment;
 exports.buildPrMergedComment = buildPrMergedComment;
 const node_crypto_1 = require("node:crypto");
 const ticket_store_1 = require("../ticket-store");
@@ -557,6 +558,16 @@ class JiraSyncManager {
                 const link = (0, jira_db_1.getLinkByLocalId)(this.db, localId);
                 if (!link || link.tombstoned)
                     continue;
+                ops.push({
+                    jiraIssueId: link.jiraIssueId,
+                    opType: 'comment',
+                    idempotencyKey: `${refId}:${localId}:comment:on-review`,
+                    payload: {
+                        jiraIssueId: link.jiraIssueId,
+                        text: buildRailReviewComment(link.jiraKey),
+                        marker: (0, jira_adf_1.railReviewCommentMarker)(refId, localId),
+                    },
+                });
                 ops.push({
                     jiraIssueId: link.jiraIssueId,
                     opType: 'transition',
@@ -1144,31 +1155,59 @@ function formatJqlDate(ms) {
     return `${d.getUTCFullYear()}-${p(d.getUTCMonth() + 1)}-${p(d.getUTCDate())} ${p(d.getUTCHours())}:${p(d.getUTCMinutes())}`;
 }
 function buildCompletionComment(args, jiraKey, needsReview) {
+    const issue = jiraKey?.trim() ? jiraKey.trim() : 'the linked Jira issue';
     if (needsReview) {
-        return 'Specrails: the implementation rail terminated abnormally after its Ship phase — the result needs review.';
+        return [
+            `Specrails rail finished for ${issue}.`,
+            'Result: needs human review.',
+            'The implementation reached its Ship phase, but the rail terminated abnormally before Specrails could fully close the run.',
+            `Run: ${args.jobId}`,
+            'Jira status: left unchanged for review.',
+        ].join('\n');
     }
     const parts = [];
     if (args.status === 'completed') {
-        parts.push('✅ Implementation completed by a Specrails rail.');
+        parts.push(`Specrails rail finished for ${issue}.`);
+        parts.push('Result: completed successfully.');
+        parts.push('Jira status: moving to Done.');
     }
     else if (args.status === 'canceled') {
-        parts.push('⏹️ The Specrails implementation rail was cancelled — the spec was returned to the backlog.');
+        parts.push(`Specrails rail finished for ${issue}.`);
+        parts.push('Result: cancelled before completion.');
+        parts.push('Jira status: returning to the backlog.');
     }
     else {
-        parts.push('❌ The Specrails implementation rail failed — the spec was returned to the backlog.');
+        parts.push(`Specrails rail finished for ${issue}.`);
+        parts.push('Result: failed before completion.');
+        parts.push('Jira status: returning to the backlog.');
     }
-    const meta = [`job ${args.jobId}`];
-    if (args.costUsd != null)
-        meta.push(`cost $${args.costUsd.toFixed(2)}`);
+    parts.push(`Run: ${args.jobId}`);
     if (args.durationMs != null)
-        meta.push(`duration ${formatDuration(args.durationMs)}`);
-    parts.push(`(${meta.join(' · ')})`);
+        parts.push(`Duration: ${formatDuration(args.durationMs)}`);
+    if (args.costUsd != null)
+        parts.push(`Cost: $${args.costUsd.toFixed(2)}`);
     return parts.join('\n');
 }
+/** Comment posted when an isolated rail has produced reviewable work. */
+function buildRailReviewComment(jiraKey) {
+    const issue = jiraKey?.trim() ? jiraKey.trim() : 'the linked Jira issue';
+    return [
+        `Specrails rail finished for ${issue}.`,
+        'Result: implementation ready for PR review.',
+        'Jira status: moving to review while the PR decision remains open in Specrails.',
+        'Next step: review the Specrails PR card, then publish/merge or discard the delivery.',
+    ].join('\n');
+}
 /** Comment posted on a linked issue when its delivery PR is merged. */
 function buildPrMergedComment(prUrl) {
-    const base = '✅ Specrails: the delivery PR was merged — the spec shipped to the integration branch.';
-    return prUrl ? `${base}\n${prUrl}` : base;
+    const parts = [
+        'Specrails delivery accepted.',
+        'Result: PR merged into the integration branch.',
+        'Jira status: moving to Done.',
+    ];
+    if (prUrl)
+        parts.push(`PR: ${prUrl}`);
+    return parts.join('\n');
 }
 function formatDuration(ms) {
     const s = Math.round(ms / 1000);

package/server/dist/mcp/guide.js

@@ -108,6 +108,15 @@ heading inside the description); \`labels\`; \`priority\`. Spec content is Engli
   (ai-spawn) launches EVERY rail that has tickets and no active run / pending
   PR decision in one call, each with its stored mode/engine/profile, returning
   per-rail outcomes (launched / skipped with reason / failed).
+- Relaunching an \`on_review\` ticket with a matching OPEN GitHub PR continues
+  that PR's head branch automatically. Jira-linked \`in_progress\` tickets can
+  also continue an open PR when the match is explicit, covering Jira projects
+  whose Review status has not been mapped to Specrails \`on_review\`. New
+  tickets, or tickets without a confident open-PR match, keep the normal
+  branch-from-integration flow.
+- Projects without Git cannot use isolated worktrees or PR continuation. A
+  launch degrades to shared-cwd execution and returns \`isolationUnavailable\`;
+  explain that it writes directly to files and no PR card/branch will appear.
 - Configure: \`set_tickets\` (replaces the assigned set), \`set_profile\` (null =
   legacy), \`set_engine\` (null = project primary), \`set_name\`.
 - Launch modes:

package/server/dist/mcp/tools/rails.js

@@ -29,6 +29,7 @@ function railsTools() {
                 'launch (ai-spawn — spawns claude/codex/gemini CLI job(s) that WRITE CODE, RUN TESTS, COMMIT, and INCUR TOKEN COST; returns 202 with jobId/jobIds/loopRunIds), ' +
                 'launch_all (ai-spawn — launches EVERY rail that has tickets and no active run/pending PR decision, in parallel, using each rail\'s stored mode/engine/profile; returns per-rail outcomes with skip reasons), ' +
                 'stop (destructive — kills all active jobs and loop runs for the rail). ' +
+                'For on_review tickets with an already-open GitHub PR, launch automatically tries to continue that PR head branch; Jira-linked in_progress tickets can do the same when the PR match is explicit; fresh tickets still start from the project integration branch. ' +
                 'When launched from the in-app agent chat without an explicit aiEngine, the engine defaults to your conversation\'s provider (pass aiEngine to override; launch_all always uses each rail\'s stored engine). ' +
                 'NAMING: railIndex is the 0-BASED internal identity; the dashboard shows rails 1-based ("Rail N" = railIndex N-1). When talking to the user, ALWAYS say "Rail <railIndex + 1>" (or the rail\'s custom name) — results include railLabel with the correct user-facing label.',
             hintTier: 'read',
@@ -234,7 +235,7 @@ function railsTools() {
                         return {
                             ...r,
                             railLabel,
-                            hint: `Launch accepted (202) on ${railLabel} (isolated worktree, PR flow active) — tell the user it runs on "${railLabel}" (UI labels are 1-based) and that the PR-decision card will appear here and on the rail header when it settles. Use specrails_watch with the returned loopRunIds to await completion only if asked. Rails run for minutes; pass untilMs up to 600000 and re-watch on timeout.`,
+                            hint: `Launch accepted (202) on ${railLabel} (isolated worktree, PR flow active) — tell the user it runs on "${railLabel}" (UI labels are 1-based). If the assigned spec is on_review with a matching open PR, or is Jira-linked in_progress with an explicit PR match, Specrails continues that PR branch automatically; otherwise it starts a fresh branch from the integration branch. The PR-decision card will appear here and on the rail header when it settles. Use specrails_watch with the returned loopRunIds to await completion only if asked. Rails run for minutes; pass untilMs up to 600000 and re-watch on timeout.`,
                         };
                     }
                     case 'launch_all': {

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

@@ -80,6 +80,8 @@ const feature_flags_1 = require("./feature-flags");
 const file_provenance_1 = require("./file-provenance");
 const file_story_1 = require("./file-story");
 const providers_1 = require("./providers");
+const pr_publisher_1 = require("./pr-publisher");
+const active_pr_continuation_1 = require("./active-pr-continuation");
 /**
  * Ticket data for the conventional branch name (pr-naming): title/labels from
  * the ticket-spec reader, the Jira key resolved with the authoritative
@@ -106,6 +108,18 @@ function unitNamingInput(ctx, ticketId) {
     }
     return { ticketId, title: spec?.title ?? null, labels: spec?.labels ?? null, jiraKey };
 }
+/**
+ * Commit messages are consumed by GitHub↔Jira development panels. Branch names
+ * already carry the Jira key for new work; commits must too, especially when
+ * continuing an existing PR whose branch name may predate the current ticket
+ * key. Keep the local id as a fallback/cross-reference for Specrails.
+ */
+function worktreeCommitMessage(ctx, ticketId, runId, partial = false) {
+    const input = unitNamingInput(ctx, ticketId);
+    const ref = (0, pr_naming_1.ticketRef)(input);
+    const subjectRef = ref === String(ticketId) ? `ticket-${ticketId}` : `${ref} ticket-${ticketId}`;
+    return `specrails: ${subjectRef}${partial ? ' partial' : ''} (run ${runId})`;
+}
 /**
  * Launch the rail's tickets in isolated worktrees + schedule the merge-back.
  * Returns the loop run ids. Throws if worktree allocation fails (the caller then
@@ -115,6 +129,7 @@ function unitNamingInput(ctx, ticketId) {
 async function launchIsolatedRail(input, io = {}) {
     const { ctx, railIndex, ticketIds, loopId, loopName, loopGraph, provider, model, effort } = input;
     const git = io.git ?? worktree_manager_1.defaultGitRunner;
+    const exec = io.exec ?? pr_publisher_1.defaultExec;
     const create = io.create ?? worktree_manager_1.createWorktree;
     const remove = io.remove ?? worktree_manager_1.removeWorktree;
     const overlay = io.overlay ?? worktree_overlay_1.applyWorktreeOverlay;
@@ -209,6 +224,7 @@ async function launchIsolatedRail(input, io = {}) {
     //    Only allocation is locked — the fan-out (the actual AI runs) below
     //    stays fully parallel.
     let integration;
+    let launchContinuation = null;
     const allocated = [];
     await (0, repo_lock_1.withRepoLock)(baseRepo, async () => {
         // Bring the repo's remote-tracking refs up to date BEFORE resolving the
@@ -243,13 +259,44 @@ async function launchIsolatedRail(input, io = {}) {
             }
             catch { /* non-fatal, mirrors notifyOverlayDegraded's broadcast guard below */ }
         }
+        // Active-PR continuation: if a ticket is already parked on_review with a
+        // matching OPEN GitHub PR (or a Jira-linked in_progress ticket explicitly
+        // matches an open PR, covering unmapped Jira "Review" statuses), run the next
+        // pass directly on that PR's head branch. Fresh tickets stay on the normal
+        // integration-base path. Keep this deliberately single-target for now: one
+        // rail delivery row can represent one PR URL, so multi-PR batches continue to
+        // use the existing new-work flow instead of silently mixing PRs.
+        const continuationTargets = await (0, active_pr_continuation_1.resolveActivePrContinuationTargets)({
+            db: ctx.db,
+            git,
+            exec,
+            repoDir: baseRepo,
+            ticketIds: units.map((u) => u.ticketId),
+            integrationBranch: integration.branch,
+            fetchOk: fetchResult.ok,
+            getTicketSpec: (ticketId) => {
+                try {
+                    return ctx.getTicketSpec(ticketId);
+                }
+                catch {
+                    return undefined;
+                }
+            },
+        });
+        const uniqueContinuationKeys = new Set(units
+            .map((u) => continuationTargets.get(u.ticketId))
+            .filter((t) => !!t)
+            .map((t) => `${t.prUrl ?? ''}\n${t.branch}`));
+        if (uniqueContinuationKeys.size === 1 && units.every((u) => continuationTargets.has(u.ticketId))) {
+            launchContinuation = continuationTargets.get(units[0].ticketId) ?? null;
+        }
         if (prMode) {
             prDeliveryId = (0, rail_pr_store_1.createPrDelivery)(ctx.db, {
                 railIndex,
                 loopId,
                 railKey: `${railIndex}-${loopId}`,
                 ticketIds: [...ticketIds],
-                baseBranch: integration.branch,
+                baseBranch: launchContinuation?.baseBranch ?? integration.branch,
                 loopName,
                 originSurface: input.originSurface ?? 'dashboard',
                 originConversationId: input.originConversationId ?? null,
@@ -266,6 +313,11 @@ async function launchIsolatedRail(input, io = {}) {
         // launches see each other's just-created branches.
         const takenBranches = await (0, worktree_manager_1.listLocalBranches)(git, baseRepo);
         const unitBranchName = (ticketId) => {
+            const continuation = launchContinuation && continuationTargets.get(ticketId);
+            if (continuation) {
+                takenBranches.add(continuation.branch);
+                return continuation.branch;
+            }
             const preferred = (0, pr_naming_1.ticketBranchName)(unitNamingInput(ctx, ticketId));
             const branch = (0, pr_naming_1.resolveCollisionFreeName)(preferred, {
                 taken: (name) => takenBranches.has(name) && !(0, rail_worktrees_store_1.railWorktreeBranchExistsForTicket)(ctx.db, ticketId, name),
@@ -276,7 +328,15 @@ async function launchIsolatedRail(input, io = {}) {
         };
         try {
             for (const unit of units) {
-                const handle = await create(git, { repoDir: baseRepo, worktreesRoot, slug, ticketId: unit.ticketId, baseRef: worktreeBaseRef.baseRef, branch: unitBranchName(unit.ticketId) });
+                const continuationTarget = launchContinuation ? continuationTargets.get(unit.ticketId) ?? null : null;
+                const handle = await create(git, {
+                    repoDir: baseRepo,
+                    worktreesRoot,
+                    slug,
+                    ticketId: unit.ticketId,
+                    baseRef: continuationTarget?.baseRef ?? worktreeBaseRef.baseRef,
+                    branch: unitBranchName(unit.ticketId),
+                });
                 // Per-run overlay: merge-link the framework surface the checkout didn't
                 // bring into the worktree (idempotent; resume-safe via its manifest).
                 let overlayExcludes = [];
@@ -315,7 +375,7 @@ async function launchIsolatedRail(input, io = {}) {
                     id: ledgerId, railIndex, ticketId: unit.ticketId, runId,
                     branch: handle.branch, worktreePath: handle.worktreePath,
                 });
-                allocated.push({ ticketId: unit.ticketId, ticketIds: unit.ticketIds, runId, ledgerId, handle, overlayExcludes, provenanceSnapshot });
+                allocated.push({ ticketId: unit.ticketId, ticketIds: unit.ticketIds, runId, ledgerId, handle, overlayExcludes, provenanceSnapshot, continuationTarget });
             }
         }
         catch (err) {
@@ -379,7 +439,7 @@ async function launchIsolatedRail(input, io = {}) {
             // Commit the run's work to its branch so the merge-back can integrate it
             // (loops like autoloop-tdd don't commit) and a re-launch can resume it.
             // Overlay scaffolding is excluded — it must never reach the branch/PR.
-            await (0, worktree_manager_1.commitWorktree)(git, a.handle.worktreePath, `specrails: ticket-${a.ticketId} (run ${a.runId})`, a.overlayExcludes);
+            await (0, worktree_manager_1.commitWorktree)(git, a.handle.worktreePath, worktreeCommitMessage(ctx, a.ticketId, a.runId), a.overlayExcludes);
             (0, rail_worktrees_store_1.updateRailWorktreeState)(ctx.db, a.ledgerId, succeeded ? 'built' : 'failed');
             return { run: a, succeeded };
         })
@@ -388,7 +448,7 @@ async function launchIsolatedRail(input, io = {}) {
             ctx.onLoopRunFinished(a.runId, 'failed', runFinishedOpts);
             recordRunProvenance(a);
             // Commit partial work too → durable in git → resumable on re-launch.
-            await (0, worktree_manager_1.commitWorktree)(git, a.handle.worktreePath, `specrails: ticket-${a.ticketId} partial (run ${a.runId})`, a.overlayExcludes);
+            await (0, worktree_manager_1.commitWorktree)(git, a.handle.worktreePath, worktreeCommitMessage(ctx, a.ticketId, a.runId, true), a.overlayExcludes);
             (0, rail_worktrees_store_1.updateRailWorktreeState)(ctx.db, a.ledgerId, 'failed');
             return { run: a, succeeded: false };
         });
@@ -427,8 +487,23 @@ async function launchIsolatedRail(input, io = {}) {
             // → auto-close (per-run settle already reverted the tickets).
             const worktreeIds = allocated.map((a) => a.ledgerId);
             const anySucceeded = results.some((r) => r.succeeded);
-            const next = anySucceeded ? 'on_review' : 'discarded';
-            if (prDeliveryId && (0, rail_pr_store_1.transitionDecision)(ctx.db, prDeliveryId, 'building', next, { branches, worktreeIds })) {
+            const settledContinuation = anySucceeded ? launchContinuation : null;
+            const next = anySucceeded
+                ? (settledContinuation
+                    ? (settledContinuation.isDraft === false ? 'pr_ready' : 'pr_draft')
+                    : 'on_review')
+                : 'discarded';
+            const patch = settledContinuation
+                ? {
+                    branches,
+                    worktreeIds,
+                    branch: settledContinuation.branch,
+                    prUrl: settledContinuation.prUrl,
+                    prNumber: settledContinuation.prNumber,
+                    prState: 'pr-created',
+                }
+                : { branches, worktreeIds };
+            if (prDeliveryId && (0, rail_pr_store_1.transitionDecision)(ctx.db, prDeliveryId, 'building', next, patch)) {
                 broadcastPrState();
                 // Completion driver: refresh the origin conversation's card in place —
                 // on_review asks the question, discarded informs the outcome.