specrails-desktop 2.26.2 → 2.28.0

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

@@ -1,6 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerJobsRoutes = registerJobsRoutes;
+const path_1 = __importDefault(require("path"));
 const db_1 = require("./db");
 const queue_manager_1 = require("./queue-manager");
 const feature_flags_1 = require("./feature-flags");
@@ -12,7 +16,22 @@ const provider_selection_1 = require("./provider-selection");
 const loop_runs_store_1 = require("./loop-runs-store");
 const metrics_1 = require("./metrics");
 const ticket_store_1 = require("./ticket-store");
+const transient_children_1 = require("./transient-children");
 const project_router_helpers_1 = require("./project-router-helpers");
+function backgroundStartBusyReason(c) {
+    const activeJobId = typeof c.queueManager?.getActiveJobId === 'function' ? c.queueManager.getActiveJobId() : null;
+    if (activeJobId)
+        return `job ${activeJobId} is still running`;
+    try {
+        const runningLoops = (0, loop_runs_store_1.listRunningLoopRuns)(c.db, c.project.id);
+        if (runningLoops.length > 0)
+            return `loop run ${runningLoops[0].id} is still running`;
+    }
+    catch {
+        // If the loop table is unavailable in a test harness, do not block startup.
+    }
+    return null;
+}
 function registerJobsRoutes(deps) {
     const { router, registry, ctx, ticketPath } = deps;
     // ─── Queue / Spawn routes ────────────────────────────────────────────────────
@@ -86,6 +105,113 @@ function registerJobsRoutes(deps) {
             },
         });
     });
+    router.get('/:projectId/background-processes', (req, res) => {
+        const c = ctx(req);
+        const chatId = typeof req.query.chatId === 'string' && req.query.chatId.trim() ? req.query.chatId.trim() : undefined;
+        res.json({
+            processes: (0, transient_children_1.listBackgroundProcesses)({
+                projectId: c.project.id,
+                ...(chatId ? { chatId } : {}),
+            }),
+        });
+    });
+    router.get('/:projectId/background-processes/:pid/logs', (req, res) => {
+        const c = ctx(req);
+        const pid = Number(req.params.pid);
+        const chatId = typeof req.query.chatId === 'string' ? req.query.chatId : '';
+        const limit = typeof req.query.limit === 'string' ? Number(req.query.limit) : undefined;
+        if (!Number.isFinite(pid)) {
+            res.status(400).json({ error: 'pid must be numeric' });
+            return;
+        }
+        if (!chatId.trim()) {
+            res.status(400).json({ error: 'chatId is required' });
+            return;
+        }
+        if (limit !== undefined && (!Number.isFinite(limit) || limit <= 0)) {
+            res.status(400).json({ error: 'limit must be a positive number' });
+            return;
+        }
+        const logs = (0, transient_children_1.getBackgroundProcessLogs)(pid, {
+            projectId: c.project.id,
+            chatId: chatId.trim(),
+            ...(limit !== undefined ? { limit } : {}),
+        });
+        if (!logs) {
+            res.status(404).json({ error: 'background process logs not found for project/chat' });
+            return;
+        }
+        res.json(logs);
+    });
+    router.post('/:projectId/background-processes', (req, res) => {
+        const { command, cwd, chatId, confirmed, allowWhileBusy } = req.body ?? {};
+        const c = ctx(req);
+        if (!command || typeof command !== 'string' || !command.trim()) {
+            res.status(400).json({ error: 'command is required' });
+            return;
+        }
+        if (!chatId || typeof chatId !== 'string' || !chatId.trim()) {
+            res.status(400).json({ error: 'chatId is required' });
+            return;
+        }
+        if (confirmed !== true) {
+            res.status(400).json({ error: 'confirmed must be true after explicit user confirmation' });
+            return;
+        }
+        const busyReason = backgroundStartBusyReason(c);
+        if (busyReason && allowWhileBusy !== true) {
+            res.status(409).json({
+                error: 'project is busy',
+                reason: busyReason,
+                hint: 'Wait for the running job/loop to finish, or pass allowWhileBusy:true only after explicit user confirmation.',
+            });
+            return;
+        }
+        const resolvedCwd = path_1.default.resolve(c.project.path, typeof cwd === 'string' && cwd.trim() ? cwd : '.');
+        const root = path_1.default.resolve(c.project.path);
+        if (resolvedCwd !== root && !resolvedCwd.startsWith(root + path_1.default.sep)) {
+            res.status(400).json({ error: 'cwd must stay within the project' });
+            return;
+        }
+        try {
+            const process = (0, transient_children_1.startBackgroundProcess)(command.trim(), resolvedCwd, chatId.trim(), c.project.id, {
+                onStarted: (process) => c.broadcast({
+                    type: 'background_process.started',
+                    process,
+                    projectId: process.projectId,
+                    timestamp: new Date().toISOString(),
+                }),
+                onExited: (process) => c.broadcast({
+                    type: 'background_process.exited',
+                    process,
+                    projectId: process.projectId,
+                    timestamp: new Date().toISOString(),
+                }),
+            });
+            res.status(202).json({ ok: true, process });
+        }
+        catch (err) {
+            res.status(500).json({ error: err instanceof Error ? err.message : 'background process failed to start' });
+        }
+    });
+    router.delete('/:projectId/background-processes/:pid', (req, res) => {
+        const c = ctx(req);
+        const pid = Number(req.params.pid);
+        const chatId = typeof req.query.chatId === 'string' ? req.query.chatId : '';
+        if (!Number.isFinite(pid)) {
+            res.status(400).json({ error: 'pid must be numeric' });
+            return;
+        }
+        if (!chatId.trim()) {
+            res.status(400).json({ error: 'chatId is required' });
+            return;
+        }
+        if (!(0, transient_children_1.killOwnedBackgroundProcess)(pid, { projectId: c.project.id, chatId: chatId.trim() })) {
+            res.status(404).json({ error: 'background process not found for project/chat' });
+            return;
+        }
+        res.json({ ok: true, pid, status: 'killing' });
+    });
     // Returns the resolved default model for Add Spec + the full provider
     // allow-list so the modal can render its picker without maintaining its
     // own copy of the model lists. Source of truth is `server/spec-models.ts`.

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

@@ -76,7 +76,7 @@ function registerSettingsRoutes(deps) {
         res.json({ scope: merged });
     });
     router.patch('/:projectId/settings', (req, res) => {
-        const { pipelineTelemetryEnabled, orchestratorModel, prePrompt, freestylePrePrompt } = req.body ?? {};
+        const { pipelineTelemetryEnabled, orchestratorModel, prePrompt, freestylePrePrompt, worktreeEnvPassthrough } = req.body ?? {};
         const patch = {};
         if (pipelineTelemetryEnabled !== undefined) {
             patch.pipelineTelemetryEnabled = Boolean(pipelineTelemetryEnabled);
@@ -103,6 +103,15 @@ function registerSettingsRoutes(deps) {
             }
             patch.freestylePrePrompt = freestylePrePrompt;
         }
+        if (worktreeEnvPassthrough !== undefined) {
+            try {
+                patch.worktreeEnvPassthrough = (0, db_1.normalizeWorktreeEnvPassthrough)(worktreeEnvPassthrough);
+            }
+            catch (err) {
+                res.status(400).json({ error: err instanceof Error ? err.message : 'invalid worktreeEnvPassthrough' });
+                return;
+            }
+        }
         if (req.body?.integrationBranch !== undefined) {
             const ib = req.body.integrationBranch;
             if (typeof ib !== 'string') {

package/server/dist/queue-manager.js

@@ -33,6 +33,7 @@ const binary_probe_1 = require("./binary-probe");
 const workspace_manager_1 = require("./workspace-manager");
 const claude_trust_1 = require("./claude-trust");
 const workspace_resolution_1 = require("./workspace-resolution");
+const project_env_1 = require("./project-env");
 const framework_manager_1 = require("./framework-manager");
 const openspec_shim_1 = require("./openspec-shim");
 const artifact_registry_1 = require("./artifact-registry");
@@ -1650,6 +1651,13 @@ class QueueManager {
         // claude honours OTEL_* env vars natively; codex does not and instead
         // gets signals synthesised by the codex-otel-bridge attached below.
         let spawnEnv = process.env;
+        // Per-project worktree/job env passthrough. The setting stores names only;
+        // values are read from the server env (with login-shell recovery for missing
+        // names) at spawn time. Apply this before Specrails' own env overlays so
+        // internal SPECRAILS_* control-plane values always win.
+        if (this._db) {
+            spawnEnv = (0, project_env_1.applyWorktreeEnvPassthrough)(this._db, spawnEnv);
+        }
         const telemetryEnabled = !!(this._projectId && this._db && (0, db_1.getProjectSettings)(this._db).pipelineTelemetryEnabled);
         // Resolve the framework version ONCE at spawn time — `framework/current`
         // is read from `~/.specrails/framework/current`. A concurrent atomic swap
@@ -1668,7 +1676,7 @@ class QueueManager {
             if (frameworkVersion)
                 extra['specrails.framework_version'] = frameworkVersion;
             spawnEnv = {
-                ...process.env,
+                ...spawnEnv,
                 ...buildTelemetryEnv(jobId, this._projectId, this._desktopPort, extra, adapter.id),
             };
         }

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

@@ -497,8 +497,9 @@ async function launchIsolatedRail(input, io = {}) {
             // Build-settle: persist the per-unit branch outcomes + this launch's
             // worktree ledger ids on the row (the deferred create-pr / discard actions
             // reconstruct their inputs from these — nothing survives in memory), then
-            // hand the decision to the user. 0 succeeded units → nothing deliverable
-            // → auto-close (per-run settle already reverted the tickets).
+            // hand the decision to the user. 0 succeeded units → nothing deliverable;
+            // keep the implementation card visible as a failed job state with run-log
+            // chips instead of silently auto-discarding or leaving it at "building".
             const worktreeIds = allocated.map((a) => a.ledgerId);
             const anySucceeded = results.some((r) => r.succeeded);
             const settledContinuation = anySucceeded ? launchContinuation : null;
@@ -522,7 +523,7 @@ async function launchIsolatedRail(input, io = {}) {
                         ? 'pr_failed'
                         : (settledContinuation.isDraft === false ? 'pr_ready' : 'pr_draft'))
                     : 'on_review')
-                : 'discarded';
+                : 'implementation_failed';
             const patch = settledContinuation
                 ? {
                     branches,
@@ -543,7 +544,7 @@ async function launchIsolatedRail(input, io = {}) {
                 syncOriginCard('update');
             }
             if (!anySucceeded) {
-                // AUTO-DISCARD CLEANUP (0 succeeded): unmount every worktree NOW rather
+                // FAILED-IMPLEMENTATION CLEANUP (0 succeeded): unmount every worktree NOW rather
                 // than leaving it for a restart's reconcile sweep — a still-mounted
                 // worktree POISONS the next run of the same ticket: the worktree path is
                 // keyed by ticketId, so the next allocation silently reuses this

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

@@ -107,7 +107,8 @@ function actionAllowed(action, row) {
             return row.decision === 'pr_draft' && row.pr_url !== null;
         case 'discard':
             return row.decision === 'on_review' || row.decision === 'pr_draft' ||
-                row.decision === 'pr_ready' || row.decision === 'pr_failed';
+                row.decision === 'pr_ready' || row.decision === 'implementation_failed' ||
+                row.decision === 'pr_failed';
         case 'poll-merge':
             return (row.decision === 'pr_draft' || row.decision === 'pr_ready') && row.pr_url !== null;
         case 'merge-local':
@@ -438,9 +439,15 @@ async function runPublish(deps, row) {
 }
 async function runDiscard(deps, row) {
     const snap = (0, rail_pr_store_1.toPrDeliverySnapshot)(row);
+    const implementationFailed = row.decision === 'implementation_failed';
     // 1. Close the PR (drops its head branch) when one exists. Best-effort — a
     //    gh failure must never leave the discard half-done.
-    if (row.pr_url) {
+    //
+    // Implementation-failed rows are different: the implement run produced no
+    // deliverable update. If the row belongs to an existing-PR continuation it may
+    // still carry that PR's url/branch from launch time; clearing the failed card
+    // must not close or delete the user's existing review branch.
+    if (row.pr_url && !implementationFailed) {
         try {
             const r = await deps.exec.run('gh', ['pr', 'close', row.pr_url, '--delete-branch'], deps.project.path);
             if (r.code !== 0) {
@@ -454,12 +461,13 @@ async function runDiscard(deps, row) {
     // 2. Remove the launch's worktrees (still on disk unless a restart already
     //    swept them) and close their ledger rows — the reconcile-style removal,
     //    branch deletion deferred to step 3 (a checked-out branch can't be -D'd).
-    const branchSet = new Set(snap.branches.map((b) => b.branch));
+    const branchSet = new Set(implementationFailed ? [] : snap.branches.map((b) => b.branch));
     for (const wtId of snap.worktreeIds) {
         const wt = (0, rail_worktrees_store_1.getRailWorktree)(deps.db, wtId);
         if (!wt)
             continue;
-        branchSet.add(wt.branch);
+        if (!implementationFailed)
+            branchSet.add(wt.branch);
         await (0, worktree_manager_1.removeWorktree)(deps.git, {
             repoDir: deps.project.path, worktreePath: wt.worktree_path, branch: wt.branch, deleteBranch: false,
         }).catch(() => { });
@@ -471,22 +479,24 @@ async function runDiscard(deps, row) {
     //    best-effort from the same ticket data the create-pr path names it from
     //    (the delivered head is already covered by row.branch). Missing branches
     //    are tolerated; the integration branch is NEVER deleted.
-    if (row.branch)
-        branchSet.add(row.branch);
-    const succeededUnits = snap.branches.filter((b) => b.succeeded);
-    if (succeededUnits.length > 1) {
-        try {
-            branchSet.add((0, pr_naming_1.batchBranchNameFor)(loadPrTicketData(deps, succeededUnits.map((b) => b.ticketId))));
+    if (!implementationFailed) {
+        if (row.branch)
+            branchSet.add(row.branch);
+        const succeededUnits = snap.branches.filter((b) => b.succeeded);
+        if (succeededUnits.length > 1) {
+            try {
+                branchSet.add((0, pr_naming_1.batchBranchNameFor)(loadPrTicketData(deps, succeededUnits.map((b) => b.ticketId))));
+            }
+            catch {
+                /* best-effort defense-in-depth only */
+            }
         }
-        catch {
-            /* best-effort defense-in-depth only */
+        for (const branch of branchSet) {
+            if (!branch || branch === row.base_branch)
+                continue;
+            await deps.git.run(['branch', '-D', branch], deps.project.path).catch(() => { });
         }
     }
-    for (const branch of branchSet) {
-        if (!branch || branch === row.base_branch)
-            continue;
-        await deps.git.run(['branch', '-D', branch], deps.project.path).catch(() => { });
-    }
     const conflict = casTransition(deps, row, 'discarded');
     if (conflict)
         return conflict;

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

@@ -6,6 +6,7 @@ exports.createPrDelivery = createPrDelivery;
 exports.getPrDelivery = getPrDelivery;
 exports.getActivePrDeliveryByRail = getActivePrDeliveryByRail;
 exports.listActivePrDeliveries = listActivePrDeliveries;
+exports.reconcileFailedBuildingPrDeliveries = reconcileFailedBuildingPrDeliveries;
 exports.transitionDecision = transitionDecision;
 exports.toPrDeliverySnapshot = toPrDeliverySnapshot;
 exports.toRailPrStateMessage = toRailPrStateMessage;
@@ -19,6 +20,7 @@ exports.ACTIVE_PR_DECISIONS = new Set([
     'on_review',
     'pr_draft',
     'pr_ready',
+    'implementation_failed',
     'pr_failed',
 ]);
 function isTerminalPrDecision(s) {
@@ -60,6 +62,40 @@ function listActivePrDeliveries(db) {
        ORDER BY rail_index, created_at DESC, rowid DESC`)
         .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.
+ */
+function reconcileFailedBuildingPrDeliveries(db) {
+    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)
+            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'))
+            continue;
+        if (runs.some((run) => run.final_outcome === 'success'))
+            continue;
+        if (transitionDecision(db, row.id, 'building', 'implementation_failed')) {
+            const updated = getPrDelivery(db, row.id);
+            if (updated)
+                reconciled.push(updated);
+        }
+    }
+    return reconciled;
+}
 // 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.

package/server/dist/rails-router.js

@@ -53,6 +53,11 @@ function emitPrDeliveryUpdate(c, prDeliveryId) {
         (0, agent_chat_registry_1.getAgentChatManager)()?.updatePrDecisionCard(row.origin_conversation_id, (0, rail_pr_store_1.toPrDecisionCardEnvelope)(c.project.id, snap));
     }
 }
+function reconcileAndEmitFailedPrDeliveries(c) {
+    for (const row of (0, rail_pr_store_1.reconcileFailedBuildingPrDeliveries)(c.db)) {
+        emitPrDeliveryUpdate(c, row.id);
+    }
+}
 function createRailsRouter() {
     const router = (0, express_1.Router)({ mergeParams: true });
     function ctx(req) {
@@ -116,6 +121,7 @@ function createRailsRouter() {
             // (non-terminal) delivery per rail slot, so a refreshed client re-renders
             // the decision surface without waiting for a broadcast. The store lists
             // newest-first within each rail — keep the first per index.
+            reconcileAndEmitFailedPrDeliveries(c);
             const prDeliveries = {};
             for (const row of (0, rail_pr_store_1.listActivePrDeliveries)(c.db)) {
                 if (!(row.rail_index in prDeliveries))
@@ -684,7 +690,7 @@ function createRailsRouter() {
                                 if (current.pr_state === 'pr-created' && current.pr_url && current.branch) {
                                     const succeeded = settled.every((s) => s.status === 'fulfilled' && s.value === true);
                                     if (!succeeded) {
-                                        if ((0, rail_pr_store_1.transitionDecision)(c.db, fallbackPrDeliveryId, 'building', 'pr_failed', { prState: 'local-only' })) {
+                                        if ((0, rail_pr_store_1.transitionDecision)(c.db, fallbackPrDeliveryId, 'building', 'implementation_failed')) {
                                             emitPrDeliveryUpdate(c, fallbackPrDeliveryId);
                                         }
                                         return;

package/server/dist/setup-manager.js

@@ -275,12 +275,12 @@ function deployTemplates(projectPath, selectedAgents) {
 // Full install: 7-phase enrichment flow (claude /specrails:enrich)
 exports.CHECKPOINTS = [
     { key: 'base_install', name: 'Base installation' },
-    { key: 'repo_analysis', name: 'Repository analysis' },
-    { key: 'stack_conventions', name: 'Stack & conventions' },
-    { key: 'product_discovery', name: 'Product discovery' },
+    { key: 'agent_selection', name: 'Agent selection' },
+    { key: 'codebase_analysis', name: 'Codebase analysis' },
+    { key: 'vpc_discovery', name: 'VPC discovery' },
     { key: 'agent_generation', name: 'Agent generation' },
-    { key: 'command_config', name: 'Command configuration' },
-    { key: 'final_verification', name: 'Final verification' },
+    { key: 'persona_synthesis', name: 'Persona synthesis' },
+    { key: 'command_generation', name: 'Command generation' },
 ];
 // Quick install: 3-phase non-interactive flow (npx init --from-config)
 exports.QUICK_CHECKPOINTS = [
@@ -303,19 +303,20 @@ function checkFilesystem(projectPath) {
     const hasCommands = (((0, fs_1.existsSync)((0, path_1.join)(projectPath, dir, 'commands', 'sr')) && hasFiles((0, path_1.join)(projectPath, dir, 'commands', 'sr'), /\.md$/)) ||
         ((0, fs_1.existsSync)((0, path_1.join)(projectPath, dir, 'commands', 'specrails')) && hasFiles((0, path_1.join)(projectPath, dir, 'commands', 'specrails'), /\.md$/)));
     const hasCLAUDE = (0, fs_1.existsSync)((0, path_1.join)(projectPath, 'CLAUDE.md'));
+    const hasInstallConfig = (0, fs_1.existsSync)((0, path_1.join)(projectPath, '.specrails', 'install-config.yaml')) ||
+        (0, fs_1.existsSync)((0, path_1.join)(projectPath, dir, 'install-config.yaml'));
+    const hasAgentConfig = (0, fs_1.existsSync)((0, path_1.join)(projectPath, dir, 'agents.yaml'));
+    const hasBacklogConfig = (0, fs_1.existsSync)((0, path_1.join)(projectPath, dir, 'backlog-config.json'));
     return {
         base_install: hasBaseInstall,
-        // repo_analysis: detected when setup templates exist and CLAUDE.md is written
-        // (Claude writes CLAUDE.md after analyzing the repo)
-        repo_analysis: hasBaseInstall && (hasCLAUDE || hasSetupTemplates),
-        // stack_conventions: detected when rules files are generated
-        stack_conventions: hasRules,
-        product_discovery: hasPersonas,
+        // Back-compat filesystem signals from older cores are translated to the
+        // current integration-contract checkpoint keys.
+        agent_selection: hasInstallConfig || hasAgentConfig || hasBacklogConfig || hasAgents || hasCommands,
+        codebase_analysis: hasBaseInstall && (hasCLAUDE || hasSetupTemplates),
+        vpc_discovery: hasPersonas,
+        persona_synthesis: hasPersonas,
         agent_generation: hasAgents,
-        command_config: hasCommands,
-        // Final verification: agents + commands must exist (manifest from install.sh is unreliable —
-        // it's created during scaffolding before /setup generates the actual artifacts)
-        final_verification: hasAgents && hasCommands,
+        command_generation: hasCommands || (hasAgents && hasRules),
     };
 }
 function hasFiles(dir, pattern) {
@@ -357,21 +358,23 @@ function readEnrichMdContent(projectPath) {
 // ─── Stream-based checkpoint detection ───────────────────────────────────────
 function detectCheckpointFromText(text) {
     const hits = [];
-    // Match phase headers from Claude's /specrails:enrich output (and legacy /setup)
+    // Match phase headers from Claude's /specrails:enrich output (and legacy /setup).
+    // Older specrails-core prompts used different checkpoint names; keep accepting
+    // those phrases but emit only the current integration-contract keys.
     if (/phase\s*1|codebase\s*analysis|repository\s*analysis/i.test(text)) {
-        hits.push({ key: 'repo_analysis', detail: 'Analyzing codebase...' });
+        hits.push({ key: 'codebase_analysis', detail: 'Analyzing codebase...' });
     }
-    if (/phase\s*2|user\s*personas|product\s*discovery/i.test(text)) {
-        hits.push({ key: 'product_discovery', detail: 'Generating personas...' });
+    if (/phase\s*2|user\s*personas|product\s*discovery|vpc\s*discovery/i.test(text)) {
+        hits.push({ key: 'vpc_discovery', detail: 'Discovering personas...' });
     }
     if (/phase\s*3|configuration|agent\s*selection|backlog\s*provider/i.test(text)) {
-        hits.push({ key: 'stack_conventions', detail: 'Configuring stack...' });
+        hits.push({ key: 'agent_selection', detail: 'Configuring agents...' });
     }
     if (/generating\s*all\s*files|writing.*agent|sr-architect|sr-developer|sr-reviewer/i.test(text)) {
         hits.push({ key: 'agent_generation', detail: 'Generating agents...' });
     }
     if (/command\s*selection|installing.*commands|\.claude\/commands\/(sr|specrails)/i.test(text)) {
-        hits.push({ key: 'command_config', detail: 'Configuring commands...' });
+        hits.push({ key: 'command_generation', detail: 'Configuring commands...' });
     }
     // TUI output patterns from specrails-core init --from-config.
     // Covers both the retired bash installer (✓ config loaded, reading
@@ -385,7 +388,7 @@ function detectCheckpointFromText(text) {
         hits.push({ key: 'agent_generation', detail: 'Installing specrails artefacts...' });
     }
     if (/writing\s*manifest|wrote\s+.*specrails-manifest/i.test(text)) {
-        hits.push({ key: 'final_verification' });
+        hits.push({ key: 'command_generation' });
     }
     if (/✓\s*installed|installation\s*complete|init\s*complete|update\s*complete/i.test(text)) {
         hits.push({ key: 'quick_complete' });
@@ -394,7 +397,7 @@ function detectCheckpointFromText(text) {
     if (text.includes('.specrails-version') || text.includes('specrails/specrails-version'))
         hits.push({ key: 'base_install' });
     if (text.includes('/agents/personas/') && text.includes('.md')) {
-        hits.push({ key: 'product_discovery', detail: 'Writing personas...' });
+        hits.push({ key: 'persona_synthesis', detail: 'Writing personas...' });
     }
     // Claude path: .claude/agents/sr-<name>.md
     if (/\/agents\/sr-[^/]+\.md/.test(text)) {
@@ -407,24 +410,24 @@ function detectCheckpointFromText(text) {
         hits.push({ key: 'agent_generation', detail: 'Writing agent skills...' });
     }
     if ((text.includes('/commands/sr/') || text.includes('/commands/specrails/')) && text.includes('.md')) {
-        hits.push({ key: 'command_config', detail: 'Writing commands...' });
+        hits.push({ key: 'command_generation', detail: 'Writing commands...' });
     }
     // Codex enrich/doctor skills (the non-rail commands) also indicate
-    // command_config progress.
+    // command_generation progress.
     if (/\.codex\/skills\/(enrich|doctor)\/SKILL\.md/.test(text)) {
-        hits.push({ key: 'command_config', detail: 'Writing codex command skills...' });
+        hits.push({ key: 'command_generation', detail: 'Writing codex command skills...' });
     }
     if (text.includes('/rules/') && text.includes('.md')) {
-        hits.push({ key: 'stack_conventions', detail: 'Writing conventions...' });
+        hits.push({ key: 'command_generation', detail: 'Writing conventions...' });
     }
     // Codex sandbox / approval policy lives inside .codex/config.toml
     // (top-level `sandbox_mode` + `approval_policy` keys, per codex
     // 0.128.0+). There is no separate Starlark rules file.
     if (/\.codex\/config\.toml/.test(text)) {
-        hits.push({ key: 'stack_conventions', detail: 'Writing codex sandbox config...' });
+        hits.push({ key: 'agent_selection', detail: 'Writing codex sandbox config...' });
     }
     if (text.includes('.specrails-manifest.json') || text.includes('specrails/specrails-manifest.json')) {
-        hits.push({ key: 'final_verification' });
+        hits.push({ key: 'command_generation' });
     }
     return hits;
 }

package/server/dist/setup-prerequisites.js

@@ -122,7 +122,7 @@ function brokenSymlinkHint(label, command, resolvedPath) {
     const where = resolvedPath ? ` at ${resolvedPath}` : '';
     return `${label} found${where} but failed to execute — possibly a broken symlink or a stale install. Reinstall ${command} or remove the stale link${resolvedPath ? ` at ${resolvedPath}` : ''}.`;
 }
-const BUNDLED_TOOL_KEYS = new Set(['node', 'npm', 'npx', 'git']);
+const BUNDLED_TOOL_KEYS = new Set(['node', 'npm', 'npx', 'git', 'uv']);
 function isBundledTool(key) {
     return BUNDLED_TOOL_KEYS.has(key);
 }
@@ -138,6 +138,7 @@ function getBundledToolCandidates(runtimesBase, tool) {
             npx: [path_1.default.join(runtimesBase, 'node', 'npx.cmd')],
             git: [path_1.default.join(runtimesBase, 'git', 'cmd', 'git.exe'), path_1.default.join(runtimesBase, 'git', 'bin', 'git.exe')],
             gh: [path_1.default.join(runtimesBase, 'gh', 'bin', 'gh.exe')],
+            uv: [path_1.default.join(runtimesBase, 'uv', 'uv.exe'), path_1.default.join(runtimesBase, 'uv', 'bin', 'uv.exe')],
         };
         return map[tool];
     }
@@ -147,6 +148,7 @@ function getBundledToolCandidates(runtimesBase, tool) {
         npx: [path_1.default.join(runtimesBase, 'node', 'bin', 'npx')],
         git: [path_1.default.join(runtimesBase, 'git', 'bin', 'git')],
         gh: [path_1.default.join(runtimesBase, 'gh', 'bin', 'gh')],
+        uv: [path_1.default.join(runtimesBase, 'uv', 'bin', 'uv'), path_1.default.join(runtimesBase, 'uv', 'uv')],
     };
     return map[tool];
 }