specrails-desktop 2.58.1 → 2.59.1

package/server/dist/modules/loops/runtime/loop-definition-events.js

@@ -129,7 +129,7 @@ function createDefinitionEventProjection(input) {
                     persist('loop_step', { index: nextCount, kind: 'core', title: workflow.nodePath, iteration: workflow.visit, startedAtMs: Date.parse(at), ...correlation });
                 }
                 else if (opening && ['step_succeeded', 'step_failed', 'step_blocked', 'step_interrupted', 'step_retrying', 'step_paused'].includes(String(workflow.type))) {
-                    persist('loop_step_end', { index: opening.index, status: workflow.type === 'step_succeeded' ? 'ok' : workflow.type === 'step_paused' ? 'paused' : workflow.type === 'step_interrupted' ? 'interrupted' : 'failed',
+                    persist('loop_step_end', { index: opening.index, status: workflow.type === 'step_succeeded' ? workflow.outcome === 'fail' ? 'failed' : 'ok' : workflow.type === 'step_paused' ? 'paused' : workflow.type === 'step_interrupted' ? 'interrupted' : 'failed',
                         runtimeStatus: String(workflow.type).slice(5), outcome: workflow.outcome, exitCode: null,
                         durationMs: Math.max(0, Date.parse(at) - Number(opening.startedAtMs)), ...correlation });
                 }

package/server/dist/modules/loops/runtime/loop-definition.js

@@ -4,12 +4,14 @@ exports.compileLoopToDefinition = compileLoopToDefinition;
 const loop_command_catalog_1 = require("./loop-command-catalog");
 const loop_constants_1 = require("./loop-constants");
 const loop_graph_1 = require("./loop-graph");
-const AI_KINDS = new Set(['prompt', 'role-turn', 'decider', 'implementation']);
+const AI_KINDS = new Set(['prompt', 'role-turn', 'decider', 'implementation', 'implementation-step']);
 const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 /** No I/O, model call, hash implementation or scheduling belongs in this adapter. */
 function compileLoopToDefinition(graph, launch) {
     (0, loop_graph_1.assertDefinitionGraph)(graph);
     const allGraphs = [graph, ...Object.values(graph.components ?? {})];
+    if (!graph.config.agents && allGraphs.some(body => body.nodes.some(node => node.data?.kind === 'implementation-step')))
+        throw new Error('Independent implementation steps require loop-owned agents');
     for (const body of allGraphs) {
         (0, loop_graph_1.assertDefinitionGraph)(body);
         const validation = (0, loop_graph_1.validateLoopGraph)(body);
@@ -41,14 +43,25 @@ function compileLoopToDefinition(graph, launch) {
                     ...(typeof node.data?.reason === 'string' ? { reason: node.data.reason } : {}),
                 }
                 : node.data.params;
-            const engineInput = object(rawParams.engine) ? rawParams.engine : {};
-            const provider = typeof engineInput.provider === 'string' ? engineInput.provider : launch.provider;
+            const promptRole = node.id === 'fix' ? 'fixer' : node.id === 'prepare' ? 'architect' : rawParams.access === 'read' ? 'reviewer' : 'developer';
+            const agents = graph.config.agents ? launch.loopAgents ?? graph.config.agents : undefined;
+            const loopEngine = agents ? (promptRole === 'fixer' ? agents.fixer ?? agents.agents.developer : agents.agents[promptRole]) : undefined;
+            const engineInput = { ...(loopEngine ? { provider: loopEngine.provider, ...(loopEngine.model ? { model: loopEngine.model } : {}), ...(loopEngine.effort ? { effort: loopEngine.effort } : {}), ...(loopEngine.thinking ? { thinking: loopEngine.thinking } : {}), ...(loopEngine.maxTurns ? { maxTurns: loopEngine.maxTurns } : {}) } : {}), ...(object(rawParams.engine) ? rawParams.engine : {}) };
+            const inherited = engineInput.provider === 'inherit';
+            const provider = inherited ? launch.provider : typeof engineInput.provider === 'string' ? engineInput.provider : launch.provider;
+            if (inherited) {
+                engineInput.provider = provider;
+                if (!engineInput.model && launch.model)
+                    engineInput.model = launch.model;
+                if (!engineInput.effort && launch.effort)
+                    engineInput.effort = launch.effort;
+            }
             const params = resolveValue(rawParams, launch, provider);
             if (kind === 'prompt') {
                 params.engine = {
                     provider,
-                    ...(provider === launch.provider && launch.model ? { model: launch.model } : {}),
-                    ...(provider === launch.provider && launch.effort ? { effort: launch.effort } : {}),
+                    ...(!loopEngine && provider === launch.provider && launch.model ? { model: launch.model } : {}),
+                    ...(!loopEngine && provider === launch.provider && launch.effort ? { effort: launch.effort } : {}),
                     ...engineInput,
                 };
                 if (typeof rawParams.text === 'string' &&
@@ -61,6 +74,15 @@ function compileLoopToDefinition(graph, launch) {
                     }
                 }
             }
+            if (kind === 'prompt' && graph.config.agents) {
+                const definition = graph.config.agents.rolePrompts?.[promptRole]?.replaceAll('{{', '{{{{');
+                if (definition) {
+                    if (object(params.nativeCommand))
+                        params.nativeCommand = { ...params.nativeCommand, args: String(params.nativeCommand.args ?? '') + '\n\nLoop agent definition:\n' + definition };
+                    else if (typeof params.text === 'string')
+                        params.text = definition + '\n\n' + params.text;
+                }
+            }
             if (launch.briefing && ['prompt', 'role-turn', 'decider'].includes(kind)) {
                 const suffix = '\n\nFrozen launch context:\n' + launch.briefing;
                 if (object(params.nativeCommand))
@@ -70,7 +92,7 @@ function compileLoopToDefinition(graph, launch) {
                         if (typeof params[field] === 'string')
                             params[field] += suffix;
             }
-            if (kind === 'implementation')
+            if ((kind === 'implementation' || kind === 'implementation-step'))
                 for (const role of ['architect', 'developer', 'reviewer'])
                     roleIds.add(role);
             if ((kind === 'role-turn' || kind === 'decider') && typeof params.roleId === 'string')
@@ -102,10 +124,51 @@ function compileLoopToDefinition(graph, launch) {
         };
     };
     const body = compileBody(graph);
+    // Specialize the Desktop Implement recipe with the frozen launch scope.
+    // Its ordinary review/candidate gates remain in place; an addendum cannot
+    // disappear behind a generic approved=true response.
+    if (launch.id === 'factory:implement' && launch.addendaIds?.length) {
+        const reviewer = body.nodes.reviewer;
+        const policy = body.nodes['review-policy'];
+        if (reviewer?.kind === 'role-turn' && policy?.kind === 'condition' && object(reviewer.params.structuredOutput)) {
+            const schema = reviewer.params.structuredOutput;
+            const entries = Object.fromEntries(launch.addendaIds.map((id, index) => [`a${index}`, {
+                    type: 'object', additionalProperties: false, required: ['id', 'verdict', 'files', 'tests'],
+                    properties: {
+                        id: { type: 'string', const: id },
+                        verdict: { enum: ['applied', 'partial', 'blocked'] },
+                        files: { type: 'array', items: { type: 'string', minLength: 1 }, maxItems: 100 },
+                        tests: { type: 'array', items: { type: 'string', minLength: 1 }, maxItems: 100 },
+                    },
+                }]));
+            reviewer.params.structuredOutput = {
+                ...schema, properties: { ...(object(schema.properties) ? schema.properties : {}), addenda: { type: 'object', additionalProperties: false, properties: entries, required: Object.keys(entries) } },
+                required: [...(Array.isArray(schema.required) ? schema.required : []), 'addenda'],
+            };
+            reviewer.params.prompt += '\nReport every frozen addendum in addenda (slots in launch order): ' + JSON.stringify(launch.addendaIds) + '. Inspect real code and verification evidence. Use applied only with concrete files and executed tests; otherwise partial or blocked. Also include one line per addendum in summary: - [id] applied — files: paths — tests: commands and results.';
+            const checks = launch.addendaIds.map((_, index) => {
+                const ref = `$outputs.reviewer.structured.addenda.a${index}`;
+                return `${ref}.verdict == "applied" && ${ref}.files.length > 0 && ${ref}.tests.length > 0`;
+            });
+            // Core bounds expression length/token count. Keep large addendum scopes
+            // in small successive gates instead of generating one unbounded expression.
+            let next = reviewer.ends.next;
+            for (let offset = checks.length - 1; offset >= 0; offset -= 10) {
+                const first = Math.max(0, offset - 9);
+                let id = `addenda-review-${first}`;
+                while (body.nodes[id])
+                    id += '-gate';
+                body.nodes[id] = { kind: 'condition', params: { expr: checks.slice(first, offset + 1).map(expr => `(${expr})`).join(' && ') }, ends: { true: next, false: policy.ends.false } };
+                next = id;
+            }
+            reviewer.ends.next = next;
+            body.maxTransitions = Math.min(10000, body.maxTransitions + Math.ceil(checks.length / 10) * graph.config.maxIterations);
+        }
+    }
     const components = Object.fromEntries(Object.entries(graph.components ?? {})
         .sort(([a], [b]) => a.localeCompare(b, 'en'))
         .map(([id, component]) => [id, compileBody(component)]));
-    const implementation = [body, ...Object.values(components)].some((component) => Object.values(component.nodes).some((node) => node.kind === 'implementation'));
+    const implementation = [body, ...Object.values(components)].some((component) => Object.values(component.nodes).some((node) => (node.kind === 'implementation' || node.kind === 'implementation-step')));
     const budget = {
         ...(graph.config.maxCostUsd && graph.config.maxCostUsd > 0
             ? { maxCostUsd: graph.config.maxCostUsd }
@@ -143,8 +206,8 @@ function pieceWrites(node, roles) {
     if (kind === 'prompt')
         return params.access !== 'read';
     if (kind === 'role-turn')
-        return roles?.[String(params.roleId)]?.access !== 'read';
-    return ['verify', 'shell', 'openspec-archive', 'implementation'].includes(kind ?? '');
+        return (roles ?? {})[String(params.roleId)]?.access !== 'read';
+    return ['verify', 'shell', 'openspec-archive', 'implementation', 'implementation-step'].includes(kind ?? '');
 }
 /** Expand templates once. Text inserted by spec/constants cannot introduce another token. */
 function resolveValue(value, launch, provider) {
@@ -153,10 +216,14 @@ function resolveValue(value, launch, provider) {
             if (token === '{{{{')
                 return token; // Core resolves the literal escape at execution.
             if (/^\{\{\s*spec\./.test(token))
-                return (0, loop_graph_1.interpolateSpec)(token, launch.spec);
+                return (0, loop_graph_1.interpolateSpec)(token, launch.spec).replaceAll('{{', '{{{{');
             if (/^\{\{\s*const:/.test(token))
-                return (0, loop_constants_1.resolveConstants)(token.replace(/\s+/g, ''), launch.constants);
-            return (0, loop_command_catalog_1.expandCommands)(token, { provider, ticketIds: launch.spec?.ticketIds, specId: launch.spec?.id });
+                return (0, loop_constants_1.resolveConstants)(token.replace(/\s+/g, ''), launch.constants).replaceAll('{{', '{{{{');
+            // Registry templates contain launch tokens themselves. Resolve only
+            // those trusted tokens, never commands introduced by task data.
+            return (0, loop_command_catalog_1.expandCommands)(token, { provider, ticketIds: launch.spec?.ticketIds, specId: launch.spec?.id }).replace(/\{\{\s*(?:spec\.\w+|const:[A-Za-z0-9_.-]+)\s*\}\}/g, nested => (/^\{\{\s*spec\./.test(nested)
+                ? (0, loop_graph_1.interpolateSpec)(nested, launch.spec)
+                : (0, loop_constants_1.resolveConstants)(nested.replace(/\s+/g, ''), launch.constants)).replaceAll('{{', '{{{{'));
         });
     }
     if (Array.isArray(value))

package/server/dist/modules/loops/runtime/loop-effect.js

@@ -11,7 +11,7 @@ function classifyLoopEffect(graph) {
         if (n.data?.kind === 'prompt')
             return n.data.params?.access !== 'read';
         // Role access binds at launch; isolation is conservative before that binding.
-        return ['role-turn', 'verify', 'shell', 'openspec-archive', 'implementation', 'component', 'map'].includes(String(n.data?.kind));
+        return ['role-turn', 'verify', 'shell', 'openspec-archive', 'implementation', 'implementation-step', 'component', 'map'].includes(String(n.data?.kind));
     }) || Object.values(graph.components ?? {}).some(component => classifyLoopEffect(component) === 'mutating');
     return writes ? 'mutating' : 'read-only';
 }

package/server/dist/modules/loops/runtime/loop-executors.js

@@ -185,10 +185,20 @@ function createLoopExecutors(opts = {}) {
             const host = (0, agent_runtime_bridge_1.readFrozenRuntimeHost)(contextPath, resolveEnv(), runId);
             await (0, agent_runtime_bridge_1.runAgentRuntimeControl)({ kind: 'cancel', runId, contextPath, requestId, ...host });
         },
-        async assertDefinitionSupport() {
+        async assertDefinitionSupport(graph) {
             const runtime = await (0, agent_runtime_loader_1.loadCoreAgentRuntime)();
             if (runtime.api?.capabilities?.engineV2 !== 1 || runtime.api?.capabilities?.workflowDefinitions !== 1)
                 throw new Error('engine_unsupported: Update Core to run workflow definitions');
+            if (graph && [graph, ...Object.values(graph.components ?? {})].some(body => body.nodes.some(node => node.data?.kind === 'artifact-contract'))) {
+                if (runtime.api?.capabilities?.workflowAgentSteps !== 1)
+                    throw new Error('engine_unsupported: Update Core to run configurable workflow agent steps');
+            }
+            if (graph && [graph, ...Object.values(graph.components ?? {})].some(body => body.nodes.some(node => node.data?.kind === 'implementation-step'))) {
+                if (runtime.api?.capabilities?.implementationSteps !== 1)
+                    throw new Error('engine_unsupported: Update Core to run independent implementation steps');
+                if (!graph.config.agents)
+                    throw new Error('Independent implementation steps require loop-owned agents');
+            }
         },
         async assertLegacyEngineSupport() {
             // Legacy traversal predates Core: only a Core that positively lacks engine 1 blocks it.
@@ -211,17 +221,21 @@ function createLoopExecutors(opts = {}) {
                 return { ...result, runtimeStatus: result.runtimeStatus ?? 'failed' };
             }
             const seeded = (0, loop_run_manager_1.seedChangeId)({ ...request, runId });
-            const briefing = [request.followUp?.briefing, request.addenda?.briefing].filter(Boolean).join('\n\n');
+            const delta = seeded && (seeded.source === 'addenda' || seeded.source === 'revision')
+                ? `DELTA OPENSPEC TARGET: ${seeded.id}. Use ONLY openspec/changes/${seeded.id}/; create it if missing. Inspect the current branch before planning. For delivered work, plan and implement ONLY the attached addenda or delivery change request, preserving existing behavior outside the delta. For work not yet implemented, implement the full spec together with its addenda. Map each requested change to acceptance checks. Do not redo or archive the original proposal. Report each addendum id with concrete files and test evidence.`
+                : undefined;
+            const briefing = [delta, request.constants?.REVISION_REQUEST, request.followUp?.briefing, request.addenda?.briefing].filter(Boolean).join('\n\n');
             const spec = request.spec && briefing ? { ...request.spec, description: [request.spec.description, briefing].filter(Boolean).join('\n\n'), ...(request.spec.tickets ? { tickets: request.spec.tickets.map(ticket => ({ ...ticket, description: [ticket.description, briefing].filter(Boolean).join('\n\n') })) } : {}) } : request.spec;
             const env = { ...programmaticStepEnv(resolveEnv(), request.repoDir, request.executionManifest), SPECRAILS_GIT_AUTO: 'false' };
-            const core = (0, core_execution_1.prepareCoreExecution)({ run: { runId, projectId: request.projectId, repositoryId: request.repositoryId, spec, goal: request.spec?.title ?? request.loopName }, cwd: request.cwd, repoDir: request.repoDir, manifest: request.executionManifest, env, sourcePath: request.executionManifest ? undefined : opts.sourcePath?.() });
+            const core = (0, core_execution_1.prepareCoreExecution)({ run: { runId, projectId: request.projectId, repositoryId: request.repositoryId, spec, goal: request.spec?.title ?? request.loopName }, cwd: request.cwd, repoDir: request.repoDir, manifest: request.executionManifest, env, sourcePath: request.executionManifest ? undefined : opts.sourcePath?.(), workspacePaths: request.executionManifest ? undefined : opts.workspacePaths?.(), selectedWorkspacePaths: request.workspacePaths });
             const result = await (0, agent_runtime_bridge_1.runAgentRuntimeInvocation)({
                 contextPath: core.contextPath, cwd: request.cwd, env: core.env,
                 configPath: runtimeConfigPath(request.cwd), engineVersion: 2,
+                loopConfig: request.graph.config.agents,
                 change: seeded?.id ?? (0, agent_runtime_bridge_1.runtimeChangeName)(runId),
                 resume: input.resume, answer: input.answer, approve: input.approve, interruptId: input.interruptId,
-                defaultProvider: request.provider, providerOverride: request.runtimeProviderOverride,
-                ...(request.graph.config.legacyDeciderRole ? { workflowRoleBindings: {
+                defaultProvider: request.provider, providerOverride: request.runtimeProviderOverride ?? (request.graph.config.agents ? { provider: request.provider, model: request.model, effort: request.effort } : undefined),
+                ...(!request.graph.config.agents && request.graph.config.legacyDeciderRole ? { workflowRoleBindings: {
                         [request.graph.config.legacyDeciderRole]: {
                             ...(request.deciderEngine ?? { provider: request.provider, model: request.model, effort: request.effort }),
                             access: 'read', artifacts: 'none',
@@ -229,9 +243,10 @@ function createLoopExecutors(opts = {}) {
                     } } : {}),
                 ...(!input.resume ? { prepareDefinition: (config) => (0, loop_definition_1.compileLoopToDefinition)(request.graph, {
                         id: request.loopId, title: request.loopName, spec: request.spec,
+                        ...(request.graph.config.agents ? { loopAgents: config } : {}),
                         constants: request.constants ?? {}, provider: request.provider, model: request.model, effort: request.effort,
                         roles: { architect: { access: 'read' }, developer: { access: 'write' }, reviewer: { access: 'read' }, ...config.roles }, repositoryCount: request.executionManifest?.repositories.length ?? 1,
-                        changeId: seeded?.id, briefing,
+                        changeId: seeded?.id, briefing: [briefing, core.workspaceBriefing].filter(Boolean).join('\n\n'), addendaIds: request.addenda?.ids,
                     }) } : {}),
                 onPrepared: input.onPrepared, onLine: input.onLine, onRuntimeEvent: input.onRuntimeEvent, onSpawn: input.onSpawn, timeoutMs: input.timeoutMs,
             });
@@ -297,7 +312,7 @@ function createLoopExecutors(opts = {}) {
             const existingContext = coreRun ? runtimeContextPath(cwd, coreRun.runId, baseEnv) : undefined;
             const programmatic = coreRun && existingContext && (coreRun.implementation || (coreRun.verificationStep && existsRuntimeRequest(existingContext)));
             const baseStepEnv = programmatic ? programmaticStepEnv(baseEnv, repoDir, executionManifest) : withProfileEnv(aiStepEnv(baseEnv, repoDir, executionManifest), provider, profileName);
-            const core = coreRun ? (0, core_execution_1.prepareCoreExecution)({ run: coreRun, cwd, repoDir, manifest: executionManifest, env: baseStepEnv, sourcePath: executionManifest ? undefined : opts.sourcePath?.() }) : undefined;
+            const core = coreRun ? (0, core_execution_1.prepareCoreExecution)({ run: coreRun, cwd, repoDir, manifest: executionManifest, env: baseStepEnv, sourcePath: executionManifest ? undefined : opts.sourcePath?.(), workspacePaths: executionManifest ? undefined : opts.workspacePaths?.(), selectedWorkspacePaths: coreRun?.workspacePaths }) : undefined;
             const stepEnv = core?.env ?? baseStepEnv;
             if (coreRun?.implementation && core) {
                 completionContexts.set(coreRun.runId, { cwd, contextPath: core.contextPath, env: stepEnv, runId: coreRun.runId });
@@ -536,7 +551,7 @@ function createLoopExecutors(opts = {}) {
             if (!adapter.capabilities.persistentStdin)
                 return null;
             const baseStepEnv = withProfileEnv(aiStepEnv(resolveEnv(), repoDir, executionManifest), provider, profileName);
-            const core = coreRun ? (0, core_execution_1.prepareCoreExecution)({ run: coreRun, cwd, repoDir, manifest: executionManifest, env: baseStepEnv, sourcePath: executionManifest ? undefined : opts.sourcePath?.() }) : undefined;
+            const core = coreRun ? (0, core_execution_1.prepareCoreExecution)({ run: coreRun, cwd, repoDir, manifest: executionManifest, env: baseStepEnv, sourcePath: executionManifest ? undefined : opts.sourcePath?.(), workspacePaths: executionManifest ? undefined : opts.workspacePaths?.(), selectedWorkspacePaths: coreRun?.workspacePaths }) : undefined;
             const stepEnv = core?.env ?? baseStepEnv;
             const extraArgs = aiStepExtraArgs(adapter, cwd, repoDir, executionManifest);
             if (repoDir) {
@@ -592,7 +607,7 @@ function createLoopExecutors(opts = {}) {
             const baseEnv = resolveEnv();
             const programmatic = existsRuntimeRequest(runtimeContextPath(cwd, coreRun.runId, baseEnv));
             const baseStepEnv = programmatic ? programmaticStepEnv(baseEnv, repoDir, executionManifest) : withProfileEnv(aiStepEnv(baseEnv, repoDir, executionManifest), provider, profileName);
-            const core = (0, core_execution_1.prepareCoreExecution)({ run: coreRun, cwd, repoDir, manifest: executionManifest, env: baseStepEnv, sourcePath: executionManifest ? undefined : opts.sourcePath?.() });
+            const core = (0, core_execution_1.prepareCoreExecution)({ run: coreRun, cwd, repoDir, manifest: executionManifest, env: baseStepEnv, sourcePath: executionManifest ? undefined : opts.sourcePath?.(), workspacePaths: executionManifest ? undefined : opts.workspacePaths?.(), selectedWorkspacePaths: coreRun?.workspacePaths });
             if (existsRuntimeRequest(core.contextPath))
                 return (0, core_execution_1.checkCoreCompletion)(core.contextPath, cwd, { ...programmaticStepEnv(resolveEnv(), repoDir, executionManifest), SPECRAILS_EXECUTION_CONTEXT: core.contextPath }, coreRun.runId);
             const env = (0, runtime_1.buildProviderEnv)((0, providers_1.getAdapter)(provider), { prompt: '', model, reasoning_effort: effort }, core.env);

package/server/dist/modules/loops/runtime/loop-factory.js

@@ -94,7 +94,7 @@ const FACTORY_BY_ID = new Map([
 function factoryLoopsForCapabilities(capabilities) {
     if (capabilities?.engineV2 !== 1 || capabilities.workflowDefinitions !== 1)
         return exports.FACTORY_LOOPS;
-    return exports.FACTORY_LOOPS.map(factory => ({ ...factory, graph: (0, loop_core_factory_1.coreFactoryGraph)(factory.id === 'factory:implement' ? 'implement' : factory.id === 'factory:freestyle' ? 'freestyle' : 'quick-sdd') }));
+    return exports.FACTORY_LOOPS.map(factory => ({ ...factory, graph: (0, loop_core_factory_1.coreFactoryGraph)(factory.id === 'factory:implement' ? 'implement' : factory.id === 'factory:freestyle' ? 'freestyle' : 'quick-sdd', capabilities.implementationSteps === 1, capabilities.workflowAgentSteps === 1) }));
 }
 function getFactoryLoop(id, capabilities) {
     const legacy = FACTORY_BY_ID.get(id);

package/server/dist/modules/loops/runtime/loop-graph.js

@@ -1,14 +1,4 @@
 "use strict";
-/**
- * Loop graph model + validation — the pure core shared by the canvas builder
- * (`loop-builder-canvas`) and the publish gate (`loops-store.publishLoop`).
- *
- * A loop is a directed graph of typed nodes connected by edges. Cycles are
- * allowed (a loop routes back to an earlier node); the run is bounded by the
- * graph's `config.maxIterations` + `timeoutMinutes`. This module has NO I/O and
- * NO provider knowledge — it only describes and validates the shape, so it is
- * trivially unit-testable and reused verbatim by both the store and the engine.
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CORE_NODE_KINDS = void 0;
 exports.isDefinitionReviewerPath = isDefinitionReviewerPath;
@@ -24,8 +14,8 @@ exports.successors = successors;
 exports.loopNeedsTicket = loopNeedsTicket;
 exports.interpolateSpec = interpolateSpec;
 exports.CORE_NODE_KINDS = ['prompt', 'role-turn', 'decider', 'condition', 'assign', 'verify', 'shell',
-    'openspec-validate', 'openspec-archive', 'approval', 'question', 'gate', 'map', 'join',
-    'component', 'implementation', 'end'];
+    'artifact-contract', 'openspec-validate', 'openspec-archive', 'approval', 'question', 'gate', 'map', 'join',
+    'component', 'implementation', 'implementation-step', 'end'];
 function isDefinitionReviewerPath(graph, value) {
     if (typeof value !== 'string' || !value || value.length > 2048)
         return false;
@@ -38,7 +28,7 @@ function isDefinitionReviewerPath(graph, value) {
         if (!node || node.type !== 'core')
             return false;
         if (index === segments.length - 1)
-            return node.data?.kind === 'role-turn';
+            return node.data?.kind === 'role-turn' || node.data?.kind === 'implementation-step' && node.data.params?.phase === 'reviewer';
         const ref = node.data?.kind === 'component' ? node.data.params?.ref : node.data?.kind === 'map' ? node.data.params?.body : undefined;
         body = typeof ref === 'string' ? graph.components?.[ref] : undefined;
     }
@@ -176,6 +166,7 @@ function validateLoopGraph(graph, catalog) {
         (cfg.maxCostUsd !== undefined && !Number.isFinite(cfg.maxCostUsd)) ||
         (cfg.maxTransitions !== undefined && (!Number.isInteger(cfg.maxTransitions) || cfg.maxTransitions < 1 || cfg.maxTransitions > 10000)) ||
         (cfg.maxTokens !== undefined && (!Number.isInteger(cfg.maxTokens) || cfg.maxTokens < 1)) ||
+        (cfg.ticketScope !== undefined && !['all', 'per-ticket'].includes(cfg.ticketScope)) ||
         (cfg.reviewerStepId !== undefined && !isDefinitionReviewerPath(graph, cfg.reviewerStepId))) {
         errors.push({
             code: 'INVALID_CONFIG',
@@ -300,7 +291,7 @@ function loopNeedsTicket(graph) {
     if (!graph)
         return false;
     for (const node of graph.nodes) {
-        if (node.type === 'core' && node.data?.kind === 'implementation')
+        if (node.type === 'core' && ['implementation', 'implementation-step'].includes(node.data?.kind ?? ''))
             return true;
         const text = [node.data?.prompt, node.data?.command, node.data?.goal,
             node.type === 'core' ? JSON.stringify(node.data?.params) : undefined]

package/server/dist/modules/loops/runtime/loop-implement-recipe.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configurableImplementGraph = configurableImplementGraph;
+const loop_agents_1 = require("./loop-agents");
+const objectSchema = (properties, required = Object.keys(properties)) => ({ type: 'object', properties, required, additionalProperties: false });
+const string = { type: 'string' };
+const strings = { type: 'array', items: string, maxItems: 100 };
+const score = { type: 'number', minimum: 0, maximum: 100 };
+const aspects = { type_correctness: 60, pattern_adherence: 60, test_coverage: 60, security: 75, architectural_alignment: 60 };
+/** The recipe, roles, schemas and decisions are Desktop data, never Core phases. */
+function configurableImplementGraph() {
+    const agents = (0, loop_agents_1.defaultLoopAgents)();
+    agents.roles = {
+        plan: { ...agents.agents.architect, access: 'read', artifacts: 'all', openspecSkill: 'openspec-ff-change', prompt: agents.rolePrompts?.architect },
+        build: { ...agents.agents.developer, access: 'write', artifacts: 'tasks-checkboxes', openspecSkill: 'openspec-apply-change', prompt: agents.rolePrompts?.developer },
+        assess: { ...agents.agents.reviewer, access: 'read', artifacts: 'none', openspecSkill: 'openspec-verify-change', prompt: agents.rolePrompts?.reviewer },
+        correct: { ...agents.fixer, access: 'write', artifacts: 'tasks-checkboxes', openspecSkill: 'openspec-apply-change', prompt: agents.rolePrompts?.fixer },
+    };
+    const nodes = [{ id: 'start', type: 'start', position: { x: 0, y: 0 } }], edges = [];
+    const node = (id, label, kind, params, outcomes) => {
+        nodes.push({ id, type: 'core', position: { x: 0, y: nodes.length * 140 }, data: { kind, label, params } });
+        for (const [outcome, target] of Object.entries(outcomes))
+            edges.push({ id: `e-${id}-${outcome}`, source: id, target, label: outcome });
+    };
+    const turn = (id, label, roleId, prompt, schema, next) => node(id, label, 'role-turn', { roleId, prompt, structuredOutput: schema, sessionContinuity: 'none' }, { next, invalid: 'failed', failed: 'failed' });
+    const change = '{{run.changeId}}';
+    turn('architect', 'Architect', 'plan', `Plan the frozen ticket requirements for OpenSpec change ${change}. Use the bound official fast-forward skill. Author complete proposal, design, delta specs and actionable tasks. Propose existing repository verification commands for repositories with no configured checks. Return confidence, question (empty when none), and verification [{repositoryId,command,args,cwd?}]. When revisiting low confidence, investigate the missing repository evidence before asking again. Context and human answers: {{history.text}}`, objectSchema({ confidence: { enum: ['high', 'medium', 'low'] }, question: string, verification: { type: 'array', maxItems: 20, items: objectSchema({ repositoryId: string, command: string, args: strings, cwd: string }, ['repositoryId', 'command', 'args']) } }), 'confidence');
+    node('confidence', 'Planning confidence', 'condition', { expr: '$outputs.architect.structured.confidence != "low"' }, { true: 'validate', false: 'investigate' });
+    node('investigate', 'Investigate low confidence once', 'condition', { expr: '!exists($vars.planInvestigated) || $vars.planInvestigated == false' }, { true: 'mark-investigated', false: 'clarify' });
+    node('mark-investigated', 'Mark confidence investigation', 'assign', { set: { planInvestigated: true } }, { next: 'architect', failed: 'failed' });
+    node('clarify', 'Clarify plan', 'question', { text: '{{outputs.architect.structured.question}}' }, { next: 'reset-confidence' });
+    node('reset-confidence', 'Reset confidence after answer', 'assign', { set: { planInvestigated: false } }, { next: 'architect', failed: 'failed' });
+    node('validate', 'Validate OpenSpec', 'openspec-validate', { change }, { pass: 'freeze', fail: 'architect', failed: 'failed' });
+    node('freeze', 'Freeze approved artifacts', 'artifact-contract', { change, contractId: 'plan', action: 'freeze' }, { pass: 'developer', fail: 'architect', failed: 'failed' });
+    const implementation = objectSchema({ summary: string, incomplete: strings });
+    turn('developer', 'Developer', 'build', `Implement every approved task for change ${change} using the bound official apply skill. Preserve proposal, design and specs; only tick tasks you completed. Report summary and incomplete task descriptions. Prior execution evidence and human answers: {{history.text}}`, implementation, 'tasks');
+    node('tasks', 'Check artifacts and completed tasks', 'artifact-contract', { change, contractId: 'plan', action: 'check', requireCompletedTasks: true }, { pass: 'verify', fail: 'developer', failed: 'failed' });
+    node('verify', 'Verify candidate', 'verify', { commands: 'configured', additionalCommandsFrom: 'architect' }, { pass: 'reviewer', fail: 'correction-context', failed: 'failed' });
+    turn('reviewer', 'Reviewer', 'assess', `Review change ${change} read-only against all approved artifacts and frozen ticket acceptance criteria. Inspect real code and the host verification evidence: {{outputs.verify}}. Return approved, summary, issues, score (0-100), and aspects. Prior execution: {{history.text}}`, objectSchema({ approved: { type: 'boolean' }, summary: string, issues: strings, score, aspects: objectSchema(Object.fromEntries(Object.keys(aspects).map(aspect => [aspect, score]))) }), 'review-policy');
+    node('review-policy', 'Review acceptance policy', 'condition', { expr: ['$outputs.reviewer.structured.approved == true', '$outputs.reviewer.structured.issues.length == 0', '$outputs.reviewer.structured.score >= 70', ...Object.entries(aspects).map(([aspect, threshold]) => `$outputs.reviewer.structured.aspects.${aspect} >= ${threshold}`)].join(' && ') }, { true: 'approve', false: 'correction-context' });
+    node('correction-context', 'Select current review findings', 'condition', { expr: '$outputs.verify.valid == true && exists($outputs.reviewer.candidateHash) && $outputs.reviewer.candidateHash == $outputs.verify.candidateHash' }, { true: 'capture-review', false: 'clear-review' });
+    node('capture-review', 'Capture current review findings', 'assign', { set: { latestReview: '{{outputs.reviewer}}' } }, { next: 'fixer', failed: 'failed' });
+    node('clear-review', 'Clear outdated review findings', 'assign', { set: { latestReview: 'No reviewer findings for the current verified candidate. Diagnose the current host verification failure first.' } }, { next: 'fixer', failed: 'failed' });
+    turn('fixer', 'Fixer', 'correct', `Correct the reported implementation, test or review failure for change ${change} using the bound apply skill and preserving approved artifacts. Read failureSummary, command, cwd, exitCode and evidenceId first; use read_verification_evidence for truncated evidence. Reproduce the exact focused failure, inspect the assertion and tested code, then apply the smallest repair that preserves the required behavior. An unchanged filename does not prove an unrelated failure. A mandatory test inside the admitted workspace may receive a proven formatting/compatibility repair while retaining every required guard. Report diagnosis, focused commands with original exit codes, repair and unresolved failures in summary and incomplete. If the cause cannot be repaired within scope, explain the evidence and required action; an unchanged candidate with failed verification stops this run. Host verification: {{outputs.verify}}. Latest review findings for this candidate: {{run.latestReview}}. Prior execution: {{history.text}}`, implementation, 'correction-progress');
+    node('correction-progress', 'Check correction progress', 'condition', { expr: '$outputs.verify.valid == true || (exists($outputs.fixer.candidateHash) && $outputs.fixer.candidateHash != null && $outputs.fixer.candidateHash != $outputs.verify.candidateHash)' }, { true: 'tasks', false: 'correction-stalled' });
+    node('approve', 'Approve archive', 'approval', { reason: `Approve archiving the reviewed and verified candidate for change ${change}.`, bindCandidate: true, enabled: agents.approvalBeforeArchive === true }, { next: 'approval-policy' });
+    node('approval-policy', 'Approval decision', 'condition', { expr: '$outputs.approve.response.approved == true' }, { true: 'archive', false: 'failed' });
+    node('archive', 'Archive OpenSpec', 'openspec-archive', { change, allowArchived: true, requiresVerified: true, reviewedCandidate: '{{outputs.reviewer.candidateHash}}', approvedCandidate: '{{outputs.approve.candidateHash}}' }, { next: 'verify-archive', failed: 'verify' });
+    node('verify-archive', 'Verify archived candidate', 'verify', { commands: 'configured', additionalCommandsFrom: 'architect' }, { pass: 'done', fail: 'failed', failed: 'failed' });
+    nodes.push({ id: 'done', type: 'end', position: { x: 0, y: nodes.length * 140 }, data: { outcome: 'success', requiresVerified: true } }, { id: 'failed', type: 'end', position: { x: 360, y: nodes.length * 140 }, data: { outcome: 'failure' } }, { id: 'correction-stalled', type: 'end', position: { x: 720, y: nodes.length * 140 }, data: { outcome: 'failure', reason: 'Verification remains failed and the correction made no candidate changes. {{outputs.fixer.structured.summary}}' } });
+    edges.unshift({ id: 'e-start', source: 'start', target: 'architect' });
+    return { nodes, edges, config: { maxIterations: 12, maxTransitions: 200, timeoutMinutes: 0, aiStepTimeoutMinutes: 0, change: 'new', journal: 'ledger-only', ticketScope: 'all', agents, reviewerStepId: 'reviewer' } };
+}

package/server/dist/modules/loops/runtime/loop-run-manager.js

@@ -145,29 +145,37 @@ const CHANGE_ID_RE = /openspec[\\/]+changes[\\/]+(?!archive(?:[\\/]|$))([A-Za-z0
 function resolveRunVars(text, vars) {
     return text.replace(RUN_TOKEN_RE, (_m, key) => vars[key] ?? '');
 }
-const CHANGE_NAME_RE = /^[a-z0-9][a-z0-9._-]{0,99}$/i;
+const CHANGE_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 /** The authoritative OpenSpec target for a launch.
- *  Addenda/delivery deltas get a run-specific name; ordinary launches use the
+ *  Addenda/delivery deltas use durable content/lineage identity; ordinary launches use the
  *  follow-up's declared name, else the spec's `openspecChangeName`. */
 function seedChangeId(req) {
-    if (req.addenda?.ids.length) {
-        // A new generation never picks an old/archived proposal, even when the
-        // ticket metadata still names it. Resuming the same run keeps its target.
-        const hash = (0, crypto_1.createHash)('sha256').update(JSON.stringify([req.runId, req.addenda.ids, req.addenda.briefing])).digest('hex').slice(0, 20);
-        return { id: `spec-addenda-${hash}`, source: 'addenda' };
-    }
-    if (req.constants?.REVISION_REQUEST) {
-        const hash = (0, crypto_1.createHash)('sha256').update(JSON.stringify([req.runId, req.constants.REVISION_REQUEST])).digest('hex').slice(0, 20);
-        return { id: `delivery-change-${hash}`, source: 'revision' };
-    }
+    const valid = (value) => value.length <= 64 && CHANGE_NAME_RE.test(value);
     const fromFollowUp = typeof req.followUp?.openspecChangeName === 'string' ? req.followUp.openspecChangeName.trim() : '';
-    if (fromFollowUp && CHANGE_NAME_RE.test(fromFollowUp))
-        return { id: fromFollowUp, source: 'followUp' };
     const direct = typeof req.spec?.openspecChangeName === 'string' ? req.spec.openspecChangeName.trim() : '';
     const fromMetadata = typeof req.spec?.metadata?.openspecChangeName === 'string' ? req.spec.metadata.openspecChangeName.trim() : '';
-    const fromSpec = direct || fromMetadata;
-    if (fromSpec && CHANGE_NAME_RE.test(fromSpec))
-        return { id: fromSpec, source: 'spec' };
+    const declared = valid(fromFollowUp) ? fromFollowUp : valid(direct || fromMetadata) ? direct || fromMetadata : '';
+    const source = declared === fromFollowUp ? 'followUp' : 'spec';
+    if (req.addenda?.ids.length || req.constants?.REVISION_REQUEST) {
+        const state = declared ? openspecChangeState(req.cwd, declared) : 'missing';
+        // A pending implementation's addenda refine the same change. Only work
+        // already delivered/archived needs a separate delta proposal.
+        if (declared && (state === 'active' || (state === 'missing' && !req.constants?.REVISION_REQUEST && req.spec?.status !== 'on_review')))
+            return { id: declared, source };
+        const hash = (0, crypto_1.createHash)('sha256').update(JSON.stringify([
+            req.constants?.REVISION_OF_DELIVERY_ID ?? null,
+            req.constants?.REVISION_NUMBER ?? null,
+            req.constants?.REVISION_REQUEST ?? null,
+            req.addenda ? [...req.addenda.ids].sort() : [], req.addenda?.briefing ?? null,
+        ])).digest('hex').slice(0, 12);
+        const revisionNumber = req.constants?.REVISION_NUMBER;
+        const kind = req.addenda?.ids.length ? 'addenda' : 'revision';
+        const suffix = req.constants?.REVISION_REQUEST ? `rev${revisionNumber && /^[1-9]\d{0,3}$/.test(revisionNumber) ? revisionNumber : '1'}-${hash}` : `addenda-${hash}`;
+        const stem = declared || (req.ticketId && req.ticketId > 0 ? `ticket-${req.ticketId}` : 'spec');
+        return { id: `${stem.slice(0, 63 - suffix.length).replace(/-+$/, '')}-${suffix}`, source: kind };
+    }
+    if (declared)
+        return { id: declared, source };
     return undefined;
 }
 /** Where an OpenSpec change currently lives under `cwd`: an ACTIVE
@@ -498,7 +506,7 @@ class LoopRunManager {
         if ((0, loop_graph_1.isDefinitionGraph)(graph)) {
             if (!this.executors.runDefinition)
                 throw new Error('engine_unsupported: Core workflow execution is unavailable');
-            await this.executors.assertDefinitionSupport?.();
+            await this.executors.assertDefinitionSupport?.(graph);
         }
         else
             await this.executors.assertLegacyEngineSupport?.();
@@ -854,6 +862,8 @@ class LoopRunManager {
             });
             if (definitionEngine)
                 (0, loop_runs_store_1.saveDefinitionRun)(this.db, runId, { request: req, source: 'definition' });
+            if (req.launchConfig)
+                this.db.prepare('UPDATE loop_runs SET launch_config_json = ? WHERE id = ?').run(JSON.stringify(req.launchConfig), runId);
             if (req.executionManifest)
                 this.db.prepare('UPDATE loop_runs SET execution_manifest = ? WHERE id = ?').run(JSON.stringify(req.executionManifest), runId);
             (0, db_1.createJob)(this.db, {
@@ -1422,7 +1432,7 @@ class LoopRunManager {
                             const effectiveTimeoutMs = Number.isFinite(remainingMs)
                                 ? Math.max(1, Math.min(aiStepTimeoutMs === 0 ? Infinity : (aiStepTimeoutMs ?? 15 * 60_000), remainingMs))
                                 : aiStepTimeoutMs;
-                            const coreRun = { runId, implementation: requiresCoreCompletion, spec: req.spec, goal: req.spec ? undefined : JSON.stringify({ loop: req.loopName, graph: req.graph }), repositoryId: req.repositoryId, verificationStep: node.data?.requireVerificationPass === true || /\{\{\s*cmd:(?:verify|revision-verify|opsx:verify)\s*\}\}/.test(rawTemplate) };
+                            const coreRun = { runId, implementation: requiresCoreCompletion, spec: req.spec, goal: req.spec ? undefined : JSON.stringify({ loop: req.loopName, graph: req.graph }), repositoryId: req.repositoryId, workspacePaths: req.workspacePaths, verificationStep: node.data?.requireVerificationPass === true || /\{\{\s*cmd:(?:verify|revision-verify|opsx:verify)\s*\}\}/.test(rawTemplate) };
                             const interactivePlan = this.executors.planInteractiveAiStep?.({
                                 coreRun,
                                 provider: nodeProvider,
@@ -1552,7 +1562,7 @@ class LoopRunManager {
                             && requiresCoreCompletion
                             && this.executors.validateCoreCompletion) {
                             const completion = this.executors.validateCoreCompletion({
-                                coreRun: { runId, spec: req.spec, goal: req.spec ? undefined : JSON.stringify({ loop: req.loopName, graph: req.graph }), repositoryId: req.repositoryId },
+                                coreRun: { runId, spec: req.spec, goal: req.spec ? undefined : JSON.stringify({ loop: req.loopName, graph: req.graph }), repositoryId: req.repositoryId, workspacePaths: req.workspacePaths },
                                 provider: nodeProvider, model: nodeModel, effort: nodeEffort, profileName: req.profileName,
                                 cwd: req.cwd, repoDir: req.repoDir, executionManifest: req.executionManifest,
                             });

package/server/dist/modules/loops/runtime/loop-templates.js

@@ -8,6 +8,8 @@ exports.coreStarterGraph = coreStarterGraph;
 exports.supportsCoreTemplates = supportsCoreTemplates;
 exports.loopTemplatesForCapabilities = loopTemplatesForCapabilities;
 exports.getLoopTemplate = getLoopTemplate;
+const loop_core_factory_1 = require("./loop-core-factory");
+const loop_agents_1 = require("./loop-agents");
 /** Closed taxonomy a template's `category` must belong to. Single source of truth
  *  for the gallery's category chips (the client derives its chip list from the
  *  categories actually present in the served catalog). */
@@ -303,7 +305,8 @@ exports.LEGACY_LOOP_TEMPLATES = exports.LOOP_TEMPLATES;
 // - every mutating starter runs the real `verify` piece over the project's
 //   configured checks and ends with `requiresVerified: true` — a passing sentinel
 //   alone never reaches a success end;
-// - ship-and-green = native `implementation` → verify → decider → prompt(fix) loop;
+// - ship-and-green expands implementation operations when supported, then
+//   verify → decider → prompt(fix); old Core retains the compatibility wrapper;
 // - prompts, goals and iteration caps come from STARTER_TEXT (legacy parity).
 /** Fix step shared by every mutating Core starter. Reuses the tuned `{{cmd:fix}}`
  *  contract and covers the verify→fix edge, where no Decider verdict precedes it. */
@@ -324,7 +327,7 @@ function watcherVerdict(goal) {
 const CORE_GOAL_EVIDENCE = 'The configured host verification already passed on the current candidate before this decision. Judge only from concrete evidence in the history (commands run, their output, files changed); green baseline checks, setup or planning alone do not prove the goal.';
 const SHIP_AND_GREEN_GOAL = 'Stop only when the history proves the spec is implemented: every acceptance criterion maps to real code and behavioral evidence across every selected ticket and repository, and the configured host verification passed on the current candidate. Setup, planning, a launched subagent or green baseline checks alone are insufficient; continue when work is missing or incomplete.';
 /** Wall-clock cap for starters (legacy default). ship-and-green is untimed like the
- *  Implement factory: the native implementation piece runs the whole pipeline. */
+ *  Implement factory: implementation operations retain their own execution limits. */
 const STARTER_TIMEOUT_MIN = 30;
 const CORE_STARTER_SHAPES = {
     'ship-and-green': 'ship',
@@ -338,8 +341,10 @@ const CORE_STARTER_SHAPES = {
 };
 /** Core definition graph for one of the eight starters. Deterministic: same id ⇒
  *  structurally identical graph (positions included). */
-function coreStarterGraph(id) {
+function coreStarterGraph(id, independent = false, configurable = false) {
     const shape = CORE_STARTER_SHAPES[id];
+    if (shape === 'ship' && configurable)
+        return (0, loop_core_factory_1.coreFactoryGraph)('implement', true, true);
     const { prompt, goal, maxIterations } = STARTER_TEXT[id];
     const nodes = [{ id: 'start', type: 'start', position: { x: COL_X, y: 0 } }];
     const edges = [];
@@ -381,10 +386,29 @@ function coreStarterGraph(id) {
     }
     edges.unshift({ id: 'e-start', source: 'start', target: entry });
     nodes.push({ id: 'done', type: 'end', position: { x: COL_X, y: ROW_GAP * nodes.length }, data: successEnd }, { id: 'failed', type: 'end', position: { x: COL_RIGHT_X, y: ROW_GAP * nodes.length }, data: { outcome: 'failure' } });
+    if (independent) {
+        config.agents = (0, loop_agents_1.defaultLoopAgents)(shape === 'ship' ? 'implementation' : 'free');
+        if (shape === 'ship') {
+            const operations = (0, loop_core_factory_1.coreFactoryGraph)('implement', true);
+            const path = (id) => id === 'done' ? 'verify' : id === 'failed' ? 'failed' : `implementation-${id}`;
+            nodes.splice(nodes.findIndex(node => node.id === 'implement'), 1);
+            const remove = new Set(edges.filter(edge => edge.source === 'implement').map(edge => edge.id));
+            for (let i = edges.length - 1; i >= 0; i--)
+                if (remove.has(edges[i].id))
+                    edges.splice(i, 1);
+            for (const edge of edges)
+                if (edge.target === 'implement')
+                    edge.target = path('architect');
+            for (const node of operations.nodes.filter(node => node.type === 'core'))
+                nodes.push({ ...node, id: path(node.id) });
+            for (const edge of operations.edges.filter(edge => edge.source !== 'start'))
+                edges.push({ ...edge, id: 'implementation-' + edge.id, source: path(edge.source), target: path(edge.target) });
+        }
+    }
     return { nodes, edges, config };
 }
 const CORE_STARTER_DESCRIPTIONS = {
-    'ship-and-green': 'Fully autonomous: run Core\'s native implementation pipeline for the spec, then verify with the project\'s configured checks and refine (fix) on failure — verify → decide → fix until green. Success requires a verified candidate; no human intervention.',
+    'ship-and-green': 'Fully autonomous: run the loop\'s implementation steps for the spec, then verify with the project\'s configured checks and refine (fix) on failure — verify → decide → fix until green. Success requires a verified candidate; no human intervention.',
     'verify-pass': 'Autonomous verify-and-fix: run the project\'s configured build/lint/tests through Core\'s verify piece, then refine on failure — verify → fix → verify until green.',
     'ci-watch': 'Poll CI checks on the open PR (the agent uses the repo\'s CI tooling) until every check is green. Read-only: the watcher never edits the repository.',
     'lint-and-fix': 'The agent detects and runs the project\'s linter and fixes every issue, iterating until the codebase is clean. Every pass is confirmed by the project\'s configured verification before the loop can succeed.',
@@ -414,7 +438,7 @@ function loopTemplatesForCapabilities(capabilities) {
             ...template,
             description: CORE_STARTER_DESCRIPTIONS[template.id],
             ...(readOnly ? { readOnly: true } : {}),
-            graph: coreStarterGraph(template.id),
+            graph: coreStarterGraph(template.id, capabilities?.implementationSteps === 1, capabilities?.workflowAgentSteps === 1),
         };
     });
 }

package/server/dist/modules/loops/runtime/loops-router.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerLoopsRoutes = registerLoopsRoutes;
+const loop_agents_1 = require("./loop-agents");
+const agent_runtime_settings_1 = require("../../agent-runtime/runtime/agent-runtime-settings");
 const ids_1 = require("../../../ids");
 const feature_flags_1 = require("../../../feature-flags");
 const loops_store_1 = require("./loops-store");
@@ -57,6 +59,12 @@ function registerLoopsRoutes(router, deps) {
         }
         return true;
     }
+    router.get('/loop-agent-defaults', async (_req, res) => {
+        if (!guard(res))
+            return;
+        const runtime = await (0, agent_runtime_loader_1.loadCoreAgentRuntime)().catch(() => null);
+        res.json({ agents: (0, loop_agents_1.defaultLoopAgents)(), guardrails: { supported: runtime?.api?.capabilities?.configurableGuardrails === 1, catalog: runtime?.api?.guardrails ?? [] } });
+    });
     // ── Templates ──────────────────────────────────────────────────────────────
     router.get('/loop-templates', async (_req, res) => {
         if (!guard(res))
@@ -410,6 +418,15 @@ function registerLoopsRoutes(router, deps) {
                     res.status(409).json({ error: 'engine_unsupported', message: 'Update Core to publish executable workflows.' });
                     return;
                 }
+                if (current.graph.config.agents) {
+                    try {
+                        (0, agent_runtime_settings_1.validateLoopRuntimeSettings)(current.graph.config.agents);
+                    }
+                    catch (error) {
+                        res.status(422).json({ error: 'invalid_loop_agents', message: error instanceof Error ? error.message : 'Invalid loop agent settings' });
+                        return;
+                    }
+                }
                 let draft;
                 try {
                     draft = (0, loop_definition_1.compileLoopToDefinition)(current.graph, { id: current.id, title: current.name, constants: (0, loop_constants_1.loadConstantMap)(db), provider: 'claude', spec: { id: 1, title: 'Sample spec', description: 'Publication preview' } });