specrails-desktop 2.45.0 → 2.47.0

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readRuntimeEfficiency = readRuntimeEfficiency;
+exports.readRuntimeEfficiencySummary = readRuntimeEfficiencySummary;
+exports.applyRuntimeSelectionOrigins = applyRuntimeSelectionOrigins;
+const COUNTS = ['attempts', 'measuredAttempts', 'providerCalls', 'toolCalls', 'inputTokens', 'outputTokens', 'uncachedInputTokens', 'cacheReadInputTokens', 'cacheWriteInputTokens'];
+const KEYS = [...COUNTS, 'durationMs', 'agentDurationMs', 'costUsd'];
+const PHASES = ['architect', 'developer', 'verify', 'reviewer', 'archive'];
+function object(value) { return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null; }
+function counters(value) {
+    const input = object(value);
+    if (!input)
+        return null;
+    const output = {};
+    for (const key of KEYS) {
+        const number = input[key];
+        if (number === null && key !== 'attempts' && key !== 'measuredAttempts') {
+            output[key] = null;
+            continue;
+        }
+        if (typeof number !== 'number' || !Number.isFinite(number) || number < 0 || (COUNTS.includes(key) && !Number.isSafeInteger(number)))
+            return null;
+        output[key] = number;
+    }
+    if (output.measuredAttempts > output.attempts)
+        return null;
+    return output;
+}
+/** Older Core versions omit metrics; malformed/unknown versions do not break run controls. */
+function readRuntimeEfficiency(value) {
+    const input = object(value);
+    if (input?.schemaVersion !== 1 || !Array.isArray(input.phases) || input.phases.length > PHASES.length)
+        return undefined;
+    const total = counters(input.total);
+    if (!total)
+        return undefined;
+    const phases = [];
+    for (const raw of input.phases) {
+        const phase = object(raw), count = counters(phase);
+        if (!phase || !count || typeof phase.stepId !== 'string' || !PHASES.includes(phase.stepId) || phases.some(item => item.stepId === phase.stepId))
+            return undefined;
+        for (const key of ['providers', 'models'])
+            if (!Array.isArray(phase[key]) || phase[key].length > 50 || !phase[key].every((item) => typeof item === 'string' && item.length > 0 && item.length <= 256))
+                return undefined;
+        phases.push({ ...count, stepId: phase.stepId, providers: [...phase.providers], models: [...phase.models] });
+    }
+    return { schemaVersion: 1, total, phases };
+}
+function readRuntimeEfficiencySummary(value) {
+    const input = object(value), invocations = object(input?.invocations), checks = object(input?.checks);
+    if (!input || input.schemaVersion !== 1 || typeof input.runId !== 'string' || input.runId.length > 128 || typeof input.workflowVersion !== 'string' || input.workflowVersion.length > 16 || !['pending', 'validated', 'with-exceptions', 'blocked'].includes(String(input.technicalAcceptance)) || !invocations || !checks || !Array.isArray(input.roles) || input.roles.length > 3)
+        return undefined;
+    if (typeof input.archive !== 'string' || input.archive.length > 32 || typeof input.delivery !== 'string' || input.delivery.length > 32 || typeof invocations.complete !== 'boolean' || typeof checks.available !== 'boolean')
+        return undefined;
+    const count = (value, nullable = true) => (nullable && value === null) || typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+    for (const key of ['total', 'fullContexts', 'incrementalContexts'])
+        if (!count(invocations[key], false))
+            return undefined;
+    for (const key of ['promptBytes', 'contextBytes', 'handoffBytes'])
+        if (!count(invocations[key]))
+            return undefined;
+    if (checks.complete !== undefined && typeof checks.complete !== 'boolean' || checks.invalidated !== undefined && !count(checks.invalidated))
+        return undefined;
+    for (const key of ['executed', 'reused', 'notRun'])
+        if (!count(checks[key]))
+            return undefined;
+    if (checks.durationMs !== null && (typeof checks.durationMs !== 'number' || !Number.isFinite(checks.durationMs) || checks.durationMs < 0))
+        return undefined;
+    for (const key of ['planHash', 'candidateHash'])
+        if (input[key] !== null && (typeof input[key] !== 'string' || !/^[a-f0-9]{64}$/.test(input[key])))
+            return undefined;
+    if (!Array.isArray(input.currentEvidenceIds) || input.currentEvidenceIds.length > 100 || !input.currentEvidenceIds.every(id => typeof id === 'string' && /^[a-f0-9]{64}$/.test(id)))
+        return undefined;
+    const kinds = object(invocations.byKind);
+    if (!kinds || Object.keys(kinds).length !== 5 || !['initial', 'correction', 'repair', 'deepen', 'session-fallback'].every(key => count(kinds[key], false)))
+        return undefined;
+    const roles = [];
+    for (const raw of input.roles) {
+        const role = object(raw);
+        if (!role || !['architect', 'developer', 'reviewer'].includes(String(role.role)) || roles.some(item => item.role === role.role))
+            return undefined;
+        const row = { role: String(role.role) };
+        for (const key of ['provider', 'model', 'effort', 'observedModel', 'observedEffort', 'origin', 'tier']) {
+            if (role[key] !== null && (typeof role[key] !== 'string' || role[key].length > 256))
+                return undefined;
+            row[key] = role[key];
+        }
+        if (!['base', 'escalation'].includes(String(row.tier)) || typeof row.origin !== 'string')
+            return undefined;
+        roles.push(row);
+    }
+    let escalations;
+    if (input.escalations !== undefined) {
+        if (!Array.isArray(input.escalations) || input.escalations.length > 16 || typeof input.escalationsTruncated !== 'boolean')
+            return undefined;
+        escalations = [];
+        for (const item of input.escalations) {
+            const raw = object(item);
+            if (!raw || !['architect', 'developer', 'reviewer'].includes(String(raw.role)))
+                return undefined;
+            const row = { role: String(raw.role) };
+            for (const key of ['attemptId', 'provider', 'model', 'effort', 'reason']) {
+                if (raw[key] !== null && (typeof raw[key] !== 'string' || raw[key].length > 256) || ['attemptId', 'provider'].includes(key) && typeof raw[key] !== 'string')
+                    return undefined;
+                row[key] = raw[key];
+            }
+            escalations.push(row);
+        }
+    }
+    return { ...(escalations ? { escalations, escalationsTruncated: input.escalationsTruncated } : {}), schemaVersion: 1, currentEvidenceIds: [...input.currentEvidenceIds], planHash: input.planHash, candidateHash: input.candidateHash, runId: input.runId, workflowVersion: input.workflowVersion, technicalAcceptance: input.technicalAcceptance, archive: input.archive, delivery: input.delivery, roles,
+        invocations: { total: invocations.total, complete: invocations.complete, byKind: { ...kinds }, promptBytes: invocations.promptBytes, contextBytes: invocations.contextBytes, handoffBytes: invocations.handoffBytes, fullContexts: invocations.fullContexts, incrementalContexts: invocations.incrementalContexts },
+        checks: { ...(checks.complete === undefined ? {} : { complete: checks.complete }), ...(checks.invalidated === undefined ? {} : { invalidated: checks.invalidated }), available: checks.available, executed: checks.executed, reused: checks.reused, notRun: checks.notRun, durationMs: checks.durationMs } };
+}
+/** Provenance is host-owned; it never changes Core's frozen provider selection. */
+function applyRuntimeSelectionOrigins(summary, selection, runId) {
+    const record = object(selection), origins = object(record?.origins);
+    if (!summary || record?.schemaVersion !== 1 || record.runId !== runId || !origins)
+        return summary;
+    if (!['architect', 'developer', 'reviewer'].every(role => ['project-role', 'default', ...(role === 'developer' ? ['explicit-launch-override'] : [])].includes(String(origins[role]))))
+        return summary;
+    return { ...summary, roles: summary.roles.map(role => ({ ...role, origin: String(origins[role.role]) })) };
+}

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

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeEntryFingerprint = runtimeEntryFingerprint;
+exports.retainAgentRuntime = retainAgentRuntime;
+exports.resolveRetainedAgentRuntime = resolveRetainedAgentRuntime;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const SHIPPED = ['package.json', 'dist', 'bin', 'templates', 'schemas', 'commands', 'integration-contract.json', 'pinned-versions.json'];
+const SAFE_PACKAGE = /^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/i;
+function packageRoot(file, name) {
+    let directory = node_path_1.default.dirname(node_fs_1.default.realpathSync(file));
+    for (;;) {
+        const manifest = node_path_1.default.join(directory, 'package.json');
+        if (node_fs_1.default.existsSync(manifest)) {
+            const pkg = JSON.parse(node_fs_1.default.readFileSync(manifest, 'utf8'));
+            if (pkg.name === (name ?? 'specrails-core'))
+                return directory;
+        }
+        const parent = node_path_1.default.dirname(directory);
+        if (directory === parent)
+            throw new Error('Core runtime does not resolve to an identifiable package');
+        directory = parent;
+    }
+}
+/** Content identity also detects same-size edits with preserved timestamps. */
+function runtimeEntryFingerprint(cli) {
+    let root;
+    try {
+        root = packageRoot(cli);
+    }
+    catch {
+        return (0, node_crypto_1.createHash)('sha256').update(node_fs_1.default.readFileSync(cli)).digest('hex');
+    }
+    return treeDigest(root, SHIPPED);
+}
+function treeDigest(root, entries = node_fs_1.default.readdirSync(root).sort()) {
+    const hash = (0, node_crypto_1.createHash)('sha256');
+    let files = 0, bytes = 0;
+    const visit = (relative) => {
+        const file = node_path_1.default.join(root, relative), stat = node_fs_1.default.lstatSync(file);
+        if (stat.isSymbolicLink())
+            throw new Error('Retained Core package contains a symbolic link');
+        if (stat.isDirectory())
+            for (const name of node_fs_1.default.readdirSync(file).sort())
+                visit(node_path_1.default.posix.join(relative, name));
+        else if (stat.isFile()) {
+            if (++files > 100_000 || (bytes += stat.size) > 1024 * 1024 * 1024)
+                throw new Error('Core runtime package exceeds retention limits');
+            hash.update(JSON.stringify([relative, stat.size])).update('\0').update(node_fs_1.default.readFileSync(file)).update('\0');
+        }
+        else
+            throw new Error('Core runtime package contains a nonregular file');
+    };
+    for (const entry of entries)
+        if (node_fs_1.default.existsSync(node_path_1.default.join(root, entry)))
+            visit(entry);
+    return hash.digest('hex');
+}
+/** Copy only the selected package and its installed production dependency
+ * closure. Resolution follows npm's actual nested versions, without downloads. */
+function copyInstalledPackage(source, destination) {
+    const installed = new Map();
+    const copying = new Set();
+    let files = 0, bytes = 0, packages = 0;
+    const copy = (from, to, boundary) => {
+        const stat = node_fs_1.default.lstatSync(from);
+        if (stat.isSymbolicLink()) {
+            const resolved = node_fs_1.default.realpathSync(from), relative = node_path_1.default.relative(boundary, resolved);
+            if (relative.startsWith('..') || node_path_1.default.isAbsolute(relative))
+                throw new Error('Core package symlink escapes its package');
+            copy(resolved, to, boundary);
+        }
+        else if (stat.isDirectory()) {
+            const real = node_fs_1.default.realpathSync(from);
+            if (copying.has(real))
+                throw new Error('Core package contains a cyclic symbolic link');
+            copying.add(real);
+            node_fs_1.default.mkdirSync(to, { recursive: true });
+            try {
+                for (const name of node_fs_1.default.readdirSync(from).sort())
+                    if (!['node_modules', '.git', '.bin'].includes(name))
+                        copy(node_path_1.default.join(from, name), node_path_1.default.join(to, name), boundary);
+            }
+            finally {
+                copying.delete(real);
+            }
+        }
+        else if (stat.isFile()) {
+            if (++files > 100_000 || (bytes += stat.size) > 1024 * 1024 * 1024)
+                throw new Error('Core runtime package exceeds retention limits');
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(to), { recursive: true });
+            node_fs_1.default.copyFileSync(from, to);
+            node_fs_1.default.chmodSync(to, stat.mode & 0o777);
+        }
+        else
+            throw new Error('Core package contains a nonregular file');
+    };
+    const resolveDependency = (name, from) => {
+        const require = (0, node_module_1.createRequire)(node_path_1.default.join(from, 'package.json'));
+        try {
+            return packageRoot(require.resolve(name + '/package.json'), name);
+        }
+        catch {
+            return packageRoot(require.resolve(name), name);
+        }
+    };
+    const install = (from, to, root = false) => {
+        if (++packages > 2000)
+            throw new Error('Core dependency closure exceeds retention limits');
+        if (root)
+            for (const entry of SHIPPED) {
+                if (node_fs_1.default.existsSync(node_path_1.default.join(from, entry)))
+                    copy(node_path_1.default.join(from, entry), node_path_1.default.join(to, entry), from);
+            }
+        else
+            copy(from, to, from);
+        installed.set(node_fs_1.default.realpathSync(to), from);
+        const pkg = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(from, 'package.json'), 'utf8'));
+        for (const name of Object.keys({ ...pkg.dependencies, ...pkg.optionalDependencies }).sort()) {
+            if (!SAFE_PACKAGE.test(name))
+                throw new Error('Invalid Core package dependency');
+            let dependency;
+            try {
+                dependency = resolveDependency(name, from);
+            }
+            catch (error) {
+                if (pkg.optionalDependencies?.[name])
+                    continue;
+                throw error;
+            }
+            try {
+                const present = resolveDependency(name, to);
+                if (installed.get(present) === dependency)
+                    continue;
+            }
+            catch { /* Not copied into this resolution scope yet. */ }
+            install(dependency, node_path_1.default.join(to, 'node_modules', name));
+        }
+    };
+    install(source, destination, true);
+}
+function retainAgentRuntime(cli, contextPath) {
+    const pinFile = node_path_1.default.join(node_path_1.default.dirname(contextPath), 'desktop-runtime-package.json');
+    if (node_fs_1.default.existsSync(pinFile))
+        return resolveRetainedAgentRuntime(contextPath);
+    const realCli = node_fs_1.default.realpathSync(cli);
+    const root = packageRoot(realCli);
+    const relativeCli = node_path_1.default.relative(root, realCli);
+    if (relativeCli.startsWith('..') || node_path_1.default.isAbsolute(relativeCli))
+        throw new Error('Core CLI escapes its package');
+    const cache = node_path_1.default.join(node_path_1.default.dirname(node_path_1.default.dirname(contextPath)), 'runtime-packages');
+    node_fs_1.default.mkdirSync(cache, { recursive: true, mode: 0o700 });
+    const staged = node_path_1.default.join(cache, '.staged-' + (0, node_crypto_1.randomUUID)());
+    try {
+        copyInstalledPackage(root, staged);
+        const integrity = treeDigest(staged);
+        const retained = node_path_1.default.join(cache, integrity);
+        if (node_fs_1.default.existsSync(retained)) {
+            if (treeDigest(retained) !== integrity)
+                throw new Error('Retained Core runtime integrity changed');
+        }
+        else {
+            try {
+                node_fs_1.default.renameSync(staged, retained);
+            }
+            catch (error) {
+                if (!node_fs_1.default.existsSync(retained) || treeDigest(retained) !== integrity)
+                    throw error;
+            }
+        }
+        const pin = { schemaVersion: 1, packageVersion: JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(root, 'package.json'), 'utf8')).version, integrity, root: retained, cli: relativeCli };
+        try {
+            node_fs_1.default.writeFileSync(pinFile, JSON.stringify(pin) + '\n', { flag: 'wx', mode: 0o600 });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST' || resolveRetainedAgentRuntime(contextPath) !== node_path_1.default.join(retained, relativeCli))
+                throw error;
+        }
+        return node_path_1.default.join(retained, relativeCli);
+    }
+    finally {
+        node_fs_1.default.rmSync(staged, { recursive: true, force: true });
+    }
+}
+function resolveRetainedAgentRuntime(contextPath) {
+    const pinFile = node_path_1.default.join(node_path_1.default.dirname(contextPath), 'desktop-runtime-package.json');
+    if (!node_fs_1.default.existsSync(pinFile))
+        throw new Error('Original runtime identity is unrecorded. Restore a proven original Core package before continuing this saved execution.');
+    const pin = JSON.parse(node_fs_1.default.readFileSync(pinFile, 'utf8'));
+    const expected = node_path_1.default.join(node_path_1.default.dirname(node_path_1.default.dirname(contextPath)), 'runtime-packages', pin.integrity);
+    if (pin.schemaVersion !== 1 || !/^[a-f0-9]{64}$/.test(pin.integrity) || pin.root !== expected || !node_fs_1.default.existsSync(expected) || node_fs_1.default.realpathSync(expected) !== node_path_1.default.resolve(expected)
+        || typeof pin.cli !== 'string' || node_path_1.default.isAbsolute(pin.cli) || pin.cli.split(/[\\/]/).includes('..'))
+        throw new Error('The original retained Core package is unavailable or invalid. Restore it before continuing.');
+    if (treeDigest(expected) !== pin.integrity)
+        throw new Error('The original retained Core package failed its integrity check. Restore it before continuing.');
+    const cli = node_path_1.default.join(expected, pin.cli);
+    if (!node_fs_1.default.statSync(cli).isFile())
+        throw new Error('The original Core executable is unavailable');
+    return cli;
+}

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

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

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

@@ -1,16 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerAgentRuntimeSettingsRoutes = registerAgentRuntimeSettingsRoutes;
+const node_fs_1 = require("node:fs");
 const agent_runtime_loader_1 = require("./agent-runtime-loader");
 const agent_runtime_settings_1 = require("./agent-runtime-settings");
 const agent_runtime_verification_suggestions_1 = require("./agent-runtime-verification-suggestions");
 const project_repositories_1 = require("./project-repositories");
 function registerAgentRuntimeSettingsRoutes({ router, ctx }) {
-    router.get('/:projectId/agent-runtime/config', (_req, res) => {
+    router.get('/:projectId/agent-runtime/config', async (_req, res) => {
         try {
             const project = ctx(_req).project;
+            const configured = (0, node_fs_1.existsSync)((0, agent_runtime_settings_1.agentRuntimeConfigPath)(project));
             const config = (0, agent_runtime_settings_1.loadAgentRuntimeConfig)(project);
-            res.json({ configured: config !== null, config: config ?? (0, agent_runtime_settings_1.defaultAgentRuntimeConfig)(project), runtimeAvailable: (0, agent_runtime_loader_1.findCoreAgentRuntimeEntry)() !== null });
+            let efficiencyAvailable = false;
+            try {
+                efficiencyAvailable = (await (0, agent_runtime_loader_1.loadCoreAgentRuntime)()).api?.capabilities?.efficientRoleExecution === 1;
+            }
+            catch { /* Ordinary settings remain readable without capability support. */ }
+            res.json({ configured, config, runtimeAvailable: (0, agent_runtime_loader_1.findCoreAgentRuntimeEntry)() !== null, efficiencyAvailable });
         }
         catch (err) {
             const validation = err instanceof agent_runtime_settings_1.AgentRuntimeConfigError;
@@ -30,18 +37,34 @@ function registerAgentRuntimeSettingsRoutes({ router, ctx }) {
             res.status(500).json({ error: 'verification_suggestions_failed', message: 'Could not inspect the project repositories' });
         }
     });
+    router.post('/:projectId/agent-runtime/capabilities', async (req, res) => {
+        try {
+            const config = (0, agent_runtime_settings_1.validateAgentRuntimeConfig)({ ...req.body, providers: (0, agent_runtime_settings_1.loadRuntimeProviders)(), enabled: true });
+            const runtime = await (0, agent_runtime_loader_1.loadCoreAgentRuntime)();
+            if (!runtime.capabilities)
+                throw new Error('Installed Core does not support capability introspection');
+            res.json(await runtime.capabilities(config));
+        }
+        catch (error) {
+            res.status(error instanceof agent_runtime_settings_1.AgentRuntimeConfigError ? 400 : 503).json({ error: 'runtime_capabilities_unavailable', message: error instanceof agent_runtime_settings_1.AgentRuntimeConfigError ? error.message : 'Update the paired Core runtime to inspect model capabilities' });
+        }
+    });
     router.put('/:projectId/agent-runtime/config', async (req, res) => {
         try {
-            const config = (0, agent_runtime_settings_1.validateAgentRuntimeConfig)(req.body);
+            (0, agent_runtime_settings_1.validateAgentRuntimeConfig)(req.body);
+            const config = (0, agent_runtime_settings_1.validateAgentRuntimeConfig)({ ...req.body, enabled: true, providers: (0, agent_runtime_settings_1.loadRuntimeProviders)() });
             const runtimeAvailable = (0, agent_runtime_loader_1.findCoreAgentRuntimeEntry)() !== null;
             if (config.enabled && !runtimeAvailable) {
                 res.status(503).json({ error: 'runtime_unavailable', message: 'Update Core to an installation with the agent runtime before enabling it' });
                 return;
             }
-            // Disabling must remain possible even when an installed runtime is broken.
+            let efficiencyAvailable = false;
             if (config.enabled && runtimeAvailable) {
                 try {
-                    (await (0, agent_runtime_loader_1.loadCoreAgentRuntime)()).validateRuntimeConfig(config);
+                    const runtime = await (0, agent_runtime_loader_1.loadCoreAgentRuntime)();
+                    runtime.validateRuntimeConfig(config);
+                    (0, agent_runtime_loader_1.validateRequestedRoleEfforts)(runtime, config);
+                    efficiencyAvailable = runtime.api?.capabilities?.efficientRoleExecution === 1;
                 }
                 catch {
                     res.status(503).json({ error: 'runtime_incompatible', message: 'The installed Core runtime could not validate this configuration; update Core and retry' });
@@ -49,7 +72,7 @@ function registerAgentRuntimeSettingsRoutes({ router, ctx }) {
                 }
             }
             const saved = (0, agent_runtime_settings_1.saveAgentRuntimeConfig)(ctx(req).project, config);
-            res.json({ configured: true, config: saved, runtimeAvailable });
+            res.json({ configured: true, config: saved, runtimeAvailable, efficiencyAvailable });
         }
         catch (err) {
             const validation = err instanceof agent_runtime_settings_1.AgentRuntimeConfigError;