specrails-desktop 2.57.0 → 2.58.0

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assessLoopMigration = assessLoopMigration;
+const loop_compat_1 = require("./loop-compat");
+const loop_graph_1 = require("./loop-graph");
+function assessLoopMigration(loops, ports) {
+    const entries = loops.map((loop) => {
+        const engine = (0, loop_graph_1.isDefinitionGraph)(loop.graph) ? 'core' : 'legacy';
+        const base = { id: loop.id, name: loop.name, status: loop.status, engine, hasLegacyGraph: loop.hasLegacyGraph === true };
+        if (ports.isRunning(loop.id))
+            return { ...base, state: 'running', issues: [] };
+        let graph = loop.graph;
+        if (engine === 'legacy') {
+            // No repository binding is guessed: a multi-repository shell without an
+            // explicit scope stays an actionable issue, exactly as in conversion.
+            const converted = (0, loop_compat_1.convertLegacyLoop)(loop.graph);
+            if (!converted.ok)
+                return { ...base, state: 'needs_attention', issues: converted.issues };
+            graph = converted.graph;
+        }
+        let result;
+        try {
+            result = ports.validate(loop, graph);
+        }
+        catch (error) {
+            result = { ok: false, errors: [{ code: 'definition_invalid', message: error instanceof Error ? error.message : 'Invalid workflow' }] };
+        }
+        if (result.ok)
+            return { ...base, state: engine === 'core' ? 'current' : 'convertible', issues: [] };
+        return { ...base, state: engine === 'core' ? 'invalid' : 'needs_attention', issues: result.errors };
+    });
+    const summary = { current: 0, invalid: 0, convertible: 0, needs_attention: 0, running: 0 };
+    for (const entry of entries)
+        summary[entry.state] += 1;
+    return { loops: entries, summary };
+}

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

@@ -13,6 +13,8 @@ exports.previewLoop = previewLoop;
  */
 const loop_command_catalog_1 = require("./loop-command-catalog");
 const loop_graph_1 = require("./loop-graph");
+const loop_definition_1 = require("./loop-definition");
+const loop_graph_2 = require("./loop-graph");
 const loop_constants_1 = require("./loop-constants");
 /** Stand-in ticket so `{{spec.*}}` resolves to something readable in the preview. */
 exports.SAMPLE_SPEC = {
@@ -50,6 +52,14 @@ function visitOrder(graph) {
 function previewLoop(graph, opts) {
     const spec = opts.spec ?? exports.SAMPLE_SPEC;
     const steps = [];
+    if ((0, loop_graph_2.isDefinitionGraph)(graph)) {
+        const definition = (0, loop_definition_1.compileLoopToDefinition)(graph, { ...opts, spec });
+        for (const [prefix, body] of [['', definition], ...Object.entries(definition.components ?? {})])
+            for (const [id, node] of Object.entries(body.nodes)) {
+                steps.push({ nodeId: prefix ? `${prefix}/${id}` : id, kind: node.kind, label: node.label, text: JSON.stringify(node.params, null, 2) });
+            }
+        return { steps };
+    }
     for (const node of visitOrder(graph)) {
         const label = typeof node.data?.label === 'string' && node.data.label.trim() ? node.data.label.trim() : undefined;
         let text = null;

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

@@ -11,6 +11,9 @@ exports.openspecChangeState = openspecChangeState;
 exports.extractChangeId = extractChangeId;
 exports.recoverOrphanLoopStepAccounting = recoverOrphanLoopStepAccounting;
 const crypto_1 = require("crypto");
+const loop_definition_events_1 = require("./loop-definition-events");
+const legacy_launch_telemetry_1 = require("./legacy-launch-telemetry");
+const loop_definition_run_1 = require("./loop-definition-run");
 const spec_addenda_core_1 = require("../../specs/runtime/spec-addenda-core");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -441,6 +444,7 @@ class LoopRunManager {
     now;
     options;
     _disposed = false;
+    _definitionTasks = new Map();
     _cancelled = new Set();
     /** The currently-spawned child per run, so cancel/stop can actually KILL a
      *  blocked spawn (the cooperative `_cancelled` flag can't interrupt an await). */
@@ -478,6 +482,49 @@ class LoopRunManager {
      *  awaited step resolves) — NOT dispose(), which never settles and would
      *  leave the engine's `await` hanging forever. */
     cancel(runId) {
+        const frozen = (0, loop_runs_store_1.readDefinitionRun)(this.db, runId);
+        if (this.executors.cancelDefinition && frozen?.metadata.contextPath) {
+            void this.cancelDefinition(runId).catch(error => {
+                console.error(`[loop-run] durable cancellation failed for ${runId}: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            return;
+        }
+        this.cancelResident(runId, false);
+    }
+    _definitionCancellations = new Map();
+    isDefinitionCancellationPending(runId) { return this._definitionCancellations.has(runId); }
+    /** Launch-time engine check, callable before a caller allocates worktrees. */
+    async assertEngineSupport(graph) {
+        if ((0, loop_graph_1.isDefinitionGraph)(graph)) {
+            if (!this.executors.runDefinition)
+                throw new Error('engine_unsupported: Core workflow execution is unavailable');
+            await this.executors.assertDefinitionSupport?.();
+        }
+        else
+            await this.executors.assertLegacyEngineSupport?.();
+    }
+    definitionForkOwnsRun(runId) {
+        return !!(0, loop_runs_store_1.readDefinitionForkTarget)(this.db, runId) || (0, loop_runs_store_1.readDefinitionExecutionClaim)(this.db, runId)?.owner.startsWith('fork:') === true;
+    }
+    /** Persist intent in the retained Core inbox before settling a resident pause.
+     * A rejected control leaves the execution available for an explicit retry. */
+    cancelDefinition(runId, requestId = `desktop-cancel:${runId}`) {
+        if (this.definitionForkOwnsRun(runId))
+            return Promise.reject(new Error('runtime_fork_owns_worktree: Continue the forked run'));
+        const pending = this._definitionCancellations.get(runId);
+        if (pending)
+            return pending;
+        const frozen = (0, loop_runs_store_1.readDefinitionRun)(this.db, runId);
+        const contextPath = frozen?.metadata.contextPath;
+        if (!contextPath || !this.executors.cancelDefinition)
+            return Promise.reject(new Error('runtime_control_unavailable: Frozen workflow cancellation is unavailable'));
+        const task = this.executors.cancelDefinition({ runId, contextPath, requestId }).then(() => {
+            this.cancelResident(runId, true);
+        }).finally(() => { this._definitionCancellations.delete(runId); });
+        this._definitionCancellations.set(runId, task);
+        return task;
+    }
+    cancelResident(runId, graceful) {
         this._cancelled.add(runId);
         const paused = this._pausedHumanDecisions.get(runId);
         if (paused) {
@@ -491,9 +538,21 @@ class LoopRunManager {
         const child = this._activeChild.get(runId);
         if (child?.pid) {
             try {
-                (0, win_spawn_1.treeKillSafe)(child.pid, 'SIGKILL', () => { });
+                (0, win_spawn_1.treeKillSafe)(child.pid, graceful ? 'SIGTERM' : 'SIGKILL', () => { });
             }
             catch { /* already gone */ }
+            if (graceful) {
+                const timer = setTimeout(() => {
+                    if (this._activeChild.get(runId) === child && child.pid) {
+                        try {
+                            (0, win_spawn_1.treeKillSafe)(child.pid, 'SIGKILL', () => { });
+                        }
+                        catch { /* already gone */ }
+                    }
+                }, 1500);
+                timer.unref?.();
+                child.once('close', () => clearTimeout(timer));
+            }
         }
     }
     // ─── Interactive step routing (manager-agnostic /jobs/:id/messages) ─────────
@@ -511,11 +570,21 @@ class LoopRunManager {
     /** Feed one more user prompt to the ACTIVE step session owning this job row
      *  (queued behind the active turn — steering; the loop tends to continue its
      *  plan). Returns false when no interactive step is live for the id. */
-    sendInteractiveTurn(jobId, text) {
+    pendingInterrupts(jobId) {
+        return structuredClone(this._pausedHumanDecisions.get(jobId)?.pending ?? []);
+    }
+    sendInteractiveTurn(jobId, text, control) {
+        if (this.definitionForkOwnsRun(jobId))
+            return false;
         const paused = this._pausedHumanDecisions.get(jobId);
         if (paused) {
+            if (paused.pending?.length) {
+                const selected = control?.interruptId ? paused.pending.find(item => item.id === control.interruptId) : paused.pending.length === 1 ? paused.pending[0] : undefined;
+                if (!selected || (selected.kind !== 'question' && control?.approve !== true))
+                    return false;
+            }
             this._pausedHumanDecisions.delete(jobId);
-            paused.resolve({ action: 'resume', text });
+            paused.resolve({ action: 'resume', text, ...control });
             return true;
         }
         const session = this._interactiveSteps.get(jobId);
@@ -614,7 +683,76 @@ class LoopRunManager {
         }
         this._pausedHumanDecisions.clear();
     }
-    async run(req) {
+    isDisposed() { return this._disposed; }
+    isDefinitionRunActive(runId) { return this._definitionTasks.has(runId); }
+    _definitionClaims = new Map();
+    claimDefinition(req) {
+        if (this._definitionClaims.has(req.runId))
+            return;
+        const claim = (0, loop_runs_store_1.claimDefinitionExecution)(this.db, req.runId, { owner: (0, ids_1.newId)(), repositoryMounts: (0, loop_runs_store_1.definitionRepositoryMounts)(req) });
+        if (!claim.ok)
+            throw new Error(`runtime_run_active: ${claim.reason} (${claim.conflictingRunId})`);
+        this._definitionClaims.set(req.runId, claim.release);
+    }
+    releaseDefinition(runId) {
+        this._definitionClaims.get(runId)?.();
+        this._definitionClaims.delete(runId);
+    }
+    run(req) {
+        if (!(0, loop_graph_1.isDefinitionGraph)(req.graph))
+            return this._run(req);
+        const runId = req.runId ?? (0, ids_1.newId)();
+        if (this._definitionTasks.has(runId))
+            return Promise.reject(new Error('runtime_run_active: Workflow is already running'));
+        try {
+            this.claimDefinition({ ...req, runId });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        const task = this._run({ ...req, runId }).finally(() => { this.releaseDefinition(runId); this._definitionTasks.delete(runId); });
+        this._definitionTasks.set(runId, task);
+        return task;
+    }
+    resumeDefinition(runId, input = {}) {
+        try {
+            return this.beginDefinitionResume(runId, input);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    /** Synchronous admission lets HTTP reject competing writers before acknowledging a resume. */
+    beginDefinitionResume(runId, input = {}) {
+        if (this._disposed)
+            throw new Error('runtime_shutting_down: LoopRunManager is shut down');
+        const active = this._definitionTasks.get(runId);
+        if (active) {
+            const interruptId = input.interruptId ?? input.approve?.[0];
+            if (!this.isPaused(runId))
+                throw new Error('runtime_run_active: Select a pending question or approval');
+            const request = (0, loop_runs_store_1.readDefinitionRun)(this.db, runId)?.request;
+            if (!request)
+                throw new Error('runtime_run_not_found: Frozen workflow is unavailable');
+            this.claimDefinition({ ...request, runId });
+            if (!this.sendInteractiveTurn(runId, input.answer ?? '', { interruptId, approve: Boolean(input.approve?.length) })) {
+                this.releaseDefinition(runId);
+                throw new Error('runtime_run_active: Select a pending question or approval');
+            }
+            return active;
+        }
+        const frozen = (0, loop_runs_store_1.readDefinitionRun)(this.db, runId);
+        if (!frozen)
+            throw new Error('runtime_run_not_found: Frozen workflow is unavailable');
+        if (frozen.row.status === 'completed')
+            throw new Error('runtime_run_completed: Fork a completed workflow to continue');
+        this._cancelled.delete(runId);
+        this.claimDefinition({ ...frozen.request, runId });
+        const task = this._run(frozen.request, { resume: true, ...input }).finally(() => { this.releaseDefinition(runId); this._definitionTasks.delete(runId); });
+        this._definitionTasks.set(runId, task);
+        return task;
+    }
+    async _run(req, continuation) {
         // Later fresh steps must verify the admitted spec, even if its caller or
         // backlog changes while the implementation is running.
         req = { ...req, runtimeProviderOverride: (0, agent_runtime_settings_1.validateRuntimeProviderOverride)(req.runtimeProviderOverride), graph: structuredClone(req.graph) };
@@ -640,6 +778,12 @@ class LoopRunManager {
                 }
             }
         }
+        const definitionEngine = (0, loop_graph_1.isDefinitionGraph)(req.graph);
+        if (definitionEngine && !this.executors.runDefinition)
+            throw new Error('engine_unsupported: Core workflow execution is unavailable');
+        // Saved runs resume with their retained package whatever the active Core lists.
+        if (!continuation)
+            await this.assertEngineSupport(req.graph);
         if (this._disposed)
             throw new Error('LoopRunManager is shut down');
         const adapter = (0, providers_1.getAdapter)(req.provider);
@@ -708,6 +852,8 @@ class LoopRunManager {
                 iterationLimit: maxIterations,
                 startedAt: launchStartedAt,
             });
+            if (definitionEngine)
+                (0, loop_runs_store_1.saveDefinitionRun)(this.db, runId, { request: req, source: 'definition' });
             if (req.executionManifest)
                 this.db.prepare('UPDATE loop_runs SET execution_manifest = ? WHERE id = ?').run(JSON.stringify(req.executionManifest), runId);
             (0, db_1.createJob)(this.db, {
@@ -718,8 +864,15 @@ class LoopRunManager {
                 owner: 'loop',
                 causal_ownership: true,
             });
+            if (!definitionEngine)
+                (0, legacy_launch_telemetry_1.recordLegacyLaunch)(this.db, { kind: 'legacy_loop_traversal', projectId: req.projectId, runId, at: launchStartedAt });
         });
-        persistLaunch();
+        if (continuation) {
+            (0, loop_runs_store_1.resumeLoopRun)(this.db, runId);
+            this.db.prepare("UPDATE jobs SET status='running',finished_at=NULL,exit_code=NULL WHERE id=? AND owner='loop'").run(runId);
+        }
+        else
+            persistLaunch();
         this._emit({
             type: 'loop.run_started',
             projectId: req.projectId,
@@ -729,7 +882,7 @@ class LoopRunManager {
         });
         // Surface the run as a JOB so the full session streams live in the Jobs list
         // + JobDetail. Both identities committed together above, before any spawn.
-        let seq = 0;
+        let seq = continuation ? Number(this.db.prepare('SELECT COALESCE(MAX(seq),-1)+1 AS next FROM events WHERE job_id=?').get(runId).next) : 0;
         // Monotonic event-seq allocator for THIS run's job row. Shared with an
         // interactive step session (which persists its own provider events/logs on
         // the same job id) so replay ordering (getJobEvents ORDER BY seq) stays
@@ -840,7 +993,7 @@ class LoopRunManager {
         logLine(`▶ Loop "${req.loopName ?? req.loopId}" started${req.spec?.title ? ` — spec: ${req.spec.title}` : ''}`);
         if (req.isolation)
             logLine(`⎇ Isolated worktree: ${req.isolation.worktreePath} (branch ${req.isolation.branch})`);
-        if (!usageTelemetryAvailable) {
+        if (!definitionEngine && !usageTelemetryAvailable) {
             logLine(`⚠️ ${adapter.displayName} does not report token/cost usage in headless mode; usage totals will remain unavailable.` +
                 (configuredMaxCostUsd !== undefined
                     ? ' The configured maxCostUsd guard is disabled because it cannot be verified.'
@@ -856,7 +1009,8 @@ class LoopRunManager {
             model: req.model,
             iterationLimit: maxIterations,
         };
-        emitRunEvent('loop_graph', graphPayload);
+        if (!continuation)
+            emitRunEvent('loop_graph', graphPayload);
         console.log(`[loop] start run=${runId} loop=${req.loopId} provider=${req.provider} model=${req.model} nodes=${req.graph.nodes.length} cwd=${req.cwd}`);
         const byId = (0, loop_graph_1.nodesById)(req.graph);
         const start = (0, loop_graph_1.findStartNode)(req.graph);
@@ -1046,9 +1200,9 @@ class LoopRunManager {
         // that loop-back so each iteration starts FRESH (re-reading the current code),
         // keeping context bounded regardless of pass count. Within an iteration the
         // steps still resume, so RED→GREEN→REFACTOR share context.
-        const awaitHumanDecision = async (reason) => {
+        const awaitHumanDecision = async (reason, pending) => {
             const decisionPromise = new Promise((resolve) => {
-                this._pausedHumanDecisions.set(runId, { reason, resolve });
+                this._pausedHumanDecisions.set(runId, { reason, pending, resolve });
             });
             logLine(`\n■ Loop paused — needs a human decision: ${reason}`, 'stderr');
             try {
@@ -1075,6 +1229,7 @@ class LoopRunManager {
                 projectId: req.projectId,
                 jobId: runId,
                 acceptingTurns: true,
+                pendingInterrupts: pending,
                 settleMode: 'auto',
                 timestamp: pausedAt,
             });
@@ -1102,6 +1257,7 @@ class LoopRunManager {
                 projectId: req.projectId,
                 jobId: runId,
                 acceptingTurns: false,
+                pendingInterrupts: [],
                 settleMode: 'auto',
                 timestamp: resumedAt,
             });
@@ -1128,12 +1284,41 @@ class LoopRunManager {
             phaseRecovery = undefined;
             return failedId === nodeId ? successor : failedId;
         };
+        let definitionCompletion;
         const firstStepId = start ? req.graph.edges.find((e) => e.source === start.id)?.target : undefined;
         try {
             let nodeId = start?.id;
             let settled = !start; // no start node → fall through to settle as failed
             if (!start)
                 outcome = 'failed';
+            if (definitionEngine) {
+                settled = true;
+                const projectEvent = (0, loop_definition_events_1.createDefinitionEventProjection)({ db: this.db, runId, projectId: req.projectId, ticketIds: exactTicketIds, nextSequence: takeSeq,
+                    broadcast: event => this._emit({ type: 'event', jobId: runId, event_type: event.eventType, source: 'stdout', payload: event.payload, seq: event.seq, timestamp: event.timestamp }),
+                    onProgress: (count, usage) => { stepNum = count; totalCost = usage.cost; totalTokens = usage.tokensIn + usage.tokensOut; totalDuration = usage.duration; costUncertain = usage.costUnknown; usageTelemetryAvailable = usage.present; },
+                });
+                let activeDurationMs = continuation ? (0, loop_runs_store_1.getLoopRun)(this.db, runId)?.total_duration_ms ?? 0 : 0;
+                const result = await (0, loop_definition_run_1.runDefinitionLoop)(req, runId, { continuation, contextPath: () => (0, loop_runs_store_1.readDefinitionRun)(this.db, runId)?.metadata.contextPath,
+                    onPrepared: metadata => { (0, loop_runs_store_1.saveDefinitionRun)(this.db, runId, metadata); },
+                    invoke: input => { this.claimDefinition({ ...req, runId }); return this.executors.runDefinition(input); }, isCancelled: () => this._cancelled.has(runId),
+                    remainingMs: () => req.graph.config.timeoutMinutes > 0 ? Math.max(1, req.graph.config.timeoutMinutes * 60_000 - activeDurationMs) : undefined,
+                    onLine: logLine, onRuntimeEvent: projectEvent, onSpawn: child => {
+                        this._activeChild.set(runId, child);
+                        if (this._cancelled.has(runId))
+                            this.cancelResident(runId, false);
+                    },
+                    onInvocationEnd: result => { this._activeChild.delete(runId); if (result.runtimeStatus === 'paused')
+                        this.releaseDefinition(runId); if (result.durationMs !== undefined) {
+                        activeDurationMs = result.durationMs;
+                        totalDuration = result.durationMs;
+                    } }, awaitHumanDecision, });
+                definitionCompletion = result.completion;
+                if (result.durationMs !== undefined)
+                    totalDuration = result.durationMs;
+                if (result.errorText)
+                    logLine(result.errorText, 'stderr');
+                outcome = result.runtimeStatus === 'succeeded' ? 'success' : result.runtimeStatus === 'cancelled' ? 'stopped' : result.runtimeStatus === 'blocked' ? 'blocked' : 'failed';
+            }
             while (nodeId && !settled) {
                 if (this._cancelled.has(runId)) {
                     outcome = 'stopped';
@@ -1771,7 +1956,7 @@ class LoopRunManager {
         try {
             const recoveredSteps = recoverOrphanLoopStepAccounting(this.db, new Date(this.now()).toISOString(), runId);
             this._activeStepRecovery.delete(runId);
-            runtimeUsage = programmaticUsageAvailability(this.db, runId);
+            runtimeUsage = definitionEngine ? (0, loop_definition_events_1.readDefinitionUsage)(this.db, runId) : programmaticUsageAvailability(this.db, runId);
             usageTelemetryAvailable ||= runtimeUsage.present;
             const aggregate = this.db.prepare(`
         SELECT COALESCE(SUM(total_cost_usd), 0) AS cost,
@@ -1819,10 +2004,18 @@ class LoopRunManager {
         // terminal snapshot alongside counters so history does not depend on prose.
         let coreCompletion = null;
         try {
-            coreCompletion = await this.executors.readCoreCompletion?.(runId) ?? null;
+            if (!definitionEngine)
+                coreCompletion = await this.executors.readCoreCompletion?.(runId) ?? null;
         }
         catch { /* old/unavailable runtime */ }
+        if (definitionEngine) {
+            const usage = (0, loop_definition_events_1.readDefinitionUsage)(this.db, runId);
+            usageTelemetryAvailable = usage.present;
+            finalJobUsage = { tokensIn: usage.present && !usage.tokensInUnknown ? usage.tokensIn : null, tokensOut: usage.present && !usage.tokensOutUnknown ? usage.tokensOut : null, tokensCacheRead: usage.present && !usage.cacheReadUnknown ? usage.cacheRead : null, tokensCacheCreate: usage.present && !usage.cacheCreateUnknown ? usage.cacheCreate : null, numTurns: usage.present && !usage.turnsUnknown ? usage.turns : null };
+        }
         const executionOutcome = outcome;
+        if (definitionEngine && outcome === 'success' && !definitionCompletion?.ok)
+            outcome = 'blocked';
         if (outcome === 'success' && coreCompletion && (coreCompletion.completion.implementation !== 'complete' || !['verified', 'with-exceptions'].includes(coreCompletion.completion.validation)))
             outcome = 'blocked';
         const costAvailable = usageTelemetryAvailable && !runtimeUsage.costUnknown;
@@ -1831,7 +2024,7 @@ class LoopRunManager {
         emitRunEvent('loop_completion', {
             version: 1, execution: executionOutcome, steps: stepNum, deciderEvaluations: iteration,
             turns: finalJobUsage.numTurns, costUsd: usageTelemetryAvailable ? totalCost : null,
-            costUncertain, core: coreCompletion,
+            costUncertain, core: coreCompletion, ...(definitionEngine ? { engineVersion: 2, completion: definitionCompletion } : {}),
         });
         // Settle the backing job so the Jobs list + JobDetail reflect the final
         // status, and emit job.finalized so an open JobDetail re-fetches + stops the