specrails-desktop 2.46.0 → 2.48.0

package/server/dist/providers/index.js

@@ -7,7 +7,7 @@
 //
 // Spec: openspec/specs/multi-provider-architecture/spec.md
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnknownProviderError = exports.CUSTOM_MODEL_ALIAS_MAX_LENGTH = exports.isSafeCustomModelAlias = exports.isModelAvailableForAdapter = exports.isReasoningEffortValidForModel = exports.defaultReasoningEffortForModel = exports.reasoningEffortsForModel = exports.requireToolPolicy = exports.pureOutputToolPolicy = exports.supportsToolPolicy = exports.parseStreamEvents = exports.buildProviderRepoAccessArgs = exports.formatProviderCommand = exports.buildProviderEnv = exports.kimiAdapter = exports.geminiAdapter = exports.codexAdapter = exports.claudeAdapter = exports.listAdapters = exports.hasAdapter = exports.getAdapter = void 0;
+exports.UnknownProviderError = exports.CUSTOM_MODEL_ALIAS_MAX_LENGTH = exports.isSafeCustomModelAlias = exports.isModelAvailableForAdapter = exports.isReasoningEffortValidForModel = exports.defaultReasoningEffortForModel = exports.reasoningEffortsForModel = exports.requireToolPolicy = exports.pureOutputToolPolicy = exports.supportsToolPolicy = exports.parseStreamEvents = exports.buildProviderRepoAccessArgs = exports.formatProviderCommand = exports.buildProviderEnv = exports.kimiAdapter = exports.geminiAdapter = exports.codexAdapter = exports.claudeAdapter = exports.adapterKind = exports.isLocalAdapterId = exports.unregisterAdapter = exports.listAdapters = exports.hasAdapter = exports.getAdapter = void 0;
 const registry_1 = require("./registry");
 const claude_adapter_1 = require("./claude-adapter");
 Object.defineProperty(exports, "claudeAdapter", { enumerable: true, get: function () { return claude_adapter_1.claudeAdapter; } });
@@ -25,6 +25,9 @@ var registry_2 = require("./registry");
 Object.defineProperty(exports, "getAdapter", { enumerable: true, get: function () { return registry_2.getAdapter; } });
 Object.defineProperty(exports, "hasAdapter", { enumerable: true, get: function () { return registry_2.hasAdapter; } });
 Object.defineProperty(exports, "listAdapters", { enumerable: true, get: function () { return registry_2.listAdapters; } });
+Object.defineProperty(exports, "unregisterAdapter", { enumerable: true, get: function () { return registry_2.unregisterAdapter; } });
+Object.defineProperty(exports, "isLocalAdapterId", { enumerable: true, get: function () { return registry_2.isLocalAdapterId; } });
+Object.defineProperty(exports, "adapterKind", { enumerable: true, get: function () { return registry_2.adapterKind; } });
 var runtime_1 = require("./runtime");
 Object.defineProperty(exports, "buildProviderEnv", { enumerable: true, get: function () { return runtime_1.buildProviderEnv; } });
 Object.defineProperty(exports, "formatProviderCommand", { enumerable: true, get: function () { return runtime_1.formatProviderCommand; } });

package/server/dist/providers/local-adapter-registry.js

@@ -0,0 +1,56 @@
+"use strict";
+// Dynamic registration of local (OpenAI-compatible) adapters — one per
+// connection in `~/.specrails/runtime-providers.json`. Called at boot (after
+// the connections load) and after every successful `PUT /api/runtime-providers`.
+//
+// Kill switch: SPECRAILS_LOCAL_ENGINES=0|false|off ⇒ no registration, and any
+// previously registered local adapter is removed (byte-identical legacy).
+//
+// Spec: openspec/changes/local-ai-engines/specs/local-ai-engines/spec.md
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocalEnginesEnabled = isLocalEnginesEnabled;
+exports.listLocalAdapters = listLocalAdapters;
+exports.listLocalConnections = listLocalConnections;
+exports.syncLocalAdapters = syncLocalAdapters;
+const registry_1 = require("./registry");
+const local_adapter_1 = require("./local-adapter");
+function isLocalEnginesEnabled() {
+    const raw = (process.env.SPECRAILS_LOCAL_ENGINES ?? '').trim().toLowerCase();
+    return !(raw === '0' || raw === 'false' || raw === 'off');
+}
+/** Every currently registered local adapter, in registry order. */
+function listLocalAdapters() {
+    return (0, registry_1.listAdapters)().filter(local_adapter_1.isLocalAdapter);
+}
+/** The connections behind the registered local adapters. */
+function listLocalConnections() {
+    return listLocalAdapters().map((a) => a.localConnection);
+}
+function syncLocalAdapters(connections) {
+    const result = { registered: [], unregistered: [], skipped: [] };
+    const wanted = new Map();
+    if (isLocalEnginesEnabled()) {
+        for (const conn of connections) {
+            if (conn.kind !== 'openai-compatible' || typeof conn.baseUrl !== 'string')
+                continue;
+            if ((0, registry_1.hasAdapter)(conn.id) && (0, registry_1.adapterKind)(conn.id) !== 'local') {
+                result.skipped.push(conn.id);
+                continue;
+            }
+            wanted.set(conn.id, conn);
+        }
+    }
+    for (const existing of listLocalAdapters()) {
+        if (!wanted.has(existing.id)) {
+            if ((0, registry_1.unregisterAdapter)(existing.id))
+                result.unregistered.push(existing.id);
+        }
+    }
+    for (const [id, conn] of wanted) {
+        // Re-register on every sync so a changed baseUrl/rates/label takes effect;
+        // in-flight jobs keep the adapter instance they resolved earlier.
+        (0, registry_1.register)((0, local_adapter_1.createLocalAdapter)({ ...conn }), 'local');
+        result.registered.push(id);
+    }
+    return result;
+}

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

@@ -0,0 +1,426 @@
+"use strict";
+// Local (OpenAI-compatible) engine adapter.
+//
+// One adapter instance PER CONNECTION (`~/.specrails/runtime-providers.json`,
+// `kind: 'openai-compatible'`), registered dynamically by
+// `local-adapter-registry.ts`. The engine is the bundled local agent runner
+// (`local-runner/` → `src-tauri/binaries/specrails-local-runner.js`) executed
+// by the bundled Node — spawned exactly like a CLI so every manager's
+// spawn/stream/settle path is reused unchanged (design D1).
+//
+// The runner speaks a claude-shaped `stream-json` dialect (design D2). This
+// adapter owns its OWN frame parser — deliberately NOT an import of the claude
+// parser — so claude-specific heuristics (notification frames, alias pinning,
+// background tasks) never leak in and a claude parser change can't silently
+// break local engines. `total_cost_usd` is never present.
+//
+// Spec: openspec/changes/local-ai-engines/specs/local-ai-engines/spec.md
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCAL_REASONING_EFFORTS = exports.LOCAL_PROJECT_DIR = void 0;
+exports.isLocalAdapter = isLocalAdapter;
+exports.resolveLocalRunnerScript = resolveLocalRunnerScript;
+exports.resolveLocalRunnerNode = resolveLocalRunnerNode;
+exports.filterLocalExtraArgs = filterLocalExtraArgs;
+exports.parseLocalStreamLine = parseLocalStreamLine;
+exports.extractLocalResult = extractLocalResult;
+exports.createLocalAdapter = createLocalAdapter;
+exports.localConnectionRates = localConnectionRates;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const path_resolver_1 = require("../path-resolver");
+const win_spawn_1 = require("../util/win-spawn");
+const local_engine_detection_1 = require("../local-engine-detection");
+function isLocalAdapter(adapter) {
+    return typeof adapter.localConnection === 'object'
+        && adapter.localConnection !== null;
+}
+exports.LOCAL_PROJECT_DIR = '.specrails-local';
+exports.LOCAL_REASONING_EFFORTS = ['low', 'medium', 'high'];
+function fileExists(p) {
+    try {
+        return fs_1.default.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+const RUNNER_RELS = [
+    path_1.default.join('src-tauri', 'binaries', 'specrails-local-runner.js'),
+    path_1.default.join('local-runner', 'dist', 'specrails-local-runner.js'),
+];
+/**
+ * Absolute path to the bundled runner script (mirrors the MCP bridge resolution
+ * in agent-mcp-config.ts): `SPECRAILS_BUNDLED_LOCAL_RUNNER_PATH`, then the
+ * staged `src-tauri/binaries/` copy, then the `local-runner/dist/` build
+ * output. Returns null when none exists.
+ */
+function resolveLocalRunnerScript() {
+    const fromEnv = process.env.SPECRAILS_BUNDLED_LOCAL_RUNNER_PATH;
+    if (fromEnv) {
+        const cleaned = (0, win_spawn_1.stripWindowsVerbatimPrefix)(fromEnv);
+        if (fileExists(cleaned))
+            return cleaned;
+    }
+    const roots = [
+        path_1.default.resolve(__dirname, '..', '..'),
+        path_1.default.resolve(__dirname, '..', '..', '..'),
+        process.cwd(),
+    ];
+    for (const root of roots) {
+        for (const rel of RUNNER_RELS) {
+            const candidate = path_1.default.join(root, rel);
+            if (fileExists(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+/** Deterministic argv[0] even when the build output is absent (spawn then
+ *  fails with a clear "no such file" instead of an undefined argument). */
+function runnerScriptOrDefault() {
+    return resolveLocalRunnerScript() ?? path_1.default.resolve(__dirname, '..', '..', RUNNER_RELS[0]);
+}
+/** The node executable that runs the runner (bundled in the packaged app, else PATH `node`). */
+function resolveLocalRunnerNode() {
+    return (0, path_resolver_1.resolveBundledNodeExe)() ?? 'node';
+}
+// ─── extraArgs allowlist ─────────────────────────────────────────────────────
+//
+// Managers forward provider-shaped extras through `extraArgs` (context-scope
+// tool flags, `--mcp-config`, repo access, codex plugin `-c` pairs, the claude
+// openspec `--plugin-dir`…). The runner fails fast on unknown flags, so only
+// the flags it understands pass; everything else is dropped WITH its value.
+const RUNNER_VALUE_FLAGS = new Set([
+    '--tools', '--disallowedTools', '--mcp-config', '--add-dir', '--max-turns',
+    '--model', '--resume', '--system-prompt', '--append-system-prompt',
+    '--reasoning-effort', '--base-url', '--api-key-env',
+]);
+/** Flags foreign to the runner that carry a value (drop flag + value). */
+const FOREIGN_VALUE_FLAGS = new Set([
+    '--setting-sources', '--permission-mode', '--effort', '--plugin-dir', '-c',
+    '--allowedTools', '--output-format', '--input-format', '--approval-mode',
+    '--sandbox', '-i', '--image', '-m', '-S', '--session',
+]);
+function filterLocalExtraArgs(extra) {
+    if (!extra || extra.length === 0)
+        return [];
+    const out = [];
+    for (let i = 0; i < extra.length; i++) {
+        const token = extra[i];
+        if (RUNNER_VALUE_FLAGS.has(token)) {
+            if (i + 1 < extra.length) {
+                out.push(token, extra[i + 1]);
+                i++;
+            }
+            continue;
+        }
+        if (FOREIGN_VALUE_FLAGS.has(token)) {
+            if (i + 1 < extra.length && !extra[i + 1].startsWith('-'))
+                i++;
+            continue;
+        }
+        // Any other flag (`--dangerously-skip-permissions`, `--safe-mode`,
+        // `--verbose`, `--yolo`, …) or stray positional token is dropped.
+    }
+    return out;
+}
+// ─── argv ────────────────────────────────────────────────────────────────────
+function toolPolicyArgs(policy) {
+    if (policy === 'none')
+        return ['--tools', '__none__'];
+    if (policy === 'read-only')
+        return ['--tools', 'Read,Grep,Glob'];
+    return [];
+}
+function buildLocalArgs(connection, action, opts) {
+    const script = runnerScriptOrDefault();
+    const args = [script];
+    const effectiveOpts = action === 'auto-title' ? { ...opts, toolPolicy: 'none' } : opts;
+    const common = () => [
+        '--model', effectiveOpts.model || connection.defaultModel || 'default',
+        '--base-url', connection.baseUrl,
+        ...(connection.apiKeyEnv ? ['--api-key-env', connection.apiKeyEnv] : []),
+        ...toolPolicyArgs(effectiveOpts.toolPolicy),
+        ...(connection.supportsReasoningEffort && effectiveOpts.reasoning_effort
+            ? ['--reasoning-effort', effectiveOpts.reasoning_effort]
+            : []),
+        '--output-format', 'stream-json',
+    ];
+    const extras = filterLocalExtraArgs(effectiveOpts.extraArgs);
+    const maxTurns = effectiveOpts.maxTurns != null ? ['--max-turns', String(effectiveOpts.maxTurns)] : [];
+    switch (action) {
+        case 'chat-turn':
+            args.push(...common());
+            if (opts.systemPrompt)
+                args.push('--system-prompt', opts.systemPrompt);
+            args.push(...maxTurns, '-p', opts.prompt, ...extras);
+            return args;
+        case 'chat-resume':
+            if (!opts.sessionId)
+                throw new Error('chat-resume requires sessionId');
+            args.push(...common());
+            if (opts.systemPrompt)
+                args.push('--system-prompt', opts.systemPrompt);
+            args.push('--resume', opts.sessionId, ...maxTurns, '-p', opts.prompt, ...extras);
+            return args;
+        case 'chat-stream':
+            // Persistent multi-turn: the prompt arrives over stdin, one line per turn.
+            // `--max-turns` omitted on purpose (it would end the whole session).
+            args.push(...common());
+            if (opts.systemPrompt)
+                args.push('--system-prompt', opts.systemPrompt);
+            if (opts.sessionId)
+                args.push('--resume', opts.sessionId);
+            args.push('--input-format', 'stream-json', ...extras);
+            return args;
+        case 'rail-job':
+            // The slash command carries its own framing; ADD to it, never overwrite.
+            args.push(...common());
+            if (opts.systemPrompt)
+                args.push('--append-system-prompt', opts.systemPrompt);
+            args.push('-p', opts.prompt, ...extras);
+            return args;
+        case 'spec-gen':
+            args.push(...common(), ...maxTurns);
+            if (opts.systemPrompt)
+                args.push('--system-prompt', opts.systemPrompt);
+            args.push('-p', opts.prompt, ...extras);
+            return args;
+        case 'agent-refine':
+            args.push(...common());
+            if (opts.sessionId)
+                args.push('--resume', opts.sessionId);
+            args.push('-p', opts.prompt, ...extras);
+            return args;
+        case 'setup-enrich':
+            args.push('-p', opts.prompt, ...common(), ...extras);
+            return args;
+        case 'setup-enrich-resume':
+            if (!opts.sessionId)
+                throw new Error('setup-enrich-resume requires sessionId');
+            args.push('--resume', opts.sessionId, ...common(), '-p', opts.prompt, ...extras);
+            return args;
+        case 'auto-title':
+            args.push(...common(), '-p', opts.prompt);
+            return args;
+    }
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function withUsage(ev, msg) {
+    const usage = msg?.usage;
+    if (!usage || typeof usage !== 'object')
+        return ev;
+    const carrier = ev;
+    carrier.usage = usage;
+    if (typeof msg?.id === 'string')
+        carrier.messageId = msg.id;
+    if (typeof msg?.model === 'string')
+        carrier.model = msg.model;
+    return ev;
+}
+function parseLocalStreamLine(line) {
+    if (line.length === 0)
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const type = parsed.type;
+    if (!type)
+        return { kind: 'other', type: '<missing>', raw: parsed };
+    if (type === 'system' || type === 'init') {
+        const sid = parsed.session_id;
+        if (sid)
+            return { kind: 'session-started', sessionId: sid };
+        return { kind: 'other', type, raw: parsed };
+    }
+    if (type === 'result') {
+        const result = { kind: 'result', payload: parsed, ...(parsed.is_error === true ? { isError: true } : {}) };
+        // The runner puts the endpoint/loop failure text in `result` when
+        // `is_error` is set (HTTP 4xx/5xx body, connection refused, max_turns…).
+        // Surface it as an explicit error event too, so every manager reports the
+        // real reason instead of a generic "returned no output".
+        const message = parsed.is_error === true && typeof parsed.result === 'string' && parsed.result.trim()
+            ? parsed.result.trim().slice(0, 600)
+            : null;
+        return message ? [{ kind: 'error', message }, result] : result;
+    }
+    if (type === 'error') {
+        const message = typeof parsed.message === 'string' ? parsed.message
+            : typeof parsed.error === 'string' ? parsed.error : 'local runner error';
+        return { kind: 'error', message };
+    }
+    if (type === 'assistant') {
+        const msg = parsed.message;
+        const blocks = Array.isArray(msg?.content) ? msg.content : [];
+        const text = blocks
+            .filter((b) => b.type === 'text')
+            .map((b) => (typeof b.text === 'string' ? b.text : ''))
+            .join('');
+        if (text)
+            return withUsage({ kind: 'text-delta', text }, msg);
+        const tool = blocks.find((b) => b.type === 'tool_use');
+        if (tool && typeof tool.name === 'string') {
+            const input = JSON.stringify(tool.input ?? {});
+            return withUsage({
+                kind: 'tool-use',
+                name: tool.name,
+                inputPreview: input.slice(0, 200),
+                ...(typeof tool.id === 'string' ? { toolUseId: tool.id } : {}),
+            }, msg);
+        }
+        return withUsage({ kind: 'other', type, raw: parsed }, msg);
+    }
+    if (type === 'user') {
+        const msg = parsed.message;
+        const blocks = Array.isArray(msg?.content) ? msg.content : [];
+        const resultBlock = blocks.find((b) => b.type === 'tool_result');
+        if (resultBlock) {
+            const content = resultBlock.content;
+            const text = typeof content === 'string'
+                ? content
+                : Array.isArray(content)
+                    ? content
+                        .filter((c) => c.type === 'text' && typeof c.text === 'string')
+                        .map((c) => c.text)
+                        .join('\n')
+                    : '';
+            return {
+                kind: 'tool-result',
+                outputPreview: text.slice(0, 600),
+                ...(typeof resultBlock.tool_use_id === 'string' ? { toolUseId: resultBlock.tool_use_id } : {}),
+                ...(resultBlock.is_error === true ? { isError: true } : {}),
+            };
+        }
+    }
+    return { kind: 'other', type, raw: parsed };
+}
+function extractLocalResult(events) {
+    let resultPayload = null;
+    let sessionId;
+    for (const ev of events) {
+        if (ev.kind === 'result')
+            resultPayload = ev.payload;
+        else if (ev.kind === 'session-started')
+            sessionId = ev.sessionId;
+    }
+    const usageFromAssistant = () => {
+        // No terminal `result` (killed/aborted). Reconstruct per message id,
+        // last snapshot wins; each distinct message is a separate API call.
+        const perMessage = new Map();
+        let model;
+        let anonymous = 0;
+        for (const ev of events) {
+            const carrier = ev;
+            if (!carrier.usage)
+                continue;
+            perMessage.set(carrier.messageId ?? `__anon-${anonymous++}`, carrier.usage);
+            if (carrier.model)
+                model = carrier.model;
+        }
+        if (perMessage.size === 0)
+            return { session_id: sessionId };
+        let tokensIn = 0, tokensOut = 0, cacheRead = 0, cacheCreate = 0;
+        for (const u of perMessage.values()) {
+            tokensIn += readNumber(u.input_tokens);
+            tokensOut += readNumber(u.output_tokens);
+            cacheRead += readNumber(u.cache_read_input_tokens);
+            cacheCreate += readNumber(u.cache_creation_input_tokens);
+        }
+        return { tokens_in: tokensIn, tokens_out: tokensOut, tokens_cache_read: cacheRead, tokens_cache_create: cacheCreate, model, session_id: sessionId };
+    };
+    if (!resultPayload)
+        return usageFromAssistant();
+    const usage = resultPayload.usage;
+    const finalSessionId = (typeof resultPayload.session_id === 'string' ? resultPayload.session_id : undefined) ?? sessionId;
+    const tokens = usage && typeof usage === 'object'
+        ? {
+            tokens_in: typeof usage.input_tokens === 'number' ? usage.input_tokens : undefined,
+            tokens_out: typeof usage.output_tokens === 'number' ? usage.output_tokens : undefined,
+            tokens_cache_read: typeof usage.cache_read_input_tokens === 'number' ? usage.cache_read_input_tokens : undefined,
+            tokens_cache_create: typeof usage.cache_creation_input_tokens === 'number' ? usage.cache_creation_input_tokens : undefined,
+        }
+        : (() => { const r = usageFromAssistant(); return { tokens_in: r.tokens_in, tokens_out: r.tokens_out, tokens_cache_read: r.tokens_cache_read, tokens_cache_create: r.tokens_cache_create }; })();
+    return {
+        ...tokens,
+        // NEVER total_cost_usd: local engines report no cost (design D9).
+        num_turns: typeof resultPayload.num_turns === 'number' ? resultPayload.num_turns : undefined,
+        model: typeof resultPayload.model === 'string' ? resultPayload.model : undefined,
+        duration_ms: typeof resultPayload.duration_ms === 'number' ? resultPayload.duration_ms : undefined,
+        duration_api_ms: typeof resultPayload.duration_api_ms === 'number' ? resultPayload.duration_api_ms : undefined,
+        session_id: finalSessionId,
+    };
+}
+// ─── factory ─────────────────────────────────────────────────────────────────
+function createLocalAdapter(connection) {
+    const supportsEffort = connection.supportsReasoningEffort === true;
+    const displayName = connection.label?.trim() || connection.id;
+    const adapter = {
+        id: connection.id,
+        displayName,
+        binary: resolveLocalRunnerNode(),
+        minCliVersion: null,
+        projectDirName: exports.LOCAL_PROJECT_DIR,
+        instructionsFilename: 'AGENTS.md',
+        mcpRegistration: 'project-json',
+        localConnection: connection,
+        capabilities: {
+            nativeResume: true,
+            nativeStreamJson: true,
+            nativeCostUsd: false,
+            reportsUsage: true,
+            nativeOtelEnv: false,
+            profileEnvSupport: false,
+            systemPromptArg: true,
+            persistentStdin: true,
+            supportsReasoningEffort: supportsEffort,
+            ...(supportsEffort ? { reasoningEfforts: exports.LOCAL_REASONING_EFFORTS } : {}),
+            supportsImageInput: false,
+            structuredActions: false,
+            toolPolicies: ['none', 'read-only'],
+            profiles: false,
+            customModelAliases: true,
+            customRoles: false,
+            freestyle: true,
+            userMcp: false,
+        },
+        modelCatalog: () => {
+            const cached = (0, local_engine_detection_1.getCachedModels)(connection.id);
+            if (cached.length === 0) {
+                const value = connection.defaultModel ?? 'default';
+                return [{ value, label: value, default: true }];
+            }
+            const stored = connection.defaultModel && cached.includes(connection.defaultModel) ? connection.defaultModel : cached[0];
+            return cached.map((value) => ({ value, label: value, ...(value === stored ? { default: true } : {}) }));
+        },
+        defaultModel: () => connection.defaultModel ?? (0, local_engine_detection_1.getCachedModels)(connection.id)[0] ?? 'default',
+        buildArgs: (action, opts) => buildLocalArgs(connection, action, opts),
+        parseStreamLine: parseLocalStreamLine,
+        extractResult: extractLocalResult,
+        formatCoreCommand: (command) => command,
+        buildRepoAccessArgs: (paths) => paths.flatMap((p) => ['--add-dir', p]),
+        projectMcpPath: (root) => path_1.default.join(root, exports.LOCAL_PROJECT_DIR, 'mcp.json'),
+        baselineAgents: () => ['sr-architect', 'sr-developer', 'sr-reviewer'],
+        detectInstalled: async () => {
+            const probe = await (0, local_engine_detection_1.probeConnection)({ baseUrl: connection.baseUrl, apiKeyEnv: connection.apiKeyEnv });
+            return {
+                installed: probe.installed,
+                executable: probe.executable,
+                ...(probe.error ? { error: probe.error } : {}),
+            };
+        },
+    };
+    return adapter;
+}
+/** Rates of a registered local adapter (null for CLI/unknown ids or no rates). */
+function localConnectionRates(adapter) {
+    return isLocalAdapter(adapter) ? adapter.localConnection.rates ?? null : null;
+}

package/server/dist/providers/registry.js

@@ -1,19 +1,40 @@
 "use strict";
-// In-process registry of ProviderAdapter instances. Adapter modules call
-// `register(this)` on module load; managers look up by id via `getAdapter`.
+// In-process registry of ProviderAdapter instances. CLI adapter modules call
+// `register(this)` on module load; local (OpenAI-compatible) adapters are
+// registered/unregistered DYNAMICALLY by `syncLocalAdapters` when connections
+// load or save. Managers look up by id via `getAdapter`.
 //
 // Spec: openspec/specs/multi-provider-architecture/spec.md
 //   - "Provider registry exposes lookup by id"
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.register = register;
+exports.unregisterAdapter = unregisterAdapter;
 exports.getAdapter = getAdapter;
 exports.hasAdapter = hasAdapter;
+exports.adapterKind = adapterKind;
+exports.isLocalAdapterId = isLocalAdapterId;
 exports.listAdapters = listAdapters;
 exports._clearForTests = _clearForTests;
 const types_1 = require("./types");
 const _registry = new Map();
-function register(adapter) {
+const _kinds = new Map();
+/** Register an adapter. `kind` defaults to `'cli'` (module-load registrations);
+ *  local adapters pass `'local'` so they can later be unregistered. */
+function register(adapter, kind = 'cli') {
     _registry.set(adapter.id, adapter);
+    _kinds.set(adapter.id, kind);
+}
+/**
+ * Remove a LOCAL adapter. CLI adapters (claude/codex/gemini/kimi — anything
+ * registered without `kind: 'local'`) are never removed: returns false and
+ * leaves them registered.
+ */
+function unregisterAdapter(id) {
+    if (_kinds.get(id) !== 'local')
+        return false;
+    _registry.delete(id);
+    _kinds.delete(id);
+    return true;
 }
 function getAdapter(id) {
     const adapter = _registry.get(id);
@@ -25,8 +46,21 @@ function getAdapter(id) {
 function hasAdapter(id) {
     return _registry.has(id);
 }
+/** Kind of a registered adapter, or null when unknown. */
+function adapterKind(id) {
+    return _kinds.get(id) ?? null;
+}
+/** True when `id` names a registered LOCAL (OpenAI-compatible) adapter. */
+function isLocalAdapterId(id) {
+    return !!id && _kinds.get(id) === 'local';
+}
+/** CLI adapters first (registration order), then local adapters. */
 function listAdapters() {
-    return Array.from(_registry.values());
+    const all = Array.from(_registry.values());
+    return [
+        ...all.filter((a) => _kinds.get(a.id) !== 'local'),
+        ...all.filter((a) => _kinds.get(a.id) === 'local'),
+    ];
 }
 /**
  * Reset the registry. Test-only — production code MUST NOT call this.
@@ -34,4 +68,5 @@ function listAdapters() {
  */
 function _clearForTests() {
     _registry.clear();
+    _kinds.clear();
 }

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

@@ -379,7 +379,7 @@ function branchRecords(results) {
  * fallback for these errors; execution stays bound to a verified worktree.
  */
 async function launchIsolatedRail(input, io = {}) {
-    const { ctx, railIndex, ticketIds, loopId, loopName, loopGraph, provider, model, effort } = input;
+    const { ctx, railIndex, ticketIds, loopId, loopName, loopGraph, provider, model, effort, deciderEngine } = input;
     let expectedRepositoryBaseSha = input.repositoryExecution?.expectedBaseSha;
     let singleRepositoryId = input.repositoryExecution?.repositoryId;
     if (!input.repositoryExecution) {
@@ -1187,6 +1187,7 @@ async function launchIsolatedRail(input, io = {}) {
         });
         const spec = ctx.getTicketSpec(a.ticketId);
         const enginePromise = ctx.loopRunManager.run({
+            runtimeProviderOverride: input.runtimeProviderOverride,
             runId: a.runId, loopId, loopName, graph: loopGraph, projectId: ctx.project.id,
             cwd: a.handle.worktreePath, repoDir: a.handle.worktreePath,
             repositoryId: singleRepositoryId,
@@ -1204,7 +1205,7 @@ async function launchIsolatedRail(input, io = {}) {
             },
             ticketCompletionStatus: runFinishedOpts.ticketCompletionStatus,
             deferTerminalOutcome: true,
-            constants, provider, model, effort,
+            constants, provider, model, effort, ...(deciderEngine ? { deciderEngine } : {}),
             profileName: input.profileName,
         });
         runPromises.push(settleAllocatedRun(a, enginePromise));
@@ -1610,7 +1611,7 @@ async function launchIsolatedRail(input, io = {}) {
         try {
             const outcomes = await (0, rail_merge_orchestrator_1.runMergeBack)({
                 git, executor: (0, loop_executors_1.createLoopExecutors)(), baseDir: baseRepo,
-                provider, model, effort, constants, branches,
+                provider, model, effort, ...(deciderEngine ? { deciderEngine } : {}), constants, branches,
                 // CRIT-2: record every merge-back AI step (verify/resolve-merge/fix) as a
                 // `surface='job'` invocation tied to the rail (surface_ref_id
                 // `${jobId}:merge:${step}`), primary ticket = ticketIds[0].