specrails-desktop 2.60.0 → 2.62.0

package/server/dist/modules/agent-sessions/runtime/core-sessions-availability.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readSelectedSessionContract = readSelectedSessionContract;
+exports.coreSessionsAvailability = coreSessionsAvailability;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const agent_runtime_loader_1 = require("../../agent-runtime/runtime/agent-runtime-loader");
+const availability_1 = require("../domain/availability");
+const protocol_1 = require("../domain/protocol");
+/** Read `agentRuntime.sessions` from the selected Core package next to its runtime CLI. */
+function readSelectedSessionContract(cli = (0, agent_runtime_loader_1.findCoreAgentRuntimeCli)()) {
+    if (!cli)
+        return null;
+    const contract = node_path_1.default.resolve(node_path_1.default.dirname(cli), '..', '..', 'integration-contract.json');
+    if (!node_fs_1.default.existsSync(contract))
+        return null;
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(contract, 'utf8')).agentRuntime?.sessions ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Decide once per call whether Core sessions are usable now. Any failure to
+ * probe Core degrades to legacy transports with an explicit reason.
+ */
+async function coreSessionsAvailability(env = process.env) {
+    const flag = (0, availability_1.parseCoreSessionsFlag)(env.SPECRAILS_CORE_SESSIONS);
+    if (flag === 'off')
+        return (0, availability_1.resolveCoreSessionsAvailability)(flag, null);
+    try {
+        const runtime = await (0, agent_runtime_loader_1.loadCoreAgentRuntime)();
+        const contract = (0, protocol_1.checkSessionContract)(readSelectedSessionContract());
+        return (0, availability_1.resolveCoreSessionsAvailability)(flag, runtime.api?.capabilities, contract.compatible);
+    }
+    catch (error) {
+        return { enabled: false, flag, reason: `Core runtime probe failed: ${error.message}` };
+    }
+}

package/server/dist/modules/agent-sessions/runtime/session-host-registry.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionHostRegistry = void 0;
+const session_event_pump_1 = require("../application/session-event-pump");
+const errors_1 = require("../domain/errors");
+const host_state_1 = require("../domain/host-state");
+/** Failures a restart cannot fix: the scope degrades at once instead of looping. */
+const FATAL_CODES = new Set(['journal_locked', 'protocol_mismatch', 'driver_unavailable']);
+/**
+ * One supervised Core session host per scope (project key or `global`).
+ * Hosts start lazily, restart with backoff after unexpected exits, re-open and
+ * replay tracked sessions, and become degraded after repeated failures so
+ * callers can fall back to legacy transports for new turns.
+ */
+class SessionHostRegistry {
+    options;
+    scopes = new Map();
+    stopped = false;
+    constructor(options) {
+        this.options = options;
+    }
+    status(scope) {
+        return this.scopes.get(scope)?.state.status ?? 'absent';
+    }
+    /** Every known scope with its status (operator view, UI notices). */
+    hosts() {
+        return [...this.scopes].map(([scope, entry]) => ({ scope, status: entry.state.status, detail: entry.degradedReason, code: entry.degradedCode }));
+    }
+    /** Why a degraded scope is unavailable, when known. */
+    degradedCode(scope) {
+        return this.scopes.get(scope)?.degradedCode ?? null;
+    }
+    /** Whether new turns in this scope should use Core sessions now. */
+    available(scope) {
+        return !this.stopped && (0, host_state_1.acceptsSessions)(this.scopes.get(scope)?.state ?? host_state_1.INITIAL_HOST_STATE);
+    }
+    /** A ready client for the scope, starting the host when needed. */
+    async acquire(scope) {
+        if (this.stopped)
+            throw new errors_1.SessionRequestError('Session hosts are shutting down', { code: 'busy', retryable: true });
+        const entry = this.entry(scope);
+        if (entry.client && !this.isClosed(entry.client))
+            return entry.client;
+        if (entry.state.status === 'degraded') {
+            throw new errors_1.SessionRequestError(`Core sessions are unavailable for ${scope}: ${entry.degradedReason ?? 'repeated host failures'}`, { code: 'host_degraded', retryable: false });
+        }
+        if (entry.starting)
+            return entry.starting;
+        if (entry.state.status === 'ready') {
+            // The client closed before its close event was processed: count it as a failure.
+            this.fail(scope, entry, 'Session host connection closed');
+            if (this.status(scope) === 'degraded')
+                return this.acquire(scope);
+        }
+        if (entry.state.status === 'restarting') {
+            // A caller needs the host now: start immediately instead of waiting for the backoff timer.
+            entry.restartTimer?.cancel();
+            entry.restartTimer = null;
+            entry.state = (0, host_state_1.onRestartDue)(entry.state).state;
+        }
+        else if (entry.state.status === 'absent') {
+            entry.state = (0, host_state_1.onDemand)(entry.state).state;
+        }
+        return this.start(scope, entry);
+    }
+    /**
+     * Follow a session: its events are applied to `sink` and reported to
+     * `listener`. Survives host restarts (resume + replay from the sink cursor).
+     */
+    async track(scope, sessionId, sink, listener) {
+        const client = await this.acquire(scope);
+        const entry = this.entry(scope);
+        const tracked = entry.tracked.get(sessionId) ?? { sessionId, sink, listener, pump: null };
+        entry.tracked.set(sessionId, tracked);
+        tracked.pump?.detach();
+        tracked.pump = new session_event_pump_1.SessionEventPump(sessionId, client, sink, listener);
+        await tracked.pump.attach();
+        return tracked.pump;
+    }
+    untrack(scope, sessionId) {
+        const entry = this.scopes.get(scope);
+        const tracked = entry?.tracked.get(sessionId);
+        tracked?.pump?.detach();
+        entry?.tracked.delete(sessionId);
+    }
+    /** Manual retry of a degraded scope. */
+    async retry(scope) {
+        const entry = this.entry(scope);
+        const result = (0, host_state_1.onRetry)(entry.state);
+        if (result.decision.action !== 'start')
+            return;
+        entry.state = result.state;
+        entry.degradedReason = null;
+        entry.degradedCode = null;
+        await this.start(scope, entry);
+    }
+    /** Graceful stop of one scope (project removed). */
+    async stop(scope) {
+        const entry = this.scopes.get(scope);
+        if (!entry)
+            return;
+        entry.restartTimer?.cancel();
+        entry.state = (0, host_state_1.onStop)(entry.state);
+        for (const tracked of entry.tracked.values())
+            tracked.pump?.detach();
+        for (const unsubscribe of entry.unsubscribe.splice(0))
+            unsubscribe();
+        const client = entry.client ?? (entry.starting ? await entry.starting.catch(() => null) : null);
+        entry.client = null;
+        this.options.onStatus?.(scope, 'stopped');
+        if (client)
+            await client.close();
+        this.scopes.delete(scope);
+    }
+    /** App shutdown. */
+    async stopAll() {
+        this.stopped = true;
+        await Promise.allSettled([...this.scopes.keys()].map((scope) => this.stop(scope)));
+    }
+    // ── internals ─────────────────────────────────────────────────────────────
+    entry(scope) {
+        let entry = this.scopes.get(scope);
+        if (!entry) {
+            entry = { state: host_state_1.INITIAL_HOST_STATE, client: null, starting: null, restartTimer: null, tracked: new Map(), unsubscribe: [], degradedReason: null, degradedCode: null };
+            this.scopes.set(scope, entry);
+        }
+        return entry;
+    }
+    isClosed(client) {
+        return client.closed === true;
+    }
+    start(scope, entry) {
+        this.options.onStatus?.(scope, 'starting');
+        entry.starting = (async () => {
+            try {
+                const client = await this.options.launcher.launch(scope);
+                if (entry.state.status === 'stopped') {
+                    await client.close();
+                    throw new errors_1.SessionRequestError('Scope stopped', { code: 'busy', retryable: false });
+                }
+                entry.client = client;
+                entry.state = (0, host_state_1.onReady)(entry.state);
+                this.wire(scope, entry, client);
+                this.options.onStatus?.(scope, 'ready');
+                await this.reattach(entry, client);
+                return client;
+            }
+            catch (error) {
+                if (entry.state.status !== 'stopped') {
+                    if ((0, errors_1.isSessionRequestError)(error) && FATAL_CODES.has(error.code))
+                        this.fatal(scope, entry, error.code, error.message);
+                    else
+                        this.fail(scope, entry, error.message);
+                }
+                throw error;
+            }
+            finally {
+                entry.starting = null;
+            }
+        })();
+        return entry.starting;
+    }
+    wire(scope, entry, client) {
+        for (const unsubscribe of entry.unsubscribe.splice(0))
+            unsubscribe();
+        entry.unsubscribe.push(client.onEvent((envelope) => { void entry.tracked.get(envelope.sessionId)?.pump?.push(envelope).catch((error) => this.options.onStatus?.(scope, entry.state.status, `projection failed: ${error.message}`)); }), client.onLagged((sessionId) => { void entry.tracked.get(sessionId)?.pump?.catchUp().catch(() => undefined); }), client.onClose((reason, code) => {
+            if (entry.client !== client || entry.state.status === 'stopped')
+                return;
+            entry.client = null;
+            if (code && FATAL_CODES.has(code))
+                this.fatal(scope, entry, code, reason);
+            else
+                this.fail(scope, entry, reason);
+        }));
+    }
+    /** After a (re)start: resume every tracked session and replay from its cursor. */
+    async reattach(entry, client) {
+        for (const tracked of entry.tracked.values()) {
+            tracked.pump?.detach();
+            try {
+                await client.request('session.open', { resume: { sessionId: tracked.sessionId } });
+            }
+            catch (error) {
+                // Closed sessions replay as history; a session Core never opened has nothing to resume.
+                if (!(error instanceof errors_1.SessionRequestError) || (error.code !== 'session_closed' && error.code !== 'session_not_found'))
+                    throw error;
+                if (error.code === 'session_not_found')
+                    continue;
+            }
+            tracked.pump = new session_event_pump_1.SessionEventPump(tracked.sessionId, client, tracked.sink, tracked.listener);
+            await tracked.pump.attach();
+        }
+    }
+    fatal(scope, entry, code, reason) {
+        const result = (0, host_state_1.onFatal)(entry.state, reason);
+        entry.state = result.state;
+        if (result.decision.action !== 'degrade')
+            return;
+        entry.restartTimer?.cancel();
+        entry.restartTimer = null;
+        entry.degradedReason = reason;
+        entry.degradedCode = code;
+        this.options.onStatus?.(scope, 'degraded', reason, code);
+    }
+    fail(scope, entry, reason) {
+        const result = (0, host_state_1.onFailure)(entry.state, this.options.clock.now(), this.options.policy ?? host_state_1.DEFAULT_SUPERVISION);
+        entry.state = result.state;
+        if (result.decision.action === 'degrade') {
+            entry.degradedReason = `${result.decision.reason}; last: ${reason}`;
+            this.options.onStatus?.(scope, 'degraded', entry.degradedReason);
+            return;
+        }
+        if (result.decision.action === 'restart') {
+            this.options.onStatus?.(scope, 'restarting', reason);
+            entry.restartTimer?.cancel();
+            entry.restartTimer = this.options.clock.after(result.decision.delayMs, () => {
+                entry.restartTimer = null;
+                const due = (0, host_state_1.onRestartDue)(entry.state);
+                entry.state = due.state;
+                if (due.decision.action === 'start')
+                    void this.start(scope, entry).catch(() => undefined);
+            });
+        }
+    }
+}
+exports.SessionHostRegistry = SessionHostRegistry;

package/server/dist/modules/agents/runtime/agent-store.js

@@ -47,6 +47,8 @@ function mapMessage(row) {
         attachment_ids: ids,
         context_refs: parseJsonArray(row.context_refs, isContextRef),
         intents: parseIntents(row.intent),
+        ...(row.core_turn_id ? { core_turn_id: row.core_turn_id } : {}),
+        ...(row.turn_origin === 'user' || row.turn_origin === 'subagent' || row.turn_origin === 'system' ? { turn_origin: row.turn_origin } : {}),
         created_at: row.created_at,
     };
 }
@@ -128,7 +130,7 @@ function addAgentMessage(db, input) {
     const id = (0, crypto_1.randomUUID)();
     const attachmentIds = input.attachmentIds && input.attachmentIds.length ? JSON.stringify(input.attachmentIds) : null;
     const contextRefs = input.contextRefs && input.contextRefs.length ? JSON.stringify(input.contextRefs) : null;
-    db.prepare('INSERT INTO agent_messages (id, conversation_id, role, content, attachment_ids, context_refs) VALUES (?, ?, ?, ?, ?, ?)').run(id, input.conversationId, input.role, input.content, attachmentIds, contextRefs);
+    db.prepare('INSERT INTO agent_messages (id, conversation_id, role, content, attachment_ids, context_refs, turn_origin, core_turn_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(id, input.conversationId, input.role, input.content, attachmentIds, contextRefs, input.turnOrigin ?? null, input.coreTurnId ?? null);
     // Touch the parent so the list stays ordered by latest activity.
     db.prepare("UPDATE agent_conversations SET updated_at = datetime('now') WHERE id = ?").run(input.conversationId);
     return mapMessage(db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(id));

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

@@ -4,9 +4,9 @@ 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, independent = false, configurable = false) {
+function coreFactoryGraph(mode, independent = false, configurable = false, capabilities) {
     if (mode === 'implement' && configurable)
-        return (0, loop_implement_recipe_1.configurableImplementGraph)();
+        return (0, loop_implement_recipe_1.configurableImplementGraph)(capabilities);
     const nodes = [{ id: 'start', type: 'start', position: { x: 0, y: 0 } }];
     const edges = [];
     const config = { maxIterations: 12, maxTransitions: 120, timeoutMinutes: 0, aiStepTimeoutMinutes: 0,

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

@@ -41,6 +41,7 @@ function compileLoopToDefinition(graph, launch) {
                         : {}),
                     ...(typeof node.data?.exit === 'string' ? { exit: node.data.exit } : {}),
                     ...(typeof node.data?.reason === 'string' ? { reason: node.data.reason } : {}),
+                    ...(typeof node.data?.blockerFrom === 'string' ? { blockerFrom: node.data.blockerFrom } : {}),
                 }
                 : node.data.params;
             const promptRole = node.id === 'fix' ? 'fixer' : node.id === 'prepare' ? 'architect' : rawParams.access === 'read' ? 'reviewer' : 'developer';

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', capabilities.implementationSteps === 1, capabilities.workflowAgentSteps === 1) }));
+    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, capabilities) }));
 }
 function getFactoryLoop(id, capabilities) {
     const legacy = FACTORY_BY_ID.get(id);

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CORE_NODE_KINDS = void 0;
+exports.effectivePieceOutcomes = effectivePieceOutcomes;
 exports.isDefinitionReviewerPath = isDefinitionReviewerPath;
 exports.isDefinitionGraph = isDefinitionGraph;
 exports.assertDefinitionGraph = assertDefinitionGraph;
@@ -16,6 +17,12 @@ exports.interpolateSpec = interpolateSpec;
 exports.CORE_NODE_KINDS = ['prompt', 'role-turn', 'decider', 'condition', 'assign', 'verify', 'shell',
     'artifact-contract', 'openspec-validate', 'openspec-archive', 'approval', 'question', 'gate', 'map', 'join',
     'component', 'implementation', 'implementation-step', 'end'];
+/** Mirror of Core's `getOutcomes(params)`: `verify` advertises `blocked` only when the node opts into host blockers. */
+function effectivePieceOutcomes(descriptor, params) {
+    if (descriptor.kind === 'verify' && params?.hostBlockers !== true)
+        return descriptor.outcomes.filter(outcome => outcome !== 'blocked');
+    return descriptor.outcomes;
+}
 function isDefinitionReviewerPath(graph, value) {
     if (typeof value !== 'string' || !value || value.length > 2048)
         return false;
@@ -201,7 +208,7 @@ function validateLoopGraph(graph, catalog) {
             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))) {
+                    (descriptor && !effectivePieceOutcomes(descriptor, node.data?.params).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)

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

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportsHostBlockers = exports.HOST_BLOCKER_KINDS = void 0;
 exports.configurableImplementGraph = configurableImplementGraph;
 const agent_runtime_settings_1 = require("../../agent-runtime/runtime/agent-runtime-settings");
 const loop_agents_1 = require("./loop-agents");
@@ -9,8 +10,17 @@ const strings = { type: 'array', items: string, maxItems: 100 };
 const score = { type: 'number', minimum: 0, maximum: 100 };
 const aspects = { type_correctness: 60, pattern_adherence: 60, test_coverage: 60, security: 75, architectural_alignment: 60 };
 const reviewPolicy = 'approved == true; issues must be empty; score >= 70; ' + Object.entries(aspects).map(([aspect, threshold]) => `${aspect} >= ${threshold}`).join('; ');
-/** The recipe, roles, schemas and decisions are Desktop data, never Core phases. */
-function configurableImplementGraph() {
+exports.HOST_BLOCKER_KINDS = ['network', 'credential', 'environment-variable', 'toolchain', 'setup', 'environment', 'scope'];
+/** Fixer/developer structured `blocker`: the host ends the run on it instead of counting a correction round. */
+const blocker = objectSchema({ kind: { enum: [...exports.HOST_BLOCKER_KINDS] }, command: string, cwd: string, evidence: string, requiredAction: string }, ['kind', 'requiredAction']);
+/** Host-owned environment repair and structured blockers need the paired Core generation. */
+const supportsHostBlockers = (capabilities) => capabilities?.hostBlockers === 1;
+exports.supportsHostBlockers = supportsHostBlockers;
+/** The recipe, roles, schemas and decisions are Desktop data, never Core phases.
+ *  `capabilities` are the installed Core's advertised runtime capabilities: without `hostBlockers`
+ *  the verify nodes compile exactly as before (no `setup`, no `blocked` edge, no `blockerFrom`). */
+function configurableImplementGraph(capabilities) {
+    const hostBlockers = (0, exports.supportsHostBlockers)(capabilities);
     const agents = (0, loop_agents_1.defaultLoopAgents)();
     agents.roles = {
         plan: { ...agents.agents.architect, access: 'read', artifacts: 'all', openspecSkill: 'openspec-ff-change', prompt: (0, agent_runtime_settings_1.inheritedRolePrompt)(agents.rolePrompts, 'architect') },
@@ -24,7 +34,11 @@ function configurableImplementGraph() {
         for (const [outcome, target] of Object.entries(outcomes))
             edges.push({ id: `e-${id}-${outcome}`, source: id, target, label: outcome });
     };
-    const turn = (id, label, roleId, prompt, schema, next) => node(id, label, 'role-turn', { roleId, prompt, structuredOutput: schema, sessionContinuity: 'none' }, { next, invalid: 'failed', failed: 'failed' });
+    const turn = (id, label, roleId, prompt, schema, next, extra = {}) => node(id, label, 'role-turn', { roleId, prompt, structuredOutput: schema, sessionContinuity: 'none', ...extra }, { next, invalid: 'failed', failed: 'failed' });
+    const verifyParams = { commands: 'configured', additionalCommandsFrom: 'architect', ...(hostBlockers ? { setup: 'configured', hostBlockers: true } : {}) };
+    const verifyEnds = (passed, failed, blockedEnd) => ({ pass: passed, fail: failed, failed: 'failed', ...(hostBlockers ? { blocked: blockedEnd } : {}) });
+    // Same Core generation as host blockers: older role-turn schemas reject unknown params.
+    const writes = hostBlockers ? { verificationProposalsFrom: 'architect' } : {};
     const change = '{{run.changeId}}';
     turn('architect', 'Architect', 'plan', `Plan the frozen ticket requirements for OpenSpec change ${change}. Use the bound official fast-forward skill. Author complete proposal, design, delta specs and actionable tasks. Propose existing repository verification commands for repositories with no configured checks. Return confidence, question (empty when none), and verification [{repositoryId,command,args,cwd?}]. When revisiting low confidence, investigate the missing repository evidence before asking again. Context and human answers: {{history.text}}`, objectSchema({ confidence: { enum: ['high', 'medium', 'low'] }, question: string, verification: { type: 'array', maxItems: 20, items: objectSchema({ repositoryId: string, command: string, args: strings, cwd: string }, ['repositoryId', 'command', 'args']) } }), 'confidence');
     node('confidence', 'Planning confidence', 'condition', { expr: '$outputs.architect.structured.confidence != "low"' }, { true: 'validate', false: 'investigate' });
@@ -34,11 +48,22 @@ function configurableImplementGraph() {
     node('reset-confidence', 'Reset confidence after answer', 'assign', { set: { planInvestigated: false } }, { next: 'architect', failed: 'failed' });
     node('validate', 'Validate OpenSpec', 'openspec-validate', { change }, { pass: 'freeze', fail: 'architect', failed: 'failed' });
     node('freeze', 'Freeze approved artifacts', 'artifact-contract', { change, contractId: 'plan', action: 'freeze' }, { pass: 'initialize-corrections', fail: 'architect', failed: 'failed' });
-    node('initialize-corrections', 'Initialize automatic correction budget', 'assign', { set: { correctionAttempts: 0, correctionLimit: 3 } }, { next: 'developer', failed: 'failed' });
-    const implementation = objectSchema({ summary: string, incomplete: strings });
-    turn('developer', 'Developer', 'build', `Implement every approved task for change ${change} using the bound official apply skill. Preserve proposal, design and specs; only tick tasks you completed. Report summary and incomplete task descriptions. Prior execution evidence and human answers: {{history.text}}`, implementation, 'tasks');
-    node('tasks', 'Check artifacts and completed tasks', 'artifact-contract', { change, contractId: 'plan', action: 'check', requireCompletedTasks: true }, { pass: 'verify', fail: 'developer', failed: 'failed' });
-    node('verify', 'Verify candidate', 'verify', { commands: 'configured', additionalCommandsFrom: 'architect' }, { pass: 'reviewer', fail: 'correction-context', failed: 'failed' });
+    node('initialize-corrections', 'Initialize automatic correction budget', 'assign', { set: { correctionAttempts: 0, correctionLimit: 3, implementationAttempts: 0, implementationLimit: 3 } }, { next: 'developer', failed: 'failed' });
+    const implementation = objectSchema({ summary: string, incomplete: strings, blocker }, ['summary', 'incomplete']);
+    turn('developer', 'Developer', 'build', `Implement every approved task for change ${change} using the bound official apply skill. Preserve proposal, design and specs; only tick tasks you completed. Report summary and incomplete task descriptions. If a task cannot be finished because of a host precondition or environment blocker outside this change (for example the sandbox forbids starting a local server, a credential or tool is missing), keep the work done, leave that task unchecked and return the structured blocker (kind, command, cwd, evidence, requiredAction). A failing test, a test you cannot make pass, or unexpected browser or tool behaviour is NOT a host blocker: change the test or the implementation instead. The host confirms a blocker by running its own verification before ending the run; a failure it reproduces comes back as a correction. Prior execution evidence and human answers: {{history.text}}`, implementation, 'developer-blocker', writes);
+    node('developer-blocker', 'Developer reported a host blocker', 'condition', { expr: 'exists($outputs.developer.structured.blocker) && $outputs.developer.structured.blocker != null' }, { true: 'developer-blocker-kind', false: 'tasks' });
+    // Credentials, network and variables are the person's to provide. Any other
+    // blocker is confirmed by the host's own verification: a host precondition
+    // ends at host-blocked, a reproduced failure becomes a correction, and
+    // passing checks reach the reviewer, whose rejection of unfinished tasks is
+    // corrected within the same budget.
+    node('developer-blocker-kind', 'Blocker needs the person', 'condition', { expr: ['credential', 'network', 'environment-variable'].map(kind => `$outputs.developer.structured.blocker.kind == "${kind}"`).join(' || ') }, { true: 'developer-blocked', false: 'verify' });
+    node('tasks', 'Check artifacts and completed tasks', 'artifact-contract', { change, contractId: 'plan', action: 'check', requireCompletedTasks: true }, { pass: 'verify', fail: 'implementation-budget', failed: 'failed' });
+    // Incomplete tasks send the developer back, but only while each attempt changes the candidate and within budget.
+    node('implementation-budget', 'Check implementation attempt budget', 'condition', { expr: '$vars.implementationAttempts < $vars.implementationLimit' }, { true: 'implementation-progress', false: 'implementation-exhausted' });
+    node('implementation-progress', 'Check implementation progress', 'condition', { expr: '!exists($vars.lastImplementationHash) || $outputs.developer.candidateHash != $vars.lastImplementationHash' }, { true: 'begin-implementation', false: 'implementation-stalled' });
+    node('begin-implementation', 'Count implementation attempt', 'assign', { increment: { implementationAttempts: 1 }, set: { lastImplementationHash: '{{outputs.developer.candidateHash}}' } }, { next: 'developer', failed: 'failed' });
+    node('verify', 'Verify candidate', 'verify', verifyParams, verifyEnds('reviewer', 'correction-context', 'host-blocked'));
     turn('reviewer', 'Reviewer', 'assess', `Review change ${change} read-only against all approved artifacts and frozen ticket acceptance criteria. Inspect real code and the host verification evidence: {{outputs.verify}}. Return approved, summary, issues, score (0-100), and aspects. Acceptance policy: ${reviewPolicy}. For any rejection or below-threshold score, explain the concrete unmet requirement and actionable repair in summary and issues; passing commands do not prove every acceptance obligation. Prior execution: {{history.text}}`, objectSchema({ approved: { type: 'boolean' }, summary: string, issues: strings, score, aspects: objectSchema(Object.fromEntries(Object.keys(aspects).map(aspect => [aspect, score]))) }), 'review-policy');
     node('review-policy', 'Review acceptance policy', 'condition', { expr: ['$outputs.reviewer.structured.approved == true', '$outputs.reviewer.structured.issues.length == 0', '$outputs.reviewer.structured.score >= 70', ...Object.entries(aspects).map(([aspect, threshold]) => `$outputs.reviewer.structured.aspects.${aspect} >= ${threshold}`)].join(' && ') }, { true: 'approve', false: 'correction-context' });
     node('correction-context', 'Select current review findings', 'condition', { expr: '$outputs.verify.valid == true && exists($outputs.reviewer.candidateHash) && $outputs.reviewer.candidateHash == $outputs.verify.candidateHash' }, { true: 'capture-review', false: 'clear-review' });
@@ -46,13 +71,18 @@ function configurableImplementGraph() {
     node('clear-review', 'Clear outdated review findings', 'assign', { set: { latestReview: 'No reviewer findings for the current verified candidate. Diagnose the current host verification failure first.' } }, { next: 'correction-budget', failed: 'failed' });
     node('correction-budget', 'Check automatic correction budget', 'condition', { expr: '$vars.correctionAttempts < $vars.correctionLimit' }, { true: 'begin-correction', false: 'correction-exhausted' });
     node('begin-correction', 'Count automatic correction attempt', 'assign', { increment: { correctionAttempts: 1 } }, { next: 'fixer', failed: 'failed' });
-    turn('fixer', 'Fixer', 'correct', `Correct the reported implementation, test or review failure for change ${change} using the bound apply skill and preserving approved artifacts. Read failureSummary, command, cwd, exitCode and evidenceId first; use read_verification_evidence for truncated evidence. If Host verification is valid, repair the concrete rejected review obligation or below-threshold aspect instead of only rerunning green commands. Acceptance policy: ${reviewPolicy}. Reproduce the exact focused failure, inspect the assertion and tested code, then apply the smallest repair that preserves the required behavior. An unchanged filename does not prove an unrelated failure. A mandatory test inside the admitted workspace may receive a proven formatting/compatibility repair while retaining every required guard. Report diagnosis, focused commands with original exit codes, repair and unresolved failures in summary and incomplete. If the cause cannot be repaired within scope, explain the evidence and required action; any unchanged correction stops this run even when host checks pass. Do not make unrelated edits merely to change the candidate hash. Host verification: {{outputs.verify}}. Latest review findings for this candidate: {{run.latestReview}}. Prior execution: {{history.text}}`, implementation, 'correction-progress');
+    turn('fixer', 'Fixer', 'correct', `Correct the reported implementation, test or review failure for change ${change} using the bound apply skill and preserving approved artifacts. Read failureSummary, command, cwd, exitCode and evidenceId first; use read_verification_evidence for truncated evidence. If Host verification is valid, repair the concrete rejected review obligation or below-threshold aspect instead of only rerunning green commands. Acceptance policy: ${reviewPolicy}. Reproduce the exact focused failure, inspect the assertion and tested code, then apply the smallest repair that preserves the required behavior. An unchanged filename does not prove an unrelated failure. A mandatory test inside the admitted workspace may receive a proven formatting/compatibility repair while retaining every required guard. Report diagnosis, focused commands with original exit codes, repair and unresolved failures in summary and incomplete. If the cause is a host precondition or environment blocker outside this change, make no edits and return the structured blocker (kind, command, cwd, evidence, requiredAction): the host ends the run with your required action. Any other unchanged correction stops this run even when host checks pass. Do not make unrelated edits merely to change the candidate hash. Host verification: {{outputs.verify}}. Latest review findings for this candidate: {{run.latestReview}}. Prior execution: {{history.text}}`, implementation, 'correction-blocker', writes);
+    node('correction-blocker', 'Fixer reported a host blocker', 'condition', { expr: 'exists($outputs.fixer.structured.blocker) && $outputs.fixer.structured.blocker != null' }, { true: 'fixer-blocked', false: 'correction-progress' });
     node('correction-progress', 'Check correction progress', 'condition', { expr: 'exists($outputs.fixer.candidateHash) && $outputs.fixer.candidateHash != null && $outputs.fixer.candidateHash != $outputs.verify.candidateHash' }, { true: 'tasks', false: 'correction-stalled' });
     node('approve', 'Approve archive', 'approval', { reason: `Approve archiving the reviewed and verified candidate for change ${change}.`, bindCandidate: true, enabled: agents.approvalBeforeArchive === true }, { next: 'approval-policy' });
     node('approval-policy', 'Approval decision', 'condition', { expr: '$outputs.approve.response.approved == true' }, { true: 'archive', false: 'failed' });
     node('archive', 'Archive OpenSpec', 'openspec-archive', { change, allowArchived: true, requiresVerified: true, reviewedCandidate: '{{outputs.reviewer.candidateHash}}', approvedCandidate: '{{outputs.approve.candidateHash}}' }, { next: 'verify-archive', failed: 'verify' });
-    node('verify-archive', 'Verify archived candidate', 'verify', { commands: 'configured', additionalCommandsFrom: 'architect' }, { pass: 'done', fail: 'failed', failed: 'failed' });
-    nodes.push({ id: 'done', type: 'end', position: { x: 0, y: nodes.length * 140 }, data: { outcome: 'success', requiresVerified: true } }, { id: 'failed', type: 'end', position: { x: 360, y: nodes.length * 140 }, data: { outcome: 'failure' } }, { id: 'correction-stalled', type: 'end', position: { x: 720, y: nodes.length * 140 }, data: { outcome: 'failure', reason: `Automatic correction made no candidate changes. Host verification is valid: {{outputs.verify.valid}}. Acceptance policy: ${reviewPolicy}. Latest review findings: {{run.latestReview}}. Fixer diagnosis: {{outputs.fixer.structured.summary}}` } }, { id: 'correction-exhausted', type: 'end', position: { x: 1080, y: nodes.length * 140 }, data: { outcome: 'failure', reason: `Automatic correction limit reached ({{run.correctionAttempts}}/{{run.correctionLimit}}). Acceptance policy: ${reviewPolicy}. Latest review findings: {{run.latestReview}}. Fixer diagnosis: {{outputs.fixer.structured.summary}}. Host verification: {{outputs.verify}}` } });
+    node('verify-archive', 'Verify archived candidate', 'verify', verifyParams, verifyEnds('done', 'failed', 'host-blocked-archive'));
+    nodes.push({ id: 'done', type: 'end', position: { x: 0, y: nodes.length * 140 }, data: { outcome: 'success', requiresVerified: true } }, { id: 'failed', type: 'end', position: { x: 360, y: nodes.length * 140 }, data: { outcome: 'failure' } }, { id: 'correction-stalled', type: 'end', position: { x: 720, y: nodes.length * 140 }, data: { outcome: 'failure', reason: `Automatic correction made no candidate changes. Host verification is valid: {{outputs.verify.valid}}. Acceptance policy: ${reviewPolicy}. Latest review findings: {{run.latestReview}}. Fixer diagnosis: {{outputs.fixer.structured.summary}}` } }, { id: 'correction-exhausted', type: 'end', position: { x: 1080, y: nodes.length * 140 }, data: { outcome: 'failure', reason: `Automatic correction limit reached ({{run.correctionAttempts}}/{{run.correctionLimit}}). Acceptance policy: ${reviewPolicy}. Latest review findings: {{run.latestReview}}. Fixer diagnosis: {{outputs.fixer.structured.summary}}. Host verification: {{outputs.verify}}` } }, { id: 'implementation-stalled', type: 'end', position: { x: 720, y: nodes.length * 140 }, data: { outcome: 'failure', reason: 'The developer made no changes while approved tasks are still incomplete. Incomplete: {{outputs.developer.structured.incomplete}}. Developer summary: {{outputs.developer.structured.summary}}' } }, { id: 'implementation-exhausted', type: 'end', position: { x: 1080, y: nodes.length * 140 }, data: { outcome: 'failure', reason: 'Implementation attempt limit reached ({{run.implementationAttempts}}/{{run.implementationLimit}}) with approved tasks still incomplete. Incomplete: {{outputs.developer.structured.incomplete}}. Developer summary: {{outputs.developer.structured.summary}}' } }, { id: 'developer-blocked', type: 'end', position: { x: 1440, y: nodes.length * 140 }, data: { outcome: 'failure', reason: 'Developer reported a host blocker ({{outputs.developer.structured.blocker.kind}}): {{outputs.developer.structured.blocker.requiredAction}} Evidence: {{outputs.developer.structured.blocker.evidence}}', ...(hostBlockers ? { blockerFrom: 'developer' } : {}) } }, { id: 'fixer-blocked', type: 'end', position: { x: 1440, y: nodes.length * 140 }, data: { outcome: 'failure', reason: 'Fixer reported a host blocker ({{outputs.fixer.structured.blocker.kind}}): {{outputs.fixer.structured.blocker.requiredAction}} Evidence: {{outputs.fixer.structured.blocker.evidence}}', ...(hostBlockers ? { blockerFrom: 'fixer' } : {}) } });
+    if (hostBlockers) {
+        const hostBlocked = (id, source) => ({ id, type: 'end', position: { x: 1800, y: nodes.length * 140 }, data: { outcome: 'failure', blockerFrom: source, reason: `Host blocker ({{outputs.${source}.blocker.kind}}): {{outputs.${source}.blocker.reason}} Required action: {{outputs.${source}.blocker.requiredAction}}` } });
+        nodes.push(hostBlocked('host-blocked', 'verify'), hostBlocked('host-blocked-archive', 'verify-archive'));
+    }
     edges.unshift({ id: 'e-start', source: 'start', target: 'architect' });
     return { nodes, edges, config: { maxIterations: 12, maxTransitions: 200, timeoutMinutes: 0, aiStepTimeoutMinutes: 0, change: 'new', journal: 'ledger-only', ticketScope: 'all', agents, reviewerStepId: 'reviewer' } };
 }

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

@@ -756,6 +756,10 @@ class LoopRunManager {
             throw new Error('runtime_run_completed: Fork a completed workflow to continue');
         this._cancelled.delete(runId);
         this.claimDefinition({ ...frozen.request, runId });
+        // Cards and chips that showed the restart/interruption pause follow the resumed run live.
+        const request = frozen.request;
+        this._emit({ type: 'loop.run_resumed', projectId: request.projectId, loopRunId: runId, railIndex: request.railIndex ?? null,
+            ticketIds: request.spec?.ticketIds ?? (request.ticketId == null ? [] : [request.ticketId]) });
         const task = this._run(frozen.request, { resume: true, ...input }).finally(() => { this.releaseDefinition(runId); this._definitionTasks.delete(runId); });
         this._definitionTasks.set(runId, task);
         return task;

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

@@ -341,10 +341,10 @@ const CORE_STARTER_SHAPES = {
 };
 /** Core definition graph for one of the eight starters. Deterministic: same id ⇒
  *  structurally identical graph (positions included). */
-function coreStarterGraph(id, independent = false, configurable = false) {
+function coreStarterGraph(id, independent = false, configurable = false, capabilities) {
     const shape = CORE_STARTER_SHAPES[id];
     if (shape === 'ship' && configurable)
-        return (0, loop_core_factory_1.coreFactoryGraph)('implement', true, true);
+        return (0, loop_core_factory_1.coreFactoryGraph)('implement', true, true, capabilities);
     const { prompt, goal, maxIterations } = STARTER_TEXT[id];
     const nodes = [{ id: 'start', type: 'start', position: { x: COL_X, y: 0 } }];
     const edges = [];
@@ -438,7 +438,7 @@ function loopTemplatesForCapabilities(capabilities) {
             ...template,
             description: CORE_STARTER_DESCRIPTIONS[template.id],
             ...(readOnly ? { readOnly: true } : {}),
-            graph: coreStarterGraph(template.id, capabilities?.implementationSteps === 1, capabilities?.workflowAgentSteps === 1),
+            graph: coreStarterGraph(template.id, capabilities?.implementationSteps === 1, capabilities?.workflowAgentSteps === 1, capabilities),
         };
     });
 }