specrails-desktop 2.45.0 → 2.46.0

package/server/dist/agent-runtime-repositories.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolRepositories = toolRepositories;
+const node_path_1 = require("node:path");
+/** Attribute only explicit paths or repository roots present in a tool action.
+ * Never carry a previous action's repository into an unrelated tool call. */
+function toolRepositories(event, repositories, defaultCwd) {
+    const found = new Set();
+    const cwd = typeof event.cwd === 'string' && (0, node_path_1.isAbsolute)(event.cwd) ? event.cwd : defaultCwd;
+    const paths = Array.isArray(event.targetPaths) ? event.targetPaths.filter((p) => typeof p === 'string') : [];
+    if (!paths.length && typeof event.detail === 'string' && (0, node_path_1.isAbsolute)(event.detail) && !event.detail.endsWith('…'))
+        paths.push(event.detail);
+    for (const target of paths) {
+        const absolute = (0, node_path_1.resolve)(cwd, target);
+        const matches = repositories.filter(repo => {
+            if (!repo.path)
+                return false;
+            const suffix = (0, node_path_1.relative)(repo.path, absolute);
+            return suffix === '' || (!(0, node_path_1.isAbsolute)(suffix) && suffix !== '..' && !suffix.startsWith('..' + node_path_1.sep));
+        }).sort((a, b) => b.path.length - a.path.length);
+        if (matches[0])
+            found.add(matches[0].id);
+    }
+    // Shell activity may contain `cd /repo && ...` or address several repositories.
+    if (!paths.length && typeof event.detail === 'string') {
+        for (const repo of repositories) {
+            if (!repo.path)
+                continue;
+            const escaped = repo.path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            if (new RegExp('(?:^|[\\s\\x22\\x27=])' + escaped + '(?=$|[\\s/\\\\\\x22\\x27;&])').test(event.detail))
+                found.add(repo.id);
+        }
+    }
+    if (!found.size && !paths.length && typeof event.cwd === 'string' && (0, node_path_1.isAbsolute)(event.cwd))
+        return toolRepositories({ targetPaths: [event.cwd] }, repositories, defaultCwd);
+    return repositories.filter(repo => found.has(repo.id));
+}

package/server/dist/agent-runtime-settings-router.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerAgentRuntimeSettingsRoutes = registerAgentRuntimeSettingsRoutes;
+const node_fs_1 = require("node:fs");
 const agent_runtime_loader_1 = require("./agent-runtime-loader");
 const agent_runtime_settings_1 = require("./agent-runtime-settings");
 const agent_runtime_verification_suggestions_1 = require("./agent-runtime-verification-suggestions");
@@ -9,8 +10,9 @@ function registerAgentRuntimeSettingsRoutes({ router, ctx }) {
     router.get('/:projectId/agent-runtime/config', (_req, res) => {
         try {
             const project = ctx(_req).project;
+            const configured = (0, node_fs_1.existsSync)((0, agent_runtime_settings_1.agentRuntimeConfigPath)(project));
             const config = (0, agent_runtime_settings_1.loadAgentRuntimeConfig)(project);
-            res.json({ configured: config !== null, config: config ?? (0, agent_runtime_settings_1.defaultAgentRuntimeConfig)(project), runtimeAvailable: (0, agent_runtime_loader_1.findCoreAgentRuntimeEntry)() !== null });
+            res.json({ configured, config, runtimeAvailable: (0, agent_runtime_loader_1.findCoreAgentRuntimeEntry)() !== null });
         }
         catch (err) {
             const validation = err instanceof agent_runtime_settings_1.AgentRuntimeConfigError;
@@ -32,13 +34,13 @@ function registerAgentRuntimeSettingsRoutes({ router, ctx }) {
     });
     router.put('/:projectId/agent-runtime/config', async (req, res) => {
         try {
-            const config = (0, agent_runtime_settings_1.validateAgentRuntimeConfig)(req.body);
+            (0, agent_runtime_settings_1.validateAgentRuntimeConfig)(req.body);
+            const config = (0, agent_runtime_settings_1.validateAgentRuntimeConfig)({ ...req.body, enabled: true, providers: (0, agent_runtime_settings_1.loadRuntimeProviders)() });
             const runtimeAvailable = (0, agent_runtime_loader_1.findCoreAgentRuntimeEntry)() !== null;
             if (config.enabled && !runtimeAvailable) {
                 res.status(503).json({ error: 'runtime_unavailable', message: 'Update Core to an installation with the agent runtime before enabling it' });
                 return;
             }
-            // Disabling must remain possible even when an installed runtime is broken.
             if (config.enabled && runtimeAvailable) {
                 try {
                     (await (0, agent_runtime_loader_1.loadCoreAgentRuntime)()).validateRuntimeConfig(config);

package/server/dist/agent-runtime-settings.js

@@ -7,10 +7,19 @@ exports.AgentRuntimeConfigError = exports.REVIEW_THRESHOLD_FLOORS = void 0;
 exports.validateAgentRuntimeConfig = validateAgentRuntimeConfig;
 exports.defaultAgentRuntimeConfig = defaultAgentRuntimeConfig;
 exports.agentRuntimeConfigPath = agentRuntimeConfigPath;
+exports.runtimeProvidersPath = runtimeProvidersPath;
+exports.loadRuntimeProviders = loadRuntimeProviders;
+exports.validateRuntimeProviders = validateRuntimeProviders;
+exports.saveRuntimeProviders = saveRuntimeProviders;
+exports.loadRuntimeConfigFile = loadRuntimeConfigFile;
 exports.loadAgentRuntimeConfig = loadAgentRuntimeConfig;
 exports.saveAgentRuntimeConfig = saveAgentRuntimeConfig;
+exports.validateRuntimeRolePrompts = validateRuntimeRolePrompts;
+exports.loadRuntimeRolePrompts = loadRuntimeRolePrompts;
+exports.saveRuntimeRolePrompts = saveRuntimeRolePrompts;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
 const node_crypto_1 = require("node:crypto");
 const ajv_1 = __importDefault(require("ajv"));
 const agent_runtime_schema_json_1 = __importDefault(require("./schemas/agent-runtime.schema.json"));
@@ -35,6 +44,8 @@ function validateAgentRuntimeConfig(input) {
         throw new AgentRuntimeConfigError(`Invalid runtime configuration at ${error?.instancePath || '/'}: ${error?.message ?? 'invalid value'}`);
     }
     const config = input;
+    if (config.rolePrompts !== undefined)
+        validateRuntimeRolePrompts(config.rolePrompts);
     if (new Set(config.providers.map(({ id }) => id)).size !== config.providers.length)
         throw new AgentRuntimeConfigError('Provider IDs must be unique');
     for (const provider of config.providers) {
@@ -89,7 +100,7 @@ function validateAgentRuntimeConfig(input) {
 function defaultAgentRuntimeConfig(project) {
     const provider = CLI_PROVIDERS.includes(project.provider) ? project.provider : 'claude';
     return {
-        schemaVersion: 1, enabled: false,
+        schemaVersion: 1, enabled: true,
         providers: CLI_PROVIDERS.map((cli) => ({ id: cli, kind: 'cli', cli })),
         agents: { architect: { provider }, developer: { provider }, reviewer: { provider } },
         verification: [],
@@ -98,38 +109,131 @@ function defaultAgentRuntimeConfig(project) {
 function agentRuntimeConfigPath(project) {
     return node_path_1.default.join((0, workspace_resolution_1.resolveProjectExecution)(project).specrailsDir, 'agent-runtime.json');
 }
-/** Missing configuration preserves legacy execution. Malformed files fail closed. */
-function loadAgentRuntimeConfig(project) {
-    let text;
+/** Global connections are resolved for new runs; admitted runs keep their snapshot. */
+function runtimeProvidersPath() { return node_path_1.default.join(node_os_1.default.homedir(), '.specrails', 'runtime-providers.json'); }
+function atomicJson(file, value) {
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
+    const temporary = `${file}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    try {
+        node_fs_1.default.writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+        node_fs_1.default.renameSync(temporary, file);
+    }
+    finally {
+        node_fs_1.default.rmSync(temporary, { force: true });
+    }
+}
+function loadRuntimeProviders() {
     try {
-        text = node_fs_1.default.readFileSync(agentRuntimeConfigPath(project), 'utf8');
+        return validateRuntimeProviders(JSON.parse(node_fs_1.default.readFileSync(runtimeProvidersPath(), 'utf8')));
     }
-    catch (err) {
-        if (err.code === 'ENOENT')
-            return null;
-        throw err;
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return defaultAgentRuntimeConfig({ path: '' }).providers;
+        throw error;
     }
+}
+function validateRuntimeProviders(input) {
+    if (!Array.isArray(input) || !input.length)
+        throw new AgentRuntimeConfigError('At least one provider connection is required');
+    const first = input[0];
+    const role = { provider: first?.id, ...(first?.kind === 'openai-compatible' ? { model: 'validation' } : {}) };
+    return validateAgentRuntimeConfig({ schemaVersion: 1, enabled: true, providers: input, agents: { architect: role, developer: role, reviewer: role }, verification: [] }).providers;
+}
+function saveRuntimeProviders(input) {
+    const providers = validateRuntimeProviders(input);
+    atomicJson(runtimeProvidersPath(), providers);
+    return providers;
+}
+/** Migrate embedded connections once. Conflicting IDs receive a stable ID so
+ *  two projects with different endpoints never silently share a connection. */
+function loadRuntimeConfigFile(file, fallbackProvider) {
     let parsed;
+    let text;
     try {
-        parsed = JSON.parse(text);
+        text = node_fs_1.default.readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    if (text !== undefined) {
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            throw new AgentRuntimeConfigError('Saved runtime configuration is not valid JSON');
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            throw new AgentRuntimeConfigError('Saved runtime configuration must be an object');
     }
-    catch {
-        throw new AgentRuntimeConfigError('Saved runtime configuration is not valid JSON');
+    const providers = loadRuntimeProviders();
+    if (!parsed) {
+        const config = defaultAgentRuntimeConfig({ path: '', provider: fallbackProvider });
+        const selected = providers.find(item => item.id === config.agents.architect.provider) ?? providers.find(item => item.kind === 'cli');
+        if (!selected || selected.kind !== 'cli')
+            throw new AgentRuntimeConfigError('Configure project role models before using API-only connections');
+        for (const role of ROLES)
+            config.agents[role].provider = selected.id;
+        return validateAgentRuntimeConfig({ ...config, providers });
+    }
+    if (Array.isArray(parsed.providers)) {
+        const legacy = validateAgentRuntimeConfig(parsed);
+        for (const original of legacy.providers) {
+            let connection = providers.find(item => item.id === original.id);
+            if (connection && JSON.stringify(connection) !== JSON.stringify(original)) {
+                const id = `${original.id.slice(0, 117)}-${(0, node_crypto_1.createHash)('sha256').update(JSON.stringify(original)).digest('hex').slice(0, 10)}`;
+                for (const role of ROLES)
+                    if (legacy.agents[role].provider === original.id)
+                        legacy.agents[role].provider = id;
+                connection = providers.find(item => item.id === id);
+                if (!connection)
+                    providers.push({ ...original, id });
+            }
+            else if (!connection)
+                providers.push(original);
+        }
+        saveRuntimeProviders(providers);
+        const { providers: _embedded, enabled: _enabled, ...settings } = legacy;
+        atomicJson(file, settings);
+        parsed = settings;
     }
-    return validateAgentRuntimeConfig(parsed);
+    return validateAgentRuntimeConfig({ ...parsed, enabled: true, providers });
+}
+/** Missing settings use the programmatic engine. Malformed files fail closed. */
+function loadAgentRuntimeConfig(project) {
+    return loadRuntimeConfigFile(agentRuntimeConfigPath(project), project.provider);
 }
 /** Atomic replacement works on macOS and Windows, with no partial file on errors. */
 function saveAgentRuntimeConfig(project, input) {
-    const config = validateAgentRuntimeConfig(input);
+    const config = validateAgentRuntimeConfig({ ...input, enabled: true, providers: loadRuntimeProviders() });
     const file = agentRuntimeConfigPath(project);
-    node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
-    const temporary = `${file}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+    const { providers: _providers, enabled: _enabled, ...settings } = config;
+    atomicJson(file, settings);
+    return config;
+}
+function validateRuntimeRolePrompts(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        throw new AgentRuntimeConfigError('Role prompts must be an object');
+    const prompts = {};
+    for (const [role, text] of Object.entries(input)) {
+        if (!ROLES.includes(role) || typeof text !== 'string' || !text.trim() || text.length > 20000 || text.includes('\0'))
+            throw new AgentRuntimeConfigError('Role prompts must use architect, developer or reviewer with 1–20000 nonblank characters and no null bytes');
+        prompts[role] = text;
+    }
+    return prompts;
+}
+function loadRuntimeRolePrompts() {
     try {
-        node_fs_1.default.writeFileSync(temporary, `${JSON.stringify(config, null, 2)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
-        node_fs_1.default.renameSync(temporary, file);
+        return validateRuntimeRolePrompts(JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(node_os_1.default.homedir(), '.specrails', 'runtime-role-prompts.json'), 'utf8')));
     }
-    finally {
-        node_fs_1.default.rmSync(temporary, { force: true });
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {};
+        throw error;
     }
-    return config;
+}
+function saveRuntimeRolePrompts(input) {
+    const prompts = validateRuntimeRolePrompts(input);
+    atomicJson(node_path_1.default.join(node_os_1.default.homedir(), '.specrails', 'runtime-role-prompts.json'), prompts);
+    return prompts;
 }

package/server/dist/agent-runtime-settlement.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settleRuntimeContinuation = settleRuntimeContinuation;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_crypto_1 = require("node:crypto");
+const db_1 = require("./db");
+const core_execution_1 = require("./core-execution");
+const core_completion_1 = require("./core-completion");
+const worktree_manager_1 = require("./worktree-manager");
+const rail_pr_store_1 = require("./rail-pr-store");
+const multi_repo_execution_1 = require("./multi-repo-execution");
+/** Complete the host's local settlement after Core recovery. Never pushes or merges. */
+async function settleRuntimeContinuation(input, dependencies = { verify: core_execution_1.checkCoreCompletion, git: worktree_manager_1.defaultGitRunner, commit: worktree_manager_1.commitWorktreeAndVerify }) {
+    const { db, runId } = input;
+    const verified = dependencies.verify(input.contextPath, input.cwd, input.env, runId);
+    if (!verified.valid)
+        throw new Error(verified.reason ?? 'Core completion is not verified');
+    const frozen = JSON.parse(node_fs_1.default.readFileSync(input.contextPath, 'utf8'));
+    if (frozen.runId !== runId)
+        throw new Error('Runtime identity changed');
+    const all = db.prepare('SELECT * FROM rail_pr_deliveries').all().filter(row => (0, rail_pr_store_1.toPrDeliverySnapshot)(row).runIds.includes(runId));
+    const parents = new Set(all.map(row => row.parent_delivery_id).filter((id) => !!id));
+    const rows = all.filter(row => !parents.has(row.id) && row.decision === 'implementation_failed');
+    if (all.some(row => parents.has(row.id) && ['discarded', 'superseded', 'merged', 'completed'].includes(row.decision)))
+        throw new Error('Delivery is no longer available for recovery');
+    const token = (0, node_crypto_1.randomUUID)(), claimed = [];
+    const updates = [];
+    const gitText = async (args, cwd) => {
+        const result = await dependencies.git.run(args, cwd);
+        if (result.code !== 0)
+            throw new Error(`Cannot inspect recovered worktree: ${result.stderr}`);
+        return result.stdout.trim();
+    };
+    try {
+        // Claim the entire group before Git effects; a concurrent discard must win or lose atomically.
+        db.transaction(() => {
+            for (const row of all.filter(row => parents.has(row.id) || rows.includes(row))) {
+                if (!(0, rail_pr_store_1.claimPrDeliveryOperation)(db, row.id, row.decision, 'recover-and-retry', token))
+                    throw new Error('Delivery is busy; retry settlement after its current operation');
+                claimed.push(row);
+            }
+        })();
+        for (const row of rows) {
+            if (row.pr_url)
+                throw new Error('An existing PR requires explicit delivery recovery');
+            if (!(0, rail_pr_store_1.toPrDeliverySnapshot)(row).branches.some(unit => unit.runId === runId))
+                throw new Error('Delivery has no branch recorded for this runtime');
+            for (const unit of (0, rail_pr_store_1.toPrDeliverySnapshot)(row).branches.filter(unit => unit.runId === runId)) {
+                if (!unit.worktreePath || !frozen.repositories.some(repo => repo.path === unit.worktreePath) || node_fs_1.default.realpathSync(unit.worktreePath) !== unit.worktreePath)
+                    throw new Error('Recovered worktree no longer matches the frozen runtime scope');
+                if (await gitText(['branch', '--show-current'], unit.worktreePath) !== unit.branch)
+                    throw new Error('Recovered worktree branch changed');
+            }
+        }
+        for (const row of rows) {
+            const branches = (0, rail_pr_store_1.toPrDeliverySnapshot)(row).branches;
+            for (const unit of branches.filter(unit => unit.runId === runId)) {
+                const result = await dependencies.commit(dependencies.git, unit.worktreePath, `specrails: ticket-${unit.ticketId} recovered (run ${runId})`, unit.overlayExcludes ?? []);
+                if (!result.clean || result.error)
+                    throw new Error(result.error ?? 'Recovered worktree still contains uncommitted changes');
+                const sha = await gitText(['rev-parse', 'HEAD'], unit.worktreePath);
+                if (!/^[a-f0-9]{40,64}$/i.test(sha))
+                    throw new Error('Invalid recovered commit');
+                Object.assign(unit, { succeeded: true, implementationOutcome: 'succeeded', deliveryOutcome: sha !== unit.initialSha ? 'ready' : 'no_changes', finalSha: sha, changed: sha !== unit.initialSha, failureCode: null });
+            }
+            updates.push({ row, branches });
+        }
+        const finalCheck = dependencies.verify(input.contextPath, input.cwd, input.env, runId);
+        if (!finalCheck.valid)
+            throw new Error(finalCheck.reason ?? 'Candidate changed during settlement');
+        const core = await (0, core_completion_1.readCoreCompletion)(input);
+        db.transaction(() => {
+            for (const { row, branches } of updates) {
+                const ready = branches.every(unit => unit.succeeded);
+                const noChanges = ready && branches.every(unit => unit.changed === false);
+                if (!(0, rail_pr_store_1.transitionClaimedDecision)(db, row.id, row.decision, noChanges ? 'no_changes' : 'on_review', token, {
+                    branches, implementationOutcome: ready ? 'succeeded' : 'partially_succeeded', deliveryOutcome: noChanges ? 'no_changes' : 'ready',
+                    statusCode: noChanges ? 'no_changes' : ready ? 'ready_for_review' : 'partial_success', statusDetail: null,
+                    ...(branches.length === 1 ? { deliverySha: branches[0].finalSha } : {}),
+                }))
+                    throw new Error('Delivery changed during runtime settlement');
+                for (const unit of branches.filter(unit => unit.runId === runId))
+                    db.prepare("UPDATE rail_worktrees SET merge_state = 'built', updated_at = datetime('now') WHERE run_id = ? AND worktree_path = ?").run(runId, unit.worktreePath);
+            }
+            for (const parentId of parents)
+                (0, multi_repo_execution_1.refreshRepositoryDeliveryGroup)(db, parentId);
+            db.prepare("UPDATE jobs SET status = 'completed', exit_code = 0 WHERE id = ?").run(runId);
+            db.prepare("UPDATE loop_runs SET status = 'completed', final_outcome = 'success' WHERE id = ?").run(runId);
+            let seq = db.prepare('SELECT COALESCE(MAX(seq), -1) + 1 AS seq FROM events WHERE job_id = ?').get(runId).seq;
+            const lastStep = db.prepare("SELECT payload FROM events WHERE job_id = ? AND event_type = 'loop_step' ORDER BY seq DESC LIMIT 1").get(runId);
+            const lastEnd = db.prepare("SELECT payload FROM events WHERE job_id = ? AND event_type = 'loop_step_end' ORDER BY seq DESC LIMIT 1").get(runId);
+            if (lastStep && lastEnd) {
+                const step = JSON.parse(lastStep.payload), end = JSON.parse(lastEnd.payload);
+                // Supersede only this implementation step, never an unrelated shell/decider failure.
+                if (step.kind === 'ai-step' && step.template === '{{cmd:implement}}' && end.index === step.index && end.nodeId === step.nodeId && end.status === 'failed') {
+                    const job = db.prepare('SELECT duration_ms FROM jobs WHERE id = ?').get(runId);
+                    (0, db_1.appendEvent)(db, runId, seq++, { event_type: 'loop_step_end', source: 'stdout', payload: JSON.stringify({ index: step.index, nodeId: step.nodeId, status: 'ok', exitCode: 0, durationMs: job.duration_ms ?? end.durationMs, recovered: true }) });
+                }
+            }
+            const oldCompletion = db.prepare("SELECT payload FROM events WHERE job_id = ? AND event_type = 'loop_completion' ORDER BY seq DESC LIMIT 1").get(runId);
+            let previous = {};
+            try {
+                previous = oldCompletion ? JSON.parse(oldCompletion.payload) : {};
+            }
+            catch { /* old event format */ }
+            const usage = db.prepare('SELECT total_cost_usd,num_turns FROM jobs WHERE id = ?').get(runId);
+            (0, db_1.appendEvent)(db, runId, seq, { event_type: 'loop_completion', source: 'stdout', payload: JSON.stringify({ ...previous, version: 1, execution: 'success', core, turns: usage.num_turns, costUsd: usage.total_cost_usd, recovered: true }) });
+            (0, db_1.appendEvent)(db, runId, seq + 1, { event_type: 'log', source: 'stdout', payload: JSON.stringify({ line: '[runtime] Recovery verified and local delivery prepared for review. The original failed attempt remains in history. No PR was published.' }) });
+        })();
+    }
+    finally {
+        for (const row of claimed)
+            (0, rail_pr_store_1.releasePrDeliveryOperation)(db, row.id, token);
+    }
+    for (const id of new Set([...updates.map(update => update.row.id), ...parents])) {
+        const row = (0, rail_pr_store_1.getPrDelivery)(db, id);
+        try {
+            if (row)
+                input.broadcast?.((0, rail_pr_store_1.toRailPrStateMessage)(input.projectId, (0, rail_pr_store_1.toPrDeliverySnapshot)(row)));
+        }
+        catch { /* durable state remains authoritative */ }
+    }
+    const events = db.prepare('SELECT seq,event_type,source,payload,timestamp FROM events WHERE job_id = ? ORDER BY seq DESC LIMIT 3').all(runId);
+    for (const event of events.reverse()) {
+        try {
+            input.broadcast?.({ type: 'event', projectId: input.projectId, jobId: runId, ...event });
+        }
+        catch { /* replay remains available */ }
+    }
+}

package/server/dist/contract-refine-runner.js

@@ -2,7 +2,7 @@
 /**
  * Contract Refine Runner
  *
- * Standalone runner that spawns a single Claude turn to produce the
+ * Standalone runner that spawns a single provider turn to produce the
  * Contract Layer for a just-committed Explore Spec ticket. Lives outside the
  * ChatManager lifecycle for now (design.md D3 — "thin sibling helper" option):
  * the refine is fire-and-forget with a 60 s budget per invocation and no
@@ -82,12 +82,12 @@ function buildRefineArgs(adapter, model, systemPrompt, sessionId) {
         model,
         systemPrompt: foldForResume ? undefined : systemPrompt,
         sessionId,
-        toolPolicy: 'none',
+        toolPolicy: (0, runtime_1.pureOutputToolPolicy)(adapter) ?? (0, runtime_1.requireToolPolicy)(adapter, 'none'),
         maxTurns: 1,
     };
     return { args: adapter.buildArgs(action, options), options };
 }
-/** Build the pure-output, no-resume invocation used by Quick Refine and by the
+/** Build the restricted pure-output, no-resume invocation used by Quick Refine and by the
  * one-time compatibility recovery for cwd-scoped Explore sessions. */
 function buildFreshRefineArgs(adapter, model, title, description) {
     const systemPrompt = [
@@ -105,7 +105,7 @@ function buildFreshRefineArgs(adapter, model, title, description) {
         prompt: explore_contract_refine_1.CONTRACT_MARKER_USER_MESSAGE,
         model,
         systemPrompt,
-        toolPolicy: 'none',
+        toolPolicy: (0, runtime_1.pureOutputToolPolicy)(adapter) ?? (0, runtime_1.requireToolPolicy)(adapter, 'none'),
         maxTurns: 1,
     };
     return { args: adapter.buildArgs('spec-gen', options), options };
@@ -362,8 +362,8 @@ async function runContractRefine(deps, conversationId, ticketId) {
         return { ok: false, reason: 'not-explore', ticketId, conversationId };
     }
     const adapter = (0, providers_1.getAdapter)(conversation.provider ?? deps.providerId ?? 'claude');
-    if (adapter.capabilities.structuredActions !== true) {
-        console.log(`[contract-refine-runner] skip: provider '${adapter.id}' does not support structured actions`);
+    if (!(0, runtime_1.supportsContractRefine)(adapter)) {
+        console.log(`[contract-refine-runner] skip: provider '${adapter.id}' does not support contract refinement`);
         return { ok: false, reason: 'provider-unsupported', ticketId, conversationId };
     }
     // Per-conversation gating: contractRefine on the conversation's stored
@@ -602,7 +602,7 @@ async function runContractRefineForQuick(deps, ticketId, generatedTitle, generat
     }
     const admission = (0, process_admission_1.captureProcessAdmission)(deps.projectId);
     const adapter = (0, providers_1.getAdapter)(deps.providerId ?? 'claude');
-    if (adapter.capabilities.structuredActions !== true) {
+    if (!(0, runtime_1.supportsContractRefine)(adapter)) {
         return { ok: false, reason: 'provider-unsupported', ticketId, conversationId: '' };
     }
     const resolvedModel = model ?? adapter.defaultModel();

package/server/dist/core-completion.js

@@ -6,7 +6,8 @@ const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
-const path_resolver_1 = require("./path-resolver");
+const core_node_runtime_1 = require("./core-node-runtime");
+const agent_runtime_loader_1 = require("./agent-runtime-loader");
 const obj = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
 const strings = (value) => Array.isArray(value) && value.every(item => typeof item === 'string');
 const count = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
@@ -43,14 +44,16 @@ function parseCoreCompletion(value, runId) {
         }), };
 }
 async function readCoreCompletion(input) {
-    const runtime = (0, node_path_1.join)(input.cwd, '.specrails', 'runtime', 'pipeline.mjs');
-    if (!(0, node_fs_1.existsSync)(runtime))
+    const programmatic = (0, node_fs_1.existsSync)((0, node_path_1.join)((0, node_path_1.dirname)(input.contextPath), 'agent-runtime-request.json'));
+    const runtime = programmatic ? (0, agent_runtime_loader_1.findCoreAgentRuntimeCli)() : (0, node_path_1.join)(input.cwd, '.specrails', 'runtime', 'pipeline.mjs');
+    if (!runtime || !(0, node_fs_1.existsSync)(runtime))
         return null;
     try {
-        const { stdout } = await (0, node_util_1.promisify)(node_child_process_1.execFile)((0, path_resolver_1.resolveBundledNodeExe)() ?? process.execPath, [runtime, 'status', '--context', input.contextPath], {
+        const { stdout } = await (0, node_util_1.promisify)(node_child_process_1.execFile)((0, core_node_runtime_1.resolveCoreNodeRuntime)(), [runtime, 'status', '--context', input.contextPath], {
             cwd: input.cwd, env: input.env, encoding: 'utf8', timeout: 15_000, maxBuffer: 4 * 1024 * 1024, windowsHide: true,
         });
-        return parseCoreCompletion(JSON.parse(stdout), input.runId);
+        const payload = JSON.parse(stdout);
+        return parseCoreCompletion(programmatic ? payload.pipeline : payload, input.runId);
     }
     catch {
         return null;

package/server/dist/desktop-router.js

@@ -4,7 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDesktopRouter = createDesktopRouter;
+const runtime_role_prompts_router_1 = require("./runtime-role-prompts-router");
 const express_1 = require("express");
+const agent_runtime_settings_1 = require("./agent-runtime-settings");
 const crypto_1 = require("crypto");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -1227,6 +1229,30 @@ function createDesktopRouter(registry, broadcast) {
         const monthlyBudgetUsd = Number.isFinite(parsed) && parsed >= 0 ? parsed : 5.0;
         res.json({ language, monthlyBudgetUsd });
     });
+    (0, runtime_role_prompts_router_1.registerRuntimeRolePromptRoutes)(router);
+    router.get('/runtime-providers', (_req, res) => {
+        try {
+            for (const project of (0, desktop_db_1.listProjects)(registry.desktopDb))
+                (0, agent_runtime_settings_1.loadAgentRuntimeConfig)(project);
+            res.json({ providers: (0, agent_runtime_settings_1.loadRuntimeProviders)() });
+        }
+        catch (error) {
+            res.status(422).json({ message: error.message });
+        }
+    });
+    router.put('/runtime-providers', (req, res) => {
+        try {
+            const projects = (0, desktop_db_1.listProjects)(registry.desktopDb).map(project => (0, agent_runtime_settings_1.loadAgentRuntimeConfig)(project));
+            const providers = (0, agent_runtime_settings_1.validateRuntimeProviders)(req.body.providers);
+            for (const config of projects)
+                if (config)
+                    (0, agent_runtime_settings_1.validateAgentRuntimeConfig)({ ...config, providers });
+            res.json({ providers: (0, agent_runtime_settings_1.saveRuntimeProviders)(providers) });
+        }
+        catch (error) {
+            res.status(error instanceof agent_runtime_settings_1.AgentRuntimeConfigError ? 400 : 500).json({ message: error.message });
+        }
+    });
     // ─── 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.

package/server/dist/job-listing.js

@@ -37,7 +37,9 @@ function historyConditions(opts) {
     const conditions = ["jobs.status <> 'queued'"];
     const params = [];
     if (opts.status) {
-        conditions.push('jobs.status = ?');
+        const active = opts.activeRuntimeIds ?? [];
+        conditions.push(active.length ? `CASE WHEN jobs.id IN (${active.map(() => '?').join(',')}) THEN 'running' ELSE jobs.status END = ?` : 'jobs.status = ?');
+        params.push(...active);
         params.push(opts.status);
     }
     if (opts.from) {
@@ -118,14 +120,16 @@ function listUnifiedJobs(db, opts) {
         const remaining = limit - queuedRows.length;
         const historyOffset = Math.max(0, offset - queuedTotal);
         if (remaining > 0 && historyOffset < historyTotal) {
+            const active = opts.activeRuntimeIds ?? [];
+            const activeOrder = active.length ? `CASE WHEN jobs.id IN (${active.map(() => '?').join(',')}) THEN 0 ELSE 1 END, ` : '';
             historyRows = db.prepare(`
         SELECT jobs.*, jp.profile_name AS profile_name, NULL AS enqueued_at
         FROM jobs
         LEFT JOIN job_profiles jp ON jp.job_id = jobs.id
         ${history.sql}
-        ORDER BY jobs.started_at DESC, jobs.id ASC
+        ORDER BY ${activeOrder}jobs.started_at DESC, jobs.id ASC
         LIMIT ? OFFSET ?
-      `).all(...history.params, remaining, historyOffset);
+      `).all(...history.params, ...active, remaining, historyOffset);
         }
     }
     return { jobs: [...queuedRows, ...historyRows], total: queuedTotal + historyTotal };

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

@@ -68,14 +68,14 @@ exports.LOOP_COMMANDS = [
     {
         name: 'implement',
         label: 'implement',
-        description: "Run the specrails implement pipeline (architect → developer → reviewer) over the rail's tickets, via the native /specrails:implement command.",
+        description: "Run Core’s programmatic agent workflow (architect → developer → verification → reviewer → archive) over the rail's tickets.",
         coreCommand: 'implement',
         ticketScope: 'all',
     },
     {
         name: 'batch',
         label: 'batch',
-        description: "Run the batch-implement pipeline over ALL the rail's tickets in one pass (parallel internally).",
+        description: "Run all selected tickets as one frozen candidate through Core’s programmatic agent workflow.",
         coreCommand: 'batch-implement',
         ticketScope: 'all',
     },

package/server/dist/loop-executors.js

@@ -234,17 +234,19 @@ function createLoopExecutors(opts = {}) {
             // agent self-heal on Windows.
             const baseEnv = resolveEnv();
             const existingContext = coreRun ? runtimeContextPath(cwd, coreRun.runId, baseEnv) : undefined;
-            const programmatic = coreRun && existingContext && ((coreRun.implementation && (0, agent_runtime_bridge_1.selectAgentRuntime)(runtimeConfigPath(cwd), existingContext)) || (coreRun.verificationStep && existsRuntimeRequest(existingContext)));
+            const programmatic = coreRun && existingContext && (coreRun.implementation || (coreRun.verificationStep && existsRuntimeRequest(existingContext)));
             const baseStepEnv = programmatic ? programmaticStepEnv(baseEnv, repoDir, executionManifest) : withProfileEnv(aiStepEnv(baseEnv, repoDir, executionManifest), provider, profileName);
             const core = coreRun ? (0, core_execution_1.prepareCoreExecution)({ run: coreRun, cwd, repoDir, manifest: executionManifest, env: baseStepEnv }) : undefined;
             const stepEnv = core?.env ?? baseStepEnv;
-            if (coreRun?.implementation && core && (0, agent_runtime_bridge_1.selectAgentRuntime)(runtimeConfigPath(cwd), core.contextPath)) {
+            if (coreRun?.implementation && core) {
+                completionContexts.set(coreRun.runId, { cwd, contextPath: core.contextPath, env: stepEnv, runId: coreRun.runId });
                 const admitted = existsRuntimeRequest(core.contextPath);
                 // Repeated implementation nodes may validate completed work, but may
                 // never silently replay an interrupted mutating phase.
                 return (0, agent_runtime_bridge_1.runAgentRuntimeInvocation)({
                     contextPath: core.contextPath, cwd, env: { ...programmaticStepEnv(resolveEnv(), repoDir, executionManifest), SPECRAILS_EXECUTION_CONTEXT: core.contextPath }, configPath: runtimeConfigPath(cwd),
                     change: (0, agent_runtime_bridge_1.runtimeChangeName)(coreRun.runId), resume: admitted,
+                    defaultProvider: provider, selectedModel: model,
                     onLine, onRawLine, onSpawn, timeoutMs: aiStepTimeoutMs,
                 });
             }
@@ -464,7 +466,7 @@ function createLoopExecutors(opts = {}) {
                 const env = resolveEnv();
                 const root = env.SPECRAILS_TICKETS_PATH ? (0, node_path_1.dirname)((0, node_path_1.dirname)(env.SPECRAILS_TICKETS_PATH)) : cwd;
                 const contextPath = (0, node_path_1.join)(root, '.specrails', 'pipeline', coreRun.runId, 'desktop-context.json');
-                if ((coreRun.implementation && (0, agent_runtime_bridge_1.selectAgentRuntime)(runtimeConfigPath(cwd), contextPath)) || existsRuntimeRequest(contextPath))
+                if (coreRun.implementation || existsRuntimeRequest(contextPath))
                     return null;
             }
             if (!(0, feature_flags_1.isInteractiveJobsEnabled)())

package/server/dist/loop-run-manager.js

@@ -1099,7 +1099,7 @@ class LoopRunManager {
                         // were noise once the step explorer landed; the log now opens on real
                         // output). `template` is omitted when rendering changed nothing (a
                         // plain free-text prompt would just duplicate `command`).
-                        const stepTitle = `🤖 ${nodeLabel || 'AI Step'} (${nodeProvider}/${nodeModel}${nodeEffort ? `, effort: ${nodeEffort}` : ''})`;
+                        const stepTitle = requiresCoreCompletion ? '🤖 Implementation (agent runtime)' : `🤖 ${nodeLabel || 'AI Step'} (${nodeProvider}/${nodeModel}${nodeEffort ? `, effort: ${nodeEffort}` : ''})`;
                         const stepDetail = {
                             ...(rawTemplate && rawTemplate !== base ? { template: capText(rawTemplate, STEP_TEMPLATE_CAP) } : {}),
                             ...(base ? { command: capText(base, STEP_COMMAND_CAP) } : {}),
@@ -1691,7 +1691,7 @@ class LoopRunManager {
         // `≥` when any cost-bearing step ended unpriced (timeout/crash) — the figure
         // is a lower bound, not exact. Providers without usage telemetry get an
         // explicit unavailable marker, never a fabricated "$0.0000".
-        logLine(`\n■ Loop execution finished: ${outcome} — ${stepNum} step${stepNum === 1 ? '' : 's'}, ${iteration} decider evaluation${iteration === 1 ? '' : 's'}, ${finalJobUsage.numTurns ?? 'unknown'} agent turns, ` +
+        logLine(`\n■ Loop execution finished: ${outcome} — ` +
             (costAvailable
                 ? `${costUncertain ? '≥ ' : ''}$${totalCost.toFixed(4)}`
                 : 'usage/cost unavailable'));