specrails-desktop 2.34.1 → 2.36.0

package/server/dist/feature-flags.js

@@ -5,6 +5,8 @@ exports.isBrowserCaptureEnabled = isBrowserCaptureEnabled;
 exports.isJiraEnabled = isJiraEnabled;
 exports.isInteractiveJobsEnabled = isInteractiveJobsEnabled;
 exports.isLoopsEnabled = isLoopsEnabled;
+exports.isReviewPacketEnabled = isReviewPacketEnabled;
+exports.areDeliveryRevisionsEnabled = areDeliveryRevisionsEnabled;
 function isCodeExplorerEnabled() {
     return process.env.SPECRAILS_CODE_EXPLORER !== 'false';
 }
@@ -54,3 +56,24 @@ function isInteractiveJobsEnabled() {
 function isLoopsEnabled() {
     return process.env.SPECRAILS_LOOPS_SECTION !== 'false';
 }
+/**
+ * Review packet (nontech-review-experience): the plain-language what-changed +
+ * proof surface a non-technical user decides on, replacing raw git vocabulary
+ * at the review moment. Server-side default ON; set
+ * SPECRAILS_REVIEW_PACKET="false" to 404 the packet route (emergency
+ * rollback — the existing decision strip keeps working untouched). The client
+ * gates separately on VITE_FEATURE_REVIEW_PACKET.
+ */
+function isReviewPacketEnabled() {
+    return process.env.SPECRAILS_REVIEW_PACKET !== 'false';
+}
+/**
+ * Delivery revisions (nontech-review-experience Wave 3): the ability to launch a
+ * change against a delivery that is still awaiting the user's decision. Default
+ * ON; set SPECRAILS_DELIVERY_REVISIONS="false" to restore the byte-identical
+ * legacy guard — every launch against an undecided delivery 409s again and the
+ * packet's "Ask for changes" cannot be satisfied.
+ */
+function areDeliveryRevisionsEnabled() {
+    return process.env.SPECRAILS_DELIVERY_REVISIONS !== 'false';
+}

package/server/dist/loop-command-catalog.js

@@ -78,6 +78,39 @@ exports.LOOP_COMMANDS = [
         requiredCapability: 'freestyle',
         ticketScope: 'per-ticket',
     },
+    {
+        name: 'revise',
+        label: 'revise',
+        description: 'Revision step (nontech-review-experience): apply the ONE change the user asked for on top of work already delivered, then have the reviewer re-grade it. No re-planning, no re-implementing.',
+        ticketScope: 'all',
+        // Deliberately NOT the implement pipeline: the plan and the code already
+        // exist, so an Architect pass would re-derive both and pay the full cost of
+        // a first run for a one-sentence tweak. The reviewer pass is orchestrated
+        // from HERE rather than added to core, because the sr-* agents are already
+        // present in the run's worktree via the overlay — that keeps the loop a
+        // pure desktop concern with zero specrails-core coupling, and it is what
+        // keeps the review packet's reviewer tier populated for revisions.
+        template: [
+            'A previous run already delivered work for this spec, and the user has now asked for ONE specific change to it. Apply exactly that change.',
+            '',
+            'What the user asked to change:',
+            '{{const:REVISION_REQUEST}}',
+            '',
+            'If the section above is EMPTY, no change was actually requested: do not',
+            'guess, do not re-implement anything, and do not touch the branch. Report',
+            'that no revision instruction was provided and stop.',
+            '',
+            'Rules:',
+            '- Start from the work that is ALREADY on this branch. Read it first (git diff against the base branch) so you extend it instead of redoing it.',
+            '- Make the SMALLEST change that satisfies the request. Do not refactor, re-plan, or re-implement anything the user did not ask about.',
+            '- If the request is ambiguous, choose the most conservative reading and say which one you chose.',
+            '- If the request cannot be done without breaking something the spec requires, stop and report that instead of forcing it.',
+            '',
+            'Then re-grade the result: run the `sr-reviewer` agent over the resulting diff so its review report and `confidence-score.json` reflect THIS revision, not the previous run.',
+            '',
+            '{{const:GUARDRAILS}}',
+        ].join('\n'),
+    },
     {
         name: 'fix',
         label: 'fix',

package/server/dist/loop-executors.js

@@ -121,6 +121,16 @@ function aiStepExtraArgs(adapter, cwd, repoDir) {
 }
 function createLoopExecutors(opts = {}) {
     const resolveEnv = () => typeof opts.env === 'function' ? opts.env() : opts.env ?? process.env;
+    // Deciders deliberately excluded: they run no pipeline agents.
+    const withProfileEnv = (env, provider) => {
+        try {
+            const profilePath = opts.profilePathFor?.(provider) ?? null;
+            return profilePath ? { ...env, SPECRAILS_PROFILE_PATH: profilePath } : env;
+        }
+        catch {
+            return env;
+        }
+    };
     return {
         // Cheap working-tree fingerprint for the engine's non-convergence guard:
         // HEAD sha + the porcelain dirty set, hashed. Two identical fingerprints
@@ -150,7 +160,7 @@ function createLoopExecutors(opts = {}) {
             // for the pipeline's I/O exactly like QueueManager: SPECRAILS_REPO_DIR +
             // claude `--add-dir <repoDir>` (see the shared helpers above). Best-effort
             // agent self-heal on Windows.
-            const stepEnv = aiStepEnv(resolveEnv(), repoDir);
+            const stepEnv = withProfileEnv(aiStepEnv(resolveEnv(), repoDir), provider);
             const extraArgs = aiStepExtraArgs(adapter, cwd, repoDir);
             const effectivePrompt = (0, runtime_1.formatProviderCommand)(adapter, prompt, cwd, sessionId ?? undefined);
             const buildOpts = {
@@ -294,7 +304,7 @@ function createLoopExecutors(opts = {}) {
             const adapter = (0, providers_1.getAdapter)(provider);
             if (!adapter.capabilities.persistentStdin)
                 return null;
-            const stepEnv = aiStepEnv(resolveEnv(), repoDir);
+            const stepEnv = withProfileEnv(aiStepEnv(resolveEnv(), repoDir), provider);
             const extraArgs = aiStepExtraArgs(adapter, cwd, repoDir);
             if (repoDir) {
                 try {

package/server/dist/loop-factory.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FACTORY_LOOPS = void 0;
+exports.FACTORY_LOOPS = exports.FACTORY_REVISION_LOOP_ID = void 0;
 exports.getFactoryLoop = getFactoryLoop;
 exports.isFactoryLoopId = isFactoryLoopId;
 exports.factoryLoopMode = factoryLoopMode;
@@ -23,6 +23,8 @@ const SDD_QUICK_OPENSPEC_FACTORY = {
     mode: 'loop',
     graph: (0, loop_templates_1.opsxLifecycleGraph)(),
 };
+/** The Architect-less revision loop every "ask for a change" launch runs. */
+exports.FACTORY_REVISION_LOOP_ID = 'factory:revision';
 exports.FACTORY_LOOPS = [
     {
         id: 'factory:implement',
@@ -49,6 +51,19 @@ exports.FACTORY_LOOPS = [
         requiredCapability: 'freestyle',
         graph: (0, loop_templates_1.fixLoopGraph)(['{{cmd:freestyle}}'], GREEN_GOAL, FACTORY_MAX_ITERATIONS, FACTORY_LOOP_TIMEOUT_MIN, FACTORY_AI_STEP_TIMEOUT_MIN),
     },
+    {
+        id: exports.FACTORY_REVISION_LOOP_ID,
+        name: 'Revision',
+        // Listed so the platform's behaviour is discoverable, but `launchable:false`:
+        // the app runs this itself when a user asks for a change to a delivery. Its
+        // prompt consumes `{{const:REVISION_REQUEST}}`, and an unresolved constant
+        // renders as an EMPTY string, so a hand-launched run would have a blank
+        // central instruction. The launch route refuses it; the prompt guards too.
+        launchable: false,
+        description: "Apply the ONE change the user asked for on top of work already delivered, re-grade it with the reviewer, then verify + refine until green. No re-planning. Runs automatically when you ask for changes on a review — it is not started by hand.",
+        mode: 'loop',
+        graph: (0, loop_templates_1.fixLoopGraph)(['{{cmd:revise}}'], GREEN_GOAL, FACTORY_MAX_ITERATIONS, FACTORY_LOOP_TIMEOUT_MIN, FACTORY_AI_STEP_TIMEOUT_MIN),
+    },
     SDD_QUICK_OPENSPEC_FACTORY,
 ];
 const FACTORY_ALIASES = new Map([

package/server/dist/loops-router.js

@@ -65,6 +65,8 @@ function registerLoopsRoutes(router, deps) {
                 description: f.description,
                 mode: f.mode,
                 requiredCapability: f.requiredCapability ?? null,
+                // Absent means launchable (every pre-existing factory loop is).
+                launchable: f.launchable !== false,
                 graph: f.graph,
             })),
         });

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

@@ -122,6 +122,14 @@ function railsTools() {
                     .min(1)
                     .optional()
                     .describe('Deliver INTO an existing open PR instead of creating a new one (launch). When the user names an existing PR ("extend PR #151"), pass its number here — the rail then works on that PR\'s head branch and settle pushes to it; NEVER launch without it in that case (a plain launch would create a duplicate PR). The PR must be open and same-repo (fork PRs are rejected with target_pr_fork).'),
+                revisionOfDeliveryId: zod_1.z
+                    .string()
+                    .optional()
+                    .describe('Revise a delivery that is ALREADY awaiting the user\'s decision (launch). This is the only way to launch against an undecided delivery: pass its prDeliveryId (from rails.prDeliveries) together with revisionNote. Use it whenever the user asks for a change to work you already delivered — never publish/discard/merge first. The rail must still carry exactly that delivery\'s specs.'),
+                revisionNote: zod_1.z
+                    .string()
+                    .optional()
+                    .describe('What to change, in the user\'s own words (required with revisionOfDeliveryId). It is injected into the revision run and shown on the updated review packet as "what you asked to change".'),
             },
             async handler(ctx, args) {
                 const base = `${(0, types_1.projectPath)(ctx, args.projectId)}/rails`;
@@ -210,6 +218,14 @@ function railsTools() {
                             body.reasoning_effort = args.reasoning_effort;
                         if (args.targetPrNumber !== undefined)
                             body.targetPrNumber = args.targetPrNumber;
+                        // Revision of a delivery already awaiting the user's decision: the
+                        // ONE launch allowed against an undecided delivery. The route
+                        // re-validates the exemption (must be the rail's active delivery and
+                        // cover its full spec set), so a wrong id fails closed there.
+                        if (args.revisionOfDeliveryId !== undefined)
+                            body.revisionOfDeliveryId = args.revisionOfDeliveryId;
+                        if (args.revisionNote !== undefined)
+                            body.revisionNote = args.revisionNote;
                         // Origin link (safe-pr-review-flow): a launch driven by the in-app
                         // agent carries its conversation id (from the loopback header, via
                         // ctx) so the PR decision card is posted back into that conversation.

package/server/dist/project-registry.js

@@ -11,6 +11,7 @@ const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const db_1 = require("./db");
 const queue_manager_1 = require("./queue-manager");
+const agent_defaults_1 = require("./agent-defaults");
 const chat_manager_1 = require("./chat-manager");
 const setup_manager_1 = require("./setup-manager");
 const proposal_manager_1 = require("./proposal-manager");
@@ -35,6 +36,7 @@ const project_env_1 = require("./project-env");
 const workspace_manager_1 = require("./workspace-manager");
 const ticket_store_1 = require("./ticket-store");
 const jira_sync_manager_1 = require("./jira/jira-sync-manager");
+const stuck_run_detector_1 = require("./stuck-run-detector");
 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");
@@ -291,6 +293,10 @@ class ProjectRegistry {
                 ctx.jiraSyncManager.stop();
             }
             catch { /* ignore */ }
+            try {
+                ctx.stuckRunDetector.stop();
+            }
+            catch { /* ignore */ }
             // Kill any terminal sessions belonging to this project
             try {
                 (0, terminal_manager_1.getTerminalManager)().killAllForProject(id);
@@ -437,6 +443,10 @@ class ProjectRegistry {
                 ctx.jiraSyncManager.stop();
             }
             catch { /* ignore */ }
+            try {
+                ctx.stuckRunDetector.stop();
+            }
+            catch { /* ignore */ }
             // Release chokidar watchers + abort in-flight generations so a restart
             // does not leak handles/children — mirror removeProject()'s per-project teardown.
             try {
@@ -509,6 +519,10 @@ class ProjectRegistry {
             projectId: project.id,
             projectSlug: project.slug,
             desktopPort: this._desktopPort,
+            // Global Specrails Agents defaults — resolved at spawn time from
+            // desktop.sqlite so a Settings change applies to the next job without
+            // restarting (mirrors the pipelineTelemetryEnabled read-at-spawn rule).
+            agentDefaults: (provider) => (0, agent_defaults_1.resolveAgentDefaults)(this._desktopDb, provider),
             onJobAdmission: (projectDb, job) => {
                 const ticketIds = (0, ticket_store_1.extractTicketIdsFromCommand)(job.command);
                 (0, rails_store_1.claimTicketOutcomeOwners)(projectDb, ticketIds, job.id);
@@ -899,6 +913,22 @@ class ProjectRegistry {
         // 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 }, undefined, (0, project_env_1.applyWorktreeEnvPassthrough)(db, process.env)),
+            // Global Specrails Agents defaults, loop path: per-agent model overrides
+            // ride SPECRAILS_PROFILE_PATH on each ai-step spawn. Resolved per step
+            // (no restart); inert (null) unless the global layer carries per-agent
+            // models for the provider — byte-identical legacy behaviour otherwise.
+            profilePathFor: (0, agent_defaults_1.createLoopProfilePathResolver)({
+                desktopDb: this._desktopDb,
+                profileRoot: () => (0, workspace_resolution_1.resolveProjectExecution)({ slug: project.slug, path: project.path }).cwd,
+                // Lazy require: several suites mock './queue-manager' with only the
+                // class export — a top-level named import would throw on module eval.
+                // The closure only runs at loop ai-step spawn time, never in tests
+                // that stub the queue.
+                supportsProfiles: (root) => {
+                    const { projectSupportsProfiles } = require('./queue-manager');
+                    return projectSupportsProfiles(root);
+                },
+            }),
         }));
         const getTicketSpec = (ticketId) => {
             try {
@@ -1081,7 +1111,9 @@ class ProjectRegistry {
                 console.error(`[loops] terminal effects failed for ${runId}:`, err);
             }
         };
-        const ctx = { project, db, queueManager, chatManager, setupManager, proposalManager, agentRefineManager, fileSummaryManager, specLauncherManager, ticketWatcher, browserCaptureManager, jiraSyncManager, broadcast: boundBroadcast, railJobs, loopRunManager, railLoopRuns, onLoopRunFinished, getTicketSpec, desktopDb: this._desktopDb };
+        const stuckRunDetector = new stuck_run_detector_1.StuckRunDetector(project.id, { db }, boundBroadcast);
+        stuckRunDetector.start();
+        const ctx = { project, db, queueManager, chatManager, setupManager, proposalManager, agentRefineManager, fileSummaryManager, specLauncherManager, ticketWatcher, browserCaptureManager, jiraSyncManager, stuckRunDetector, broadcast: boundBroadcast, railJobs, loopRunManager, railLoopRuns, onLoopRunFinished, getTicketSpec, desktopDb: this._desktopDb };
         this._contexts.set(project.id, ctx);
         const loopRecoveryOk = this._recoverOrphanLoopRuns(project, db, railLoopRuns, onLoopRunFinished, orphanLoopRuns);
         if (loopRecoveryOk) {

package/server/dist/project-router-loop-runs.js

@@ -4,8 +4,11 @@ exports.registerLoopRunRoutes = registerLoopRunRoutes;
 const feature_flags_1 = require("./feature-flags");
 const loops_store_1 = require("./loops-store");
 const loop_runs_store_1 = require("./loop-runs-store");
+const run_duration_stats_1 = require("./run-duration-stats");
 const loop_constants_1 = require("./loop-constants");
 const providers_1 = require("./providers");
+const runtime_1 = require("./providers/runtime");
+const agent_defaults_1 = require("./agent-defaults");
 const provider_selection_1 = require("./provider-selection");
 const spec_models_1 = require("./spec-models");
 const workspace_resolution_1 = require("./workspace-resolution");
@@ -40,6 +43,22 @@ function registerLoopRunRoutes(deps) {
                 },
         });
     });
+    // Measured duration band for "runs like this have taken X–Y". Returns
+    // `range: null` below the sample floor — the caller MUST render nothing
+    // rather than a guess (honest-metrics contract; see run-duration-stats).
+    router.get('/:projectId/run-duration-range', (req, res) => {
+        const c = ctx(req);
+        const loopId = typeof req.query.loopId === 'string' ? req.query.loopId : null;
+        const command = typeof req.query.command === 'string' ? req.query.command : null;
+        if (!loopId && !command) {
+            res.status(400).json({ error: 'loopId or command is required' });
+            return;
+        }
+        const range = loopId
+            ? (0, run_duration_stats_1.getLoopDurationRange)(c.db, c.project.id, loopId)
+            : (0, run_duration_stats_1.getJobCommandDurationRange)(c.db, (0, run_duration_stats_1.jobCommandShape)(command));
+        res.json({ range, minSamples: run_duration_stats_1.MIN_DURATION_SAMPLES });
+    });
     router.post('/:projectId/loop-runs', (req, res) => {
         if (!(0, feature_flags_1.isLoopsEnabled)()) {
             res.status(404).json({ error: 'Not Found' });
@@ -89,7 +108,9 @@ function registerLoopRunRoutes(deps) {
             return;
         }
         // Optional explicit model — validated against the chosen provider's catalog
-        // (mirrors Add Spec). Omitted ⇒ the provider's default.
+        // (mirrors Add Spec). Omitted ⇒ the global Specrails Agents default when
+        // set (read at launch time — no restart), else the provider's default.
+        const globalAgentDefaults = (0, agent_defaults_1.resolveAgentDefaults)(c.desktopDb, provider);
         let model;
         if (requestedModel !== undefined && requestedModel !== null) {
             if (!(0, spec_models_1.isValidModelForProvider)(requestedModel, provider)) {
@@ -99,7 +120,7 @@ function registerLoopRunRoutes(deps) {
             model = requestedModel;
         }
         else {
-            model = adapter.defaultModel();
+            model = globalAgentDefaults?.pipelineModel ?? adapter.defaultModel();
         }
         let effort;
         if (reasoning_effort !== undefined && reasoning_effort !== null) {
@@ -114,6 +135,10 @@ function registerLoopRunRoutes(deps) {
             }
             effort = reasoning_effort;
         }
+        else if (globalAgentDefaults?.pipelineEffort
+            && (0, runtime_1.isReasoningEffortValidForModel)(adapter, model, globalAgentDefaults.pipelineEffort)) {
+            effort = globalAgentDefaults.pipelineEffort;
+        }
         const exec = (0, workspace_resolution_1.resolveProjectExecution)({ slug: c.project.slug, path: c.project.path });
         const runId = (0, ids_1.newId)();
         c.loopRunManager

package/server/dist/providers/claude-adapter.js

@@ -292,14 +292,51 @@ function parseClaudeStreamLine(line) {
         const tool = blocks.find((b) => b.type === 'tool_use');
         if (tool?.name) {
             const input = JSON.stringify(parsed.message?.content?.[0]?.input ?? {});
-            return withAssistantUsage({ kind: 'tool-use', name: tool.name, inputPreview: input.slice(0, 200) }, msg);
+            return withAssistantUsage({
+                kind: 'tool-use',
+                name: tool.name,
+                inputPreview: input.slice(0, 200),
+                ...(typeof tool.id === 'string'
+                    ? { toolUseId: tool.id }
+                    : {}),
+            }, msg);
         }
         return withAssistantUsage({ kind: 'other', type, raw: parsed }, msg);
     }
     if (type === 'tool_use') {
         const name = parsed.name ?? '<unnamed>';
         const input = JSON.stringify(parsed.input ?? {});
-        return { kind: 'tool-use', name, inputPreview: input.slice(0, 200) };
+        return {
+            kind: 'tool-use',
+            name,
+            inputPreview: input.slice(0, 200),
+            ...(typeof parsed.id === 'string' ? { toolUseId: parsed.id } : {}),
+        };
+    }
+    // `user`-role frames carry tool RESULTS back to the model. Surface a bounded
+    // text projection so activity surfaces (agent chat's execution log) can show
+    // what a tool returned; frames without a tool_result block stay 'other'.
+    if (type === 'user') {
+        const msg = parsed.message;
+        const blocks = Array.isArray(msg?.content) ? msg.content : [];
+        const resultBlock = blocks.find((b) => b.type === 'tool_result');
+        if (resultBlock) {
+            const content = resultBlock.content;
+            const text = typeof content === 'string'
+                ? content
+                : Array.isArray(content)
+                    ? content
+                        .filter((c) => c.type === 'text' && typeof c.text === 'string')
+                        .map((c) => c.text)
+                        .join('\n')
+                    : '';
+            return {
+                kind: 'tool-result',
+                outputPreview: text.slice(0, 600),
+                ...(typeof resultBlock.tool_use_id === 'string' ? { toolUseId: resultBlock.tool_use_id } : {}),
+                ...(resultBlock.is_error === true ? { isError: true } : {}),
+            };
+        }
     }
     return { kind: 'other', type, raw: parsed };
 }

package/server/dist/queue-manager.js

@@ -26,6 +26,7 @@ const result_event_1 = require("./result-event");
 const crypto_1 = require("crypto");
 const providers_1 = require("./providers");
 const runtime_1 = require("./providers/runtime");
+const agent_defaults_1 = require("./agent-defaults");
 const codex_otel_bridge_1 = require("./codex-otel-bridge");
 const db_1 = require("./db");
 const interactive_job_session_1 = require("./interactive-job-session");
@@ -250,6 +251,7 @@ class QueueManager {
      *  For codex it controls the catalog model used at spawn time and as the
      *  fallback model name stamped onto the ai_invocations row. */
     _resolvedModel;
+    _agentDefaults;
     _onJobFinished;
     /** Project-owned durable effects that are part of every queue admission
      *  (for example, recovery/rail ownership). Invoked after queued_jobs has
@@ -356,6 +358,7 @@ class QueueManager {
         this._getDesktopDailyBudget = options?.getDesktopDailyBudget ?? null;
         this._adapter = (0, providers_1.getAdapter)(options?.provider ?? 'claude');
         this._resolvedModel = options?.resolvedModel ?? null;
+        this._agentDefaults = options?.agentDefaults ?? null;
         this._onJobFinished = options?.onJobFinished ?? null;
         this._onJobAdmission = options?.onJobAdmission ?? null;
         this._onBudgetExceeded = options?.onBudgetExceeded ?? null;
@@ -2272,9 +2275,22 @@ class QueueManager {
         // Per-job model override (consumed once) takes precedence — used by the
         // freestyle model picker so the user can choose haiku/sonnet/opus per launch.
         const modelOverride = this._jobModelSelection.get(jobId);
-        const fallbackRailModel = adapter.id === 'claude' && this._db
-            ? (0, db_1.getProjectSettings)(this._db).orchestratorModel
-            : (this._resolvedModel ?? adapter.defaultModel());
+        // Global Specrails Agents defaults (app Settings ▸ Specrails Agents) —
+        // read AT SPAWN TIME (no restart) and layered BELOW every project-level
+        // choice, ABOVE the built-in adapter default.
+        let globalAgentDefaults = null;
+        try {
+            globalAgentDefaults = this._agentDefaults?.(adapter.id) ?? null;
+        }
+        catch {
+            globalAgentDefaults = null;
+        }
+        const claudeProjectSettings = adapter.id === 'claude' && this._db ? (0, db_1.getProjectSettings)(this._db) : null;
+        const fallbackRailModel = claudeProjectSettings
+            ? (claudeProjectSettings.orchestratorModelExplicit
+                ? claudeProjectSettings.orchestratorModel
+                : globalAgentDefaults?.pipelineModel ?? claudeProjectSettings.orchestratorModel)
+            : (this._resolvedModel ?? globalAgentDefaults?.pipelineModel ?? adapter.defaultModel());
         // Relocate-artifacts: when relocated, claude is spawned from the workspace
         // so add `--add-dir <repoDir>` so its tools can still reach repo files by
         // absolute path. (gemini/codex get env-only tweaks at spawn time below.)
@@ -2301,7 +2317,24 @@ class QueueManager {
                 if (selection !== null && coreSupports) {
                     // selection is string (explicit) or undefined (default resolution)
                     const { resolveProfile, snapshotForJob, persistJobProfile, } = require('./profile-manager');
-                    const resolved = resolveProfile(execution.cwd, selection ?? undefined, adapter.id);
+                    let resolved = resolveProfile(execution.cwd, selection ?? undefined, adapter.id);
+                    // Global agent defaults: fill per-agent model gaps in the resolved
+                    // profile, or synthesize a baseline profile when the project has
+                    // none. Explicit profile choices always win; inert when the global
+                    // layer is off (byte-identical legacy behaviour).
+                    if (globalAgentDefaults && adapter.capabilities.profiles === true) {
+                        if (resolved) {
+                            const merged = (0, agent_defaults_1.mergeProfileWithAgentDefaults)(resolved.profile, globalAgentDefaults);
+                            if (merged.changed)
+                                resolved = { name: resolved.name, profile: merged.profile };
+                        }
+                        else if (Object.keys(globalAgentDefaults.agentModels).length > 0) {
+                            resolved = {
+                                name: agent_defaults_1.GLOBAL_DEFAULTS_PROFILE_NAME,
+                                profile: (0, agent_defaults_1.synthesizeProfileFromDefaults)(adapter, globalAgentDefaults),
+                            };
+                        }
+                    }
                     if (resolved) {
                         profileSnapshotPath = snapshotForJob(this._projectSlug, jobId, resolved);
                         profileName = resolved.name;
@@ -2322,10 +2355,19 @@ class QueueManager {
         // explicit per-job override > resolved profile orchestrator > project/default.
         // resolveProfile validates the profile model against this adapter's catalog.
         const railModel = modelOverride ?? profileOrchestratorModel ?? fallbackRailModel;
+        // Pipeline-level reasoning effort from the global layer (rails never had a
+        // per-job effort knob, so this is purely additive). Validated against the
+        // FINAL model — claude/codex sub-agents inherit the process-level effort,
+        // kimi rides its env knob via buildProviderEnv, gemini has no effort.
+        const globalRailEffort = globalAgentDefaults?.pipelineEffort
+            && (0, runtime_1.isReasoningEffortValidForModel)(adapter, railModel, globalAgentDefaults.pipelineEffort)
+            ? globalAgentDefaults.pipelineEffort
+            : undefined;
         const railSpawnOptions = {
             prompt: railPrompt,
             systemPrompt: systemAppend || undefined,
             model: railModel,
+            ...(globalRailEffort ? { reasoning_effort: globalRailEffort } : {}),
             extraArgs: railExtraArgs.length > 0 ? railExtraArgs : undefined,
         };
         const args = adapter.buildArgs('rail-job', railSpawnOptions);
@@ -2544,6 +2586,7 @@ class QueueManager {
                 // spawn and APPEND on top of the CLI default instead of replacing it.
                 systemPrompt: isFreestyle ? (systemAppend || undefined) : undefined,
                 model: railModel,
+                ...(globalRailEffort ? { reasoning_effort: globalRailEffort } : {}),
                 extraArgs: !isFreestyle && systemAppend
                     ? ['--append-system-prompt', systemAppend, ...(railExtraArgs ?? [])]
                     : (railExtraArgs.length > 0 ? railExtraArgs : undefined),

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

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PrContinuationIsolationError = void 0;
+exports.buildSpecSnapshot = buildSpecSnapshot;
 exports.launchIsolatedRail = launchIsolatedRail;
 exports.reconcileRailWorktrees = reconcileRailWorktrees;
 /**
@@ -70,6 +71,7 @@ const rail_worktrees_store_1 = require("./rail-worktrees-store");
 const pr_naming_1 = require("./pr-naming");
 const jira_db_1 = require("./jira/jira-db");
 const db_1 = require("./db");
+const delivery_evidence_1 = require("./delivery-evidence");
 const integration_branch_1 = require("./integration-branch");
 const repo_lock_1 = require("./repo-lock");
 const rail_isolation_1 = require("./rail-isolation");
@@ -79,6 +81,7 @@ const rail_merge_orchestrator_1 = require("./rail-merge-orchestrator");
 const loop_executors_1 = require("./loop-executors");
 const worktree_overlay_1 = require("./worktree-overlay");
 const worktree_node_modules_1 = require("./worktree-node-modules");
+const revision_seed_1 = require("./revision-seed");
 const workspace_resolution_1 = require("./workspace-resolution");
 const feature_flags_1 = require("./feature-flags");
 const file_provenance_1 = require("./file-provenance");
@@ -125,6 +128,66 @@ function unitNamingInput(ctx, ticketId) {
     }
     return { ticketId, title: spec?.title ?? null, labels: spec?.labels ?? null, jiraKey };
 }
+/**
+ * Assemble the revision briefing from the generation being revised. Reads only
+ * durable rows, tolerates every one of them being absent (a legacy row carries
+ * no snapshot or evidence), and never throws — a thinner briefing is far better
+ * than a failed revision launch.
+ */
+function buildRevisionSeedForLaunch(db, revision, ticketIds) {
+    try {
+        const previous = (0, rail_pr_store_1.getPrDelivery)(db, revision.ofDeliveryId);
+        const branches = previous
+            ? [...new Set(JSON.parse(previous.branches || '[]').map((b) => b.branch).filter(Boolean))]
+            : [];
+        // Revision depth walks the supersession chain, bounded so a corrupted
+        // lineage can never spin here.
+        let depth = 1;
+        let cursor = previous;
+        for (let hops = 0; hops < 20 && cursor?.revision_of; hops++) {
+            depth += 1;
+            cursor = (0, rail_pr_store_1.getPrDelivery)(db, cursor.revision_of) ?? undefined;
+        }
+        return (0, revision_seed_1.buildRevisionSeed)({
+            note: revision.note,
+            specSnapshot: previous ? (0, rail_pr_store_1.readSpecSnapshot)(previous.spec_snapshot) : null,
+            ticketIds: [...ticketIds],
+            branches,
+            baseBranch: previous?.base_branch ?? 'the integration branch',
+            branchDiffSummary: null,
+            evidence: previous ? (0, delivery_evidence_1.readSettleEvidence)(previous.settle_evidence) : null,
+            revisionNumber: depth,
+        });
+    }
+    catch {
+        // Absolute floor: the user's instruction still reaches the run.
+        return revision.note;
+    }
+}
+/**
+ * Launch-time freeze of every covered ticket for the delivery row's
+ * spec_snapshot column (migration 56). The review packet's "what you asked"
+ * section renders this snapshot, never the live store — a spec edited mid-run
+ * must not rewrite what the delivery was asked to do. Failure-tolerant: an
+ * unreadable ticket degrades to a bare-id entry.
+ */
+function buildSpecSnapshot(ctx, ticketIds) {
+    return ticketIds.map((ticketId) => {
+        let spec;
+        try {
+            spec = ctx.getTicketSpec(ticketId);
+        }
+        catch {
+            /* tolerated — snapshot stays bare */
+        }
+        return {
+            ticketId,
+            title: spec?.title ?? null,
+            description: spec?.description ?? null,
+            labels: Array.isArray(spec?.labels) ? spec.labels : [],
+        };
+    });
+}
 /**
  * Commit messages are consumed by GitHub↔Jira development panels. Branch names
  * already carry the Jira key for new work; commits must too, especially when
@@ -323,7 +386,18 @@ async function launchIsolatedRail(input, io = {}) {
     const baseRepo = ctx.project.path;
     const slug = ctx.project.slug;
     const worktreesRoot = path.join((0, artifact_registry_1.resolveHome)(), '.specrails', 'projects', slug, 'worktrees');
-    const constants = (0, loop_constants_1.loadConstantMap)(ctx.desktopDb);
+    // A revision run is seeded with a full briefing (the instruction PLUS the
+    // frozen spec, the branch that carries the work and what the previous run
+    // actually reported) rather than the bare sentence — the run starts a FRESH
+    // provider session by contract, so durable context is the only thing it has.
+    // Per-RUN data, so it is layered over the project's constant map for this
+    // launch only and never persisted as a constant.
+    const constants = input.revision
+        ? {
+            ...(0, loop_constants_1.loadConstantMap)(ctx.desktopDb),
+            REVISION_REQUEST: buildRevisionSeedForLaunch(ctx.db, input.revision, ticketIds),
+        }
+        : (0, loop_constants_1.loadConstantMap)(ctx.desktopDb);
     // Capture the PR-delivery mode ONCE at launch entry so a mid-flight env flip
     // can never split one launch across the two delivery paths.
     const prMode = (0, rail_isolation_1.isRailPrDeliveryEnabled)();
@@ -582,9 +656,16 @@ async function launchIsolatedRail(input, io = {}) {
                     supersedesDeliveryId: launchContinuation?.source === 'rail-pr-delivery'
                         ? launchContinuation.deliveryId
                         : null,
+                    specSnapshot: buildSpecSnapshot(ctx, ticketIds),
+                    ...(input.revision ? { revisionNote: input.revision.note, revisionOf: input.revision.ofDeliveryId } : {}),
                 }, input.requiredPrContinuation
                     ? { id: input.requiredPrContinuation.deliveryId, decision: input.requiredPrContinuation.decision }
-                    : null);
+                    // A revision replaces the generation it revises, atomically, so the rail
+                    // never shows two active deliveries and a failed revision restores the
+                    // predecessor through the shipped rollback path.
+                    : input.revision
+                        ? { id: input.revision.ofDeliveryId, decision: input.revision.decision }
+                        : null);
                 prDeliveryId = generation.delivery.id;
                 supersededDelivery = generation.superseded;
                 input.onPrDeliveryCreated?.(prDeliveryId);
@@ -1362,7 +1443,25 @@ async function launchIsolatedRail(input, io = {}) {
             const expectedHeadByBranch = (0, rail_worktree_release_1.durableBranchHeads)(settledBranchRecords);
             const overlayEvidenceByBranch = (0, rail_worktree_release_1.durableOverlayCleanupEvidence)(settledBranchRecords);
             const settlementIgnoredByBranch = (0, rail_worktree_release_1.durableSettlementIgnoredPaths)(settledBranchRecords);
+            // Review-packet evidence harvest (deterministic, no model calls) — MUST
+            // run while the reviewable worktrees are still mounted, i.e. before the
+            // releaseRailWorktrees calls below. harvestDeliveryEvidence never throws
+            // by contract; the belt-and-braces catch keeps settle unconditional.
+            const harvest = io.harvestEvidence ?? delivery_evidence_1.harvestDeliveryEvidence;
+            let settleEvidence;
+            try {
+                settleEvidence = harvest({ readEvents: (runId) => (0, db_1.getJobEvents)(ctx.db, runId) }, results.map((result) => ({
+                    ticketId: result.run.ticketId,
+                    runId: result.run.runId,
+                    worktreePath: result.run.handle.worktreePath,
+                })));
+            }
+            catch (e) {
+                console.warn(`[rail-isolated] evidence harvest failed: ${e instanceof Error ? e.message : String(e)}`);
+                settleEvidence = undefined;
+            }
             const patch = {
+                settleEvidence,
                 branches: settledBranchRecords,
                 worktreeIds,
                 implementationOutcome,