specrails-desktop 2.44.2 → 2.45.0

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAgentRuntimeSettingsRoutes = registerAgentRuntimeSettingsRoutes;
+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");
+const project_repositories_1 = require("./project-repositories");
+function registerAgentRuntimeSettingsRoutes({ router, ctx }) {
+    router.get('/:projectId/agent-runtime/config', (_req, res) => {
+        try {
+            const project = ctx(_req).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 });
+        }
+        catch (err) {
+            const validation = err instanceof agent_runtime_settings_1.AgentRuntimeConfigError;
+            res.status(validation ? 422 : 500).json({ error: validation ? 'invalid_runtime_config' : 'runtime_config_read_failed', message: validation ? err.message : 'Could not read runtime configuration' });
+        }
+    });
+    /** Offline detection of each repository's own checks; never invokes a model.
+     *  Verification stays optional: the architect proposes commands for uncovered
+     *  repositories at run time, and Core admits repositories without any check. */
+    router.get('/:projectId/agent-runtime/verification-suggestions', (req, res) => {
+        try {
+            const project = ctx(req).project;
+            const repositories = (0, project_repositories_1.getProjectRepositories)(project).map((repository) => ({ id: repository.id, name: repository.name, path: repository.path }));
+            res.json({ repositories: repositories.map(({ id, name }) => ({ id, name })), suggestions: (0, agent_runtime_verification_suggestions_1.suggestVerificationCommands)(repositories) });
+        }
+        catch {
+            res.status(500).json({ error: 'verification_suggestions_failed', message: 'Could not inspect the project repositories' });
+        }
+    });
+    router.put('/:projectId/agent-runtime/config', async (req, res) => {
+        try {
+            const config = (0, agent_runtime_settings_1.validateAgentRuntimeConfig)(req.body);
+            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);
+                }
+                catch {
+                    res.status(503).json({ error: 'runtime_incompatible', message: 'The installed Core runtime could not validate this configuration; update Core and retry' });
+                    return;
+                }
+            }
+            const saved = (0, agent_runtime_settings_1.saveAgentRuntimeConfig)(ctx(req).project, config);
+            res.json({ configured: true, config: saved, runtimeAvailable });
+        }
+        catch (err) {
+            const validation = err instanceof agent_runtime_settings_1.AgentRuntimeConfigError;
+            res.status(validation ? 400 : 500).json({ error: validation ? 'invalid_runtime_config' : 'runtime_config_write_failed', message: validation ? err.message : 'Could not save runtime configuration' });
+        }
+    });
+}

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

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentRuntimeConfigError = exports.REVIEW_THRESHOLD_FLOORS = void 0;
+exports.validateAgentRuntimeConfig = validateAgentRuntimeConfig;
+exports.defaultAgentRuntimeConfig = defaultAgentRuntimeConfig;
+exports.agentRuntimeConfigPath = agentRuntimeConfigPath;
+exports.loadAgentRuntimeConfig = loadAgentRuntimeConfig;
+exports.saveAgentRuntimeConfig = saveAgentRuntimeConfig;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+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"));
+const workspace_resolution_1 = require("./workspace-resolution");
+/** Core's own review gate. Configured thresholds may only tighten it (mirrors Core's config.ts). */
+exports.REVIEW_THRESHOLD_FLOORS = {
+    minScore: 70,
+    aspects: { type_correctness: 60, pattern_adherence: 60, test_coverage: 60, security: 75, architectural_alignment: 60 },
+};
+const CLI_PROVIDERS = ['claude', 'codex', 'gemini', 'kimi'];
+const ROLES = ['architect', 'developer', 'reviewer'];
+const schemaValidator = new ajv_1.default({ allErrors: true }).compile(agent_runtime_schema_json_1.default);
+class AgentRuntimeConfigError extends Error {
+    constructor(message) { super(message); this.name = 'AgentRuntimeConfigError'; }
+}
+exports.AgentRuntimeConfigError = AgentRuntimeConfigError;
+/** Vendored from Core's schema; parity tests keep offline configuration aligned.
+ *  Semantic checks mirror Core because JSON Schema cannot check provider refs. */
+function validateAgentRuntimeConfig(input) {
+    if (!schemaValidator(input)) {
+        const error = schemaValidator.errors?.[0];
+        throw new AgentRuntimeConfigError(`Invalid runtime configuration at ${error?.instancePath || '/'}: ${error?.message ?? 'invalid value'}`);
+    }
+    const config = input;
+    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) {
+        if (provider.kind !== 'openai-compatible')
+            continue;
+        let url;
+        try {
+            url = new URL(provider.baseUrl);
+        }
+        catch {
+            throw new AgentRuntimeConfigError('Provider base URL must be an absolute HTTP(S) URL');
+        }
+        if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash || provider.baseUrl.includes('\0'))
+            throw new AgentRuntimeConfigError('Provider URLs must use HTTP(S) without credentials, query parameters or fragments');
+    }
+    for (const role of ROLES) {
+        const agent = config.agents[role];
+        const provider = config.providers.find(({ id }) => id === agent.provider);
+        if (!provider)
+            throw new AgentRuntimeConfigError(`Role ${role} references a provider that is not configured`);
+        if (provider.kind === 'openai-compatible' && !agent.model)
+            throw new AgentRuntimeConfigError(`Role ${role} requires a model for its API provider`);
+        if (agent.model !== undefined && !agent.model.trim())
+            throw new AgentRuntimeConfigError(`Role ${role} requires a nonempty model identifier`);
+        if (agent.maxTurns !== undefined && !Number.isSafeInteger(agent.maxTurns))
+            throw new AgentRuntimeConfigError(`Role ${role} maxTurns must be a safe integer`);
+    }
+    for (const [key, value] of Object.entries(config.limits ?? {})) {
+        if (!Number.isFinite(value) || (key !== 'maxCostUsd' && !Number.isSafeInteger(value)))
+            throw new AgentRuntimeConfigError('Workflow limits must be finite, safe numbers');
+    }
+    for (const command of config.verification) {
+        if (![command.command, ...command.args, ...(command.cwd === undefined ? [] : [command.cwd])].every((value) => !value.includes('\0')) || !command.command.trim() || (command.cwd !== undefined && !command.cwd.trim()))
+            throw new AgentRuntimeConfigError('Verification command contains an empty or invalid value');
+        if (command.timeoutMs !== undefined && !Number.isSafeInteger(command.timeoutMs))
+            throw new AgentRuntimeConfigError('Verification timeout must be a safe integer');
+        for (const [key, value] of Object.entries(command.env ?? {})) {
+            if (/(?:token|secret|password|api_?key|credential)/i.test(key))
+                throw new AgentRuntimeConfigError('Verification credentials must be inherited from environment variables, never saved');
+            if (value.includes('\0'))
+                throw new AgentRuntimeConfigError('Verification environment contains an invalid value');
+        }
+    }
+    if (config.review?.minScore !== undefined && config.review.minScore < exports.REVIEW_THRESHOLD_FLOORS.minScore)
+        throw new AgentRuntimeConfigError(`Review threshold review.minScore must be at least ${exports.REVIEW_THRESHOLD_FLOORS.minScore} (Core's own review gate)`);
+    for (const [aspect, value] of Object.entries(config.review?.aspects ?? {})) {
+        if (value < exports.REVIEW_THRESHOLD_FLOORS.aspects[aspect])
+            throw new AgentRuntimeConfigError(`Review threshold review.aspects.${aspect} must be at least ${exports.REVIEW_THRESHOLD_FLOORS.aspects[aspect]} (Core's own review gate)`);
+    }
+    return structuredClone(config);
+}
+function defaultAgentRuntimeConfig(project) {
+    const provider = CLI_PROVIDERS.includes(project.provider) ? project.provider : 'claude';
+    return {
+        schemaVersion: 1, enabled: false,
+        providers: CLI_PROVIDERS.map((cli) => ({ id: cli, kind: 'cli', cli })),
+        agents: { architect: { provider }, developer: { provider }, reviewer: { provider } },
+        verification: [],
+    };
+}
+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;
+    try {
+        text = node_fs_1.default.readFileSync(agentRuntimeConfigPath(project), 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new AgentRuntimeConfigError('Saved runtime configuration is not valid JSON');
+    }
+    return validateAgentRuntimeConfig(parsed);
+}
+/** Atomic replacement works on macOS and Windows, with no partial file on errors. */
+function saveAgentRuntimeConfig(project, input) {
+    const config = validateAgentRuntimeConfig(input);
+    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`;
+    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);
+    }
+    finally {
+        node_fs_1.default.rmSync(temporary, { force: true });
+    }
+    return config;
+}

package/server/dist/agent-runtime-verification-suggestions.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestVerificationCommands = suggestVerificationCommands;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const NPM_TEST_PLACEHOLDER = /no test specified/i;
+/** Script names worth running as verification, in priority order. Only scripts
+ *  that exist in the repository are proposed; nothing is invented. */
+const SCRIPT_CANDIDATES = [
+    { names: ['test', 'test:unit', 'test:ci'], label: 'test script' },
+    { names: ['typecheck', 'type-check', 'types', 'check-types'], label: 'type check script' },
+    { names: ['lint'], label: 'lint script' },
+];
+const BUILD_SCRIPTS = ['build', 'compile'];
+function exists(root, ...parts) {
+    try {
+        return node_fs_1.default.existsSync(node_path_1.default.join(root, ...parts));
+    }
+    catch {
+        return false;
+    }
+}
+function readJson(file) {
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(file, 'utf8'));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function packageManager(root) {
+    if (exists(root, 'pnpm-lock.yaml'))
+        return 'pnpm';
+    if (exists(root, 'yarn.lock'))
+        return 'yarn';
+    if (exists(root, 'bun.lockb') || exists(root, 'bun.lock'))
+        return 'bun';
+    return 'npm';
+}
+function runScript(manager, script) {
+    // `npm test` and `npm run <x>` are the portable forms; on Windows the npm
+    // shim is resolved by Core's verification runner, never through a shell.
+    if (script === 'test')
+        return { command: manager, args: ['test'] };
+    return { command: manager, args: ['run', script] };
+}
+function nodeSuggestions(repository) {
+    const pkg = readJson(node_path_1.default.join(repository.path, 'package.json'));
+    if (!pkg)
+        return [];
+    const scripts = pkg.scripts && typeof pkg.scripts === 'object' && !Array.isArray(pkg.scripts) ? pkg.scripts : {};
+    const manager = packageManager(repository.path);
+    const out = [];
+    for (const candidate of SCRIPT_CANDIDATES) {
+        const name = candidate.names.find((script) => typeof scripts[script] === 'string' && String(scripts[script]).trim() && !NPM_TEST_PLACEHOLDER.test(String(scripts[script])));
+        if (name)
+            out.push({ repositoryId: repository.id, ...runScript(manager, name), reason: `package.json ${candidate.label} "${name}"` });
+    }
+    if (!out.length) {
+        const build = BUILD_SCRIPTS.find((script) => typeof scripts[script] === 'string' && String(scripts[script]).trim());
+        if (build)
+            out.push({ repositoryId: repository.id, ...runScript(manager, build), reason: `package.json build script "${build}" (no test or type check script found)` });
+    }
+    return out;
+}
+function otherSuggestions(repository) {
+    const root = repository.path;
+    const windows = process.platform === 'win32';
+    const out = [];
+    const add = (command, args, reason) => out.push({ repositoryId: repository.id, command, args, reason });
+    if (exists(root, 'Cargo.toml'))
+        add('cargo', ['test'], 'Cargo.toml');
+    if (exists(root, 'go.mod'))
+        add('go', ['test', './...'], 'go.mod');
+    if (exists(root, 'pyproject.toml') || exists(root, 'pytest.ini') || exists(root, 'setup.cfg') || exists(root, 'tox.ini')) {
+        if (exists(root, 'tests') || exists(root, 'test') || exists(root, 'pytest.ini'))
+            add(windows ? 'python' : 'python3', ['-m', 'pytest'], 'Python project with a tests directory');
+    }
+    if (exists(root, 'mix.exs'))
+        add('mix', ['test'], 'mix.exs');
+    if (exists(root, 'Package.swift'))
+        add('swift', ['test'], 'Package.swift');
+    if (exists(root, 'Gemfile') && exists(root, 'spec'))
+        add('bundle', ['exec', 'rspec'], 'Gemfile with a spec directory');
+    if (exists(root, 'pom.xml'))
+        add(exists(root, windows ? 'mvnw.cmd' : 'mvnw') ? (windows ? 'mvnw.cmd' : './mvnw') : 'mvn', ['-q', 'test'], 'pom.xml');
+    if (exists(root, 'build.gradle') || exists(root, 'build.gradle.kts'))
+        add(exists(root, windows ? 'gradlew.bat' : 'gradlew') ? (windows ? 'gradlew.bat' : './gradlew') : 'gradle', ['test'], 'Gradle build');
+    try {
+        if (node_fs_1.default.readdirSync(root).some((name) => /\.(sln|csproj|fsproj)$/i.test(name)))
+            add('dotnet', ['test'], '.NET solution or project');
+    }
+    catch { /* unreadable root: nothing to suggest */ }
+    if (!out.length && !windows && exists(root, 'Makefile')) {
+        try {
+            if (/^test\s*:/m.test(node_fs_1.default.readFileSync(node_path_1.default.join(root, 'Makefile'), 'utf8')))
+                add('make', ['test'], 'Makefile test target');
+        }
+        catch { /* ignore */ }
+    }
+    return out;
+}
+/** Deterministic, offline detection of a repository's own checks. Repositories
+ *  with nothing recognisable produce no entry: the architect proposes commands
+ *  at run time, and Core admits repositories that have no automated check. */
+function suggestVerificationCommands(repositories) {
+    const out = [];
+    for (const repository of repositories) {
+        if (!repository.path || !node_fs_1.default.existsSync(repository.path))
+            continue;
+        const node = nodeSuggestions(repository);
+        out.push(...(node.length ? node : otherSuggestions(repository)));
+    }
+    return out;
+}

package/server/dist/core-execution.js

@@ -6,8 +6,9 @@ exports.checkCoreCompletion = checkCoreCompletion;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const path_resolver_1 = require("./path-resolver");
+const core_node_runtime_1 = require("./core-node-runtime");
 const core_update_state_1 = require("./core-update-state");
+const agent_runtime_loader_1 = require("./agent-runtime-loader");
 const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 // Resolve existing ancestors too: the tickets file may not exist yet, and macOS
 // exposes temporary directories through both /var and /private/var.
@@ -35,7 +36,7 @@ function prepareCoreExecution(input) {
     (0, core_update_state_1.assertWorkspaceCoreReady)(cwd);
     const repositories = manifest
         ? manifest.repositories.map(repo => ({ id: repo.repositoryId, name: repo.name, path: (0, node_fs_1.realpathSync)(repo.worktreePath), baseSha: repo.baseSha }))
-        : [{ id: run.repositoryId ?? (run.spec?.repositoryIds?.length === 1 ? run.spec.repositoryIds[0] : 'primary'), name: (0, node_path_1.basename)(input.repoDir ?? cwd), path: (0, node_fs_1.realpathSync)(input.repoDir ?? cwd) }];
+        : [{ id: run.repositoryId ?? (run.spec?.repositoryIds?.length === 1 ? run.spec.repositoryIds[0] : run.projectId ? `primary-${run.projectId}` : 'primary'), name: (0, node_path_1.basename)(input.repoDir ?? cwd), path: (0, node_fs_1.realpathSync)(input.repoDir ?? cwd) }];
     if (!repositories.length || repositories.some(repo => !SAFE_ID.test(repo.id)))
         throw new Error('Invalid Core repository scope');
     const artifactRepositoryId = manifest?.artifactRepositoryId ?? repositories[0].id;
@@ -91,7 +92,7 @@ function coreVerificationContext(contextPath, cwd, env, runId) {
     if (!(0, node_fs_1.existsSync)(helper))
         return '';
     try {
-        const stdout = (0, node_child_process_1.execFileSync)((0, path_resolver_1.resolveBundledNodeExe)() ?? process.execPath, [helper, 'status', '--context', contextPath], {
+        const stdout = (0, node_child_process_1.execFileSync)((0, core_node_runtime_1.resolveCoreNodeRuntime)(), [helper, 'status', '--context', contextPath], {
             cwd, env, encoding: 'utf8', timeout: 15_000, maxBuffer: 4 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'],
         });
         const status = JSON.parse(stdout);
@@ -115,14 +116,18 @@ function coreVerificationContext(contextPath, cwd, env, runId) {
  * revalidate the journal on disk before Desktop accepts the implementation step,
  * including when an agent claims PASS after its final receipt went stale. */
 function checkCoreCompletion(contextPath, cwd, env, runId) {
-    const helper = (0, node_path_1.join)(cwd, '.specrails', 'runtime', 'pipeline.mjs');
-    if (!(0, node_fs_1.existsSync)(helper))
+    const programmatic = (0, node_fs_1.existsSync)((0, node_path_1.join)((0, node_path_1.dirname)(contextPath), 'agent-runtime-request.json'));
+    const helper = programmatic ? (0, agent_runtime_loader_1.findCoreAgentRuntimeCli)() : (0, node_path_1.join)(cwd, '.specrails', 'runtime', 'pipeline.mjs');
+    if (!helper || !(0, node_fs_1.existsSync)(helper))
         return { valid: false, reason: 'Core completion cannot be validated: pipeline runtime is missing' };
     try {
-        const stdout = (0, node_child_process_1.execFileSync)((0, path_resolver_1.resolveBundledNodeExe)() ?? process.execPath, [helper, 'status', '--context', contextPath], {
+        const stdout = (0, node_child_process_1.execFileSync)((0, core_node_runtime_1.resolveCoreNodeRuntime)(), [helper, 'status', '--context', contextPath, ...(programmatic ? ['--compact'] : [])], {
             cwd, env, encoding: 'utf8', timeout: 15_000, maxBuffer: 4 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'],
         });
-        const status = JSON.parse(stdout);
+        const payload = JSON.parse(stdout);
+        if (programmatic && payload.state?.status !== 'succeeded')
+            return { valid: false, reason: 'Programmatic workflow has not completed successfully' };
+        const status = (programmatic ? payload.pipeline : payload);
         if (status.schemaVersion !== 1 || status.runId !== runId)
             return { valid: false, reason: 'Core completion returned an invalid or mismatched run identity' };
         const reasons = [];
@@ -146,7 +151,11 @@ function checkCoreCompletion(contextPath, cwd, env, runId) {
         if (status.resumePhase && ['architect', 'developer', 'reviewer', 'archive'].includes(status.resumePhase))
             reasons.push(`resume from ${status.resumePhase}`);
         const receipt = status.verification?.receipt;
-        if (status.verification?.valid !== true || receipt?.kind !== 'full' || !receipt.commands?.length || receipt.commands.some(command => command.exitCode !== 0)) {
+        // A full receipt may explicitly record repositories without any automated
+        // check (the runtime admits them); an empty command list without that record
+        // is still no evidence.
+        const admittedWithoutCommands = Array.isArray(receipt?.unverifiedRepositories) && receipt.unverifiedRepositories.length > 0;
+        if (status.verification?.valid !== true || receipt?.kind !== 'full' || !Array.isArray(receipt.commands) || (!receipt.commands.length && !admittedWithoutCommands) || receipt.commands.some(command => command.exitCode !== 0)) {
             reasons.push(...(status.verification?.reasons?.length ? status.verification.reasons : ['No valid full verification receipt']));
         }
         return reasons.length ? { valid: false, reason: `Core completion blocked: ${[...new Set(reasons)].join('; ')}` } : { valid: true };

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/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,26 @@ 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 && (0, agent_runtime_bridge_1.selectAgentRuntime)(runtimeConfigPath(cwd), existingContext)) || (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)) {
+                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,
+                    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 +460,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 && (0, agent_runtime_bridge_1.selectAgentRuntime)(runtimeConfigPath(cwd), contextPath)) || existsRuntimeRequest(contextPath))
+                    return null;
+            }
             if (!(0, feature_flags_1.isInteractiveJobsEnabled)())
                 return null;
             const adapter = (0, providers_1.getAdapter)(provider);
@@ -490,8 +526,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: [