specrails-desktop 2.34.0 → 2.35.0

package/server/dist/delivery-evidence.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIDENCE_RAW_CAP = exports.VERIFY_TAIL_CAP = void 0;
+exports.parseVerificationSentinel = parseVerificationSentinel;
+exports.extractVerifyStepText = extractVerifyStepText;
+exports.parseConfidenceScore = parseConfidenceScore;
+exports.harvestDeliveryEvidence = harvestDeliveryEvidence;
+exports.readSettleEvidence = readSettleEvidence;
+/**
+ * Deterministic settle-time evidence harvest for the review packet
+ * (nontech-review-experience Wave 1). Reads three sources with zero model
+ * calls: the `VERIFICATION: PASS/FAIL` sentinel from the run's persisted
+ * stream (the rail-merge-orchestrator regex precedent), a bounded tail of the
+ * verify step's output, and the reviewer's `confidence-score.json` written
+ * into the worktree's `openspec/changes/<name>/` (core ≥4.12 — previously read
+ * by nothing). Harvest NEVER throws and never blocks settle: every missing or
+ * malformed source degrades to an absent value on the evidence record, so the
+ * packet can always state honestly what it does and does not know.
+ */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/** Bounded tail of the verify step's raw output persisted per unit. */
+exports.VERIFY_TAIL_CAP = 4096;
+/** Raw confidence-score.json payloads are capped before persistence. */
+exports.CONFIDENCE_RAW_CAP = 8192;
+/** Last sentinel wins: the verify prompt itself quotes the format, so earlier
+ * mentions in assistant reasoning must not shadow the final verdict line. */
+const SENTINEL_RE = /VERIFICATION:\s*(PASS|FAIL)\b[ \t]*(?:[—:-][ \t]*)?([^\n]*)/gi;
+function parseVerificationSentinel(text) {
+    let verdict = 'absent';
+    let detail = null;
+    for (const match of text.matchAll(SENTINEL_RE)) {
+        verdict = match[1].toUpperCase() === 'PASS' ? 'pass' : 'fail';
+        const tail = (match[2] ?? '').trim();
+        detail = verdict === 'fail' && tail ? tail.slice(0, 512) : null;
+    }
+    return { verdict, detail };
+}
+function parseLoopStepPayload(payload) {
+    try {
+        const parsed = JSON.parse(payload);
+        return {
+            index: typeof parsed.index === 'number' ? parsed.index : null,
+            nodeId: typeof parsed.nodeId === 'string' ? parsed.nodeId : null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Extract human-readable text from one persisted event row. Assistant rows
+ * hold the raw provider JSONL line; log rows hold plain text. Everything else
+ * contributes nothing (structured/loop events are boundaries, not output). */
+function eventText(event) {
+    if (event.event_type === 'log')
+        return event.payload;
+    if (event.event_type !== 'assistant')
+        return '';
+    try {
+        const frame = JSON.parse(event.payload);
+        const blocks = frame.message?.content;
+        if (!Array.isArray(blocks))
+            return '';
+        return blocks
+            .filter((block) => block?.type === 'text' && typeof block.text === 'string')
+            .map((block) => block.text)
+            .join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Text of the LAST `verify` step in the run (loop_step nodeId === 'verify'
+ * through its loop_step_end / next step / stream end). Runs without a verify
+ * step boundary (non-loop jobs, legacy runs) fall back to the whole stream's
+ * text — still raw output, just unscoped.
+ */
+function extractVerifyStepText(events) {
+    let start = -1;
+    let end = events.length;
+    let stepIndex = null;
+    for (let i = 0; i < events.length; i++) {
+        const event = events[i];
+        if (event.event_type === 'loop_step') {
+            const step = parseLoopStepPayload(event.payload);
+            if (step?.nodeId === 'verify') {
+                start = i;
+                stepIndex = step.index;
+                end = events.length;
+            }
+            else if (start >= 0 && i > start) {
+                // A later non-verify step closes the previous verify range unless a
+                // later verify step reopens it (loop iterations: last verify wins).
+                if (end === events.length)
+                    end = i;
+            }
+        }
+        else if (start >= 0 && end === events.length && event.event_type === 'loop_step_end' &&
+            stepIndex !== null && parseLoopStepPayload(event.payload)?.index === stepIndex) {
+            end = i;
+        }
+    }
+    const range = start >= 0 ? events.slice(start, end) : events;
+    const text = range.map(eventText).filter(Boolean).join('\n');
+    return { text, scoped: start >= 0 };
+}
+function toNumberRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw === 'number' && Number.isFinite(raw))
+            out[key] = raw;
+        else if (raw && typeof raw === 'object' && typeof raw.score === 'number') {
+            out[key] = raw.score;
+        }
+    }
+    return out;
+}
+/** Tolerant parse of a confidence-score.json payload. Returns null only when
+ * the payload is not a JSON object at all. */
+function parseConfidenceScore(rawJson, changeName) {
+    let parsed;
+    try {
+        parsed = JSON.parse(rawJson);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const obj = parsed;
+    return {
+        changeName,
+        overall: typeof obj.overall === 'number' && Number.isFinite(obj.overall) ? obj.overall : null,
+        aspects: toNumberRecord(obj.aspects ?? obj.scores),
+        flags: Array.isArray(obj.flags) ? obj.flags.filter((f) => typeof f === 'string').slice(0, 20) : [],
+        raw: rawJson.length > exports.CONFIDENCE_RAW_CAP ? null : parsed,
+    };
+}
+/** Newest confidence-score.json under `<worktree>/openspec/changes/<name>/`.
+ * A worktree hosts at most a handful of change dirs; when several carry a
+ * score (unusual), the lexicographically last dir wins deterministically. */
+function readConfidenceFromWorktree(worktreePath, io) {
+    const changesDir = path_1.default.join(worktreePath, 'openspec', 'changes');
+    let dirs;
+    try {
+        dirs = io.listDir(changesDir);
+    }
+    catch {
+        return null;
+    }
+    let found = null;
+    for (const dir of [...dirs].sort()) {
+        const scorePath = path_1.default.join(changesDir, dir, 'confidence-score.json');
+        try {
+            if (!io.fileExists(scorePath))
+                continue;
+            const raw = io.readFile(scorePath);
+            const parsed = parseConfidenceScore(raw, dir);
+            if (parsed)
+                found = parsed;
+        }
+        catch {
+            /* unreadable file = absent, not fatal */
+        }
+    }
+    return found;
+}
+/**
+ * Harvest evidence for every unit of a settling delivery. Never throws; the
+ * per-unit try/catch turns internal errors into `partial`/`failed` harvest
+ * status while absence of a source stays `ok` (absence is honest data).
+ */
+function harvestDeliveryEvidence(io, units) {
+    const readFile = io.readFile ?? ((p) => fs_1.default.readFileSync(p, 'utf8'));
+    const listDir = io.listDir ?? ((p) => fs_1.default.readdirSync(p));
+    const fileExists = io.fileExists ?? ((p) => fs_1.default.existsSync(p));
+    const fsIo = { readFile, listDir, fileExists };
+    let errored = 0;
+    const harvested = units.map((unit) => {
+        const evidence = {
+            ticketId: unit.ticketId,
+            runId: unit.runId,
+            sentinel: 'absent',
+            sentinelDetail: null,
+            verifyTail: null,
+            confidence: null,
+        };
+        let unitErrored = false;
+        try {
+            if (unit.runId) {
+                const events = io.readEvents(unit.runId);
+                const { text } = extractVerifyStepText(events);
+                if (text) {
+                    const sentinel = parseVerificationSentinel(text);
+                    evidence.sentinel = sentinel.verdict;
+                    evidence.sentinelDetail = sentinel.detail;
+                    evidence.verifyTail = text.slice(-exports.VERIFY_TAIL_CAP);
+                }
+            }
+        }
+        catch {
+            unitErrored = true;
+        }
+        try {
+            if (unit.worktreePath) {
+                evidence.confidence = readConfidenceFromWorktree(unit.worktreePath, fsIo);
+            }
+        }
+        catch {
+            unitErrored = true;
+        }
+        if (unitErrored)
+            errored++;
+        return evidence;
+    });
+    return {
+        schemaVersion: 1,
+        harvest: units.length > 0 && errored === units.length ? 'failed' : errored > 0 ? 'partial' : 'ok',
+        harvestedAt: (io.now?.() ?? new Date()).toISOString(),
+        units: harvested,
+    };
+}
+/** Parse a persisted settle_evidence column value (null-tolerant). */
+function readSettleEvidence(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.units))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}

package/server/dist/desktop-router.js

@@ -17,6 +17,7 @@ const specrails_tech_client_1 = require("./specrails-tech-client");
 const core_compat_1 = require("./core-compat");
 const providers_1 = require("./providers");
 const provider_detection_1 = require("./provider-detection");
+const agent_defaults_1 = require("./agent-defaults");
 const workspace_manager_1 = require("./workspace-manager");
 const workspace_resolution_1 = require("./workspace-resolution");
 const desktop_analytics_1 = require("./desktop-analytics");
@@ -1130,6 +1131,28 @@ function createDesktopRouter(registry, broadcast) {
         const monthlyBudgetUsd = Number.isFinite(parsed) && parsed >= 0 ? parsed : 5.0;
         res.json({ language, monthlyBudgetUsd });
     });
+    // ─── Specrails Agents defaults (global per-provider agent model/effort) ───
+    // App-level layer read AT SPAWN TIME by QueueManager / rails-router / loop
+    // executors — a change applies to the next run with zero restart.
+    router.get('/agent-defaults', (_req, res) => {
+        res.json({
+            settings: (0, agent_defaults_1.readAgentDefaultsSettings)(registry.desktopDb),
+            catalog: (0, agent_defaults_1.buildAgentDefaultsCatalog)(),
+        });
+    });
+    router.patch('/agent-defaults', (req, res) => {
+        try {
+            const settings = (0, agent_defaults_1.applyAgentDefaultsPatch)(registry.desktopDb, req.body);
+            res.json({ settings, catalog: (0, agent_defaults_1.buildAgentDefaultsCatalog)() });
+        }
+        catch (err) {
+            if (err instanceof agent_defaults_1.AgentDefaultsValidationError) {
+                res.status(400).json({ error: err.code, message: err.message });
+                return;
+            }
+            res.status(500).json({ error: 'agent_defaults_failed', message: err.message });
+        }
+    });
     // ─── specrails-core update channel (app-global) ─────────────────────────────
     // Detect + apply a specrails-core framework update independently of the desktop
     // app update. See server/core-update-manager.ts. A single manager instance

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