specrails-desktop 2.44.2 → 2.46.0

package/server/dist/core-node-runtime.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCoreNodeRuntime = resolveCoreNodeRuntime;
+const path_resolver_1 = require("./path-resolver");
+/** External Core CLIs need ordinary Node. A pkg sidecar's process.execPath is
+ * the server executable: using it would recursively launch another server. */
+function resolveCoreNodeRuntime() {
+    const bundled = (0, path_resolver_1.resolveBundledNodeExe)();
+    if (bundled)
+        return bundled;
+    return process.pkg ? 'node' : process.execPath;
+}

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

@@ -11,6 +11,7 @@ exports.createLoopExecutors = createLoopExecutors;
  */
 const core_completion_1 = require("./core-completion");
 const core_execution_1 = require("./core-execution");
+const agent_runtime_bridge_1 = require("./agent-runtime-bridge");
 const codex_spawn_1 = require("./plugins/codex-spawn");
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
@@ -41,6 +42,7 @@ const SHELL_OUTPUT_CAP = 256 * 1024;
 // Match the queue's idle budget: a long implementation may keep running while
 // producing output; a silent, wedged CLI must eventually release its rail.
 const DEFAULT_INACTIVITY_TIMEOUT_MS = 30 * 60_000;
+const existsRuntimeRequest = (contextPath) => (0, node_fs_1.existsSync)((0, node_path_1.join)((0, node_path_1.dirname)(contextPath), 'agent-runtime-request.json'));
 function runShellCommand(command, cwd, env, timeoutMs, onLine, onSpawn) {
     return new Promise((resolve) => {
         const isWin = process.platform === 'win32';
@@ -116,6 +118,15 @@ function aiStepEnv(env, repoDir, manifest) {
     const withMap = (0, repo_map_1.injectRepoMapEnv)(base, repoDir);
     return manifest || (0, rail_isolation_1.isRailPrDeliveryEnabled)() ? { ...withMap, SPECRAILS_GIT_AUTO: 'false' } : withMap;
 }
+function programmaticStepEnv(env, repoDir, manifest) {
+    const result = aiStepEnv(env, repoDir, manifest);
+    delete result.SPECRAILS_PROFILE_PATH;
+    return result;
+}
+function runtimeContextPath(cwd, runId, env) {
+    const root = env.SPECRAILS_TICKETS_PATH ? (0, node_path_1.dirname)((0, node_path_1.dirname)(env.SPECRAILS_TICKETS_PATH)) : cwd;
+    return (0, node_path_1.join)(root, '.specrails', 'pipeline', runId, 'desktop-context.json');
+}
 /**
  * Relocated cwd is the workspace; the source repo is reached via the
  * `./project` symlink + SPECRAILS_REPO_DIR. Each provider must be told the
@@ -163,6 +174,7 @@ function createLoopExecutors(opts = {}) {
         }
     };
     const completionContexts = new Map();
+    const runtimeConfigPath = (cwd) => (0, node_path_1.join)(opts.pluginScope?.().stateRoot ?? cwd, '.specrails', 'agent-runtime.json');
     return {
         async readCoreCompletion(runId) {
             const context = completionContexts.get(runId);
@@ -220,9 +232,28 @@ 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 baseStepEnv = withProfileEnv(aiStepEnv(resolveEnv(), repoDir, executionManifest), provider, profileName);
+            const baseEnv = resolveEnv();
+            const existingContext = coreRun ? runtimeContextPath(cwd, coreRun.runId, baseEnv) : undefined;
+            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) {
+                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,
+                });
+            }
+            if (coreRun?.verificationStep && core && existsRuntimeRequest(core.contextPath)) {
+                const checked = (0, core_execution_1.checkCoreCompletion)(core.contextPath, cwd, { ...programmaticStepEnv(resolveEnv(), repoDir, executionManifest), SPECRAILS_EXECUTION_CONTEXT: core.contextPath }, coreRun.runId);
+                return { text: checked.valid ? 'VERIFICATION: PASS — Core verified the exact implementation and review.' : checked.reason ?? 'Core verification failed', failed: !checked.valid, errorText: checked.reason, provider: 'agent-runtime', model: 'deterministic-verification', cost: 0, tokensIn: 0, tokensOut: 0, tokens: 0, estimated: false, durationMs: 0 };
+            }
             let extraArgs = aiStepExtraArgs(adapter, cwd, repoDir, executionManifest);
             const pluginScope = adapter.id === 'codex' ? opts.pluginScope?.() : undefined;
             const pluginArgs = (0, codex_spawn_1.buildCodexPluginArgs)({ providerId: adapter.id, stateRoot: pluginScope?.stateRoot ?? stepEnv.SPECRAILS_WORKSPACE_DIR ?? cwd, repositoryPath: repoDir ?? cwd, legacyProviderId: pluginScope?.legacyProviderId });
@@ -431,6 +462,13 @@ function createLoopExecutors(opts = {}) {
          * (non-claude providers, or the kill-switch) — byte-identical legacy.
          */
         planInteractiveAiStep({ coreRun, provider, model, effort, profileName, cwd, repoDir, executionManifest, sessionId, aiStepTimeoutMs, idleTimeoutMs }) {
+            if (coreRun?.implementation || coreRun?.verificationStep) {
+                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 || existsRuntimeRequest(contextPath))
+                    return null;
+            }
             if (!(0, feature_flags_1.isInteractiveJobsEnabled)())
                 return null;
             const adapter = (0, providers_1.getAdapter)(provider);
@@ -490,8 +528,12 @@ function createLoopExecutors(opts = {}) {
             };
         },
         validateCoreCompletion({ coreRun, provider, model, effort, profileName, cwd, repoDir, executionManifest }) {
-            const baseStepEnv = withProfileEnv(aiStepEnv(resolveEnv(), repoDir, executionManifest), provider, profileName);
+            const baseEnv = resolveEnv();
+            const programmatic = existsRuntimeRequest(runtimeContextPath(cwd, coreRun.runId, baseEnv));
+            const baseStepEnv = programmatic ? programmaticStepEnv(baseEnv, repoDir, executionManifest) : withProfileEnv(aiStepEnv(baseEnv, repoDir, executionManifest), provider, profileName);
             const core = (0, core_execution_1.prepareCoreExecution)({ run: coreRun, cwd, repoDir, manifest: executionManifest, env: baseStepEnv });
+            if (existsRuntimeRequest(core.contextPath))
+                return (0, core_execution_1.checkCoreCompletion)(core.contextPath, cwd, { ...programmaticStepEnv(resolveEnv(), repoDir, executionManifest), SPECRAILS_EXECUTION_CONTEXT: core.contextPath }, coreRun.runId);
             const env = (0, runtime_1.buildProviderEnv)((0, providers_1.getAdapter)(provider), { prompt: '', model, reasoning_effort: effort }, core.env);
             return (0, core_execution_1.checkCoreCompletion)(core.contextPath, cwd, env, coreRun.runId);
         },

package/server/dist/loop-factory.js

@@ -21,7 +21,7 @@ function coreImplementationGraph(command) {
     return {
         nodes: [
             { id: 'start', type: 'start', position: { x: 0, y: 0 } },
-            { id: 'main-1', type: 'ai-step', position: { x: 0, y: 110 }, data: { prompt: `{{cmd:${command}}}` } },
+            { id: 'main-1', type: 'ai-step', position: { x: 0, y: 110 }, data: { operation: 'core-implementation', prompt: `{{cmd:${command}}}` } },
             { id: 'done', type: 'end', position: { x: 0, y: 220 }, data: { outcome: 'success' } },
         ],
         edges: [

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

@@ -19,6 +19,7 @@ const ai_invocations_1 = require("./ai-invocations");
 const provider_limit_1 = require("./provider-limit");
 const ids_1 = require("./ids");
 const providers_1 = require("./providers");
+const agent_runtime_accounting_1 = require("./agent-runtime-accounting");
 const runtime_1 = require("./providers/runtime");
 const result_event_1 = require("./result-event");
 const rails_store_1 = require("./rails-store");
@@ -137,6 +138,13 @@ function extractChangeId(text) {
     const m = CHANGE_ID_RE.exec(text);
     return m ? m[1] : undefined;
 }
+function programmaticUsageAvailability(db, runId) {
+    const row = db.prepare(`SELECT COUNT(*) AS count,
+    MAX(total_cost_usd IS NULL) AS cost_unknown,
+    MAX(tokens_in IS NULL) AS input_unknown, MAX(tokens_out IS NULL) AS output_unknown
+    FROM ai_invocations WHERE surface = 'loop' AND loop_run_id = ? AND provider = 'agent-runtime'`).get(runId);
+    return { present: row.count > 0, costUnknown: Boolean(row.cost_unknown), tokensInUnknown: Boolean(row.input_unknown), tokensOutUnknown: Boolean(row.output_unknown) };
+}
 function insertLoopInvocation(db, payload, result, finishedAt) {
     const ticketIds = Array.isArray(payload.ticketIds)
         ? [...new Set(payload.ticketIds)]
@@ -193,14 +201,15 @@ function insertLoopInvocation(db, payload, result, finishedAt) {
       FROM ai_invocations
      WHERE surface = 'loop' AND loop_run_id = ?
   `).get(payload.runId);
-    const usageTelemetryAvailable = (0, providers_1.getAdapter)(payload.provider).capabilities.reportsUsage !== false;
+    const runtimeUsage = programmaticUsageAvailability(db, payload.runId);
+    const usageTelemetryAvailable = runtimeUsage.present || (0, providers_1.getAdapter)(payload.provider).capabilities.reportsUsage !== false;
     db.prepare(`
     UPDATE jobs
        SET total_cost_usd = ?, tokens_in = ?, tokens_out = ?,
            tokens_cache_read = ?, tokens_cache_create = ?,
            duration_ms = ?, num_turns = ?
      WHERE id = ? AND owner = 'loop'
-  `).run(usageTelemetryAvailable ? aggregate.cost : null, usageTelemetryAvailable ? aggregate.tokens_in : null, usageTelemetryAvailable ? aggregate.tokens_out : null, usageTelemetryAvailable ? aggregate.cache_read : null, usageTelemetryAvailable ? aggregate.cache_create : null, aggregate.duration, usageTelemetryAvailable ? aggregate.turns : null, payload.runId);
+  `).run(usageTelemetryAvailable && !runtimeUsage.costUnknown ? aggregate.cost : null, usageTelemetryAvailable && !runtimeUsage.tokensInUnknown ? aggregate.tokens_in : null, usageTelemetryAvailable && !runtimeUsage.tokensOutUnknown ? aggregate.tokens_out : null, usageTelemetryAvailable && !runtimeUsage.present ? aggregate.cache_read : null, usageTelemetryAvailable && !runtimeUsage.present ? aggregate.cache_create : null, aggregate.duration, usageTelemetryAvailable && !runtimeUsage.present ? aggregate.turns : null, payload.runId);
 }
 /** Recover every AI/decider step that was staged before provider spawn but did
  * not atomically land its invocation. Completed interactive turns are the jobs
@@ -266,6 +275,23 @@ function recoverOrphanLoopStepAccounting(db, finishedAt = new Date().toISOString
        WHERE job_id = ? AND seq > ? AND source = 'stdout'
        ORDER BY seq
     `).all(payload.runId, payload.completedEventSeq ?? -1);
+        const programmatic = (0, agent_runtime_accounting_1.parseProgrammaticUsage)(rawRows.map(row => row.payload)) ?? (payload.provider === 'agent-runtime'
+            ? { provider: 'agent-runtime', model: 'per-role', estimated: true, failed: true }
+            : undefined);
+        if (programmatic) {
+            const durationMs = boundedInflightDurationMs(payload, finishedAt);
+            const didRecover = (0, loop_runs_store_1.completeLoopStepRecovery)(db, payload.runId, payload.stepKey, stable => {
+                insertLoopInvocation(db, stable, { ...programmatic, durationMs }, finishedAt);
+                const aggregate = (0, loop_runs_store_1.readLoopJobUsage)(db, payload.runId);
+                const duration = (payload.loopDurationBaseline ?? 0) + durationMs;
+                db.prepare(`UPDATE loop_runs SET total_cost_usd = ?, total_tokens = ?, total_duration_ms = ?, iteration_count = MAX(iteration_count, COALESCE(?, iteration_count)) WHERE id = ?`)
+                    .run(aggregate.totalCostUsd, aggregate.tokensIn + aggregate.tokensOut, duration, stable.iterationCount ?? null, payload.runId);
+                db.prepare(`UPDATE jobs SET duration_ms = ? WHERE id = ? AND owner = 'loop'`).run(duration, payload.runId);
+            });
+            if (didRecover)
+                recovered += 1;
+            continue;
+        }
         const adapter = (0, providers_1.getAdapter)(payload.provider);
         const usageTelemetryAvailable = adapter.capabilities.reportsUsage !== false;
         const events = rawRows
@@ -560,7 +586,7 @@ class LoopRunManager {
         if (req.graph.nodes.some((node) => node.type === 'decider')) {
             (0, providers_1.requireToolPolicy)(adapter, 'read-only');
         }
-        const usageTelemetryAvailable = adapter.capabilities.reportsUsage !== false;
+        let usageTelemetryAvailable = adapter.capabilities.reportsUsage !== false;
         const neverAfterDispose = () => new Promise(() => { });
         const runId = req.runId ?? (0, ids_1.newId)();
         const maxIterations = req.graph.config.maxIterations;
@@ -828,20 +854,20 @@ class LoopRunManager {
         // The REAL turn-start instant, captured before the step/decider await. The
         // row is bucketed/ordered by started_at, so it must be the start, not finish.
         startedAt, stepKey) => {
+            if (r.provider === 'agent-runtime')
+                usageTelemetryAvailable = true;
             if (usageTelemetryAvailable)
                 totalCost += r.cost ?? 0;
-            // A cost-bearing step that produced work (tokens) or hard-failed but reports
-            // no priced cost → its real spend is missing from the total. The common case
-            // is a claude step killed by timeout before its terminal `result` event:
-            // tokens streamed, but cost (and tokens) are dropped, so the step bills $0.
-            // Flag the run total as a lower bound and say so, per occurrence.
+            // Missing pricing does not identify the failure cause or prove zero spend:
+            // providers can omit billing after a successful call or reject a request
+            // before model work starts. Retain known costs and flag the incomplete sum.
             const costBearingButUnpriced = usageTelemetryAvailable
                 && r.cost == null
                 && (r.failed === true || (r.tokens ?? 0) > 0);
             if (costBearingButUnpriced) {
                 costUncertain = true;
                 costUnknownWarned = true; // this line already carries the cap caveat below
-                logLine(`⚠️ Step cost unknown — the process ended before billing (timeout/crash), so it counts as $0. The loop total is a lower bound.${maxCostUsd !== undefined ? ' The cost cap may under-count.' : ''}`, 'stderr');
+                logLine(`⚠️ Step cost unknown — this step did not report a priced cost. The reported loop total includes known costs only.${maxCostUsd !== undefined ? ' The cost cap may under-count.' : ''}`, 'stderr');
             }
             // Honest cost-cap caveat: a cost-bearing step that reports no figure means
             // the cap can't be enforced precisely from here on. Warn once (live).
@@ -1058,7 +1084,7 @@ class LoopRunManager {
                         // --yes`, codex `$implement #<id> --yes`) — then resolve `{{spec.*}}`
                         // data tokens and finally `{{const:*}}` library constants.
                         const rawTemplate = String(node.data?.prompt ?? '');
-                        const requiresCoreCompletion = /\{\{\s*cmd:(?:implement|batch)\s*\}\}/.test(rawTemplate)
+                        const requiresCoreCompletion = node.data?.operation === 'core-implementation' || /\{\{\s*cmd:(?:implement|batch)\s*\}\}/.test(rawTemplate)
                             || /^\s*(?:\/specrails:|\/skill:specrails-|\$)(?:implement|batch-implement)(?:\s|$)/.test(rawTemplate);
                         const expanded = (0, loop_constants_1.resolveConstants)(resolveRunVars((0, loop_graph_1.interpolateSpec)((0, loop_command_catalog_1.expandCommands)(rawTemplate, { provider: nodeProvider, ticketIds: req.spec?.ticketIds, specId: req.spec?.id }), req.spec), runVars), constMap);
                         const base = [(0, multi_repo_execution_store_1.executionManifestPrompt)(req.executionManifest), withReviewContinuationContext(expanded, rawTemplate, req.spec)].filter(Boolean).join('\n\n');
@@ -1073,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) } : {}),
@@ -1096,7 +1122,7 @@ class LoopRunManager {
                             const effectiveTimeoutMs = Number.isFinite(remainingMs)
                                 ? Math.max(1, Math.min(aiStepTimeoutMs === 0 ? Infinity : (aiStepTimeoutMs ?? 15 * 60_000), remainingMs))
                                 : aiStepTimeoutMs;
-                            const coreRun = { runId, spec: req.spec, goal: req.spec ? undefined : JSON.stringify({ loop: req.loopName, graph: req.graph }), repositoryId: req.repositoryId, verificationStep: node.data?.requireVerificationPass === true || /\{\{\s*cmd:(?:verify|revision-verify|opsx:verify)\s*\}\}/.test(rawTemplate) };
+                            const coreRun = { runId, implementation: requiresCoreCompletion, spec: req.spec, goal: req.spec ? undefined : JSON.stringify({ loop: req.loopName, graph: req.graph }), repositoryId: req.repositoryId, verificationStep: node.data?.requireVerificationPass === true || /\{\{\s*cmd:(?:verify|revision-verify|opsx:verify)\s*\}\}/.test(rawTemplate) };
                             const interactivePlan = this.executors.planInteractiveAiStep?.({
                                 coreRun,
                                 provider: nodeProvider,
@@ -1248,9 +1274,7 @@ class LoopRunManager {
                                 ? `blocked — ${blockedReason}`
                                 : verificationFailed
                                     ? 'verification did not finish with VERIFICATION: PASS'
-                                    : undefined);
-                        if (verificationFailed && !blockedReason)
-                            logLine(`✖ ${stepErrorText}`, 'stderr');
+                                    : res.failed ? 'provider invocation failed without a reported reason' : undefined);
                         // Make the failure reason land visibly INSIDE the step's log
                         // segment (the interactive session already surfaced its own note at
                         // settle; the Template/Command flat-log lines are gone, so without
@@ -1258,6 +1282,14 @@ class LoopRunManager {
                         if (oneShotZeroWork) {
                             logLine(`✖ Zero work performed — the command never ran${res.text.trim() ? `: ${res.text.trim()}` : ''}`, 'stderr');
                         }
+                        else if (stepFailed && stepErrorText) {
+                            // Executors can return a structured failure without streaming any
+                            // text (configuration rejection, missing CLI, provider startup).
+                            // Persist its reason before the step closes, including early stops.
+                            logLine(`✖ ${stepErrorText}`, 'stderr');
+                        }
+                        record(`loop:${runId}`, { ...res, failed: stepFailed }, aiStepStart, aiRecoveryKey);
+                        this._activeStepRecovery.delete(runId);
                         // Step tail marker — after the step's last streamed output (both the
                         // one-shot and interactive paths have fully persisted their frames by
                         // here: the session resolves inside onSettle, past its final writes).
@@ -1281,8 +1313,6 @@ class LoopRunManager {
                         else if (stepFailed)
                             aiSessionId = undefined;
                         history.push(`AI Step${stepFailed ? ` FAILED (${stepErrorText ?? 'provider invocation failed'})` : ''}: ${truncate(res.text)}`);
-                        record(`loop:${runId}`, { ...res, failed: stepFailed }, aiStepStart, aiRecoveryKey);
-                        this._activeStepRecovery.delete(runId);
                         if (blockedReason) {
                             const decision = await awaitHumanDecision(blockedReason);
                             if (decision.action === 'stop') {
@@ -1579,6 +1609,7 @@ class LoopRunManager {
         // The ONLY way a persisted stream ends with an open step is a mid-flight
         // dispose (shutdown/project removal), where this code never runs.
         emitStepEnd({ status: 'failed' });
+        let runtimeUsage = { present: false, costUnknown: false, tokensInUnknown: false, tokensOutUnknown: false };
         // A traversal exception can bypass record(). Reconcile the staged step
         // BEFORE writing aggregate job totals, while its jobs baseline is still
         // valid. If reconciliation itself fails, finishLoopRunAndJob detects the
@@ -1586,6 +1617,8 @@ class LoopRunManager {
         try {
             const recoveredSteps = recoverOrphanLoopStepAccounting(this.db, new Date(this.now()).toISOString(), runId);
             this._activeStepRecovery.delete(runId);
+            runtimeUsage = programmaticUsageAvailability(this.db, runId);
+            usageTelemetryAvailable ||= runtimeUsage.present;
             const aggregate = this.db.prepare(`
         SELECT COALESCE(SUM(total_cost_usd), 0) AS cost,
                COALESCE(SUM(tokens_in), 0) AS tokens_in,
@@ -1617,11 +1650,11 @@ class LoopRunManager {
             }
             if (usageTelemetryAvailable) {
                 finalJobUsage = {
-                    tokensIn: aggregate.tokens_in,
-                    tokensOut: aggregate.tokens_out,
-                    tokensCacheRead: aggregate.cache_read,
-                    tokensCacheCreate: aggregate.cache_create,
-                    numTurns: aggregate.turns,
+                    tokensIn: runtimeUsage.tokensInUnknown ? null : aggregate.tokens_in,
+                    tokensOut: runtimeUsage.tokensOutUnknown ? null : aggregate.tokens_out,
+                    tokensCacheRead: runtimeUsage.present ? null : aggregate.cache_read,
+                    tokensCacheCreate: runtimeUsage.present ? null : aggregate.cache_create,
+                    numTurns: runtimeUsage.present ? null : aggregate.turns,
                 };
             }
         }
@@ -1638,8 +1671,9 @@ class LoopRunManager {
         const executionOutcome = outcome;
         if (outcome === 'success' && coreCompletion && (coreCompletion.completion.implementation !== 'complete' || !['verified', 'with-exceptions'].includes(coreCompletion.completion.validation)))
             outcome = 'blocked';
+        const costAvailable = usageTelemetryAvailable && !runtimeUsage.costUnknown;
         console.log(`[loop] settle run=${runId} outcome=${outcome} iterations=${iteration} ` +
-            (usageTelemetryAvailable ? `cost=$${totalCost.toFixed(4)}` : 'usage=unavailable'));
+            (costAvailable ? `cost=$${totalCost.toFixed(4)}` : 'cost=unavailable'));
         emitRunEvent('loop_completion', {
             version: 1, execution: executionOutcome, steps: stepNum, deciderEvaluations: iteration,
             turns: finalJobUsage.numTurns, costUsd: usageTelemetryAvailable ? totalCost : null,
@@ -1657,8 +1691,8 @@ 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, ` +
-            (usageTelemetryAvailable
+        logLine(`\n■ Loop execution finished: ${outcome} — ` +
+            (costAvailable
                 ? `${costUncertain ? '≥ ' : ''}$${totalCost.toFixed(4)}`
                 : 'usage/cost unavailable'));
         if (coreCompletion)
@@ -1678,7 +1712,7 @@ class LoopRunManager {
             job: {
                 exitCode: outcome === 'success' ? 0 : 1,
                 status: jobStatus,
-                totalCostUsd: usageTelemetryAvailable ? totalCost : null,
+                totalCostUsd: costAvailable ? totalCost : null,
                 tokensIn: finalJobUsage.tokensIn,
                 tokensOut: finalJobUsage.tokensOut,
                 tokensCacheRead: finalJobUsage.tokensCacheRead,
@@ -1699,7 +1733,7 @@ class LoopRunManager {
                 tokens_out: finalJobUsage.tokensOut,
                 tokens_cache_read: finalJobUsage.tokensCacheRead,
                 tokens_cache_create: finalJobUsage.tokensCacheCreate,
-                total_cost_usd: usageTelemetryAvailable ? totalCost : null,
+                total_cost_usd: costAvailable ? totalCost : null,
                 num_turns: finalJobUsage.numTurns,
             },
             timestamp: new Date(this.now()).toISOString(),
@@ -1716,7 +1750,7 @@ class LoopRunManager {
             runId,
             outcome,
             iterations: iteration,
-            totalCostUsd: usageTelemetryAvailable ? totalCost : null,
+            totalCostUsd: costAvailable ? totalCost : null,
             ...(outcome === 'stalled' && stallReason ? { stallReason } : {}),
             ...(providerLimitHit ? { providerLimit: providerLimitHit } : {}),
         };

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

@@ -59,7 +59,8 @@ function specsTools() {
                 '— pass contractRefine: false to skip it, e.g. when the user declined it), ' +
                 'generate (same as create but takes a pre-formed idea string; both accept contextScope/attachments/createLocal), ' +
                 'ai_edit (ai-spawn, AI-edit a ticket title+description), ' +
-                'cancel_ai_edit (abort an in-flight ai-edit), contract_refine (ai-spawn, append/re-fire a Contract Layer — Claude-only; ' +
+                'cancel_ai_edit (abort an in-flight ai-edit), contract_refine (ai-spawn, append/re-fire a Contract Layer — Claude or Codex; ' +
+                'pass numeric id, not ticketId; optional aiEngine selects the provider for origin-less specs, while Explore specs retain their origin provider; ' +
                 'works on Explore-origin AND agent-authored/Quick specs), ' +
                 'smash (ai-spawn, decompose a spec into N child sub-specs under an epic — Claude-only), ' +
                 'smash_undo (destructive, reverse a prior SMASH), delete_epic_children (destructive, delete all children of an epic), ' +
@@ -150,7 +151,7 @@ function specsTools() {
                 aiEngine: zod_1.z
                     .string()
                     .optional()
-                    .describe('create/generate: provider/engine override (must be an installed provider; defaults to primary)'),
+                    .describe('create/generate/contract_refine: provider/engine override (must be installed; contract_refine cannot switch an Explore-origin provider)'),
                 contextScope: zod_1.z
                     .record(zod_1.z.unknown())
                     .optional()
@@ -158,7 +159,7 @@ function specsTools() {
                 contractRefine: zod_1.z
                     .boolean()
                     .optional()
-                    .describe('create/generate/commit_draft: enrich the spec with a Contract Layer post-persist (Claude-only). DEFAULTS TO TRUE — pass false to opt out (e.g. the user asked for no contract layer)'),
+                    .describe('create/generate/commit_draft: enrich the spec with a Contract Layer post-persist (Claude or Codex). DEFAULTS TO TRUE — pass false to opt out (e.g. the user asked for no contract layer)'),
                 attachmentIds: zod_1.z.array(zod_1.z.string()).optional().describe('create/generate/ai_edit: attachment ids (create/generate require pendingSpecId)'),
                 // ── ai_edit ──────────────────────────────────────────────────────
                 instructions: zod_1.z.string().optional().describe('ai_edit: natural-language editing instructions (required)'),
@@ -428,7 +429,9 @@ function specsTools() {
                         return { ...r, hint: WATCH_HINT };
                     }
                     case 'contract_refine': {
-                        const r = await (0, types_1.apiCall)(ctx, 'POST', `${base}/tickets/${requireId()}/contract-refine`);
+                        const r = await (0, types_1.apiCall)(ctx, 'POST', `${base}/tickets/${requireId()}/contract-refine`, {
+                            aiEngine: args.aiEngine,
+                        });
                         return { ...r, hint: CONTRACT_REFINE_HINT };
                     }
                     case 'smash': {

package/server/dist/multi-repo-execution.js

@@ -353,6 +353,7 @@ async function launchMultiRepositoryRail(input, io = {}) {
             };
             await (0, rail_isolated_launch_1.launchIsolatedRail)({
                 ...input, ctx: childCtx, scope: effectiveScope, loopGraph: graph,
+                runtimeStateProject: ctx.project,
                 revision: input.revision && previous ? { ...input.revision, ofDeliveryId: previous.id, decision: previous.decision } : undefined,
                 requiredPrContinuation: continuation,
                 explicitPrTarget: continuation?.prNumber ? { prNumber: continuation.prNumber } : input.explicitPrTarget,

package/server/dist/project-registry.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectRegistry = void 0;
 exports.emitRecoveredPrDelivery = emitRecoveredPrDelivery;
 exports.reprojectActivePrDeliveries = reprojectActivePrDeliveries;
+const agent_runtime_controls_router_1 = require("./agent-runtime-controls-router");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
@@ -305,6 +306,10 @@ class ProjectRegistry {
             // Loop engine teardown: dispose any resident interactive step sessions
             // (SIGTERM, no settle) + kill in-flight one-shot loop children — BEFORE
             // db.close() so a late close handler can't write to the closed handle.
+            try {
+                (0, agent_runtime_controls_router_1.shutdownAgentRuntimeControls)(ctx);
+            }
+            catch { /* ignore */ }
             try {
                 ctx.loopRunManager.shutdown();
             }
@@ -540,6 +545,10 @@ class ProjectRegistry {
             catch { /* ignore */ }
             // Loop engine: dispose resident interactive step sessions + kill in-flight
             // one-shot loop children so a quit mid-run doesn't orphan claude processes.
+            try {
+                (0, agent_runtime_controls_router_1.shutdownAgentRuntimeControls)(ctx);
+            }
+            catch { /* ignore */ }
             try {
                 ctx.loopRunManager.shutdown();
             }

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerJobsRoutes = registerJobsRoutes;
+const agent_runtime_controls_router_1 = require("./agent-runtime-controls-router");
 const ids_1 = require("./ids");
 const db_1 = require("./db");
 const queue_manager_1 = require("./queue-manager");
@@ -229,6 +230,10 @@ function registerJobsRoutes(deps) {
     router.post('/:projectId/jobs/:id/cancel', (req, res) => {
         const id = req.params.id;
         const c = ctx(req);
+        if ((0, agent_runtime_controls_router_1.cancelRuntimeContinuation)(c, id)) {
+            res.json({ ok: true, status: 'canceling' });
+            return;
+        }
         // A loop run is backed by a job row but is NOT a QueueManager job — it is
         // driven by the LoopRunManager. Cancel it through the engine (which settles
         // it 'stopped' → finishJob('canceled') + releases the rail's tickets).
@@ -409,12 +414,13 @@ function registerJobsRoutes(deps) {
         const from = req.query.from;
         const to = req.query.to;
         const { db } = ctx(req);
-        const result = (0, job_listing_1.listUnifiedJobs)(db, { limit, offset, status, from, to });
+        const result = (0, job_listing_1.listUnifiedJobs)(db, { limit, offset, status, from, to, activeRuntimeIds: (0, agent_runtime_controls_router_1.activeRuntimeContinuationIds)(ctx(req)) });
         // Annotate each job with hasTelemetry so the client can show the
         // Export diagnostic button without an extra round trip.
         const jobsWithTelemetry = (0, db_1.getJobsWithTelemetry)(db);
         const annotatedJobs = result.jobs.map((j) => ({
             ...j,
+            ...((0, agent_runtime_controls_router_1.isRuntimeContinuationActive)(ctx(req), j.id) ? { status: 'running', finished_at: null } : {}),
             hasTelemetry: jobsWithTelemetry.has(j.id),
         }));
         res.json({ jobs: annotatedJobs, total: result.total });
@@ -593,7 +599,7 @@ function registerJobsRoutes(deps) {
             interactiveAcceptingTurns = qmMode !== null || loopStepActive || loopPaused;
             interactiveSettleMode = qmMode ?? ((loopStepActive || loopPaused || loopRun) ? 'auto' : null);
         }
-        const annotated = { ...job, hasTelemetry: (0, db_1.hasJobTelemetry)(db, jobId), tickets, interactiveSettleMode, interactiveAcceptingTurns, loopPaused, loopPauseReason };
+        const annotated = { ...job, ...((0, agent_runtime_controls_router_1.isRuntimeContinuationActive)(c, jobId) ? { status: 'running', finished_at: null } : {}), hasTelemetry: (0, db_1.hasJobTelemetry)(db, jobId), tickets, interactiveSettleMode, interactiveAcceptingTurns, loopPaused, loopPauseReason };
         res.json({ job: annotated, events, phaseDefinitions });
     });
     router.delete('/:projectId/jobs', (req, res) => {

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

@@ -19,7 +19,11 @@ const terminal_settings_1 = require("./terminal-settings");
 const terminal_marks_store_1 = require("./terminal-marks-store");
 const project_router_helpers_1 = require("./project-router-helpers");
 const install_config_path_1 = require("./install-config-path");
+const agent_runtime_settings_router_1 = require("./agent-runtime-settings-router");
+const agent_runtime_controls_router_1 = require("./agent-runtime-controls-router");
 function registerSettingsRoutes(deps) {
+    (0, agent_runtime_settings_router_1.registerAgentRuntimeSettingsRoutes)(deps);
+    (0, agent_runtime_controls_router_1.registerAgentRuntimeControlRoutes)(deps);
     const { router, registry, ctx, ticketPath } = deps;
     // ─── Project settings (pipeline telemetry) ───────────────────────────────────
     router.get('/:projectId/settings', (req, res) => {

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

@@ -271,7 +271,7 @@ function registerTicketsRoutes(deps) {
         const rawScope = req.body?.contextScope;
         // Contract Layer is available only when the selected adapter advertises a
         // safe structured-action implementation.
-        const quickContractRefine = (0, providers_1.getAdapter)(provider).capabilities.structuredActions !== true
+        const quickContractRefine = !(0, runtime_1.supportsContractRefine)((0, providers_1.getAdapter)(provider))
             ? false
             : typeof req.body?.contractRefine === 'boolean'
                 ? req.body.contractRefine
@@ -1057,7 +1057,7 @@ function registerTicketsRoutes(deps) {
             if (conversationId &&
                 created &&
                 convoProvider &&
-                (0, providers_1.getAdapter)(convoProvider).capabilities.structuredActions === true) {
+                (0, runtime_1.supportsContractRefine)((0, providers_1.getAdapter)(convoProvider))) {
                 const createdTicketId = created.id;
                 const convoId = conversationId;
                 console.log(`[project-router] from-draft hook: scheduling refine ticket=${createdTicketId} conv=${convoId}`);
@@ -1093,7 +1093,7 @@ function registerTicketsRoutes(deps) {
                 const requestedAgentProvider = typeof body.agentProvider === 'string' ? body.agentProvider : null;
                 const providerCheck = (0, provider_selection_1.validateRequestedProvider)(project, requestedAgentProvider);
                 const refineProvider = providerCheck.ok ? providerCheck.provider : null;
-                if (refineProvider && (0, providers_1.getAdapter)(refineProvider).capabilities.structuredActions === true) {
+                if (refineProvider && (0, runtime_1.supportsContractRefine)((0, providers_1.getAdapter)(refineProvider))) {
                     const refineTicketId = created.id;
                     const refineTitle = created.title;
                     const refineDescription = created.description;
@@ -1262,7 +1262,7 @@ function registerTicketsRoutes(deps) {
                 return;
             }
             const refineProvider = refineProviderCheck.provider;
-            if ((0, providers_1.getAdapter)(refineProvider).capabilities.structuredActions !== true) {
+            if (!(0, runtime_1.supportsContractRefine)((0, providers_1.getAdapter)(refineProvider))) {
                 res.status(409).json({ error: `contract_refine_unsupported_for_${refineProvider}` });
                 return;
             }