specrails-desktop 2.58.1 → 2.59.0

package/server/dist/modules/delivery/runtime/rails-router.js

@@ -510,7 +510,7 @@ function createRailsRouter() {
         }
         // Non-string values fail the VALID_MODES check below.
         let mode = normalizeRailMode(req.body?.mode ?? 'implement');
-        const { repositoryIds: rawRepositoryIds, baseDeliveryIds, profileName, aiEngine, model, loopId: rawLoopId, reasoning_effort, originConversationId, originSurface, targetPrNumber, revisionOfDeliveryId, revisionNote, baseBranch: rawBaseBranch, followUp: rawFollowUp } = req.body ?? {};
+        const { repositoryIds: rawRepositoryIds, workspaceSelection: rawWorkspaceSelection, baseDeliveryIds, profileName, aiEngine, model, loopId: rawLoopId, reasoning_effort, originConversationId, originSurface, targetPrNumber, revisionOfDeliveryId, revisionNote, baseBranch: rawBaseBranch, followUp: rawFollowUp } = req.body ?? {};
         // PR review follow-up (pr-follow-up-fixes): a typed, bounded, FROZEN scope
         // for "resolve these review comments". It rides the delivery row and every
         // ai-step prompt — never the spec, whose description Jira-linked projects
@@ -570,6 +570,7 @@ function createRailsRouter() {
             res.status(400).json({ error: 'base_branch_requires_isolation', detail: 'baseBranch requires an isolated (worktree) loop launch; loops are disabled' });
             return;
         }
+        const explicitLoop = (typeof rawLoopId === 'string' && rawLoopId.length > 0) || req.body?.mode != null;
         let loopId = rawLoopId;
         // Origin link (safe-pr-review-flow): an agent-chat/MCP launch tags itself so
         // the PR decision can later be posted back into the launching conversation.
@@ -609,8 +610,8 @@ function createRailsRouter() {
         if ((0, feature_flags_1.isLoopsEnabled)() && (typeof loopId !== 'string' || !loopId) && mode !== 'loop') {
             loopId = (0, loop_factory_1.factoryLoopForMode)(mode)?.id;
         }
-        // Delivery continuation always uses Quick SDD; the old Revision loop is retired.
-        if (revisionOfDeliveryId && (0, feature_flags_1.isLoopsEnabled)()) {
+        // Quick SDD is the continuation default; an explicit workflow takes precedence.
+        if (revisionOfDeliveryId && (0, feature_flags_1.isLoopsEnabled)() && !explicitLoop) {
             loopId = 'factory:sdd-quick-openspec';
             mode = 'loop';
         }
@@ -649,18 +650,20 @@ function createRailsRouter() {
             res.status(400).json({ error: 'Rail has no tickets assigned' });
             return;
         }
-        // The durable delta chooses Quick SDD regardless of stale rail/agent defaults.
+        // A durable delta defaults to Quick SDD when the caller has not chosen a workflow.
         // Revision is a delivery-continuation mechanism, not the implementation loop.
         const launchAddenda = (0, spec_addenda_1.planSpecAddendaAt)((0, spec_addenda_1.ticketStorePathForProject)(c.project), rail.ticketIds);
-        if (launchAddenda.length && (0, feature_flags_1.isLoopsEnabled)()) {
+        if (launchAddenda.length && (0, feature_flags_1.isLoopsEnabled)() && !explicitLoop) {
             loopId = 'factory:sdd-quick-openspec';
             mode = 'loop';
         }
         let repositoryIds;
+        let workspaceSelection;
         const primaryRepository = (0, project_repositories_1.getProjectRepositories)(c.project).find((repository) => repository.isPrimary);
         try {
             const requiredRepositoryIds = [...new Set(rail.ticketIds.flatMap((id) => (0, project_repositories_1.validateTicketRepositoryIds)(c.project, c.getTicketSpec?.(id)?.repositoryIds) ?? [primaryRepository.id]))];
             repositoryIds = (0, project_repositories_1.validateTicketRepositoryIds)(c.project, rawRepositoryIds) ?? requiredRepositoryIds;
+            workspaceSelection = (0, project_repositories_1.validateWorkspaceSelection)(c.project, rawWorkspaceSelection, repositoryIds);
             const missing = requiredRepositoryIds.filter((id) => !repositoryIds.includes(id));
             if (missing.length) {
                 res.status(400).json({ error: 'repository_scope_incomplete', missingRepositoryIds: missing,
@@ -717,9 +720,29 @@ function createRailsRouter() {
             res.status(409).json({ error: 'tickets_in_flight', ticketIds: inFlightOverlap });
             return;
         }
+        // Resolve once: a concurrent publication cannot mix one recipe's agents
+        // with another recipe's graph. Loop-owned roles bypass project launch presets.
+        let builtinSelection;
+        let librarySelection;
+        if ((0, feature_flags_1.isLoopsEnabled)() && typeof loopId === 'string' && loopId) {
+            if ((0, loop_factory_1.isFactoryLoopId)(loopId)) {
+                let capabilities;
+                try {
+                    capabilities = (await (0, agent_runtime_loader_1.loadCoreAgentRuntime)()).api?.capabilities;
+                }
+                catch { /* Retained legacy recipes remain available. */ }
+                builtinSelection = (0, builtin_loops_1.resolveBuiltinLoop)(c.desktopDb, loopId, capabilities);
+            }
+            else
+                librarySelection = (0, loops_store_1.getLoop)(c.desktopDb, loopId);
+        }
+        const loopAgents = builtinSelection?.graph.config.agents ?? (librarySelection?.status === 'published' ? librarySelection.graph.config.agents : undefined);
+        const ownsLoopEngine = !!loopAgents && loopAgents.agents.developer.provider !== 'inherit';
+        if (ownsLoopEngine)
+            runtimeProviderOverride = undefined;
         // AI engine precedence: explicit body param > stored rail engine > primary.
         // `undefined`/empty in both means "run on the project's primary provider".
-        const requestedEngineRaw = aiEngine === undefined ? (rail.aiEngine ?? undefined) : aiEngine;
+        const requestedEngineRaw = ownsLoopEngine ? loopAgents.agents.developer.provider : aiEngine === undefined ? (runtimeProviderOverride?.provider ?? rail.aiEngine ?? undefined) : aiEngine;
         // `roles` (hybrid-role-engines): the pipeline roles keep the project's
         // per-role runtime settings (no flattening override) and the loop's own
         // steps come from the stored loop-role engines — verifier for every
@@ -734,7 +757,9 @@ function createRailsRouter() {
         const requestedEngine = rolesMode
             ? (loopRoleEngines.verifier?.provider && (0, provider_selection_1.validateRequestedProvider)(c.project, loopRoleEngines.verifier.provider).ok ? loopRoleEngines.verifier.provider : undefined)
             : requestedEngineRaw;
-        const engineCheck = (0, provider_selection_1.validateRequestedProvider)(c.project, requestedEngine);
+        const engineCheck = ownsLoopEngine
+            ? (0, registry_1.hasAdapter)(loopAgents.agents.developer.provider) ? { ok: true, provider: loopAgents.agents.developer.provider } : { ok: false, error: 'Loop agent provider is not configured' }
+            : (0, provider_selection_1.validateRequestedProvider)(c.project, requestedEngine);
         if (!engineCheck.ok) {
             res.status(400).json({ error: engineCheck.error });
             return;
@@ -753,7 +778,7 @@ function createRailsRouter() {
             res.status(400).json({ error: 'runtime_provider_mismatch', detail: 'A roles launch carries no provider override' });
             return;
         }
-        if (!runtimeProviderOverride && requestedEngine && !rolesMode) {
+        if (!ownsLoopEngine && !runtimeProviderOverride && requestedEngine && !rolesMode) {
             try {
                 runtimeProviderOverride = (0, agent_runtime_settings_1.validateRuntimeProviderOverride)({ provider: engineCheck.provider, ...(model ? { model } : {}), ...(reasoning_effort && !localEngine ? { effort: reasoning_effort } : {}) });
             }
@@ -769,7 +794,7 @@ function createRailsRouter() {
         if (localEngine && runtimeProviderOverride?.effort !== undefined) {
             runtimeProviderOverride = { provider: runtimeProviderOverride.provider, ...(runtimeProviderOverride.model !== undefined ? { model: runtimeProviderOverride.model } : {}) };
         }
-        if (localEngine && req.body?.maxCostUsd !== undefined && req.body?.maxCostUsd !== null) {
+        if (!ownsLoopEngine && localEngine && req.body?.maxCostUsd !== undefined && req.body?.maxCostUsd !== null) {
             res.status(400).json({ error: 'local_engine_no_cost_cap' });
             return;
         }
@@ -781,7 +806,7 @@ function createRailsRouter() {
         }
         // Freestyle is provider-owned. Validate its optional model against the
         // selected engine instead of a Claude-only alias list.
-        if (mode === 'freestyle' &&
+        if (!ownsLoopEngine && mode === 'freestyle' &&
             model !== undefined &&
             model !== null &&
             (typeof model !== 'string' || !(0, spec_models_1.isValidModelForProvider)(model, engineCheck.provider))) {
@@ -795,7 +820,7 @@ function createRailsRouter() {
         // `null` in the body explicitly forces legacy mode. Providers without
         // profile support run in legacy mode.
         let resolvedProfile;
-        if (mode === 'freestyle') {
+        if (loopAgents || mode === 'freestyle') {
             // Freestyle runs no agent pipeline, so profiles do not apply.
             resolvedProfile = null;
         }
@@ -826,15 +851,10 @@ function createRailsRouter() {
                 let loopGraph;
                 let loopName;
                 if ((0, loop_factory_1.isFactoryLoopId)(loopId)) {
-                    let capabilities;
-                    try {
-                        capabilities = (await (0, agent_runtime_loader_1.loadCoreAgentRuntime)()).api?.capabilities;
-                    }
-                    catch { /* Existing Core remains supported through the legacy factory. */ }
                     // Editable built-ins: an edited row runs its Published graph (or the
                     // last Published snapshot while an edit is Draft); otherwise the
                     // current code default for this Core.
-                    const f = (0, builtin_loops_1.resolveBuiltinLoop)(c.desktopDb, loopId, capabilities);
+                    const f = builtinSelection;
                     if (!f) {
                         res.status(404).json({ error: 'Factory loop not found' });
                         return;
@@ -855,7 +875,7 @@ function createRailsRouter() {
                     loopName = f.name;
                 }
                 else {
-                    const loop = (0, loops_store_1.getLoop)(c.desktopDb, loopId);
+                    const loop = librarySelection;
                     if (!loop) {
                         res.status(404).json({ error: 'Loop not found' });
                         return;
@@ -898,7 +918,7 @@ function createRailsRouter() {
                     });
                     return;
                 }
-                if (typeof model === 'string' && model && !(0, spec_models_1.isValidModelForProvider)(model, loopProvider)) {
+                if (!ownsLoopEngine && typeof model === 'string' && model && !(0, spec_models_1.isValidModelForProvider)(model, loopProvider)) {
                     res.status(400).json({ error: `model is not valid for provider "${loopProvider}"`, allowed: (0, spec_models_1.getModelsForProvider)(loopProvider) });
                     return;
                 }
@@ -919,14 +939,15 @@ function createRailsRouter() {
                     }
                 }
                 const verifierEngine = rolesMode ? (0, loop_role_engines_1.resolveLoopRoleEngine)(c.project, 'verifier', { provider: loopProvider, model: loopAdapter.defaultModel() }, loopRoleEngines) : undefined;
-                const loopModel = typeof model === 'string' && model
-                    ? model
-                    : (verifierEngine?.model ?? profileModel ?? globalAgentDefaults?.pipelineModel ?? loopAdapter.defaultModel());
+                const loopModel = ownsLoopEngine ? loopAgents.agents.developer.model ?? loopAdapter.defaultModel() :
+                    loopAgents?.agents.developer.model ?? runtimeProviderOverride?.model ?? (typeof model === 'string' && model
+                        ? model
+                        : (verifierEngine?.model ?? profileModel ?? globalAgentDefaults?.pipelineModel ?? loopAdapter.defaultModel()));
                 let effort;
                 // Local (OpenAI-compatible) engines have no per-invocation effort knob
                 // unless the connection opts in; a requested effort is DROPPED, not a
                 // 400 — the engine selectors send the last-used effort blindly.
-                const effortRequested = localEngine && !loopAdapter.capabilities.supportsReasoningEffort ? undefined : (reasoning_effort ?? verifierEngine?.effort);
+                const effortRequested = localEngine && !loopAdapter.capabilities.supportsReasoningEffort ? undefined : ownsLoopEngine ? loopAgents.agents.developer.effort : (loopAgents?.agents.developer.effort ?? runtimeProviderOverride?.effort ?? reasoning_effort ?? verifierEngine?.effort);
                 if (effortRequested !== undefined && effortRequested !== null) {
                     const allowed = (0, providers_1.reasoningEffortsForModel)(loopAdapter, loopModel);
                     if (typeof effortRequested !== 'string' ||
@@ -939,7 +960,7 @@ function createRailsRouter() {
                     }
                     effort = effortRequested;
                 }
-                else if (globalAgentDefaults?.pipelineEffort
+                else if (!ownsLoopEngine && globalAgentDefaults?.pipelineEffort
                     && (0, runtime_1.isReasoningEffortValidForModel)(loopAdapter, loopModel, globalAgentDefaults.pipelineEffort)) {
                     effort = globalAgentDefaults.pipelineEffort;
                 }
@@ -961,7 +982,7 @@ function createRailsRouter() {
                     res.status(400).json({ error: `This loop uses a command unsupported by provider '${loopProvider}'` });
                     return;
                 }
-                const scope = (0, loop_command_catalog_1.dominantTicketScope)(promptsText);
+                const scope = loopGraph.config.ticketScope ?? (loopGraph.config.journal === 'implementation' ? 'all' : (0, loop_command_catalog_1.dominantTicketScope)(promptsText));
                 // Parallel isolation (default-on; disable with SPECRAILS_RAIL_WORKTREES=0):
                 // a per-ticket rail on a repo-mutating loop runs each ticket in its own git
                 // worktree, then merges the branches back. A non-git repo or an unborn
@@ -1114,7 +1135,7 @@ function createRailsRouter() {
                         try {
                             const ids = await (0, rail_isolated_launch_1.launchIsolatedRail)({
                                 runtimeProviderOverride,
-                                ctx: c, railIndex, ticketIds: [...rail.ticketIds], repositoryIds, ...repositoryBases, loopId, loopName, loopGraph,
+                                ctx: c, railIndex, ticketIds: [...rail.ticketIds], repositoryIds, workspaceSelection, ...repositoryBases, loopId, loopName, loopGraph,
                                 provider: loopProvider, model: loopModel, effort, scope,
                                 ...(deciderEngine ? { deciderEngine } : {}),
                                 profileName: resolvedProfile,
@@ -1256,6 +1277,7 @@ function createRailsRouter() {
                         graph: loopGraph,
                         projectId: c.project.id,
                         repositoryId: primaryRepository.id,
+                        workspacePaths: workspaceSelection?.[primaryRepository.id],
                         cwd: loopExec.cwd,
                         repoDir: loopExec.relocated ? loopExec.repoDir : undefined,
                         railIndex,

package/server/dist/modules/delivery/runtime/review-packet.js

@@ -280,7 +280,7 @@ function computeDriftNudges(input) {
 function followUpReportSource(evidence) {
     if (!evidence)
         return null;
-    const parts = evidence.units.flatMap((unit) => [unit.verifyTail, unit.sentinelDetail]).filter((v) => typeof v === 'string' && v.length > 0);
+    const parts = evidence.units.flatMap((unit) => [unit.verifyTail, unit.sentinelDetail, unit.runtime?.review?.summary]).filter((v) => typeof v === 'string' && v.length > 0);
     return parts.length > 0 ? parts.join('\n') : null;
 }
 function composeReviewPacket({ db, row, repositoryId = row.repository_id ?? undefined, includeLegacyProvenance = false }) {

package/server/dist/modules/loops/runtime/loop-agent-defaults.json

@@ -0,0 +1,6 @@
+{
+    "architect": "## Your task: architecture\n\nYou are the Specrails architect. Turn the requested work into an unambiguous, implementable plan that a developer agent will execute without talking to you.\n\n1. Orient quickly: locate the code the change touches, the tests that cover it and the conventions that apply. Calibrate depth to the blast radius. A localized change gets a short proposal, focused design and only the tasks it needs; a cross-cutting change earns a full impact analysis.\nIn design.md include a Local reference patterns section: cite actual repository paths and symbols for the closest existing implementation and its tests. Explain async rendering/state updates, error propagation and test setup when relevant. Check installed framework versions. If no equivalent exists, state that explicitly; never invent references.\n2. Decide the approach, name the exact files/modules to create or change (inside the repository scope when one is declared), and call out risks, edge cases and compatibility concerns. Plan only the change the requested work needs; unrelated clean-ups are out of scope.\n3. Break the work into ordered, atomic tasks. Each task names concrete files and includes its own tests. Every task must be completable by an agent that can only edit files and run commands: never add tasks such as \"run the test suite\", \"verify\", \"test manually in a browser\", \"commit\" or \"open a PR\". Core runs verification and the host owns delivery.\n4. Execute the official OpenSpec fast-forward skill. Query status and instructions in dependency order; author the real delta specs and other artifacts using those templates and project rules. Preserve existing requirements through OpenSpec delta semantics. Do not fabricate complete replacement specs.\n5. Propose verification. For each repository listed below without a configured verification command, name the existing command that proves the change: the project's test script, type check, build or lint (for example `npm` with args `[\"test\"]`, or `cargo` with `[\"test\"]`). Only propose commands that exist in the repository today or that a task in this plan adds; omit repositories where nothing automated applies. For a repository with a scope, the command must exercise that scope: omit cwd (it then runs in the scope directory) or name a directory inside it; never a command that runs every workspace of a larger checkout. Core runs them after the developer finishes and feeds failures back.\n6. Score your confidence honestly: `high` when the code evidence is conclusive; `medium` when the design rests on one non-obvious assumption (name it in the design); `low` when several plausible designs exist and you cannot choose without missing information. With `low`, put the single question whose answer decides the design in `question`. Core first lets you investigate further, then either asks the requester that exact question or proceeds on your stated assumptions, depending on the project configuration.",
+    "developer": "## Your task: implementation\n\nYou are the Specrails developer. Execute the official openspec-apply-change skill for the approved change, implement its pending tasks completely and update their progress through that workflow. Do not substitute a hand-written approximation of apply.\n\n1. Load and execute openspec-apply-change through the supplied binding. Consult its status and instructions apply, read the context files OpenSpec returns, then the relevant existing code and tests.\n2. Work task by task in order. Use test-driven development: write or extend the test first, make it pass with the smallest correct change, then tidy up. Run only focused tests that cover what you touched while iterating. Core owns the complete verification plan and runs it after your turn; do not duplicate that full run. Fix the precise failures Core returns on a correction pass.\n3. Immediately after completing each task, mark it `- [x]` in `tasks.md`; do not postpone all progress updates until the end of the phase. Only mark tasks whose code and tests are complete. Change nothing else in `tasks.md`, and never edit `proposal.md`, `design.md` or the specs: those documents are frozen, and editing them invalidates the run. If a task cannot be completed, leave it `- [ ]` and list it under `incomplete` with the reason.\n4. Keep the implementation consistent with the repository: naming, error handling, import style, formatting and existing utilities. Do not add dependencies unless the design requires them. Change only what the tasks require: the diff should contain the requested change and its tests, nothing else.\nInvestigation budget: consult the local reference patterns in design.md and equivalent application tests before framework internals or node_modules. After three unsuccessful experiments on the same failure, stop repeating commands: state the hypothesis, evidence and next discriminating experiment, then change approach. If three further experiments add no evidence, report the specific blocker under incomplete rather than consuming the remaining turn budget. Never weaken assertions or change acceptance criteria to make a test pass.\nVerification evidence: run tests without piping their output through grep/head or other filters that mask the original exit status. Capture complete stdout/stderr in a temporary log and preserve the test process exit code; inspect that log separately. Report the command and original exit code. Remove temporary debug tests before finishing. Core independently runs the final verification commands.\n5. If the shell is unavailable, still finish every task that only needs code and tests; Core runs the verification commands after your turn and returns the exact failures to you.\n\n## Durable implementation progress\n\nWhen loading the official apply skill, read its savedProgress handoff before repeating investigation. Reconcile it with the current diff and tasks; it is advisory history, never accepted verification evidence. Preserve completed work and previously discovered test commands or environment blockers. Recheck a blocker only when its relevant condition changed.\nAfter each completed task, and whenever the next action or a blocker changes, call the scoped workflow action write_progress with progress: {summary, completedTasks, nextTasks, checks: [{command, outcome}], blockers}. Replace the previous handoff with a concise current account (at most 8 KB); include exact focused test commands, original exit outcomes, relevant paths and the next discriminating action. Keep nextTasks concrete enough for a fresh session to continue unfinished work. Do not include full logs, credentials or claims that old checks authorize acceptance. The host persists this record outside the frozen OpenSpec artifacts. Use read_progress to refresh it. If interrupted, the next session receives it from load_skill; do not write runtime files directly.",
+    "reviewer": "## Your task: review\n\nYou are the Specrails reviewer and the last gate before this change is archived. Inspect the implementation, the approved artifacts and the verification evidence read-only. Do not fix anything.\n\nCheck, in this order:\n1. Spec completeness: every requirement in the change specs and every acceptance criterion is implemented. Cross-reference each one against the code.\n2. Task completion: every task in `tasks.md` is `- [x]` and is backed by real code and tests, not just a ticked box.\n3. Test quality: new behavior has tests that assert on behavior, cover error paths, and would fail without the change. Missing tests for production code are a blocking issue.\n4. Correctness and conventions: types and signatures fit the codebase, patterns match the repository, imports and error handling are consistent, no unrelated changes.\n5. Security: no secrets, injection, path traversal, unsafe deserialization, missing authorization or new attack surface. Scale scrutiny to what the change touches.\n6. Performance: no obvious N+1, unbounded loops or blocking work on hot paths introduced by the change.\n\nJudge BEHAVIOUR against the acceptance criteria, never the shape of the code against the wording of the plan: module layout, file lists, class or function names, naming conventions and implementation techniques named in the ticket, the design or a \"contract layer\" are suggestions the developer may legitimately improve on. A working implementation that satisfies a criterion by other means is correct; asking to rename, move or rewrite it to match the plan's wording is NOT an issue. Only a criterion that is not met, a defect, a missing test or a regression is.\n\nReview THE CHANGE. The change set below lists every file this run changed relative to its base, measured by Core from git. Judge those changes and the behavior they affect; code the change did not touch is not an issue unless the change breaks it. Never ask for edits to pre-existing code, other packages or workspaces, or configuration outside the change. An environment problem (credentials, registry access, missing tools) is not a code issue: record it under findings, never as an issue for the fixer.\n\nThe verification evidence below comes from real subprocesses run by Core after the developer finished; treat it as fact, not as a claim by the developer.",
+    "fixer": "## Your task: correction\n\nYou are the Specrails FIXER. The verification commands (or the review) failed after the developer's pass; your only job is to make them pass with minimal, precise edits to this change.\n\n1. Read the failing output below first: the exact command, its exit code and the reported files and lines. Start from those files, not from the plan.\n2. Decide whether this change caused the failure. It did when the failure points at files in the change set below or at behavior they affect. A failure in code the change never touched (another package or workspace, a pre-existing test), in the environment (missing credentials, environment variables, registry access or tools) or in configuration outside the change is NOT yours to fix: edit nothing for it, and report it under `incomplete` with the exact error. Core then stops and asks the host instead of starting another round.\n3. Patch exactly the files and lines the failure names; touch neighbouring code only when the failure cannot be fixed otherwise. Rewrite a file only when a patch cannot express the change.\n4. Never re-implement a feature, rename or restructure, reformat, add dependencies, or widen the change beyond the failure. Never weaken an assertion, delete a test or change acceptance criteria to make a check pass — if a test is wrong, fix the test to the specification and say so.\n5. A test file the host reports as never executed must be wired into the repository's test command (the test script or runner configuration) and then made to pass.\n6. Confirm with the narrowest command that reproduces the failure (the failing test file or test name). Do not re-run whole suites or other workspaces: Core re-runs the complete verification plan after your turn.\n7. Do not read the repository beyond the files the failure names and their direct dependencies. `proposal.md`, `design.md` and the specs are frozen; in `tasks.md` only tick a task you completed.\n8. Finish with the same JSON summary object as the developer, listing under `incomplete` only failures you could not fix and why.\n\n## Durable implementation progress\n\nWhen loading the official apply skill, read its savedProgress handoff before repeating investigation. Reconcile it with the current diff and tasks; it is advisory history, never accepted verification evidence. Preserve completed work and previously discovered test commands or environment blockers. Recheck a blocker only when its relevant condition changed.\nAfter each completed task, and whenever the next action or a blocker changes, call the scoped workflow action write_progress with progress: {summary, completedTasks, nextTasks, checks: [{command, outcome}], blockers}. Replace the previous handoff with a concise current account (at most 8 KB); include exact focused test commands, original exit outcomes, relevant paths and the next discriminating action. Keep nextTasks concrete enough for a fresh session to continue unfinished work. Do not include full logs, credentials or claims that old checks authorize acceptance. The host persists this record outside the frozen OpenSpec artifacts. Use read_progress to refresh it. If interrupted, the next session receives it from load_skill; do not write runtime files directly."
+}

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

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLoopAgents = defaultLoopAgents;
+const loop_agent_defaults_json_1 = __importDefault(require("./loop-agent-defaults.json"));
+function defaultLoopAgents(mode = 'implementation') {
+    return {
+        schemaVersion: 1,
+        agents: { architect: { provider: 'inherit' }, developer: { provider: 'inherit' }, reviewer: { provider: 'inherit' } },
+        fixer: { provider: 'inherit' },
+        rolePrompts: mode === 'implementation' ? { ...loop_agent_defaults_json_1.default } : {
+            architect: 'Explore the repositories and plan the requested work from the supplied goal and acceptance criteria.',
+            developer: 'Implement the supplied spec directly in the existing codebase. Explore relevant code, make the requested changes and add meaningful tests. Use the project verification commands. If a human decision is required, finish with LOOP_BLOCKED: followed by the specific question.',
+            reviewer: 'Review actual code and verification evidence against the supplied acceptance criteria. Report correctness, security and regression issues.',
+            fixer: 'Correct the reported implementation or verification failures with focused changes and tests. Preserve previously completed requirements. If a human decision is required, finish with LOOP_BLOCKED: followed by the specific question.',
+        },
+        roles: { 'loop-decider': { provider: 'inherit', access: 'read', artifacts: 'none', prompt: 'Inspect actual implementation and verification evidence against every frozen acceptance criterion. Request corrections until the goal is satisfied.' } },
+    };
+}

package/server/dist/modules/loops/runtime/loop-command-catalog.js

@@ -165,7 +165,7 @@ exports.LOOP_COMMANDS = [
             FROZEN_SPEC_SCOPE,
             '',
             '- Missing or incomplete implementation: implement the missing pieces whether verification reported `VERIFICATION: FAIL` or `VERIFICATION: PASS`. Passing baseline tests do not satisfy missing acceptance criteria. If the main step only prepared the environment, planned, or launched unfinished delegated work, continue the required implementation now; do not merely re-run the unchanged baseline.',
-            '- Resume from the last completed phase and preserve correct work already on disk. Follow the selected pipeline and its governing OpenSpec artifacts, including remaining design, developer, and reviewer obligations; do not bypass them or restart completed phases. Read the frozen spec and current files rather than assuming the previous agent finished.',
+            '- Resume from completed work and preserve correct code already on disk. If the selected workflow uses OpenSpec, follow its approved artifacts and remaining obligations without restarting completed phases. In a free-form workflow, implement the frozen spec directly; do not require or fabricate an OpenSpec change. Read the frozen spec and current files rather than assuming the previous agent finished.',
             '- Implementation present but checks fail: repair the reported code/test/type-check/lint/build defects with the smallest relevant change, then run focused checks. Do not weaken tests or add unrelated edits. If implementation gaps and check failures coexist, address both within the authorized scope.',
             '- For a delivery revision, the authorized scope is the requested delta and its frozen briefing. Preserve the delivered feature; do not turn a revision repair into a new implementation of unrelated requirements.',
             '',

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

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.coreFactoryGraph = coreFactoryGraph;
+const loop_implement_recipe_1 = require("./loop-implement-recipe");
+const loop_agents_1 = require("./loop-agents");
 /** App-owned definition graphs. Core supplies schemas, execution and canonical versions. */
-function coreFactoryGraph(mode) {
+function coreFactoryGraph(mode, independent = false, configurable = false) {
+    if (mode === 'implement' && configurable)
+        return (0, loop_implement_recipe_1.configurableImplementGraph)();
     const nodes = [{ id: 'start', type: 'start', position: { x: 0, y: 0 } }];
     const edges = [];
     const config = { maxIterations: 12, maxTransitions: 120, timeoutMinutes: 0, aiStepTimeoutMinutes: 0,
@@ -15,10 +19,22 @@ function coreFactoryGraph(mode) {
     const next = (id) => ({ next: id, failed: 'failed' });
     const promptNext = (id) => ({ ...next(id), blocked: 'failed' });
     const verify = (id, passed = 'done', failed = 'failed') => node(id, 'verify', { commands: 'configured' }, { pass: passed, fail: failed, failed: 'failed' });
+    if (independent)
+        config.agents = (0, loop_agents_1.defaultLoopAgents)(mode === 'freestyle' ? 'free' : 'implementation');
     let entry;
     if (mode === 'implement') {
-        entry = 'implement';
-        node(entry, 'implementation', {}, { next: 'done', rejected: 'failed', failed: 'failed' });
+        if (independent) {
+            entry = 'architect';
+            for (const [phase, next] of Object.entries({ architect: 'developer', developer: 'verify', fixer: 'verify', verify: 'reviewer', reviewer: 'archive', archive: 'done' })) {
+                node(phase, 'implementation-step', { phase }, { next, incomplete: 'developer', rejected: 'fixer', replan: 'architect', reverify: 'verify', rereview: 'reviewer', failed: 'failed' });
+                nodes.at(-1).data.label = phase.charAt(0).toUpperCase() + phase.slice(1);
+                nodes.at(-1).position = phase === 'fixer' ? { x: 360, y: 360 } : { x: 0, y: (['architect', 'developer', 'verify', 'reviewer', 'archive'].indexOf(phase) + 1) * 140 };
+            }
+        }
+        else {
+            entry = 'implement';
+            node(entry, 'implementation', {}, { next: 'done', rejected: 'failed', failed: 'failed' });
+        }
     }
     else if (mode === 'quick-sdd') {
         entry = 'prepare';

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);