specrails-desktop 2.30.2 → 2.31.0

package/server/dist/providers/runtime.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUSTOM_MODEL_ALIAS_MAX_LENGTH = void 0;
+exports.isSafeCustomModelAlias = isSafeCustomModelAlias;
+exports.isModelAvailableForAdapter = isModelAvailableForAdapter;
+exports.supportsToolPolicy = supportsToolPolicy;
+exports.pureOutputToolPolicy = pureOutputToolPolicy;
+exports.requireToolPolicy = requireToolPolicy;
+exports.reasoningEffortsForModel = reasoningEffortsForModel;
+exports.defaultReasoningEffortForModel = defaultReasoningEffortForModel;
+exports.isReasoningEffortValidForModel = isReasoningEffortValidForModel;
+exports.buildProviderEnv = buildProviderEnv;
+exports.formatProviderCommand = formatProviderCommand;
+exports.buildProviderRepoAccessArgs = buildProviderRepoAccessArgs;
+exports.parseStreamEvents = parseStreamEvents;
+/**
+ * Conservative grammar for provider-configured model aliases passed as the
+ * value immediately following a CLI model flag (for example Kimi's `-m`).
+ *
+ * Keep aliases shell-neutral even though Desktop spawns with argv arrays:
+ * no leading `-`, whitespace, controls, quoting, or unbounded values. Common
+ * provider/model forms such as `kimi-code/k3`, `team/model:v2`, and dotted
+ * registry ids remain valid and are preserved byte-for-byte after validation.
+ */
+exports.CUSTOM_MODEL_ALIAS_MAX_LENGTH = 128;
+const SAFE_CUSTOM_MODEL_ALIAS_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/:-]*$/;
+function isSafeCustomModelAlias(value) {
+    return typeof value === 'string'
+        && value.length > 0
+        && value.length <= exports.CUSTOM_MODEL_ALIAS_MAX_LENGTH
+        && SAFE_CUSTOM_MODEL_ALIAS_PATTERN.test(value);
+}
+/**
+ * Provider-aware model validation.
+ *
+ * Catalog entries are always accepted. Off-catalog values are accepted only
+ * when the adapter explicitly advertises configured aliases and the value
+ * satisfies the safe argv grammar above.
+ */
+function isModelAvailableForAdapter(adapter, value) {
+    if (typeof value !== 'string' || value.length === 0)
+        return false;
+    if (adapter.modelCatalog().some((model) => model.value === value))
+        return true;
+    return adapter.capabilities.customModelAliases === true
+        && isSafeCustomModelAlias(value);
+}
+/** Whether an adapter natively enforces the requested non-default boundary. */
+function supportsToolPolicy(adapter, policy) {
+    return (adapter.capabilities.toolPolicies ?? []).includes(policy);
+}
+/**
+ * Safest boundary for a pure-output transform. Prefer a true no-tools mode;
+ * read-only is an acceptable fallback when the CLI has no native `none`.
+ * `null` means the action must fail closed before a child is spawned.
+ */
+function pureOutputToolPolicy(adapter) {
+    if (supportsToolPolicy(adapter, 'none'))
+        return 'none';
+    if (supportsToolPolicy(adapter, 'read-only'))
+        return 'read-only';
+    return null;
+}
+/** Throw a stable, provider-identifying error for an unsupported boundary. */
+function requireToolPolicy(adapter, policy) {
+    if (!supportsToolPolicy(adapter, policy)) {
+        throw new Error(`provider_tool_policy_unsupported:${adapter.id}:${policy}`);
+    }
+    return policy;
+}
+/** Exact effort tiers accepted by a provider for the effective model. */
+function reasoningEffortsForModel(adapter, model) {
+    if (adapter.capabilities.supportsReasoningEffort !== true)
+        return [];
+    return adapter.reasoningEffortsForModel?.(model)
+        ?? adapter.capabilities.reasoningEfforts
+        ?? [];
+}
+/**
+ * Safe app default for a model: medium where available, otherwise high where
+ * available, then the first tier. Kimi K3's native default is high; preferring
+ * it over low keeps an omitted Desktop selection semantically identical to the
+ * upstream CLI without changing the ordered selector catalog.
+ */
+function defaultReasoningEffortForModel(adapter, model) {
+    const efforts = reasoningEffortsForModel(adapter, model);
+    if (efforts.includes('medium'))
+        return 'medium';
+    if (efforts.includes('high'))
+        return 'high';
+    return efforts[0];
+}
+/** Narrow an untrusted effort value against the model-specific catalog. */
+function isReasoningEffortValidForModel(adapter, model, value) {
+    return typeof value === 'string'
+        && reasoningEffortsForModel(adapter, model).includes(value);
+}
+/** Merge provider runtime overrides without mutating the caller or process.env. */
+function buildProviderEnv(adapter, opts, baseEnv = process.env) {
+    const merged = { ...baseEnv };
+    for (const [key, value] of Object.entries(adapter.buildEnv?.(opts) ?? {})) {
+        // Windows treats environment names case-insensitively. Remove every
+        // inherited casing before applying an adapter-owned override/deletion so
+        // `kimi_code_experimental_flag` cannot survive a scrub of the canonical
+        // `KIMI_CODE_EXPERIMENTAL_FLAG` (and likewise for reasoning effort).
+        const foldedKey = key.toLowerCase();
+        for (const inheritedKey of Object.keys(merged)) {
+            if (inheritedKey.toLowerCase() === foldedKey)
+                delete merged[inheritedKey];
+        }
+        if (value !== undefined)
+            merged[key] = value;
+    }
+    return merged;
+}
+/**
+ * Provider-native Core command/prompt, identity when no hook is declared.
+ * `cwd` points at the provider artifact root for adapters that must load the
+ * headless workflow content before spawn.
+ */
+function formatProviderCommand(adapter, command, cwd, sessionId) {
+    return adapter.formatCoreCommand?.(command, cwd, sessionId) ?? command;
+}
+/** Flatten provider-native access flags for additional repository roots. */
+function buildProviderRepoAccessArgs(adapter, paths) {
+    return adapter.buildRepoAccessArgs?.(paths) ?? [];
+}
+/**
+ * Normalize an adapter's single-or-batch parser contract into an event list.
+ * One JSONL record may contain assistant text and several tool calls (Kimi).
+ */
+function parseStreamEvents(adapter, line) {
+    const parsed = adapter.parseStreamLine(line);
+    if (parsed == null)
+        return [];
+    return Array.isArray(parsed) ? parsed : [parsed];
+}

package/server/dist/queue-manager.js

@@ -24,6 +24,7 @@ const file_provenance_1 = require("./file-provenance");
 const result_event_1 = require("./result-event");
 const crypto_1 = require("crypto");
 const providers_1 = require("./providers");
+const runtime_1 = require("./providers/runtime");
 const codex_otel_bridge_1 = require("./codex-otel-bridge");
 const db_1 = require("./db");
 const interactive_job_session_1 = require("./interactive-job-session");
@@ -2155,7 +2156,7 @@ class QueueManager {
         // true forces interactive where capable, undefined = default ON. Derived
         // HERE (spawn time), not at enqueue, so legacy queued rows with no explicit
         // selection still receive the current default after restart.
-        const isFreestyle = adapter.id === 'claude' && exports.FREESTYLE_COMMAND_RE.test(commandToRun);
+        const isFreestyle = adapter.capabilities.freestyle === true && exports.FREESTYLE_COMMAND_RE.test(commandToRun);
         const interactiveOverride = this._jobInteractiveSelection.get(jobId);
         const spawnInteractive = (0, feature_flags_1.isInteractiveJobsEnabled)() &&
             adapter.capabilities.persistentStdin &&
@@ -2259,36 +2260,26 @@ class QueueManager {
         //    claude slash command — propose-spec, implement, batch-implement,
         //    explore-spec, retry, …). This is the rail equivalent of the
         //    user typing `$implement #1 --yes` themselves in `codex`.
-        // Freestyle (Claude only): skip the slash command entirely and send the
-        // pre-prompt + spec text directly as the prompt. The server route guards
-        // that freestyle never reaches a non-claude adapter; defensively, a codex
-        // adapter still falls through to its skill-translation path below.
+        // Freestyle (capability-gated; currently Claude and Kimi): skip the slash
+        // command entirely and send the pre-prompt + spec text directly as the
+        // prompt. The server route rejects adapters that do not advertise
+        // `freestyle` before this point.
         // (`isFreestyle` itself is resolved above, before the systemAppend build.)
         const railPrompt = isFreestyle
             ? this._buildFreestylePrompt(commandToRun)
-            : adapter.id === 'codex'
-                ? commandToRun.replace(/^\/(specrails|sr):([\w-]+)/, '$$$2')
-                : commandToRun;
+            : (0, runtime_1.formatProviderCommand)(adapter, commandToRun, execution.cwd);
         // Per-job model override (consumed once) takes precedence — used by the
         // freestyle model picker so the user can choose haiku/sonnet/opus per launch.
         const modelOverride = this._jobModelSelection.get(jobId);
-        const railModel = modelOverride
-            ? modelOverride
-            : adapter.id === 'claude' && this._db
-                ? (0, db_1.getProjectSettings)(this._db).orchestratorModel
-                : (this._resolvedModel ?? adapter.defaultModel());
+        const fallbackRailModel = adapter.id === 'claude' && this._db
+            ? (0, db_1.getProjectSettings)(this._db).orchestratorModel
+            : (this._resolvedModel ?? adapter.defaultModel());
         // Relocate-artifacts: when relocated, claude is spawned from the workspace
         // so add `--add-dir <repoDir>` so its tools can still reach repo files by
         // absolute path. (gemini/codex get env-only tweaks at spawn time below.)
-        const railExtraArgs = execution.relocated && adapter.id === 'claude'
-            ? ['--add-dir', execution.repoDir]
-            : undefined;
-        const args = adapter.buildArgs('rail-job', {
-            prompt: railPrompt,
-            systemPrompt: systemAppend || undefined,
-            model: railModel,
-            extraArgs: railExtraArgs,
-        });
+        const railExtraArgs = execution.relocated
+            ? (0, runtime_1.buildProviderRepoAccessArgs)(adapter, [execution.repoDir])
+            : [];
         // Resolve agent profile (if any) and snapshot per-job before spawn.
         // Super mode only (projectId + projectSlug + cwd all present).
         // Skipped when the adapter does not honour `SPECRAILS_PROFILE_PATH` AND
@@ -2299,6 +2290,7 @@ class QueueManager {
         // tracked in OpenSpec change task §13.
         let profileSnapshotPath = null;
         let profileName = null;
+        let profileOrchestratorModel = null;
         if (adapter.capabilities.profileEnvSupport && this._projectId && this._projectSlug && this._cwd) {
             try {
                 const selection = this._jobProfileSelection.get(jobId); // undefined|null|string
@@ -2312,6 +2304,7 @@ class QueueManager {
                     if (resolved) {
                         profileSnapshotPath = snapshotForJob(this._projectSlug, jobId, resolved);
                         profileName = resolved.name;
+                        profileOrchestratorModel = resolved.profile.orchestrator.model;
                         if (this._db) {
                             persistJobProfile(this._db, jobId, resolved);
                         }
@@ -2324,6 +2317,17 @@ class QueueManager {
                 console.warn(`[queue-manager] profile resolution failed for job ${jobId}: ${err.message}`);
             }
         }
+        // One authoritative model for both transports:
+        // explicit per-job override > resolved profile orchestrator > project/default.
+        // resolveProfile validates the profile model against this adapter's catalog.
+        const railModel = modelOverride ?? profileOrchestratorModel ?? fallbackRailModel;
+        const railSpawnOptions = {
+            prompt: railPrompt,
+            systemPrompt: systemAppend || undefined,
+            model: railModel,
+            extraArgs: railExtraArgs.length > 0 ? railExtraArgs : undefined,
+        };
+        const args = adapter.buildArgs('rail-job', railSpawnOptions);
         // Read pipelineTelemetryEnabled at spawn time (not constructor time) so
         // toggling the setting takes effect on the next job without restarting.
         // OTEL env injection is gated on `adapter.capabilities.nativeOtelEnv`:
@@ -2369,10 +2373,9 @@ class QueueManager {
         // or timed out. Degraded does NOT block spawn — rail proceeds, UI gets
         // a `plugin.degraded` event so the user can reinstall.
         //
-        // Today PluginManager only supports the `project-json` MCP registration
-        // (claude). Codex (`cli-add`) is covered by tasks §14 — until that lands
-        // we skip plugin resolution for non-`project-json` adapters so the rail
-        // spawns cleanly without errors.
+        // Project-json providers (Claude, Kimi, Gemini) resolve only the plugin
+        // installations scoped to this rail's effective provider. CLI-managed MCP
+        // registries remain outside this snapshot path.
         let pluginActive = [];
         let pluginDegraded = [];
         let pluginSnapshotPath = null;
@@ -2386,7 +2389,7 @@ class QueueManager {
                     snapshotter = pluginIntegration.snapshotPluginsForJob;
                 }
                 // Relocated ⇒ `.mcp.json`/plugin state live in the workspace (execution.cwd).
-                const resolution = await resolver(execution.cwd, this._projectId, jobId);
+                const resolution = await resolver(execution.cwd, this._projectId, jobId, adapter.id, this._adapter.id, this._projectSlug);
                 // shutdown() may have run while plugin verification was awaiting. Never
                 // snapshot, broadcast, or spawn for a manager generation that no longer
                 // owns this active slot.
@@ -2405,6 +2408,7 @@ class QueueManager {
                         type: 'plugin.degraded',
                         projectId: this._projectId,
                         name: d.name,
+                        providerId: adapter.id,
                         reason: d.reason,
                         jobId,
                         timestamp: new Date().toISOString(),
@@ -2525,7 +2529,7 @@ class QueueManager {
                     console.warn(`[queue-manager] provenance snapshot failed: ${err.message}`);
                 }
             }
-            const interactiveArgs = adapter.buildArgs('chat-stream', {
+            const interactiveSpawnOptions = {
                 // chat-stream feeds the prompt over stdin per-turn, so the argv `prompt`
                 // is unused — pass empty to satisfy the shared SpawnOptions shape.
                 prompt: '',
@@ -2538,9 +2542,10 @@ class QueueManager {
                 model: railModel,
                 extraArgs: !isFreestyle && systemAppend
                     ? ['--append-system-prompt', systemAppend, ...(railExtraArgs ?? [])]
-                    : railExtraArgs,
-            });
-            this._startInteractiveJob(jobId, job, adapter, { binary, args: interactiveArgs, cwd: spawnCwd, env: spawnEnv }, railPrompt, interactiveSettleMode);
+                    : (railExtraArgs.length > 0 ? railExtraArgs : undefined),
+            };
+            const interactiveArgs = adapter.buildArgs('chat-stream', interactiveSpawnOptions);
+            this._startInteractiveJob(jobId, job, adapter, { binary, args: interactiveArgs, cwd: spawnCwd, env: (0, runtime_1.buildProviderEnv)(adapter, interactiveSpawnOptions, spawnEnv) }, railPrompt, interactiveSettleMode);
             return;
         }
         // Code-Explorer pre-spawn snapshot. Captures the working-tree state via
@@ -2579,7 +2584,7 @@ class QueueManager {
         this._consumePendingSelections(jobId);
         // spawnAiCli reroutes multi-line argv values through stdin on Windows.
         const child = (0, cli_prompt_1.spawnAiCli)(binary, args, {
-            env: spawnEnv,
+            env: (0, runtime_1.buildProviderEnv)(adapter, railSpawnOptions, spawnEnv),
             stdio: ['ignore', 'pipe', 'pipe'],
             cwd: spawnCwd,
         });
@@ -2729,13 +2734,13 @@ class QueueManager {
             // alongside the raw event persistence below, NOT in place of it: the
             // raw event log is what feeds the live Job Detail UI and the
             // telemetry export ZIP for non-bridge providers.
-            const adapterEv = adapter.parseStreamLine(line);
-            if (adapterEv) {
+            const adapterEventsForLine = (0, runtime_1.parseStreamEvents)(adapter, line);
+            for (const adapterEv of adapterEventsForLine) {
                 adapterEvents.push(adapterEv);
                 otelBridge?.consumeEvent(adapterEv);
             }
             if (parsed) {
-                const eventType = parsed.type ?? 'unknown';
+                const eventType = parsed.type ?? parsed.role ?? 'unknown';
                 const persisted = persistEvent({
                     event_type: eventType,
                     source: 'stdout',
@@ -2774,8 +2779,9 @@ class QueueManager {
                 // For adapters whose stream is JSONL (claude, codex), a non-parseable
                 // line is unexpected noise. For future plain-text adapters this is
                 // their normal output. emitLine surfaces it either way.
-                if (adapterEv?.kind === 'text-delta') {
-                    emitLine('stdout', adapterEv.text);
+                const textEvent = adapterEventsForLine.find((event) => event.kind === 'text-delta');
+                if (textEvent?.kind === 'text-delta') {
+                    emitLine('stdout', textEvent.text);
                 }
                 else {
                     emitLine('stdout', line);
@@ -2878,6 +2884,12 @@ class QueueManager {
         const wasZombie = this._zombieJobs.has(jobId);
         const wasCanceling = this._cancelingJobs.has(jobId);
         const wasPersistenceFailed = this._persistenceFailedJobs.has(jobId);
+        // A provider may report a semantic turn failure while its CLI still exits
+        // successfully (code 0). AdapterEvent is the provider-neutral contract for
+        // that condition, so do not let the process exit code relabel it completed.
+        // Cancellation/zombie outcomes retain precedence because they describe the
+        // user/manager-owned termination of the whole job.
+        const providerReportedError = adapterEvents.some((event) => event.kind === 'error');
         let finalStatus;
         if (wasPersistenceFailed) {
             finalStatus = 'failed';
@@ -2888,15 +2900,26 @@ class QueueManager {
         else if (wasCanceling) {
             finalStatus = 'canceled';
         }
+        else if (providerReportedError) {
+            finalStatus = 'failed';
+        }
         else if (code === 0) {
             finalStatus = 'completed';
         }
         else {
             finalStatus = 'failed';
         }
+        const finishedAt = new Date().toISOString();
+        const startedAtMs = job.startedAt ? new Date(job.startedAt).getTime() : Number.NaN;
+        const finishedAtMs = new Date(finishedAt).getTime();
+        const wallDurationMs = Number.isFinite(startedAtMs)
+            ? Math.max(0, finishedAtMs - startedAtMs)
+            : undefined;
         // Adapter-driven finalisation must happen before staging so the immutable
-        // intent owns the same usage that lands on jobs and ai_invocations.
-        const { result: normalised, estimated } = (0, result_event_1.finaliseInvocationResult)(adapter, adapterEvents, { fallbackModel: spawnedModel });
+        // intent owns the same usage that lands on jobs and ai_invocations. The
+        // manager wall clock fills providers such as Kimi that emit no duration;
+        // a provider-native duration retains precedence inside the finaliser.
+        const { result: normalised, estimated } = (0, result_event_1.finaliseInvocationResult)(adapter, adapterEvents, { fallbackModel: spawnedModel, durationMs: wallDurationMs });
         const tokenData = lastResultEvent || adapterEvents.length > 0
             ? {
                 tokens_in: normalised.tokens_in,
@@ -2912,7 +2935,6 @@ class QueueManager {
                 session_id: normalised.session_id,
             }
             : {};
-        const finishedAt = new Date().toISOString();
         const invStatus = finalStatus === 'completed'
             ? 'success'
             : (finalStatus === 'canceled' || finalStatus === 'zombie_terminated')
@@ -3765,11 +3787,11 @@ class QueueManager {
         }
         const parse = (row) => {
             try {
-                return adapter.parseStreamLine(row.payload);
+                return (0, runtime_1.parseStreamEvents)(adapter, row.payload);
             }
             catch (err) {
                 console.warn(`[queue-manager] ignored malformed durable event for ${jobId}:`, err);
-                return null;
+                return [];
             }
         };
         const makeUsageAccumulator = () => {
@@ -3844,18 +3866,19 @@ class QueueManager {
          ORDER BY seq, id
       `).iterate(jobId);
             for (const row of events) {
-                const event = parse(row);
-                if (event?.kind === 'result') {
-                    const finalised = (0, result_event_1.finaliseInvocationResult)(adapter, [event], {
-                        fallbackModel: fallbackModel ?? undefined,
-                    });
-                    lastValidResult = {
-                        ...finalised,
-                        result: sanitizeRecoveredResult(finalised.result),
-                    };
-                }
-                else if (event) {
-                    accumulator.add(event, row.seq);
+                for (const event of parse(row)) {
+                    if (event.kind === 'result') {
+                        const finalised = (0, result_event_1.finaliseInvocationResult)(adapter, [event], {
+                            fallbackModel: fallbackModel ?? undefined,
+                        });
+                        lastValidResult = {
+                            ...finalised,
+                            result: sanitizeRecoveredResult(finalised.result),
+                        };
+                    }
+                    else {
+                        accumulator.add(event, row.seq);
+                    }
                 }
             }
             const fallback = accumulator.result();
@@ -3905,27 +3928,28 @@ class QueueManager {
        ORDER BY seq, id
     `).iterate(jobId);
         for (const row of resultRows) {
-            const event = parse(row);
-            if (event?.kind !== 'result')
-                continue;
-            const finalised = (0, result_event_1.finaliseInvocationResult)(adapter, [event], { fallbackModel: model });
-            const result = sanitizeRecoveredResult(finalised.result);
-            totals.tokens_in += result.tokens_in ?? 0;
-            totals.tokens_out += result.tokens_out ?? 0;
-            totals.tokens_cache_read += result.tokens_cache_read ?? 0;
-            totals.tokens_cache_create += result.tokens_cache_create ?? 0;
-            const cumulativeCost = result.total_cost_usd ?? baselineCost;
-            totals.total_cost_usd += Math.max(0, cumulativeCost - baselineCost);
-            baselineCost = cumulativeCost;
-            const cumulativeTurns = result.num_turns ?? (baselineTurns + 1);
-            totals.num_turns += Math.max(0, cumulativeTurns - baselineTurns);
-            baselineTurns = cumulativeTurns;
-            totals.duration_ms += result.duration_ms ?? 0;
-            totals.duration_api_ms += result.duration_api_ms ?? 0;
-            model = result.model ?? model;
-            sessionId = result.session_id ?? sessionId;
-            estimated = estimated || finalised.estimated;
-            lastResultSeq = row.seq;
+            for (const event of parse(row)) {
+                if (event.kind !== 'result')
+                    continue;
+                const finalised = (0, result_event_1.finaliseInvocationResult)(adapter, [event], { fallbackModel: model });
+                const result = sanitizeRecoveredResult(finalised.result);
+                totals.tokens_in += result.tokens_in ?? 0;
+                totals.tokens_out += result.tokens_out ?? 0;
+                totals.tokens_cache_read += result.tokens_cache_read ?? 0;
+                totals.tokens_cache_create += result.tokens_cache_create ?? 0;
+                const cumulativeCost = result.total_cost_usd ?? baselineCost;
+                totals.total_cost_usd += Math.max(0, cumulativeCost - baselineCost);
+                baselineCost = cumulativeCost;
+                const cumulativeTurns = result.num_turns ?? (baselineTurns + 1);
+                totals.num_turns += Math.max(0, cumulativeTurns - baselineTurns);
+                baselineTurns = cumulativeTurns;
+                totals.duration_ms += result.duration_ms ?? 0;
+                totals.duration_api_ms += result.duration_api_ms ?? 0;
+                model = result.model ?? model;
+                sessionId = result.session_id ?? sessionId;
+                estimated = estimated || finalised.estimated;
+                lastResultSeq = row.seq;
+            }
         }
         const tail = makeUsageAccumulator();
         const tailRows = db.prepare(`
@@ -3934,9 +3958,10 @@ class QueueManager {
        ORDER BY seq, id
     `).iterate(jobId, lastResultSeq);
         for (const row of tailRows) {
-            const event = parse(row);
-            if (event && event.kind !== 'result')
-                tail.add(event, row.seq);
+            for (const event of parse(row)) {
+                if (event.kind !== 'result')
+                    tail.add(event, row.seq);
+            }
         }
         const tailUsage = tail.result();
         const tailResult = tailUsage.result;

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

@@ -1479,7 +1479,7 @@ function recoveryOverlayExcludes(repoDir, worktreePath) {
                 return false;
             if (value === worktree_overlay_1.OVERLAY_MANIFEST)
                 return true;
-            if (!/^\.(?:claude|codex|gemini)\/[^/]+(?:\/[^/]+)*$/.test(value))
+            if (!/^\.(?:claude|codex|gemini|kimi-code)\/[^/]+(?:\/[^/]+)*$/.test(value))
                 return false;
             try {
                 // Manifest contents are worktree-writable and therefore not authority.

package/server/dist/rails-router.js

@@ -32,12 +32,6 @@ const repo_lock_1 = require("./repo-lock");
 const agent_chat_registry_1 = require("./agent-chat-registry");
 const process_admission_1 = require("./process-admission");
 const VALID_MODES = new Set(['implement', 'batch-implement', 'freestyle', 'loop']);
-// Models the freestyle picker exposes (Claude aliases). Mirrors the client
-// RailModelSelector options and the project-router orchestrator-model allow-list.
-const VALID_FREESTYLE_MODELS = new Set(['haiku', 'sonnet', 'opus', 'fable']);
-// Reasoning-effort tiers a loop launch may request (mirrors the client selector
-// + the provider adapters' supported values).
-const VALID_REASONING_EFFORTS = new Set(['low', 'medium', 'high']);
 function prDeliveryContinuesTickets(delivery, ticketIds) {
     if (delivery.decision !== 'pr_draft' && delivery.decision !== 'pr_ready')
         return false;
@@ -446,15 +440,7 @@ function createRailsRouter() {
             res.status(400).json({ error: 'target_pr_requires_pr_mode', detail: 'targetPrNumber requires loops and PR delivery to be enabled' });
             return;
         }
-        // Freestyle model picker: optional, validated against the allow-list.
-        // Ignored for non-freestyle modes (they use the orchestrator model).
-        if (mode === 'freestyle' && model !== undefined && model !== null) {
-            if (typeof model !== 'string' || !VALID_FREESTYLE_MODELS.has(model)) {
-                res.status(400).json({ error: 'model must be one of: haiku, sonnet, opus, fable' });
-                return;
-            }
-        }
-        // Interactive in-job chat is ON by default for EVERY claude job — the
+        // Interactive in-job chat is ON by default for providers that expose the
         // spawn-time gate in QueueManager (kill-switch + persistent-stdin
         // capability) decides, so the launch no longer passes an explicit flag. A
         // legacy `interactive` body param is accepted and ignored (wire compat).
@@ -503,21 +489,33 @@ function createRailsRouter() {
         // Only pass a provider override when one was actually requested (keeps
         // single-provider rails on the legacy code path).
         const railProvider = requestedEngine ? engineCheck.provider : undefined;
-        // Freestyle bypasses the OpenSpec pipeline and hands the raw spec to
-        // Claude. It is Claude-only — reject when the effective engine is not claude.
-        if (mode === 'freestyle' && engineCheck.provider !== 'claude') {
-            res.status(400).json({ error: 'Freestyle requires the Claude provider' });
+        // Freestyle bypasses the OpenSpec pipeline and hands the raw spec to a
+        // provider that explicitly advertises autonomous freestyle support.
+        if (mode === 'freestyle' && (0, providers_1.getAdapter)(engineCheck.provider).capabilities.freestyle !== true) {
+            res.status(400).json({ error: `Freestyle is not supported by provider '${engineCheck.provider}'` });
+            return;
+        }
+        // Freestyle is provider-owned. Validate its optional model against the
+        // selected engine instead of a Claude-only alias list.
+        if (mode === 'freestyle' &&
+            model !== undefined &&
+            model !== null &&
+            (typeof model !== 'string' || !(0, spec_models_1.isValidModelForProvider)(model, engineCheck.provider))) {
+            res.status(400).json({
+                error: `model is not valid for provider "${engineCheck.provider}"`,
+                allowed: (0, spec_models_1.getModelsForProvider)(engineCheck.provider),
+            });
             return;
         }
         // Profile selection precedence: explicit body param > stored rail profile > default resolution.
-        // `null` in the body explicitly forces legacy mode. Codex has no agent
-        // profiles, so force legacy mode whenever the chosen engine is not claude.
+        // `null` in the body explicitly forces legacy mode. Providers without
+        // profile support run in legacy mode.
         let resolvedProfile;
         if (mode === 'freestyle') {
             // Freestyle runs no agent pipeline, so profiles do not apply.
             resolvedProfile = null;
         }
-        else if (railProvider && railProvider !== 'claude') {
+        else if (railProvider && (0, providers_1.getAdapter)(railProvider).capabilities.profiles !== true) {
             resolvedProfile = null;
         }
         else if (profileName === null) {
@@ -573,27 +571,44 @@ function createRailsRouter() {
                     loopGraph = loop.graph;
                     loopName = loop.name;
                 }
+                const loopProvider = railProvider ?? c.project.provider ?? 'claude';
+                const loopAdapter = (0, providers_1.getAdapter)(loopProvider);
+                if (loopGraph.nodes.some((node) => node.type === 'decider')
+                    && !(0, providers_1.supportsToolPolicy)(loopAdapter, 'read-only')) {
+                    res.status(409).json({
+                        code: 'provider_tool_policy_unsupported',
+                        provider: loopProvider,
+                        requiredPolicy: 'read-only',
+                        error: `Provider '${loopProvider}' cannot run Loop Deciders because its headless CLI ` +
+                            'does not enforce a read-only tool policy.',
+                    });
+                    return;
+                }
+                if (typeof model === 'string' && model && !(0, spec_models_1.isValidModelForProvider)(model, loopProvider)) {
+                    res.status(400).json({ error: `model is not valid for provider "${loopProvider}"`, allowed: (0, spec_models_1.getModelsForProvider)(loopProvider) });
+                    return;
+                }
+                const loopModel = typeof model === 'string' && model ? model : loopAdapter.defaultModel();
                 let effort;
                 if (reasoning_effort !== undefined && reasoning_effort !== null) {
-                    if (typeof reasoning_effort !== 'string' || !VALID_REASONING_EFFORTS.has(reasoning_effort)) {
-                        res.status(400).json({ error: 'reasoning_effort must be one of: low, medium, high' });
+                    const allowed = (0, providers_1.reasoningEffortsForModel)(loopAdapter, loopModel);
+                    if (typeof reasoning_effort !== 'string' ||
+                        !allowed.includes(reasoning_effort)) {
+                        res.status(400).json({
+                            error: `reasoning_effort is not valid for provider "${loopProvider}" and model "${loopModel}"`,
+                            allowed,
+                        });
                         return;
                     }
                     effort = reasoning_effort;
                 }
-                const loopProvider = railProvider ?? c.project.provider ?? 'claude';
-                if (typeof model === 'string' && model && !(0, spec_models_1.isValidModelForProvider)(model, loopProvider)) {
-                    res.status(400).json({ error: `model is not valid for provider "${loopProvider}"`, allowed: (0, spec_models_1.getModelsForProvider)(loopProvider) });
-                    return;
-                }
-                const loopModel = typeof model === 'string' && model ? model : (0, providers_1.getAdapter)(loopProvider).defaultModel();
-                // The loop's command(s) declare ticket scope + claude-only-ness.
+                // The loop's command(s) declare ticket scope + required capabilities.
                 const promptsText = loopGraph.nodes
                     .filter((n) => n.type === 'ai-step')
                     .map((n) => String(n.data?.prompt ?? ''))
                     .join('\n');
-                if ((0, loop_command_catalog_1.referencesClaudeOnlyCommand)(promptsText) && loopProvider !== 'claude') {
-                    res.status(400).json({ error: 'This loop uses a Claude-only command and requires the Claude provider' });
+                if ((0, loop_command_catalog_1.referencesUnsupportedProviderCommand)(promptsText, loopProvider)) {
+                    res.status(400).json({ error: `This loop uses a command unsupported by provider '${loopProvider}'` });
                     return;
                 }
                 const scope = (0, loop_command_catalog_1.dominantTicketScope)(promptsText);
@@ -831,13 +846,11 @@ function createRailsRouter() {
             }
             let jobId;
             if (mode === 'freestyle') {
-                // Freestyle launches ONE independent Claude job per ticket — each gets
+                // Freestyle launches ONE independent provider-owned job per ticket — each gets
                 // its own log and runs the spec autonomously (no pipeline). The rail UI
                 // tracks the first job as its representative active job; every job is
                 // registered so its ticket is marked done on completion.
-                // `provider: 'claude'` is explicit so the spawn resolves the claude
-                // adapter regardless of the project's primary.
-                const freestyleModel = mode === 'freestyle' && typeof model === 'string' && VALID_FREESTYLE_MODELS.has(model)
+                const freestyleModel = mode === 'freestyle' && typeof model === 'string'
                     ? model
                     : undefined;
                 const jobIds = [];
@@ -845,7 +858,7 @@ function createRailsRouter() {
                     const command = `/specrails:freestyle #${ticketId} --yes`;
                     const job = c.queueManager.enqueue(command, 'normal', {
                         profileName: null,
-                        provider: 'claude',
+                        provider: engineCheck.provider,
                         ...(freestyleModel ? { model: freestyleModel } : {}),
                         // No explicit `interactive` — QueueManager's spawn-time default
                         // (kill-switch + persistent-stdin capability) covers it, and the