specrails-desktop 2.20.1 → 2.22.0

package/server/dist/project-registry.js

@@ -35,6 +35,7 @@ const jira_sync_manager_1 = require("./jira/jira-sync-manager");
 const loop_run_manager_1 = require("./loop-run-manager");
 const loop_executors_1 = require("./loop-executors");
 const rail_isolated_launch_1 = require("./rail-isolated-launch");
+const rail_isolation_1 = require("./rail-isolation");
 const loop_runs_store_1 = require("./loop-runs-store");
 const rails_store_1 = require("./rails-store");
 const desktop_db_1 = require("./desktop-db");
@@ -162,6 +163,13 @@ class ProjectRegistry {
                 ctx.chatManager.shutdown();
             }
             catch { /* ignore */ }
+            // Loop engine teardown: dispose any resident interactive step sessions
+            // (SIGTERM, no settle) + kill in-flight one-shot loop children — BEFORE
+            // db.close() so a late close handler can't write to the closed handle.
+            try {
+                ctx.loopRunManager.shutdown();
+            }
+            catch { /* ignore */ }
             try {
                 ctx.setupManager.abort(id);
             }
@@ -310,6 +318,12 @@ class ProjectRegistry {
                 ctx.chatManager.shutdown();
             }
             catch { /* ignore */ }
+            // Loop engine: dispose resident interactive step sessions + kill in-flight
+            // one-shot loop children so a quit mid-run doesn't orphan claude processes.
+            try {
+                ctx.loopRunManager.shutdown();
+            }
+            catch { /* ignore */ }
             // Install/enrich wizard children + the 3s install poll interval are NOT
             // torn down by the spawner shutdowns above — mirror removeProject()'s
             // setupManager.abort() so a quit mid-wizard doesn't orphan them.
@@ -428,7 +442,7 @@ class ProjectRegistry {
                 }
                 catch { /* best-effort */ }
             },
-            onJobFinished: (jobId, status, costUsd) => {
+            onJobFinished: (jobId, status, costUsd, opts) => {
                 const jobRow = db.prepare('SELECT command, duration_ms FROM jobs WHERE id = ?').get(jobId);
                 const event = status === 'completed' ? 'job.completed' : status === 'canceled' ? 'job.canceled' : 'job.failed';
                 webhookManager.deliver(project.id, event, {
@@ -452,10 +466,20 @@ class ProjectRegistry {
                         completedTicketIds = matches.map((m) => parseInt(m.slice(1), 10));
                 }
                 // Apply the job outcome to its tickets. Success promotes todo/in_progress
-                // → done (→ Specs Done); failure/cancel/zombie reverts in_progress → todo
+                // → done (→ Specs Done) — or → on_review under the ask-first PR-delivery
+                // methodology (below); failure/cancel/zombie reverts in_progress → todo
                 // (→ Specs) or flags an already-done spec for review. zombie_terminated is
                 // treated as a failure here (and is included in the _onJobExit callback
                 // guard) so a timed-out rail releases its specs instead of stranding them.
+                //
+                // Ask-first methodology (safe-pr-workflow, universal): QueueManager
+                // captures the PR-delivery flag ONCE at this job's spawn and threads it
+                // here as `opts.ticketCompletionStatus` — so a mid-flight env flip can't
+                // split one job's behavior. Under the flag a COMPLETED job parks its
+                // tickets at on_review (the human decides done via PR merge or a manual
+                // move), never done. Absent opts (legacy callers / never-spawned failure
+                // paths) ⇒ 'done', byte-identical to the pre-change promotion.
+                const completedStatus = opts?.ticketCompletionStatus ?? 'done';
                 if (completedTicketIds.length > 0 &&
                     (status === 'completed' || status === 'failed' || status === 'canceled' || status === 'zombie_terminated')) {
                     try {
@@ -468,7 +492,7 @@ class ProjectRegistry {
                         const now = new Date().toISOString();
                         let changedIds = [];
                         const store = (0, ticket_store_1.mutateStore)(ticketFile, (s) => {
-                            changedIds = (0, ticket_store_1.applyJobOutcomeToTickets)(s, completedTicketIds, status, now);
+                            changedIds = (0, ticket_store_1.applyJobOutcomeToTickets)(s, completedTicketIds, status, now, { completedStatus });
                         });
                         for (const tid of changedIds) {
                             const ticket = store.tickets[String(tid)];
@@ -487,15 +511,24 @@ class ProjectRegistry {
                         // wrapped so a Jira failure can never break the job-exit handler.
                         if (status === 'completed' || status === 'failed' || status === 'canceled' || status === 'zombie_terminated') {
                             try {
-                                const needsReviewIds = completedTicketIds.filter((tid) => store.tickets[String(tid)]?.needs_review === true);
-                                jiraSyncManager.onJobOutcome({
-                                    ticketIds: completedTicketIds,
-                                    status,
-                                    jobId,
-                                    costUsd: costUsd ?? null,
-                                    durationMs: jobRow?.duration_ms ?? null,
-                                    needsReviewIds,
-                                });
+                                if (status === 'completed' && completedStatus === 'on_review') {
+                                    // Under review, not done — enqueue the Jira on_review
+                                    // transition instead of the done-flavoured completion
+                                    // (comment + Done). Mirrors onLoopRunFinished's split; the
+                                    // Done transition rides the later PR-merge / manual move.
+                                    jiraSyncManager.onRailReview(changedIds, jobId);
+                                }
+                                else {
+                                    const needsReviewIds = completedTicketIds.filter((tid) => store.tickets[String(tid)]?.needs_review === true);
+                                    jiraSyncManager.onJobOutcome({
+                                        ticketIds: completedTicketIds,
+                                        status,
+                                        jobId,
+                                        costUsd: costUsd ?? null,
+                                        durationMs: jobRow?.duration_ms ?? null,
+                                        needsReviewIds,
+                                    });
+                                }
                             }
                             catch (err) {
                                 console.error('[project-registry] jira onJobOutcome failed:', err);
@@ -650,7 +683,16 @@ class ProjectRegistry {
             .then((n) => { if (n > 0)
             console.log(`[loops] reconciled ${n} orphan worktree(s) for ${project.slug}`); })
             .catch(() => { });
-        const loopRunManager = new loop_run_manager_1.LoopRunManager(db, boundBroadcast, (0, loop_executors_1.createLoopExecutors)());
+        // Loop executors resolve their base env LAZILY per step: a RELOCATED project
+        // injects core's env-first artifact indirection (tickets/backlog/profiles/
+        // state → the workspace) so an ISOLATED worktree run — whose cwd-relative
+        // `${ENV:-legacy}` defaults resolve inside the worktree, where only tracked
+        // files exist — still reads the real project state. SPECRAILS_REPO_DIR stays
+        // per-run (the worktree for isolated runs). Legacy projects keep process.env
+        // byte-identical. See resolveLoopBaseEnv.
+        const loopRunManager = new loop_run_manager_1.LoopRunManager(db, boundBroadcast, (0, loop_executors_1.createLoopExecutors)({
+            env: () => (0, workspace_resolution_1.resolveLoopBaseEnv)({ slug: project.slug, path: project.path }),
+        }));
         const getTicketSpec = (ticketId) => {
             try {
                 const exec = (0, workspace_resolution_1.resolveProjectExecution)({ slug: project.slug, path: project.path });
@@ -677,7 +719,7 @@ class ProjectRegistry {
         // Releases a finished loop run's tickets + rail slots. The engine already
         // emitted loop.run_completed; this mirrors onJobFinished's ticket/rail
         // release (kept separate so the critical job path is untouched).
-        const onLoopRunFinished = (runId, outcome) => {
+        const onLoopRunFinished = (runId, outcome, opts) => {
             const meta = railLoopRuns.get(runId);
             if (!meta)
                 return;
@@ -686,13 +728,23 @@ class ProjectRegistry {
             if (ticketIds.length === 0)
                 return;
             const status = outcome === 'success' ? 'completed' : outcome === 'stopped' ? 'canceled' : 'failed';
+            // Ask-first PR delivery parks a completed run's tickets at on_review (the
+            // user decides done vs discard via the PR decision flow / a manual move).
+            // Explicit opts (the isolated-rail launch passes its launch-captured
+            // prMode) always win — idempotent with the default. ABSENT opts
+            // (shared-cwd rail runs, standalone loop runs, isolation-unavailable
+            // fallbacks) derive the default from the PR-delivery flag, read ONCE here
+            // and reused by the Jira split below so one settle can never split across
+            // the two paths. Kill-switch off ⇒ 'done', the legacy promotion
+            // byte-identical; failures ignore the field.
+            const completedStatus = opts?.ticketCompletionStatus ?? ((0, rail_isolation_1.isRailPrDeliveryEnabled)() ? 'on_review' : 'done');
             try {
                 const exec = (0, workspace_resolution_1.resolveProjectExecution)({ slug: project.slug, path: project.path });
                 const ticketFile = exec.relocated ? exec.ticketsPath : (0, ticket_store_1.resolveTicketStoragePath)(project.path);
                 const now = new Date().toISOString();
                 let changedIds = [];
                 const store = (0, ticket_store_1.mutateStore)(ticketFile, (s) => {
-                    changedIds = (0, ticket_store_1.applyJobOutcomeToTickets)(s, ticketIds, status, now);
+                    changedIds = (0, ticket_store_1.applyJobOutcomeToTickets)(s, ticketIds, status, now, { completedStatus });
                 });
                 for (const tid of changedIds) {
                     const ticket = store.tickets[String(tid)];
@@ -706,8 +758,16 @@ class ProjectRegistry {
                     });
                 }
                 try {
-                    const needsReviewIds = ticketIds.filter((tid) => store.tickets[String(tid)]?.needs_review === true);
-                    jiraSyncManager.onJobOutcome({ ticketIds, status, jobId: runId, costUsd: null, durationMs: null, needsReviewIds });
+                    if (status === 'completed' && completedStatus === 'on_review') {
+                        // Under review, not done — enqueue the Jira on_review transition
+                        // instead of the done-flavoured completion (comment + Done). The
+                        // Done transition rides the later PR-merge / manual move.
+                        jiraSyncManager.onRailReview(changedIds, runId);
+                    }
+                    else {
+                        const needsReviewIds = ticketIds.filter((tid) => store.tickets[String(tid)]?.needs_review === true);
+                        jiraSyncManager.onJobOutcome({ ticketIds, status, jobId: runId, costUsd: null, durationMs: null, needsReviewIds });
+                    }
                 }
                 catch (err) {
                     console.error('[project-registry] jira loop onJobOutcome failed:', err);

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

@@ -9,6 +9,7 @@ const hooks_1 = require("./hooks");
 const explore_smash_1 = require("./explore-smash");
 const spec_models_1 = require("./spec-models");
 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 project_router_helpers_1 = require("./project-router-helpers");
@@ -117,6 +118,16 @@ function registerJobsRoutes(deps) {
         }
         catch (err) {
             if (err instanceof queue_manager_1.JobNotFoundError) {
+                // STANDALONE loop runs (railIndex=null, POST /loop-runs) never enter
+                // railLoopRuns, so they fall through to the queue and land here while
+                // the loop is still executing — cancel through the engine instead of
+                // 404ing with a live child (the mission-modal "cancel did nothing" bug).
+                const loopRun = (0, loop_runs_store_1.getLoopRun)(c.db, id);
+                if (loopRun && loopRun.status === 'running' && c.loopRunManager) {
+                    c.loopRunManager.cancel(id);
+                    res.json({ ok: true, status: 'canceling' });
+                    return;
+                }
                 res.status(404).json({ error: 'Job not found' });
             }
             else if (err instanceof queue_manager_1.JobAlreadyTerminalError) {
@@ -134,10 +145,14 @@ function registerJobsRoutes(deps) {
             }
         }
     });
-    // ─── Interactive ultracode jobs ────────────────────────────────────────────
+    // ─── Interactive jobs (manager-agnostic) ───────────────────────────────────
     // Send one more user prompt to a running interactive job (queued behind the
-    // active turn — see InteractiveJobSession). 202 = accepted; 409 = the job is
-    // not an active interactive session (unknown / non-interactive / finalized).
+    // active turn — see InteractiveJobSession). The job row may be owned by
+    // EITHER manager: QueueManager (rail/ultracode/spawned jobs) or
+    // LoopRunManager (a loop run's job row, addressed by its ACTIVE step
+    // session). Try the queue first, then the loop engine. 202 = accepted;
+    // 409 = neither manager has an active interactive session for the id
+    // (unknown / non-interactive / finalized / between loop steps).
     router.post('/:projectId/jobs/:id/messages', (req, res) => {
         if (!(0, feature_flags_1.isInteractiveJobsEnabled)()) {
             res.status(403).json({ error: 'Interactive jobs are disabled on this server' });
@@ -148,9 +163,10 @@ function registerJobsRoutes(deps) {
             res.status(400).json({ error: 'text is required' });
             return;
         }
-        const { queueManager } = ctx(req);
+        const c = ctx(req);
         const jobId = req.params.id;
-        const accepted = queueManager.sendInteractiveTurn(jobId, text);
+        const accepted = c.queueManager.sendInteractiveTurn(jobId, text)
+            || (c.loopRunManager?.sendInteractiveTurn(jobId, text) ?? false);
         if (!accepted) {
             res.status(409).json({ error: 'Job is not an active interactive session' });
             return;
@@ -158,22 +174,25 @@ function registerJobsRoutes(deps) {
         res.status(202).json({ ok: true });
     });
     // Finalize a running interactive job: SIGTERM the resident child; the summed
-    // token/cost totals + 'completed' status are stamped asynchronously when the
+    // token/cost totals + terminal status are stamped asynchronously when the
     // child closes (the client also learns the final state via the job.finalized
-    // WS broadcast). 202 = finalize scheduled; 409 = not an active interactive job.
+    // WS broadcast). On a QueueManager job this completes the JOB; on a loop
+    // run's job it settles the ACTIVE STEP now — the loop advances with what the
+    // step produced. 202 = finalize scheduled; 409 = not an active interactive job.
     router.post('/:projectId/jobs/:id/finalize', (req, res) => {
         if (!(0, feature_flags_1.isInteractiveJobsEnabled)()) {
             res.status(403).json({ error: 'Interactive jobs are disabled on this server' });
             return;
         }
-        const { db, queueManager } = ctx(req);
+        const c = ctx(req);
         const jobId = req.params.id;
-        const scheduled = queueManager.finalizeInteractive(jobId);
+        const scheduled = c.queueManager.finalizeInteractive(jobId)
+            || (c.loopRunManager?.finalizeInteractive(jobId) ?? false);
         if (!scheduled) {
             res.status(409).json({ error: 'Job is not an active interactive session' });
             return;
         }
-        res.status(202).json({ ok: true, job: (0, db_1.getJob)(db, jobId) ?? null });
+        res.status(202).json({ ok: true, job: (0, db_1.getJob)(c.db, jobId) ?? null });
     });
     router.patch('/:projectId/jobs/:id/priority', (req, res) => {
         const { priority } = req.body ?? {};
@@ -367,7 +386,8 @@ function registerJobsRoutes(deps) {
         res.json({ jobs: rows });
     });
     router.get('/:projectId/jobs/:id', (req, res) => {
-        const { db, queueManager, project } = ctx(req);
+        const c = ctx(req);
+        const { db, queueManager, project } = c;
         const jobId = req.params.id;
         const job = (0, db_1.getJob)(db, jobId);
         if (!job) {
@@ -405,13 +425,33 @@ function registerJobsRoutes(deps) {
             };
             const phaseDefinitions = queueManager.phasesForCommand(synthetic.command);
             const tickets = (0, ticket_store_1.resolveTicketsFromCommand)(project.path, synthetic.command, ticketPath(req));
-            res.json({ job: { ...synthetic, hasTelemetry: false, tickets }, events: [], phaseDefinitions });
+            // Queued ⇒ no resident session yet; the client refetches on the
+            // queued→running flip to learn the real interactive surface state.
+            res.json({
+                job: { ...synthetic, hasTelemetry: false, tickets, interactiveSettleMode: null, interactiveAcceptingTurns: false },
+                events: [],
+                phaseDefinitions,
+            });
             return;
         }
         const events = (0, db_1.getJobEvents)(db, jobId);
         const phaseDefinitions = queueManager.phasesForCommand(job.command);
         const tickets = (0, ticket_store_1.resolveTicketsFromCommand)(project.path, job.command, ticketPath(req));
-        const annotated = { ...job, hasTelemetry: (0, db_1.hasJobTelemetry)(db, jobId), tickets };
+        // Interactive surface state (S3): the settle mode of the resident session
+        // plus whether it is accepting turns RIGHT NOW. A QueueManager job's session
+        // lives for the whole run; a loop run's ACTIVE ai-step owns it (absent
+        // between steps / decider / shell nodes — POST /messages would 409 there).
+        // A between-steps loop GET still reports 'auto' via its loop_runs row so the
+        // composer can phrase the waiting state truthfully instead of guessing.
+        let interactiveSettleMode = null;
+        let interactiveAcceptingTurns = false;
+        if ((0, feature_flags_1.isInteractiveJobsEnabled)() && job.interactive && job.status === 'running') {
+            const qmMode = queueManager.getInteractiveSettleMode?.(jobId) ?? null;
+            const loopStepActive = c.loopRunManager?.isInteractiveJob?.(jobId) ?? false;
+            interactiveAcceptingTurns = qmMode !== null || loopStepActive;
+            interactiveSettleMode = qmMode ?? ((loopStepActive || (0, loop_runs_store_1.getLoopRun)(db, jobId)) ? 'auto' : null);
+        }
+        const annotated = { ...job, hasTelemetry: (0, db_1.hasJobTelemetry)(db, jobId), tickets, interactiveSettleMode, interactiveAcceptingTurns };
         res.json({ job: annotated, events, phaseDefinitions });
     });
     router.delete('/:projectId/jobs', (req, res) => {

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

@@ -10,6 +10,8 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const db_1 = require("./db");
 const telemetry_export_1 = require("./telemetry-export");
+const integration_branch_1 = require("./integration-branch");
+const worktree_manager_1 = require("./worktree-manager");
 const context_budget_1 = require("./context-budget");
 const context_scope_1 = require("./context-scope");
 const terminal_settings_1 = require("./terminal-settings");
@@ -101,6 +103,20 @@ function registerSettingsRoutes(deps) {
             }
             patch.ultraPrePrompt = ultraPrePrompt;
         }
+        if (req.body?.integrationBranch !== undefined) {
+            const ib = req.body.integrationBranch;
+            if (typeof ib !== 'string') {
+                res.status(400).json({ error: 'integrationBranch must be a string' });
+                return;
+            }
+            // Empty = clear (auto-resolve). A non-empty value flows into `git worktree
+            // add … <base>`, so it must be a safe branch name (no arg-injection).
+            if (ib.trim() !== '' && !(0, integration_branch_1.isValidBranchName)(ib)) {
+                res.status(400).json({ error: 'integrationBranch is not a valid branch name' });
+                return;
+            }
+            patch.integrationBranch = ib;
+        }
         try {
             (0, db_1.updateProjectSettings)(ctx(req).db, patch);
             res.json({ ok: true, settings: (0, db_1.getProjectSettings)(ctx(req).db) });
@@ -110,6 +126,23 @@ function registerSettingsRoutes(deps) {
             res.status(500).json({ error: 'Failed to update settings' });
         }
     });
+    // Resolve the effective integration branch (configured value + what it resolves
+    // to right now + provenance) so the client can show the base before launch.
+    router.get('/:projectId/integration-branch', async (req, res) => {
+        const { project, db } = ctx(req);
+        const configured = (0, db_1.getProjectSettings)(db).integrationBranch;
+        try {
+            const resolved = await (0, integration_branch_1.resolveIntegrationBranch)(worktree_manager_1.defaultGitRunner, {
+                repoDir: project.path,
+                projectSetting: configured,
+            });
+            res.json({ configured, branch: resolved.branch, source: resolved.source });
+        }
+        catch (err) {
+            console.error('[project-router] integration-branch resolve failed:', err);
+            res.status(500).json({ error: 'failed to resolve integration branch' });
+        }
+    });
     // ─── Agent models ────────────────────────────────────────────────────────────
     router.get('/:projectId/agent-models', (req, res) => {
         const { project } = ctx(req);

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

@@ -300,6 +300,22 @@ function registerTerminalsRoutes(deps) {
             res.status(500).json({ error: 'Failed clipboard op' });
         }
     });
+    // Switch the viewed page between the root page and the top popup (OAuth login
+    // window). Low-rate UI action → REST, not the WS control channel.
+    router.post('/:projectId/browser/sessions/:id/popup-view', requireBrowserCaptureEnabled, (req, res) => {
+        const mgr = ctx(req).browserCaptureManager;
+        const target = req.body?.target;
+        if (target !== 'root' && target !== 'popup') {
+            res.status(400).json({ error: 'target must be root | popup' });
+            return;
+        }
+        const ok = mgr.setPopupView(req.params.id, target);
+        if (!ok) {
+            res.status(404).json({ error: 'browser_session_not_found' });
+            return;
+        }
+        res.json({ ok: true });
+    });
     router.delete('/:projectId/browser/sessions/:id', requireBrowserCaptureEnabled, async (req, res) => {
         const mgr = ctx(req).browserCaptureManager;
         const ok = await mgr.kill(req.params.id);

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

@@ -1034,6 +1034,41 @@ function registerTicketsRoutes(deps) {
             else if (conversationId && created && convoProvider && convoProvider !== 'claude') {
                 console.log(`[project-router] from-draft contract refine skipped for ${convoProvider} conversation (ticket #${created.id})`);
             }
+            else if (!conversationId && draftTicketId === null && created && body.contractRefine === true) {
+                // Conversation-less commits (the in-app operator agent's commit_draft
+                // path — a spec authored in the agent conversation, no Explore origin):
+                // `contractRefine: true` on the body opts the fresh spec into the SAME
+                // post-persist Contract Layer enrichment the Quick path runs (no
+                // --resume; seeded with the just-inserted spec body). Default OFF at
+                // this layer so Explore-client payloads stay byte-identical — the MCP
+                // specs facade defaults it ON for agent-authored commit_drafts. The
+                // kill switch is checked inside the runner; Claude-only because the
+                // refine spawn hardcodes the `claude` binary.
+                const projectProviders = Array.isArray(project.providers) && project.providers.length > 0
+                    ? project.providers
+                    : [project.provider].filter((p) => typeof p === 'string');
+                if (projectProviders.includes('claude')) {
+                    const refineTicketId = created.id;
+                    const refineTitle = created.title;
+                    const refineDescription = created.description;
+                    console.log(`[project-router] from-draft hook: scheduling quick-style refine for agent-authored ticket=${refineTicketId}`);
+                    process.nextTick(() => {
+                        void (0, contract_refine_runner_1.runContractRefineForQuick)({
+                            db: ctx(req).db,
+                            projectId: project.id,
+                            projectSlug: project.slug,
+                            projectPath: project.path,
+                            projectName: project.name,
+                            broadcast: broadcast,
+                        }, refineTicketId, refineTitle, refineDescription, null).catch((err) => {
+                            console.error('[project-router] from-draft runContractRefineForQuick error:', err);
+                        });
+                    });
+                }
+                else {
+                    console.log(`[project-router] from-draft contract refine skipped (ticket #${created.id}): claude not installed on project`);
+                }
+            }
         }
         catch (err) {
             console.error('[project-router] from-draft create error:', err);
@@ -1166,7 +1201,26 @@ function registerTicketsRoutes(deps) {
                 return;
             }
             if (!ticket.origin_conversation_id) {
-                res.status(409).json({ error: 'ticket has no origin conversation' });
+                // No Explore origin (agent-authored commit_draft / Quick spec that
+                // skipped the refine): fall back to the Quick-style refine, seeded
+                // with the ticket's user-authored body (existing Contract Layer
+                // stripped so a re-run is seeded clean — the writer replaces any
+                // prior layer idempotently anyway).
+                const seedBody = (0, explore_contract_refine_1.splitDescriptionAtContractLayer)(ticket.description ?? '').user;
+                const seedTitle = ticket.title;
+                res.status(202).json({ scheduled: true, mode: 'quick' });
+                process.nextTick(() => {
+                    void (0, contract_refine_runner_1.runContractRefineForQuick)({
+                        db,
+                        projectId: project.id,
+                        projectSlug: project.slug,
+                        projectPath: project.path,
+                        projectName: project.name,
+                        broadcast: broadcast,
+                    }, ticketId, seedTitle, seedBody, null).catch((err) => {
+                        console.error('[project-router] retry runContractRefineForQuick error:', err);
+                    });
+                });
                 return;
             }
             const convoId = ticket.origin_conversation_id;
@@ -1322,7 +1376,7 @@ function registerTicketsRoutes(deps) {
             return;
         }
         if (status !== undefined && !(0, ticket_store_1.isValidStatus)(status)) {
-            res.status(400).json({ error: 'status must be one of: draft, todo, in_progress, done, cancelled' });
+            res.status(400).json({ error: 'status must be one of: draft, todo, in_progress, on_review, done, cancelled' });
             return;
         }
         const finalStatus = (status ?? 'todo');
@@ -1382,7 +1436,7 @@ function registerTicketsRoutes(deps) {
         }
         const { title, description, status, priority, labels, assignee, prerequisites, metadata, acceptanceCriteria, short_summary } = req.body ?? {};
         if (status !== undefined && !(0, ticket_store_1.isValidStatus)(status)) {
-            res.status(400).json({ error: 'status must be one of: draft, todo, in_progress, done, cancelled' });
+            res.status(400).json({ error: 'status must be one of: draft, todo, in_progress, on_review, done, cancelled' });
             return;
         }
         if (priority !== undefined && priority !== null && !(0, ticket_store_1.isValidPriority)(priority)) {

package/server/dist/project-router.js

@@ -11,6 +11,10 @@ const code_explorer_router_1 = require("./code-explorer-router");
 const jira_router_1 = require("./jira-router");
 const ticket_store_1 = require("./ticket-store");
 const workspace_resolution_1 = require("./workspace-resolution");
+const file_story_manager_1 = require("./file-story-manager");
+const file_summary_generator_1 = require("./file-summary-generator");
+const providers_1 = require("./providers");
+const desktop_db_1 = require("./desktop-db");
 const project_router_jobs_1 = require("./project-router-jobs");
 const project_router_spending_1 = require("./project-router-spending");
 const project_router_chat_1 = require("./project-router-chat");
@@ -85,19 +89,54 @@ function createProjectRouter(registry) {
     const codeRouterByCtx = new WeakMap();
     router.use('/:projectId/code', (req, res, next) => {
         const projectCtx = ctx(req);
-        const codeRouter = memoizedSubRouter(codeRouterByCtx, projectCtx, () => (0, code_explorer_router_1.createCodeExplorerRouter)({
-            db: projectCtx.db,
-            projectPath: projectCtx.project.path,
-            projectId: projectCtx.project.id,
-            broadcast: projectCtx.broadcast,
-            fileSummaryManager: projectCtx.fileSummaryManager,
-            // Relocate-artifacts: summary JSON OUTPUTS live in the workspace when
-            // relocated (source tree still read from project.path). Resolved per-call.
-            resolveSummaryRoot: () => {
-                const exec = (0, workspace_resolution_1.resolveProjectExecution)({ slug: projectCtx.project.slug, path: projectCtx.project.path });
-                return exec.relocated && exec.workspaceDir ? exec.workspaceDir : projectCtx.project.path;
-            },
-        }));
+        const codeRouter = memoizedSubRouter(codeRouterByCtx, projectCtx, () => {
+            // Construction-story contribution generator — per-ctx (memoized with the
+            // router). Reuses the file-summary spawn skeleton with the story prompt,
+            // and the SAME monthly budget setting + ai_invocations surface, so the
+            // whole Code-section AI spend rides one budget (see file-story-manager).
+            const storyAdapter = (0, providers_1.getAdapter)(projectCtx.project.provider ?? 'claude');
+            const fileStoryManager = new file_story_manager_1.FileStoryManager({
+                db: projectCtx.db,
+                broadcast: projectCtx.broadcast,
+                generate: (0, file_summary_generator_1.createFileSummaryGenerator)({
+                    adapter: storyAdapter,
+                    cwd: projectCtx.project.path,
+                    systemPrompt: file_story_manager_1.buildStorySystemPrompt,
+                }),
+                monthToDateSpend: (projectId) => {
+                    const row = projectCtx.db.prepare(`SELECT COALESCE(SUM(total_cost_usd), 0) AS total FROM ai_invocations
+             WHERE project_id = ? AND surface = 'file-summary'
+               AND started_at >= strftime('%Y-%m-01', 'now')`).get(projectId);
+                    return row?.total ?? 0;
+                },
+                monthlyBudgetUsd: () => {
+                    const raw = (0, desktop_db_1.getDesktopSetting)(projectCtx.desktopDb, 'summary_monthly_budget_usd');
+                    const n = parseFloat(raw ?? '5.00');
+                    return isNaN(n) ? 5.0 : n;
+                },
+                language: () => {
+                    const raw = (0, desktop_db_1.getDesktopSetting)(projectCtx.desktopDb, 'summary_language');
+                    return raw === 'es' ? 'es' : 'en';
+                },
+                providerId: () => storyAdapter.id,
+                getTicketSpec: projectCtx.getTicketSpec,
+            });
+            return (0, code_explorer_router_1.createCodeExplorerRouter)({
+                db: projectCtx.db,
+                projectPath: projectCtx.project.path,
+                projectId: projectCtx.project.id,
+                broadcast: projectCtx.broadcast,
+                fileSummaryManager: projectCtx.fileSummaryManager,
+                getTicketSpec: projectCtx.getTicketSpec,
+                fileStoryManager,
+                // Relocate-artifacts: summary JSON OUTPUTS live in the workspace when
+                // relocated (source tree still read from project.path). Resolved per-call.
+                resolveSummaryRoot: () => {
+                    const exec = (0, workspace_resolution_1.resolveProjectExecution)({ slug: projectCtx.project.slug, path: projectCtx.project.path });
+                    return exec.relocated && exec.workspaceDir ? exec.workspaceDir : projectCtx.project.path;
+                },
+            });
+        });
         codeRouter(req, res, next);
     });
     // Relocate-artifacts gate (single chokepoint for ALL project-router ticket