specrails-desktop 2.58.1 → 2.59.1

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

@@ -7,6 +7,7 @@ exports.readFrozenRuntimeHost = readFrozenRuntimeHost;
 exports.runAgentRuntimeInvocation = runAgentRuntimeInvocation;
 exports.assertRetainedForkSupport = assertRetainedForkSupport;
 exports.runAgentRuntimeControl = runAgentRuntimeControl;
+const agent_runtime_verification_suggestions_1 = require("./agent-runtime-verification-suggestions");
 const agent_runtime_history_1 = require("./agent-runtime-history");
 const agent_runtime_repositories_1 = require("./agent-runtime-repositories");
 const node_util_1 = require("node:util");
@@ -32,15 +33,126 @@ function runtimeChangeName(runId) {
  * cwd is relative to the registered directory; one already inside the scope is kept.
  */
 function scopedHostChecks(checks, repositories = []) {
-    return checks.map(check => {
-        const scope = repositories.find(repository => repository.id === check.repositoryId)?.scope?.[0];
-        if (!scope || (check.cwd !== undefined && (0, node_path_1.isAbsolute)(check.cwd)))
-            return check;
-        const cwd = (check.cwd ?? '.').replace(/\\/g, '/');
-        const inside = cwd === scope || cwd.startsWith(scope + '/');
-        return { ...check, cwd: inside ? cwd : node_path_1.posix.normalize(node_path_1.posix.join(scope, cwd)) };
+    return checks.flatMap(check => {
+        const repository = repositories.find(repository => repository.id === check.repositoryId);
+        const scopes = repository?.scope;
+        if (!repository || !scopes?.length)
+            return [check];
+        if (check.cwd === undefined)
+            return scopes.map((scope, index) => ({ ...check, cwd: scope,
+                ...(check.key && scopes.length > 1 ? { key: check.key.slice(0, 90) + '-workspace-' + index } : {}),
+            }));
+        const declared = repository.registeredScope;
+        const inputCwd = check.cwd.replace(/\\/g, '/');
+        const rawCwd = (0, node_path_1.isAbsolute)(inputCwd) && repository.path ? (0, node_path_1.relative)(repository.path, inputCwd).split(node_path_1.sep).join('/') : inputCwd;
+        if (!(0, node_path_1.isAbsolute)(rawCwd) && declared?.some(root => rawCwd === root || rawCwd.startsWith(root + '/')) && !scopes.some(root => rawCwd === root || rawCwd.startsWith(root + '/')))
+            return [];
+        let cwd = check.cwd.replace(/\\/g, '/');
+        if ((0, node_path_1.isAbsolute)(cwd)) {
+            if (!repository.path)
+                throw new Error('Verification workspace root is unavailable');
+            cwd = (0, node_path_1.relative)(repository.path, cwd).split(node_path_1.sep).join('/');
+        }
+        else {
+            const normalized = node_path_1.posix.normalize(cwd);
+            if (scopes.some(scope => cwd === scope || cwd.startsWith(scope + '/')))
+                cwd = normalized;
+            else if (scopes.length === 1)
+                cwd = node_path_1.posix.join(scopes[0], normalized);
+            else
+                throw new Error('Verification must select an explicit workspace cwd when several scopes are configured');
+        }
+        cwd = node_path_1.posix.normalize(cwd);
+        if (!scopes.some(root => cwd === root || cwd.startsWith(root + '/')))
+            throw new Error(`Verification cwd ${JSON.stringify(check.cwd)} escapes the selected code workspace ${scopes.join(', ')}`);
+        return [{ ...check, cwd }];
     });
 }
+/** Discover only checks belonging to the admitted worktrees. Explicit host
+ * checks win; inferred commands are frozen per run, never saved to project settings. */
+function completeHostChecks(config, repositories) {
+    for (const repository of repositories) {
+        if (config.verification.some(check => check.repositoryId === repository.id) || !repository.path)
+            continue;
+        const workspacePaths = (repository.scope?.length ? repository.scope.map(scope => (0, node_path_1.resolve)(repository.path, scope)) : [repository.path]).filter(workspace => (0, node_fs_1.existsSync)(workspace));
+        const root = (0, node_fs_1.realpathSync)(repository.path);
+        for (const workspace of workspacePaths) {
+            const inside = (0, node_path_1.relative)(root, (0, node_fs_1.realpathSync)(workspace));
+            if ((0, node_path_1.isAbsolute)(inside) || inside === '..' || inside.startsWith('..' + node_path_1.sep))
+                throw new Error('Verification workspace escapes its admitted repository');
+        }
+        const suggestions = (0, agent_runtime_verification_suggestions_1.suggestVerificationCommands)([{ id: repository.id, path: repository.path, workspacePaths }]);
+        config.verification.push(...suggestions.map(({ reason: _reason, ...check }) => check));
+    }
+}
+/** Configured-only gates cannot obtain missing checks from an agent later. */
+function requiresConfiguredChecks(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const body = value;
+    return Object.values(body.nodes ?? {}).some(node => node.kind === 'verify' && node.params?.commands === 'configured' && !node.params.additionalCommandsFrom && node.params.unverified !== true)
+        || Object.values(body.components ?? {}).some(requiresConfiguredChecks);
+}
+/** Keep TAP failure diagnostics and totals in the readable log. The unfiltered
+ * event stream remains available as runtime evidence. State is invocation-local. */
+function verificationLogFilter() {
+    const streams = new Map();
+    return text => (0, node_util_1.stripVTControlCharacters)(text).split(/(?<=\n)/).flatMap(line => {
+        const match = line.match(/^(\[verification [^\]]+\] )?(.*?)(?:\n)?$/);
+        if (!match)
+            return [line];
+        const key = match[1] ?? '', body = match[2].trim();
+        const state = streams.get(key) ?? { tap: false, failed: false, yaml: false, inputLines: null };
+        streams.set(key, state);
+        if (/AssertionError\b.*\bInput:\s*$/.test(body))
+            state.inputLines = 0;
+        else if (state.inputLines !== null) {
+            // Node prints assert.match's entire source input as quoted concatenation
+            // lines. Bound only that block; stacks, expected values and other streams
+            // remain visible and original events remain intact.
+            if (/^["'`]/.test(body)) {
+                state.inputLines++;
+                if (state.inputLines > 2)
+                    return state.inputLines === 3 ? [key + '[Assertion input shortened; inspect raw evidence]\n'] : [];
+            }
+            else if (!body)
+                return [];
+            else
+                state.inputLines = null;
+        }
+        if (/^[✔✓]\s/.test(body))
+            return [];
+        if (/^[✖✗]\s/.test(body)) {
+            state.failed = true;
+            return [line];
+        }
+        if (/^TAP version |^# Subtest:/.test(body)) {
+            state.tap = true;
+            return [];
+        }
+        if (/^(?:not )?ok \d+\b/.test(body)) {
+            state.tap = true;
+            state.failed = body.startsWith('not ok');
+            state.yaml = false;
+            return state.failed ? [line] : [];
+        }
+        if (!state.tap)
+            return [line];
+        if (body === '---') {
+            state.yaml = true;
+            return state.failed ? [line] : [];
+        }
+        if (body === '...') {
+            state.yaml = false;
+            return state.failed ? [line] : [];
+        }
+        if (state.yaml)
+            return state.failed ? [line] : [];
+        if (/^1\.\.\d+$/.test(body) || !body)
+            return [];
+        return [line];
+    }).map(line => line.length > 2_000 ? line.slice(0, 1_900) + '\n[Long diagnostic line shortened; inspect raw evidence]\n' : line).join('');
+}
 exports.RUNTIME_HOST_ENV_KEYS = [
     'SPECRAILS_REPO_DIR', 'SPECRAILS_GIT_AUTO', 'SPECRAILS_REPO_MAP_PATH',
     'SPECRAILS_EXECUTION_CONTEXT', 'SPECRAILS_EXECUTION_MANIFEST', 'SPECRAILS_REPOSITORIES',
@@ -80,7 +192,7 @@ function readFrozenRuntimeHost(contextPath, baseEnv, runId) {
  * rail's cancellation and worktree ownership remain in Desktop. */
 async function runAgentRuntimeInvocation(options) {
     const definitionEngine = options.engineVersion === 2 || options.definitionPath !== undefined || options.prepareDefinition !== undefined;
-    if (options.resume && (options.definitionPath || options.prepareDefinition || options.workflowRoleBindings))
+    if (options.resume && (options.definitionPath || options.prepareDefinition || options.workflowRoleBindings || options.loopConfig))
         throw new Error('Resume must use the frozen workflow definition and role bindings');
     const selectedCli = options.resume ? (0, agent_runtime_package_1.resolveRetainedAgentRuntime)(options.contextPath) : (0, agent_runtime_loader_1.findCoreAgentRuntimeCli)();
     let cli = selectedCli;
@@ -96,11 +208,14 @@ async function runAgentRuntimeInvocation(options) {
         if (!Array.isArray(admittedContext.repositories) || !admittedContext.repositories.length || admittedContext.repositories.some(repo => !repo || typeof repo.id !== 'string' || !repo.id))
             throw new Error('Core context is missing its repository scope');
         const source = (0, node_fs_1.existsSync)(options.configPath) ? 'project-role' : 'default';
-        const { config, origins } = (0, agent_runtime_effective_config_1.resolveEffectiveRuntimeConfig)((0, agent_runtime_settings_1.loadRuntimeConfigFile)(options.configPath, options.defaultProvider), {
-            repositoryIds: admittedContext.repositories.map(repo => repo.id), source, providerOverride: options.providerOverride,
+        const { config, origins } = (0, agent_runtime_effective_config_1.resolveEffectiveRuntimeConfig)(options.loopConfig ? (0, agent_runtime_settings_1.loadLoopRuntimeConfig)(options.configPath, options.loopConfig, options.providerOverride ?? { provider: options.defaultProvider ?? 'claude' }) : (0, agent_runtime_settings_1.loadRuntimeConfigFile)(options.configPath, options.defaultProvider), {
+            repositoryIds: admittedContext.repositories.map(repo => repo.id), source: options.loopConfig ? 'loop-role' : source, providerOverride: options.loopConfig ? undefined : options.providerOverride,
         });
         config.verification = scopedHostChecks(config.verification, admittedContext.repositories);
-        config.rolePrompts = { ...(await (0, agent_runtime_loader_1.loadCoreAgentRuntime)()).rolePromptDefaults(), ...(0, agent_runtime_settings_1.loadRuntimeRolePrompts)(), ...config.rolePrompts };
+        if (definitionEngine)
+            completeHostChecks(config, admittedContext.repositories);
+        if (!options.loopConfig)
+            config.rolePrompts = { ...(await (0, agent_runtime_loader_1.loadCoreAgentRuntime)()).rolePromptDefaults(), ...(0, agent_runtime_settings_1.loadRuntimeRolePrompts)(), ...config.rolePrompts };
         // Core rejects unknown connection keys: drop the desktop-only local-engine
         // fields (label/defaultModel/rates/supportsReasoningEffort) before Core sees it.
         const runtime = await (0, agent_runtime_loader_1.loadCoreAgentRuntime)();
@@ -119,9 +234,21 @@ async function runAgentRuntimeInvocation(options) {
             : options.definitionPath ? JSON.parse((0, node_fs_1.readFileSync)(options.definitionPath, 'utf8')) : undefined : undefined;
         if (definitionEngine && !draft)
             throw new Error('A new Core workflow requires a definition');
+        if (requiresConfiguredChecks(draft)) {
+            const missing = admittedContext.repositories.filter(repository => !config.verification.some(check => check.repositoryId === repository.id));
+            if (missing.length)
+                throw new Error(`verification_checks_missing: No configured or detected verification commands for ${missing.map(repository => repository.name ?? repository.id).join(', ')}. Configure checks in project agent-runtime settings before starting this workflow.`);
+            if (config.verification.length > 100)
+                throw new Error('verification_checks_limit: This workflow supports at most 100 verification commands. Reduce the configured checks before starting it.');
+        }
         const selectedOrigins = (0, agent_runtime_effective_config_1.bindWorkflowRoleSelections)(config, draft, options.workflowRoleBindings);
+        if (options.loopConfig && draft?.roles?.includes('loop-decider') && !config.roles?.['loop-decider'])
+            throw new Error('The loop must define its loop-decider agent');
         const workflowOrigins = { ...(0, agent_runtime_effective_config_1.bindWorkflowRoleDefaults)(config, draft), ...selectedOrigins };
-        const override = options.providerOverride;
+        if (options.loopConfig)
+            for (const role of Object.keys(config.roles ?? {}))
+                workflowOrigins[role] = 'loop-role';
+        const override = options.loopConfig ? undefined : options.providerOverride;
         runtime.validateRuntimeConfig(JSON.parse(JSON.stringify(config)));
         (0, agent_runtime_loader_1.validateRequestedRoleEfforts)(runtime, config);
         cli = (0, agent_runtime_package_1.retainAgentRuntime)(cli, options.contextPath);
@@ -169,6 +296,17 @@ async function runAgentRuntimeInvocation(options) {
     const definitionFile = (0, node_path_1.join)((0, node_path_1.dirname)(options.contextPath), 'desktop-workflow-definition.json');
     const requiresVerified = definitionEngine && JSON.parse((0, node_fs_1.readFileSync)(definitionFile, 'utf8')).delivery?.requiresVerified === true;
     const frozenPath = (0, node_path_1.join)((0, node_path_1.dirname)(options.contextPath), 'desktop-runtime-config.json');
+    if ((0, node_fs_1.existsSync)(frozenPath)) {
+        const checks = JSON.parse((0, node_fs_1.readFileSync)(frozenPath, 'utf8')).verification;
+        for (const check of checks) {
+            const repository = admittedContext.repositories?.find(repo => repo.id === check.repositoryId);
+            const cwd = repository?.path ? (0, node_path_1.resolve)(repository.path, check.cwd ?? repository.scope?.[0] ?? '.') : check.cwd;
+            try {
+                options.onLine?.(`[verification scope] ${JSON.stringify({ repositoryId: check.repositoryId, workspace: repository?.name, cwd, command: check.command, args: check.args })}\n`);
+            }
+            catch { /* Advisory log observer. */ }
+        }
+    }
     if ((0, node_fs_1.existsSync)(frozenPath)) {
         const frozen = JSON.parse((0, node_fs_1.readFileSync)(frozenPath, 'utf8'));
         for (const [role, assignment] of [...Object.entries(frozen.agents), ...(frozen.fixer ? [['fixer', frozen.fixer]] : [])]) {
@@ -198,6 +336,7 @@ async function runAgentRuntimeInvocation(options) {
         let result;
         let graph;
         let stderr = '', summary = '', invalidProtocol = false, timedOut = false;
+        const stepFailures = new Map();
         let timer;
         const child = (0, node_child_process_1.spawn)((0, core_node_runtime_1.resolveCoreNodeRuntime)(), args, {
             cwd: options.cwd, env: (0, win_spawn_1.windowsSpawnEnv)(options.env), shell: false, windowsHide: true,
@@ -217,6 +356,7 @@ async function runAgentRuntimeInvocation(options) {
             callback?.();
         }
         catch { /* Logging cannot replay a workflow. */ } };
+        const readableVerification = verificationLogFilter();
         const lines = (0, node_readline_1.createInterface)({ input: child.stdout });
         lines.on('line', line => {
             if (line.length > 2_000_000) {
@@ -267,8 +407,17 @@ async function runAgentRuntimeInvocation(options) {
             }
             else if (event.type === 'workflow-event') {
                 const payload = event.event;
-                if (payload?.type)
-                    observe(() => options.onLine?.(`[runtime] ${payload.type}${payload.stepId ? ': ' + payload.stepId : ''}${payload.message ? ' — ' + payload.message : ''}\n`));
+                const kind = payload?.type === 'step_succeeded' && payload.outcome === 'fail' ? 'verification_failed' : payload?.type;
+                const detail = payload?.error?.message ?? payload?.message;
+                const stepKey = JSON.stringify([payload?.scopeId ?? null, payload?.nodePath ?? payload?.stepId ?? null]);
+                if (payload?.type === 'step_failed' && typeof detail === 'string' && detail.trim()) {
+                    stepFailures.delete(stepKey);
+                    stepFailures.set(stepKey, detail.trim().slice(0, 4_000));
+                }
+                else if (payload?.type === 'step_succeeded')
+                    stepFailures.delete(stepKey);
+                if (kind)
+                    observe(() => options.onLine?.(`[runtime] ${kind}${payload.stepId ? ': ' + payload.stepId : ''}${detail ? ' — ' + detail : ''}\n`));
             }
             else if (event.type === 'agent-event') {
                 const payload = event.event;
@@ -285,7 +434,9 @@ async function runAgentRuntimeInvocation(options) {
                 }
             }
             else if (event.type === 'verification-output' && typeof event.text === 'string') {
-                observe(() => options.onLine?.((0, node_util_1.stripVTControlCharacters)(String(event.text))));
+                const readable = readableVerification(String(event.text));
+                if (readable)
+                    observe(() => options.onLine?.(readable));
             }
             else if (event.type === 'span') {
                 // Trace spans are telemetry; the raw line is already recorded for diagnostics.
@@ -321,6 +472,7 @@ async function runAgentRuntimeInvocation(options) {
             const validPause = definitionEngine && code === 2 && result?.status === 'paused';
             const failed = (!validPause && (code !== 0 || result?.status !== 'succeeded')) || invalidProtocol || timedOut || Boolean(observerError) || Boolean(acceptanceBlocked);
             const runtimeError = typeof result?.error === 'string' ? result.error : result?.error?.message;
+            const completionError = Array.isArray(result?.completion?.reasons) ? result.completion.reasons.filter(reason => typeof reason === 'string' && reason.trim()).join('; ').slice(0, 4_000) : '';
             const runtimeStatus = invalidProtocol || timedOut || observerError || (result?.status === 'paused' && !validPause) || (result?.status === 'succeeded' && code !== 0) ? 'failed' : acceptanceBlocked ? 'blocked' : ['succeeded', 'paused', 'failed', 'blocked', 'cancelled'].includes(result?.status ?? '') ? result.status : 'failed';
             const errorText = observerError ?? (timedOut ? 'Programmatic workflow timed out; inspect its checkpoint before recovery'
                 : invalidProtocol ? 'Core returned an invalid runtime event stream'
@@ -328,9 +480,9 @@ async function runAgentRuntimeInvocation(options) {
                         : runtimeError ?? (result?.status === 'paused' ? (typeof result.pendingQuestion?.question === 'string' && result.pendingQuestion.question.trim()
                             ? `Workflow awaits an answer in Agent Runtime settings: ${result.pendingQuestion.question.trim().slice(0, 500)}`
                             : 'Workflow awaits approval in Agent Runtime settings')
-                            : failed ? stderr || 'Core exited without a successful programmatic workflow result' : undefined));
+                            : failed ? completionError || [...stepFailures.values()].at(-1) || stderr || 'Core exited without a successful programmatic workflow result' : undefined));
             try {
-                (0, agent_runtime_history_1.writeRuntimeHistory)(options.contextPath, invalidProtocol || timedOut || observerError || !result ? { status: 'failed', error: errorText } : { ...result });
+                (0, agent_runtime_history_1.writeRuntimeHistory)(options.contextPath, invalidProtocol || timedOut || observerError || !result ? { status: 'failed', error: errorText } : { ...result, ...(failed && errorText ? { error: errorText } : {}) });
             }
             catch { /* Projection failure cannot replay a completed execution. */ }
             resolve({

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

@@ -121,7 +121,7 @@ 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]))))
+    if (!['architect', 'developer', 'reviewer'].every(role => ['loop-role', 'project-role', 'default', ...(role === 'developer' ? ['explicit-launch-override'] : [])].includes(String(origins[role]))))
         return summary;
     return { ...summary, roles: summary.roles.map(role => {
             const origin = origins[role.role];

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

@@ -84,7 +84,7 @@ function registerAgentRuntimeSettingsRoutes({ router, ctx }) {
     router.get('/:projectId/agent-runtime/verification-suggestions', (req, res) => {
         try {
             const project = ctx(req).project;
-            const repositories = (0, project_repositories_1.getProjectRepositories)(project).map((repository) => ({ id: repository.id, name: repository.name, path: repository.path }));
+            const repositories = (0, project_repositories_1.getProjectRepositories)(project).map((repository) => ({ id: repository.id, name: repository.name, path: repository.path, workspacePath: repository.workspacePath, workspacePaths: repository.workspacePaths }));
             res.json({ repositories: repositories.map(({ id, name }) => ({ id, name })), suggestions: (0, agent_runtime_verification_suggestions_1.suggestVerificationCommands)(repositories) });
         }
         catch {

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

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentRuntimeConfigError = exports.REVIEW_THRESHOLD_FLOORS = exports.MAX_OUTPUT_TOKENS_MAX = exports.MAX_OUTPUT_TOKENS_MIN = exports.CONTEXT_WINDOW_TOKENS_MAX = exports.CONTEXT_WINDOW_TOKENS_MIN = exports.RUNTIME_ROLE_ID = void 0;
 exports.stripDesktopConnectionFields = stripDesktopConnectionFields;
 exports.coreConnectionFieldGates = coreConnectionFieldGates;
+exports.validateLoopRuntimeSettings = validateLoopRuntimeSettings;
+exports.loadLoopRuntimeConfig = loadLoopRuntimeConfig;
 exports.validateAgentRuntimeConfig = validateAgentRuntimeConfig;
 exports.defaultAgentRuntimeConfig = defaultAgentRuntimeConfig;
 exports.agentRuntimeConfigPath = agentRuntimeConfigPath;
@@ -121,6 +123,46 @@ exports.REVIEW_THRESHOLD_FLOORS = {
     minScore: 70,
     aspects: { type_correctness: 60, pattern_adherence: 60, test_coverage: 60, security: 75, architectural_alignment: 60 },
 };
+/** Validate a portable recipe without accepting host-owned fields or project fallbacks. */
+function validateLoopRuntimeSettings(input, providers = loadRuntimeProviders()) {
+    if (!input || typeof input !== 'object' || Array.isArray(input) || Object.keys(input).some(key => ![
+        'schemaVersion', 'agents', 'fixer', 'roles', 'rolePrompts', 'limits', 'review', 'architect', 'approvalBeforeArchive', 'efficiency', 'guardrails',
+    ].includes(key)))
+        throw new AgentRuntimeConfigError('Invalid loop agent configuration');
+    // "inherit" is a recipe-only assignment, resolved before Core sees it.
+    const portableProviders = [...providers, { id: 'inherit', kind: 'cli', cli: 'claude' }];
+    const config = validateAgentRuntimeConfig({ ...input, enabled: true, providers: portableProviders, verification: [] });
+    if (['architect', 'developer', 'reviewer', 'fixer'].some(role => !config.rolePrompts?.[role]?.trim()))
+        throw new AgentRuntimeConfigError('Loop agents require an explicit definition for architect, developer, reviewer and fixer');
+    const { enabled: _enabled, providers: _providers, verification: _checks, ...settings } = config;
+    return settings;
+}
+/** Read only repository checks from the old project file. Role migration is explicit. */
+function loadLoopRuntimeConfig(file, input, selection = { provider: 'claude' }) {
+    let verification = [];
+    try {
+        const saved = JSON.parse(node_fs_1.default.readFileSync(file, 'utf8'));
+        if (!saved || typeof saved !== 'object' || Array.isArray(saved))
+            throw new AgentRuntimeConfigError('Saved runtime configuration must be an object');
+        verification = saved.verification ?? [];
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    const providers = loadRuntimeProviders();
+    const settings = validateLoopRuntimeSettings(input, providers);
+    const inherit = (agent) => agent.provider !== 'inherit' ? agent : {
+        ...agent, provider: selection.provider, model: agent.model ?? selection.model, effort: agent.effort ?? selection.effort,
+    };
+    for (const role of ROLES)
+        settings.agents[role] = inherit(settings.agents[role]);
+    if (settings.fixer)
+        settings.fixer = inherit(settings.fixer);
+    for (const [role, agent] of Object.entries(settings.roles ?? {}))
+        settings.roles[role] = inherit(agent);
+    return validateAgentRuntimeConfig({ ...settings, providers, enabled: true, verification });
+}
 const CLI_PROVIDERS = ['claude', 'codex', 'gemini', 'kimi'];
 const ROLES = ['architect', 'developer', 'reviewer'];
 const schemaValidator = new ajv_1.default({ allErrors: true }).compile(agent_runtime_schema_json_1.default);

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

@@ -110,10 +110,16 @@ function otherSuggestions(repository) {
 function suggestVerificationCommands(repositories) {
     const out = [];
     for (const repository of repositories) {
-        if (!repository.path || !node_fs_1.default.existsSync(repository.path))
-            continue;
-        const node = nodeSuggestions(repository);
-        out.push(...(node.length ? node : otherSuggestions(repository)));
+        const workspaces = repository.workspacePaths ?? (repository.workspacePath ? [repository.workspacePath] : [repository.path]);
+        for (const workspace of workspaces) {
+            if (!workspace || !node_fs_1.default.existsSync(workspace))
+                continue;
+            const member = { ...repository, path: workspace };
+            const node = nodeSuggestions(member);
+            const checks = node.length ? node : otherSuggestions(member);
+            const cwd = node_path_1.default.relative(repository.path, workspace).split(node_path_1.default.sep).join('/');
+            out.push(...checks.map(check => cwd ? { ...check, cwd, reason: `${cwd}: ${check.reason}` } : check));
+        }
     }
     return out;
 }

package/server/dist/modules/builder/runtime/milestone-chain.js

@@ -4,14 +4,11 @@
 // "Launch Milestone N": order the milestone's todo specs by their declared
 // dependencies (prerequisites, then execution_order), put ONE spec on each
 // rail (mode `implement`), launch the first through the ORDINARY rails launch
-// route, and — when that spec's delivery settles — launch the next one STACKED
-// on the delivered branch, so a greenfield walking skeleton accumulates without
-// waiting for a merge. Launches are always sequential (the Parallel option was
-// removed); auto-continue is on by default and a failure always pauses. The plan lives in SQLite (survives window close, app
-// restart, machine sleep), advances from the delivery-settle chokepoint (the
-// `rail.pr_state` broadcast tapped in the project's bound broadcast — the
-// engine's `onLoopRunFinished` fires BEFORE the delivery row leaves
-// `building`, so it is only a fallback for delivery-less shared-cwd runs),
+// route, and integrate each completed delivery through the guarded local decision
+// path BEFORE allocating the next worktree from the integration branch. Older
+// adapters without integration retain their historical stacking behavior.
+// Launches are sequential; auto-continue is on by default. The plan lives in
+// SQLite and retains the current delivery through integration and recovery.
 // pauses with a typed reason on any failure (never skips ahead), and is
 // visible/controllable (resume / cancel) from every surface.
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -77,6 +74,7 @@ class MilestoneChainManager {
     db;
     projectId;
     io;
+    integrating = new Set();
     constructor(db, projectId, io) {
         this.db = db;
         this.projectId = projectId;
@@ -218,7 +216,7 @@ class MilestoneChainManager {
     }
     /**
      * Launch a milestone. Always sequential: one spec per rail, each stacked on
-     * the previous delivered branch. `autoAdvance` defaults to ON; turning it off
+     * the accumulated integration branch when integration is bound. `autoAdvance` defaults to ON; turning it off
      * parks the chain at a checkpoint after every delivered rail.
      */
     async start(n, opts = {}) {
@@ -308,7 +306,7 @@ class MilestoneChainManager {
             return;
         }
         const earlierDeliveries = (0, milestone_chain_store_1.parseLaunched)(row).filter((entry) => entry.chunk <= chunkIndex && entry.deliveryId).map((entry) => entry.deliveryId);
-        const multiRepositoryHistory = earlierDeliveries.some((id) => this.io.getDelivery(id)?.executionManifest);
+        const multiRepositoryHistory = !this.io.integrateDelivery && earlierDeliveries.some((id) => this.io.getDelivery(id)?.executionManifest);
         if (!multiRepositoryHistory && head && !(await this.branchExistsSafe(head))) {
             this.pause(row, 'head_missing', { headBranch: head });
             return;
@@ -371,6 +369,56 @@ class MilestoneChainManager {
             return 'chunk_stopped';
         return 'chunk_failed';
     }
+    completeIntegrated(row) {
+        if (!row.current_delivery_id || !(0, milestone_chain_store_1.isActiveChainStatus)(row.status))
+            return;
+        (0, milestone_chain_store_1.updateChain)(this.db, row.id, row.status, { status: 'waiting', currentDeliveryId: null, currentRunIds: [], headBranch: row.integration_branch, pauseReason: 'integration_complete' }, this.now());
+        this.afterChunkSuccess(row.id, row.integration_branch);
+    }
+    /** Keep the delivery attached until its guarded integration is durably confirmed. */
+    async integrateChunk(chainId) {
+        if (!this.io.integrateDelivery || this.integrating.has(chainId))
+            return;
+        const row = (0, milestone_chain_store_1.getChain)(this.db, chainId);
+        if (!row?.current_delivery_id || !(0, milestone_chain_store_1.isActiveChainStatus)(row.status))
+            return;
+        const snap = this.io.getDelivery(row.current_delivery_id);
+        if (!snap) {
+            this.pause(row, 'integration_failed:delivery_missing');
+            return;
+        }
+        if (snap.implementationOutcome === 'partially_succeeded' || snap.implementationOutcome === 'failed') {
+            this.pauseFailedChunk(row, 'chunk_failed');
+            return;
+        }
+        if (snap.decision === 'merged' || snap.decision === 'completed') {
+            this.completeIntegrated(row);
+            return;
+        }
+        this.integrating.add(chainId);
+        (0, milestone_chain_store_1.updateChain)(this.db, row.id, row.status, { status: 'waiting', pauseReason: 'integration_pending' }, this.now());
+        const pending = (0, milestone_chain_store_1.getChain)(this.db, chainId);
+        this.emit(pending);
+        try {
+            const result = await this.io.integrateDelivery(snap);
+            const current = (0, milestone_chain_store_1.getChain)(this.db, chainId);
+            if (!current || !(0, milestone_chain_store_1.isActiveChainStatus)(current.status) || current.current_delivery_id !== snap.id)
+                return;
+            const settled = this.io.getDelivery(snap.id);
+            if (settled?.decision === 'merged' || settled?.decision === 'completed')
+                this.completeIntegrated(current);
+            else
+                this.pause(current, 'integration_failed:' + (result.ok ? 'not_confirmed' : result.error));
+        }
+        catch {
+            const current = (0, milestone_chain_store_1.getChain)(this.db, chainId);
+            if (current && (0, milestone_chain_store_1.isActiveChainStatus)(current.status) && current.current_delivery_id === snap.id)
+                this.pause(current, 'integration_failed:unavailable');
+        }
+        finally {
+            this.integrating.delete(chainId);
+        }
+    }
     /** The delivery-settle chokepoint: a `rail.pr_state` for the in-flight chunk. */
     handleDeliveryState(snap) {
         for (const row of (0, milestone_chain_store_1.listActiveChains)(this.db)) {
@@ -378,6 +426,13 @@ class MilestoneChainManager {
                 continue;
             if (snap.decision === 'building')
                 continue;
+            if (this.io.integrateDelivery && SUCCESS_DECISIONS.has(snap.decision)) {
+                if (row.status === 'running' || row.status === 'waiting' && row.pause_reason === 'integration_pending')
+                    void this.integrateChunk(row.id);
+                else if (row.pause_reason?.startsWith('integration_') && ['merged', 'completed'].includes(snap.decision))
+                    this.completeIntegrated(row);
+                continue;
+            }
             if (SUCCESS_DECISIONS.has(snap.decision)) {
                 const delivered = snap.executionManifest ? null : snap.decision === 'no_changes'
                     ? row.head_branch
@@ -457,6 +512,10 @@ class MilestoneChainManager {
             return { ok: false, status: 404, error: 'chain_not_found' };
         if (row.status !== 'paused' && row.status !== 'awaiting_approval')
             return { ok: false, status: 409, error: 'chain_not_paused', detail: `chain is ${row.status}` };
+        if (this.io.integrateDelivery && row.current_delivery_id && row.pause_reason?.startsWith('integration_')) {
+            await this.integrateChunk(id);
+            return { ok: true, status: 202, chain: (0, milestone_chain_store_1.toChainSnapshot)((0, milestone_chain_store_1.getChain)(this.db, id)) };
+        }
         if (row.head_branch && !(await this.branchExistsSafe(row.head_branch))) {
             (0, milestone_chain_store_1.updateChain)(this.db, row.id, row.status, { status: 'paused', pauseReason: 'head_missing' }, this.now());
             const fresh = (0, milestone_chain_store_1.getChain)(this.db, row.id);
@@ -503,6 +562,13 @@ class MilestoneChainManager {
      */
     async recoverOnStartup() {
         for (const row of (0, milestone_chain_store_1.listActiveChains)(this.db)) {
+            if (this.io.integrateDelivery && row.status === 'waiting' && row.pause_reason?.startsWith('integration_')) {
+                if (row.current_delivery_id)
+                    await this.integrateChunk(row.id);
+                else if (row.pause_reason === 'integration_complete')
+                    this.afterChunkSuccess(row.id, row.integration_branch);
+                continue;
+            }
             if (row.status !== 'running')
                 continue;
             if (row.current_delivery_id) {

package/server/dist/modules/delivery/runtime/delivery-evidence.js

@@ -475,7 +475,7 @@ function projectDefinitionRuntimeEvidence(status, reviewerStepId) {
         if (!['succeeded', 'failed'].includes(scope.status) || !scope.attemptId || !isRecord(scope.output))
             continue;
         const output = scope.output;
-        if (scope.kind === 'verify' && typeof output.receiptId === 'string' && Array.isArray(output.commands)) {
+        if ((scope.kind === 'verify' || scope.kind === 'implementation-step' && output.phase === 'verify') && typeof output.receiptId === 'string' && Array.isArray(output.commands)) {
             for (const raw of output.commands) {
                 if (commands.length >= RUNTIME_LIST_CAP)
                     break;
@@ -487,7 +487,8 @@ function projectDefinitionRuntimeEvidence(status, reviewerStepId) {
             }
         }
         const review = scope.status !== 'succeeded' ? null : scope.kind === 'implementation' ? parseRuntimeReview(output.review)
-            : reviewerStepId === scope.nodePath && scope.kind === 'role-turn' ? parseRuntimeReview(output.structured ?? output) : null;
+            : scope.kind === 'implementation-step' && output.phase === 'reviewer' ? parseRuntimeReview(output)
+                : reviewerStepId === scope.nodePath && scope.kind === 'role-turn' ? parseRuntimeReview(output.structured ?? output) : null;
         if (review)
             scopedReviews.push({ nodePath: scope.nodePath, scopeId: scope.scopeId, attemptId: scope.attemptId, review });
     }

package/server/dist/modules/delivery/runtime/multi-repo-execution.js

@@ -231,7 +231,7 @@ async function launchMultiRepositoryRail(input, io = {}) {
             integrationBranches.set(repo.id, target.branch);
         }
     }
-    const previousParentId = input.revision?.ofDeliveryId ?? input.repositoryContinuation?.deliveryId;
+    const previousParentId = input.revision?.ofDeliveryId ?? input.repositoryContinuation?.deliveryId ?? input.retryOfDelivery?.deliveryId;
     const previousParent = previousParentId ? (0, rail_pr_store_1.getPrDelivery)(ctx.db, previousParentId) : undefined;
     const previousManifest = (0, multi_repo_execution_store_1.readExecutionManifest)(previousParent?.execution_manifest);
     const previousChildren = previousParentId ? listRepositoryDeliveries(ctx.db, previousParentId) : [];
@@ -268,12 +268,13 @@ async function launchMultiRepositoryRail(input, io = {}) {
         artifactRepositoryId, selectedRepositoryIds: selected.map((repo) => repo.id), repositories: [],
     };
     const generation = (0, rail_pr_store_1.createPrDeliveryGeneration)(ctx.db, {
+        launchConfig: input.launchConfig,
         id: parentId, railIndex: input.railIndex, loopId: input.loopId, railKey: `${input.railIndex}-${input.loopId}`,
         ticketIds: input.ticketIds, baseBranch: input.baseBranch ?? '', loopName: input.loopName,
         originSurface: input.originSurface ?? 'dashboard', originConversationId: input.originConversationId,
         specSnapshot: (0, rail_isolated_launch_1.buildSpecSnapshot)(ctx, input.ticketIds),
         ...(input.revision ? { revisionNote: input.revision.note, revisionOf: input.revision.ofDeliveryId } : {}),
-    }, input.revision ? { id: input.revision.ofDeliveryId, decision: input.revision.decision } : input.repositoryContinuation ? { id: input.repositoryContinuation.deliveryId, decision: input.repositoryContinuation.decision } : null);
+    }, input.revision ? { id: input.revision.ofDeliveryId, decision: input.revision.decision } : input.repositoryContinuation ? { id: input.repositoryContinuation.deliveryId, decision: input.repositoryContinuation.decision } : input.retryOfDelivery ? { id: input.retryOfDelivery.deliveryId, decision: input.retryOfDelivery.decision } : null);
     for (const child of previousChildren) {
         if (!['merged', 'completed', 'discarded', 'superseded'].includes(child.decision))
             (0, rail_pr_store_1.transitionDecision)(ctx.db, child.id, child.decision, 'superseded');
@@ -315,14 +316,14 @@ async function launchMultiRepositoryRail(input, io = {}) {
             const childSettlement = deferred();
             const previous = previousChildren.find((row) => row.repository_id === repository.id);
             const previousRepository = previousManifest?.repositories.find((row) => row.repositoryId === repository.id);
-            const previousBaseBranch = previous && ['merged', 'completed'].includes(previous.decision)
+            const previousBaseBranch = input.retryOfDelivery ? undefined : previous && ['merged', 'completed'].includes(previous.decision)
                 ? previousRepository?.integrationBranch ?? previous.base_branch
                 : previous?.base_branch;
             const oldSnapshot = previous ? (0, rail_pr_store_1.toPrDeliverySnapshot)(previous) : null;
             const revisionBranches = new Map();
-            if (oldSnapshot && !['merged', 'completed', 'discarded'].includes(oldSnapshot.decision) && !previous?.pr_url) {
+            if (!input.retryOfDelivery && oldSnapshot && !['merged', 'completed', 'discarded'].includes(oldSnapshot.decision) && !previous?.pr_url) {
                 for (const unit of oldSnapshot.branches) {
-                    if (unit.finalSha)
+                    if (unit.succeeded && unit.finalSha && unit.implementationOutcome !== 'failed' && unit.deliveryOutcome !== 'blocked')
                         revisionBranches.set(unit.ticketId, { branch: unit.branch, sha: unit.finalSha });
                 }
             }
@@ -355,6 +356,7 @@ async function launchMultiRepositoryRail(input, io = {}) {
                 ...input, ctx: childCtx, scope: effectiveScope, loopGraph: graph,
                 runtimeStateProject: ctx.project,
                 revision: input.revision && previous ? { ...input.revision, ofDeliveryId: previous.id, decision: previous.decision } : undefined,
+                retryOfDelivery: input.retryOfDelivery && previous ? { deliveryId: previous.id, decision: previous.decision } : undefined,
                 requiredPrContinuation: continuation,
                 explicitPrTarget: continuation?.prNumber ? { prNumber: continuation.prNumber } : input.explicitPrTarget,
                 originConversationId: undefined,
@@ -389,6 +391,9 @@ async function launchMultiRepositoryRail(input, io = {}) {
                 if (head.code !== 0 || !/^[a-f0-9]{40,64}$/i.test(head.stdout.trim()))
                     throw new Error(`Cannot freeze HEAD for ${repository.name}`);
                 manifest.repositories.push({ repositoryId: repository.id, name: repository.name, sourcePath: repository.path,
+                    ...(repository.workspacePath ? { workspacePath: repository.workspacePath } : {}),
+                    ...(repository.workspacePaths ? { workspacePaths: [...repository.workspacePaths] } : {}),
+                    ...((input.workspaceSelection?.[repository.id] ?? previousRepository?.selectedWorkspacePaths) ? { selectedWorkspacePaths: [...(input.workspaceSelection?.[repository.id] ?? previousRepository.selectedWorkspacePaths)] } : {}),
                     gitCommonDir: (0, repo_lock_1.repositoryLockKey)(repository.path), baseBranch: child.base_branch, integrationBranch: integrationBranches.get(repository.id) ?? previousRepository?.integrationBranch ?? child.base_branch, baseSha: head.stdout.trim(),
                     worktreePath: worktree.worktree_path, branch: worktree.branch, worktreeId: worktree.id });
             }