specrails-desktop 2.57.0 → 2.58.0

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

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 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 ?? {})];
+    for (const body of allGraphs) {
+        (0, loop_graph_1.assertDefinitionGraph)(body);
+        const validation = (0, loop_graph_1.validateLoopGraph)(body);
+        if (!validation.valid)
+            throw new Error(validation.errors.map((error) => `${error.nodeId ?? 'graph'}: ${error.message}`).join('\n'));
+        if (body !== graph && body.components && Object.keys(body.components).length) {
+            throw new Error('Reusable components belong in the top-level component library; nested pieces reference that library.');
+        }
+    }
+    const writes = allGraphs.some((body) => body.nodes.some((node) => pieceWrites(node, launch.roles)));
+    const roleIds = new Set();
+    const compileBody = (body) => {
+        const start = body.nodes.find((node) => node.type === 'start');
+        const entry = body.edges.find((edge) => edge.source === start.id).target;
+        if (body.edges.some((edge) => edge.target === start.id))
+            throw new Error('A Core workflow cannot route back to the visual Start node.');
+        const nodes = {};
+        for (const node of [...body.nodes].sort((a, b) => a.id.localeCompare(b.id, 'en'))) {
+            if (node.type === 'start')
+                continue;
+            const kind = node.type === 'end' ? 'end' : node.data.kind;
+            const rawParams = node.type === 'end'
+                ? {
+                    outcome: node.data?.outcome ?? 'success',
+                    ...(typeof node.data?.requiresVerified === 'boolean'
+                        ? { requiresVerified: node.data.requiresVerified }
+                        : {}),
+                    ...(typeof node.data?.exit === 'string' ? { exit: node.data.exit } : {}),
+                    ...(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 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 } : {}),
+                    ...engineInput,
+                };
+                if (typeof rawParams.text === 'string' &&
+                    /^\s*\{\{\s*cmd:[\w:-]+\s*\}\}/.test(rawParams.text) &&
+                    typeof params.text === 'string') {
+                    const native = params.text.match(/^\s*(?:\/|\$)([a-z][a-z0-9:_-]*)(?:\s+([\s\S]*))?$/);
+                    if (native) {
+                        params.nativeCommand = { id: native[1].replace(/^skill:/, ''), args: native[2] ?? '' };
+                        delete params.text;
+                    }
+                }
+            }
+            if (launch.briefing && ['prompt', 'role-turn', 'decider'].includes(kind)) {
+                const suffix = '\n\nFrozen launch context:\n' + launch.briefing;
+                if (object(params.nativeCommand))
+                    params.nativeCommand = { ...params.nativeCommand, args: String(params.nativeCommand.args ?? '') + suffix };
+                else
+                    for (const field of ['text', 'prompt', 'goal'])
+                        if (typeof params[field] === 'string')
+                            params[field] += suffix;
+            }
+            if (kind === 'implementation')
+                for (const role of ['architect', 'developer', 'reviewer'])
+                    roleIds.add(role);
+            if ((kind === 'role-turn' || kind === 'decider') && typeof params.roleId === 'string')
+                roleIds.add(params.roleId);
+            if (kind === 'end' && params.outcome === 'success' && params.requiresVerified === undefined)
+                params.requiresVerified = writes;
+            const ends = Object.fromEntries(body.edges.filter((edge) => edge.source === node.id).map((edge) => [edge.label, edge.target]));
+            nodes[node.id] = {
+                kind,
+                params,
+                ends,
+                ...(node.data?.retry
+                    ? {
+                        retry: {
+                            ...node.data.retry,
+                            ...(node.data.retry.retryOn ? { retryOn: [...node.data.retry.retryOn] } : {}),
+                        },
+                    }
+                    : {}),
+                ...(typeof node.data?.label === 'string' ? { label: node.data.label } : {}),
+            };
+        }
+        return {
+            entry,
+            nodes,
+            maxTransitions: expandedTransitionBound(body, graph.components ?? {}, launch),
+            ...(body.inputs ? { inputs: [...body.inputs] } : {}),
+            ...(body.outputs ? { outputs: [...body.outputs] } : {}),
+        };
+    };
+    const body = compileBody(graph);
+    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 budget = {
+        ...(graph.config.maxCostUsd && graph.config.maxCostUsd > 0
+            ? { maxCostUsd: graph.config.maxCostUsd }
+            : {}),
+        ...(graph.config.maxTokens ? { maxTokens: graph.config.maxTokens } : {}),
+        ...(graph.config.timeoutMinutes > 0
+            ? { maxDurationMs: Math.round(graph.config.timeoutMinutes * 60_000) }
+            : {}),
+    };
+    const id = (launch.id ?? 'desktop-workflow')
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '-')
+        .slice(0, 64);
+    if (!/^[a-z0-9]/.test(id))
+        throw new Error('Workflow id must start with a letter or number.');
+    return {
+        schemaVersion: 1,
+        id,
+        title: launch.title ?? 'Workflow',
+        journal: graph.config.journal ?? (implementation ? 'implementation' : 'ledger-only'),
+        change: graph.config.change ?? (implementation ? (launch.changeId ? 'existing' : 'new') : 'none'),
+        ...body,
+        maxTransitions: body.maxTransitions,
+        roles: [...roleIds].sort(),
+        ...(Object.keys(budget).length ? { budget } : {}),
+        ...(graph.config.policies ? { policies: { ...graph.config.policies } } : {}),
+        ...(Object.keys(components).length ? { components } : {}),
+        delivery: { requiresVerified: writes },
+    };
+}
+function pieceWrites(node, roles) {
+    if (node.type !== 'core')
+        return false;
+    const kind = node.data?.kind, params = node.data?.params ?? {};
+    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 ?? '');
+}
+/** Expand templates once. Text inserted by spec/constants cannot introduce another token. */
+function resolveValue(value, launch, provider) {
+    if (typeof value === 'string') {
+        return value.replace(/\{\{\{\{|\{\{\s*(?:spec\.\w+|const:[A-Za-z0-9_.-]+|cmd:[\w:-]+)\s*\}\}/g, (token) => {
+            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);
+            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 });
+        });
+    }
+    if (Array.isArray(value))
+        return value.map((item) => resolveValue(item, launch, provider));
+    if (object(value))
+        return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, resolveValue(child, launch, provider)]));
+    return value;
+}
+/** Nested visits share Core's global budget. Dynamic fan-out requires an explicit cap or the engine ceiling. */
+function expandedTransitionBound(body, library, launch, ancestors = []) {
+    if (body.config.maxTransitions !== undefined)
+        return body.config.maxTransitions;
+    const weights = new Map();
+    for (const node of body.nodes) {
+        const kind = node.data?.kind, params = node.data?.params ?? {};
+        if (kind === 'implementation' || (kind === 'map' && object(params.over)))
+            return 10_000;
+        if (kind !== 'component' && kind !== 'map')
+            continue;
+        const ref = String(kind === 'component' ? params.ref : params.body);
+        if (ancestors.includes(ref))
+            throw new Error('Reusable components cannot recursively reference themselves.');
+        const child = library[ref];
+        if (!child)
+            continue; // Core reports the exact missing-reference diagnostic.
+        const visits = expandedTransitionBound(child, library, launch, [...ancestors, ref]);
+        if (visits === 10_000)
+            return 10_000;
+        const count = kind === 'map'
+            ? params.over === 'tickets'
+                ? Math.max(1, launch.spec?.ticketIds?.length ?? 1)
+                : launch.repositoryCount
+            : 1;
+        if (count === undefined)
+            return 10_000;
+        weights.set(node.id, 1 + visits * count);
+    }
+    return transitionBound(body, weights);
+}
+/** Count the largest strongly connected region; retries have a separate bounded allowance. */
+function transitionBound(graph, weights = new Map()) {
+    const nodes = graph.nodes.filter((node) => node.type !== 'start');
+    const adjacency = new Map(nodes.map((node) => [
+        node.id,
+        graph.edges.filter((edge) => edge.source === node.id).map((edge) => edge.target),
+    ]));
+    let nextIndex = 0, largestCycle = 0, cyclicNodes = 0;
+    const indices = new Map(), low = new Map(), stack = [], active = new Set();
+    const visit = (id) => {
+        indices.set(id, nextIndex);
+        low.set(id, nextIndex++);
+        stack.push(id);
+        active.add(id);
+        for (const target of adjacency.get(id) ?? []) {
+            if (!indices.has(target)) {
+                visit(target);
+                low.set(id, Math.min(low.get(id), low.get(target)));
+            }
+            else if (active.has(target))
+                low.set(id, Math.min(low.get(id), indices.get(target)));
+        }
+        if (low.get(id) !== indices.get(id))
+            return;
+        let count = 0, members = 0, current;
+        do {
+            current = stack.pop();
+            active.delete(current);
+            count += weights.get(current) ?? 1;
+            members += 1;
+        } while (current !== id);
+        if (members > 1 || adjacency.get(id)?.includes(id)) {
+            largestCycle = Math.max(largestCycle, count);
+            cyclicNodes += count;
+        }
+    };
+    for (const node of nodes)
+        if (!indices.has(node.id))
+            visit(node.id);
+    const retryNodes = nodes.filter((node) => node.data?.retry ? (node.data.retry.maxAttempts ?? 1) > 1 : AI_KINDS.has(node.data?.kind)).length;
+    const bound = Math.max([...nodes].reduce((sum, node) => sum + (weights.get(node.id) ?? 1), 0), graph.config.maxIterations * largestCycle +
+        nodes.reduce((sum, node) => sum + (weights.get(node.id) ?? 1), 0) -
+        cyclicNodes) +
+        2 * retryNodes;
+    if (bound > 10_000)
+        throw new Error('Workflow transition budget exceeds Core limit of 10000.');
+    return Math.max(1, bound);
+}

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

@@ -3,7 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyLoopEffect = classifyLoopEffect;
 exports.loopIsMutating = loopIsMutating;
 function classifyLoopEffect(graph) {
-    const writes = graph.nodes.some((n) => n.type === 'ai-step' || n.type === 'shell');
+    const writes = graph.nodes.some(n => {
+        if (n.type === 'ai-step' || n.type === 'shell')
+            return true;
+        if (n.type !== 'core')
+            return false;
+        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));
+    }) || Object.values(graph.components ?? {}).some(component => classifyLoopEffect(component) === 'mutating');
     return writes ? 'mutating' : 'read-only';
 }
 /** Convenience: true when the loop mutates the repo (derived from its nodes). */

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

@@ -9,6 +9,9 @@ exports.createLoopExecutors = createLoopExecutors;
  * from coverage; the engine's traversal/decision logic is unit-tested against
  * fake executors in `loop-run-manager.test.ts`.
  */
+const loop_definition_1 = require("./loop-definition");
+const agent_runtime_loader_1 = require("../../agent-runtime/runtime/agent-runtime-loader");
+const agent_runtime_engines_1 = require("../../agent-runtime/runtime/agent-runtime-engines");
 const core_completion_1 = require("../../../core-completion");
 const core_execution_1 = require("../../../core-execution");
 const agent_runtime_bridge_1 = require("../../agent-runtime/runtime/agent-runtime-bridge");
@@ -33,6 +36,7 @@ const repo_map_1 = require("../../../repo-map");
 const feature_flags_1 = require("../../../feature-flags");
 const loop_step_idle_1 = require("./loop-step-idle");
 const runtime_1 = require("../../../providers/runtime");
+const loop_run_manager_1 = require("./loop-run-manager");
 const loop_shell_invocation_1 = require("./loop-shell-invocation");
 // Per-step wall-clock caps so a single hung step can't block the engine's
 // overall deadline check (which only runs between nodes).
@@ -177,6 +181,62 @@ function createLoopExecutors(opts = {}) {
     const completionContexts = new Map();
     const runtimeConfigPath = (cwd) => (0, node_path_1.join)(opts.pluginScope?.().stateRoot ?? cwd, '.specrails', 'agent-runtime.json');
     return {
+        async cancelDefinition({ runId, contextPath, requestId }) {
+            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() {
+            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');
+        },
+        async assertLegacyEngineSupport() {
+            // Legacy traversal predates Core: only a Core that positively lacks engine 1 blocks it.
+            let runtime;
+            try {
+                runtime = await (0, agent_runtime_loader_1.loadCoreAgentRuntime)();
+            }
+            catch {
+                return;
+            }
+            if (!(0, agent_runtime_engines_1.supportedEngines)(runtime.api).includes(1))
+                throw new Error('legacy_engine_unavailable: The installed Core runs only workflow definitions. Convert this loop to Core first.');
+        },
+        async runDefinition(input) {
+            const { request, runId } = input;
+            if (input.resume) {
+                const contextPath = input.contextPath ?? runtimeContextPath(request.cwd, runId, resolveEnv());
+                const host = (0, agent_runtime_bridge_1.readFrozenRuntimeHost)(contextPath, resolveEnv(), runId);
+                const result = await (0, agent_runtime_bridge_1.runAgentRuntimeInvocation)({ contextPath, ...host, engineVersion: 2, resume: true, answer: input.answer, approve: input.approve, recover: input.recover, interruptId: input.interruptId, onLine: input.onLine, onRuntimeEvent: input.onRuntimeEvent, onSpawn: input.onSpawn, timeoutMs: input.timeoutMs });
+                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 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 result = await (0, agent_runtime_bridge_1.runAgentRuntimeInvocation)({
+                contextPath: core.contextPath, cwd: request.cwd, env: core.env,
+                configPath: runtimeConfigPath(request.cwd), engineVersion: 2,
+                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: {
+                        [request.graph.config.legacyDeciderRole]: {
+                            ...(request.deciderEngine ?? { provider: request.provider, model: request.model, effort: request.effort }),
+                            access: 'read', artifacts: 'none',
+                        },
+                    } } : {}),
+                ...(!input.resume ? { prepareDefinition: (config) => (0, loop_definition_1.compileLoopToDefinition)(request.graph, {
+                        id: request.loopId, title: request.loopName, spec: request.spec,
+                        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,
+                    }) } : {}),
+                onPrepared: input.onPrepared, onLine: input.onLine, onRuntimeEvent: input.onRuntimeEvent, onSpawn: input.onSpawn, timeoutMs: input.timeoutMs,
+            });
+            return { ...result, runtimeStatus: result.runtimeStatus ?? 'failed' };
+        },
         async readCoreCompletion(runId) {
             const context = completionContexts.get(runId);
             completionContexts.delete(runId);
@@ -237,7 +297,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 }) : undefined;
+            const core = coreRun ? (0, core_execution_1.prepareCoreExecution)({ run: coreRun, cwd, repoDir, manifest: executionManifest, env: baseStepEnv, sourcePath: executionManifest ? undefined : opts.sourcePath?.() }) : undefined;
             const stepEnv = core?.env ?? baseStepEnv;
             if (coreRun?.implementation && core) {
                 completionContexts.set(coreRun.runId, { cwd, contextPath: core.contextPath, env: stepEnv, runId: coreRun.runId });
@@ -476,7 +536,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 }) : undefined;
+            const core = coreRun ? (0, core_execution_1.prepareCoreExecution)({ run: coreRun, cwd, repoDir, manifest: executionManifest, env: baseStepEnv, sourcePath: executionManifest ? undefined : opts.sourcePath?.() }) : undefined;
             const stepEnv = core?.env ?? baseStepEnv;
             const extraArgs = aiStepExtraArgs(adapter, cwd, repoDir, executionManifest);
             if (repoDir) {
@@ -532,7 +592,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 });
+            const core = (0, core_execution_1.prepareCoreExecution)({ run: coreRun, cwd, repoDir, manifest: executionManifest, env: baseStepEnv, sourcePath: executionManifest ? undefined : opts.sourcePath?.() });
             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

@@ -1,10 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FACTORY_LOOPS = exports.FACTORY_REVISION_LOOP_ID = void 0;
+exports.factoryLoopsForCapabilities = factoryLoopsForCapabilities;
 exports.getFactoryLoop = getFactoryLoop;
 exports.isFactoryLoopId = isFactoryLoopId;
 exports.factoryLoopMode = factoryLoopMode;
 exports.factoryLoopForMode = factoryLoopForMode;
+/**
+ * Built-in "factory" loops — the app-owned loops that replace the old rail modes
+ * (`implement` / Freestyle's `freestyle` mode). These are the code DEFAULTS;
+ * `builtin-loops.ts` seeds them as editable loop rows (same ids) and resolves
+ * launches to an edited, published row when one exists.
+ *
+ * Each carries the canonical rail `mode` it maps to. The rail launch routes a
+ * factory loop to the matching engine via that mode (QueueManager slash command /
+ * Freestyle prompt) — the graph here is the faithful representation used for the
+ * gallery preview and as the seed when forked into a custom loop.
+ *
+ * IDs are namespaced `factory:<mode-ish>` so they never collide with user loop ids
+ * (which are random) and the rail resolver can recognise a factory loop.
+ */
+const loop_core_factory_1 = require("./loop-core-factory");
 const loop_templates_1 = require("./loop-templates");
 const GREEN_GOAL = 'Stop only when the latest verification step reports {{const:VERIFICATION_PASS}} and the history proves every acceptance criterion is implemented across all required tickets and repositories, with the relevant behavioral checks and configured tests/build passing. Green baseline checks, setup, or planning alone do not prove completion.';
 // Factory loops run the WHOLE architect→developer→reviewer pipeline inside a
@@ -48,17 +64,10 @@ exports.FACTORY_LOOPS = [
     {
         id: 'factory:implement',
         name: 'Implement',
-        description: 'Run the Core implementation pipeline for the spec. Core owns implementation, review, verification and corrections.',
+        description: 'Implements every spec on the rail in one run: plan, implement, review and verify, fixing failures until the checks pass.',
         mode: 'implement',
         graph: coreImplementationGraph('implement'),
     },
-    {
-        id: 'factory:batch',
-        name: 'Batch Implement',
-        description: 'Run the Core batch implementation pipeline for all the rail\'s tickets. Core owns implementation, review, verification and corrections across the batch.',
-        mode: 'batch-implement',
-        graph: coreImplementationGraph('batch'),
-    },
     {
         id: 'factory:freestyle',
         // User-facing name for the canonical freestyle mode: it hands the spec straight to the model
@@ -73,6 +82,8 @@ exports.FACTORY_LOOPS = [
     SDD_QUICK_OPENSPEC_FACTORY,
 ];
 const FACTORY_ALIASES = new Map([
+    // Batch was removed: `implement` already runs every rail ticket in one aggregate run.
+    ['factory:batch', exports.FACTORY_LOOPS.find(f => f.id === 'factory:implement')],
     ['factory:openspec', SDD_QUICK_OPENSPEC_FACTORY],
     [exports.FACTORY_REVISION_LOOP_ID, SDD_QUICK_OPENSPEC_FACTORY],
 ]);
@@ -80,8 +91,16 @@ const FACTORY_BY_ID = new Map([
     ...exports.FACTORY_LOOPS.map((f) => [f.id, f]),
     ...FACTORY_ALIASES,
 ]);
-function getFactoryLoop(id) {
-    return FACTORY_BY_ID.get(id);
+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') }));
+}
+function getFactoryLoop(id, capabilities) {
+    const legacy = FACTORY_BY_ID.get(id);
+    if (!legacy)
+        return undefined;
+    return factoryLoopsForCapabilities(capabilities).find(factory => factory.id === legacy.id);
 }
 /** True for any `factory:*` loop id. */
 function isFactoryLoopId(id) {
@@ -93,12 +112,13 @@ function factoryLoopMode(id) {
 }
 /** Map a legacy rail mode → the matching factory loop (so a legacy rail with a
  *  `mode` and no selected loop resolves to a factory loop on read). */
-function factoryLoopForMode(mode) {
+function factoryLoopForMode(mode, capabilities) {
     if (mode === 'implement')
-        return FACTORY_BY_ID.get('factory:implement');
-    if (mode === 'batch-implement')
-        return FACTORY_BY_ID.get('factory:batch');
+        return getFactoryLoop('factory:implement', capabilities);
+    // Removed Batch mode: stored `batch-implement` / `batch` rails resolve to Implement.
+    if (mode === 'batch-implement' || mode === 'batch')
+        return getFactoryLoop('factory:implement', capabilities);
     if (mode === 'freestyle')
-        return FACTORY_BY_ID.get('factory:freestyle');
+        return getFactoryLoop('factory:freestyle', capabilities);
     return undefined;
 }

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

@@ -10,6 +10,10 @@
  * 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;
+exports.isDefinitionGraph = isDefinitionGraph;
+exports.assertDefinitionGraph = assertDefinitionGraph;
 exports.assertLoopShellRepositoryScope = assertLoopShellRepositoryScope;
 exports.assertLoopFailureRecovery = assertLoopFailureRecovery;
 exports.emptyLoopGraph = emptyLoopGraph;
@@ -19,6 +23,35 @@ exports.findStartNode = findStartNode;
 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'];
+function isDefinitionReviewerPath(graph, value) {
+    if (typeof value !== 'string' || !value || value.length > 2048)
+        return false;
+    const segments = value.split('/');
+    if (segments.length > 32)
+        return false;
+    let body = graph;
+    for (let index = 0; index < segments.length; index++) {
+        const node = body?.nodes.find(item => item.id === segments[index]);
+        if (!node || node.type !== 'core')
+            return false;
+        if (index === segments.length - 1)
+            return node.data?.kind === 'role-turn';
+        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;
+    }
+    return false;
+}
+function isDefinitionGraph(graph) {
+    return graph.nodes.some(node => node.type === 'core');
+}
+function assertDefinitionGraph(graph) {
+    if (!isDefinitionGraph(graph) || graph.nodes.some(node => !['start', 'core', 'end'].includes(node.type))) {
+        throw new Error('A Core workflow must contain Core pieces and cannot mix Desktop execution steps.');
+    }
+}
 /** A named shell target must never silently fall back to another checkout. */
 function assertLoopShellRepositoryScope(graph, repositoryIds) {
     for (const node of graph.nodes) {
@@ -61,20 +94,33 @@ function emptyLoopGraph() {
  * Returns all errors found (not just the first) so the builder can highlight
  * every problem at once.
  */
-function validateLoopGraph(graph) {
+function validateLoopGraph(graph, catalog) {
     const errors = [];
     if (!graph || !Array.isArray(graph.nodes) || !Array.isArray(graph.edges)) {
         return { valid: false, errors: [{ code: 'INVALID_CONFIG', message: 'A loop graph must contain nodes and edges arrays.' }] };
     }
     const nodes = graph.nodes;
     const edges = graph.edges;
-    const kinds = new Set(['start', 'ai-step', 'shell', 'decider', 'condition', 'end']);
+    const kinds = new Set(['start', 'ai-step', 'shell', 'decider', 'condition', 'core', 'end']);
     if (nodes.some((node) => !node || typeof node.id !== 'string' || !node.id.trim() || !kinds.has(node.type))) {
         return { valid: false, errors: [{ code: 'INVALID_NODE', message: 'Every node needs a non-empty id and a supported node type.' }] };
     }
     if (edges.some((edge) => !edge || typeof edge.id !== 'string' || !edge.id.trim() || typeof edge.source !== 'string' || typeof edge.target !== 'string')) {
         return { valid: false, errors: [{ code: 'DANGLING_EDGE', message: 'Every edge needs a non-empty id, source and target.' }] };
     }
+    const definition = isDefinitionGraph(graph);
+    if (definition && nodes.some(node => !['start', 'core', 'end'].includes(node.type))) {
+        errors.push({ code: 'MIXED_ENGINES', message: 'Core workflows cannot mix Core pieces with Desktop execution steps.' });
+    }
+    for (const node of nodes) {
+        if (definition && (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,119}$/.test(node.id) || ['START', 'END', '__start__', '__end__', 'next'].includes(node.id))) {
+            errors.push({ code: 'INVALID_NODE', nodeId: node.id, message: 'Core node IDs must be safe, non-reserved identifiers.' });
+        }
+        if (node.type === 'core' && (!exports.CORE_NODE_KINDS.includes(node.data?.kind) || !node.data?.params ||
+            typeof node.data.params !== 'object' || Array.isArray(node.data.params))) {
+            errors.push({ code: 'INVALID_NODE', nodeId: node.id, message: 'A Core piece needs a supported kind and an object of parameters.' });
+        }
+    }
     for (const [items, code] of [[nodes, 'DUPLICATE_NODE'], [edges, 'DUPLICATE_EDGE']]) {
         const ids = new Set();
         for (const item of items) {
@@ -110,11 +156,16 @@ function validateLoopGraph(graph) {
         }
     }
     // ── End presence ────────────────────────────────────────────────────────────
-    if (!nodes.some((n) => n.type === 'end')) {
+    if (!nodes.some((n) => n.type === 'end' || n.type === 'core' && n.data?.kind === 'end')) {
         errors.push({ code: 'NO_END', message: 'The loop must have at least one End node.' });
     }
     // ── Config sanity ─────────────────────────────────────────────────────────────
     const cfg = graph.config;
+    if (cfg?.legacyDeciderRole !== undefined && (!definition ||
+        typeof cfg.legacyDeciderRole !== 'string' || !/^[a-z][a-z0-9-]{0,63}$/.test(cfg.legacyDeciderRole) ||
+        !nodes.some(node => node.type === 'core' && node.data?.kind === 'decider' && node.data.params?.roleId === cfg.legacyDeciderRole))) {
+        errors.push({ code: 'INVALID_CONFIG', message: 'The legacy decision binding must identify a declared Core decider role.' });
+    }
     if (!cfg ||
         !Number.isInteger(cfg.maxIterations) ||
         cfg.maxIterations < 1 ||
@@ -122,10 +173,13 @@ function validateLoopGraph(graph) {
         !Number.isFinite(cfg.timeoutMinutes) ||
         cfg.timeoutMinutes < 0 ||
         (cfg.aiStepTimeoutMinutes !== undefined && (!Number.isFinite(cfg.aiStepTimeoutMinutes) || cfg.aiStepTimeoutMinutes < 0)) ||
-        (cfg.maxCostUsd !== undefined && !Number.isFinite(cfg.maxCostUsd))) {
+        (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.reviewerStepId !== undefined && !isDefinitionReviewerPath(graph, cfg.reviewerStepId))) {
         errors.push({
             code: 'INVALID_CONFIG',
-            message: 'maxIterations must be ≥ 1; timeouts must be finite and ≥ 0 (0 = no timeout); maxCostUsd must be finite.',
+            message: 'maxIterations must be ≥ 1; timeouts must be finite and ≥ 0 (0 = no timeout); maxCostUsd must be finite; reviewerStepId must identify a Core role-turn.',
         });
     }
     // ── Dangling edges ────────────────────────────────────────────────────────────
@@ -143,10 +197,26 @@ function validateLoopGraph(graph) {
     // shell or condition node would silently skip all but its first branch.
     for (const node of nodes) {
         const out = edges.filter((edge) => edge.source === node.id);
-        if (node.type === 'end') {
+        if (node.type === 'end' || node.type === 'core' && node.data?.kind === 'end') {
             if (out.length)
                 errors.push({ code: 'INVALID_BRANCH', nodeId: node.id, message: 'End nodes cannot have outgoing edges.' });
         }
+        else if (node.type === 'core') {
+            const descriptor = catalog?.find(piece => piece.kind === node.data?.kind);
+            if (catalog && !descriptor)
+                errors.push({ code: 'INVALID_NODE', nodeId: node.id, message: 'The installed Core does not advertise this piece.' });
+            if (!out.length)
+                errors.push({ code: 'DEAD_END', nodeId: node.id, message: 'A Core piece needs labeled outcome edges.' });
+            const labels = new Set();
+            for (const edge of out) {
+                if (typeof edge.label !== 'string' || !/^[a-z][a-z0-9-]{0,31}$/.test(edge.label) || labels.has(edge.label) ||
+                    (descriptor && !descriptor.outcomes.includes(edge.label))) {
+                    errors.push({ code: 'INVALID_BRANCH', nodeId: node.id, edgeId: edge.id, message: 'Core outcome edges need unique labels advertised by the piece.' });
+                }
+                if (edge.label)
+                    labels.add(edge.label);
+            }
+        }
         else if (node.type === 'decider') {
             const labeled = out.some((edge) => edge.branch !== undefined);
             const validBranches = labeled
@@ -218,7 +288,8 @@ function successors(graph, nodeId) {
         .filter((n) => n !== undefined);
 }
 /** Whether a loop "needs a ticket/spec" — it references a `{{spec.*}}` token or a
- *  ticket-consuming command (`{{cmd:implement|batch|freestyle}}`). Ticket-needing
+ *  ticket-consuming command (`{{cmd:implement|freestyle}}`, plus the legacy
+ *  `{{cmd:batch}}` alias of implement). Ticket-needing
  *  loops belong on a rail (the rail provides the spec). Ticket-LESS loops are
  *  standalone (repo-wide CI watch, lint, audit…) and run from the Loops page's
  *  "Run" action, NOT a rail — launching one on a rail would just re-run the same
@@ -229,12 +300,17 @@ function loopNeedsTicket(graph) {
     if (!graph)
         return false;
     for (const node of graph.nodes) {
-        const text = [node.data?.prompt, node.data?.command, node.data?.goal]
+        if (node.type === 'core' && node.data?.kind === 'implementation')
+            return true;
+        const text = [node.data?.prompt, node.data?.command, node.data?.goal,
+            node.type === 'core' ? JSON.stringify(node.data?.params) : undefined]
             .filter((v) => typeof v === 'string')
             .join('\n');
         if (SPEC_TOKEN_RE.test(text) || TICKET_CMD_RE.test(text))
             return true;
     }
+    if (Object.values(graph.components ?? {}).some(component => loopNeedsTicket(component)))
+        return true;
     return false;
 }
 function interpolateSpec(text, spec) {