specrails-desktop 2.61.0 → 2.62.0

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-implement-recipe.js

@@ -48,10 +48,21 @@ function configurableImplementGraph(capabilities) {
     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' });
+    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. Prior execution evidence and human answers: {{history.text}}`, implementation, 'tasks', writes);
-    node('tasks', 'Check artifacts and completed tasks', 'artifact-contract', { change, contractId: 'plan', action: 'check', requireCompletedTasks: true }, { pass: 'verify', fail: 'developer', failed: 'failed' });
+    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' });
@@ -67,7 +78,7 @@ function configurableImplementGraph(capabilities) {
     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', 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: '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' } : {}) } });
+    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'));

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;