specrails-desktop 2.59.2 → 2.59.3

package/server/dist/jira/jira-sync-manager.js

@@ -999,6 +999,11 @@ class JiraSyncManager {
             return;
         let changed = false;
         while (!this.authPaused) {
+            // A failed transition may have acquired a newer intention while its HTTP
+            // request was in flight. Reconcile before each claim, including legacy
+            // manual retries whose newer transition has already completed.
+            if ((0, jira_db_1.reconcileSupersededTransitions)(this.db) > 0)
+                changed = true;
             const batch = (0, jira_db_1.claimDrainable)(this.db, MAX_DRAIN_BATCH);
             if (batch.length === 0)
                 break;
@@ -1099,6 +1104,7 @@ class JiraSyncManager {
             // the SAME category (e.g. In Progress → In Review, both indeterminate)
             // while still noop-ing when the issue already sits on the target.
             currentStatusName: issue.data.fields.status?.name,
+            currentStatusId: issue.data.fields.status?.id,
             explicitTarget,
             getTransitions: async () => {
                 const res = await client.getTransitions(payload.jiraIssueId);
@@ -1231,6 +1237,7 @@ class JiraSyncManager {
         }
     }
     broadcastOutboxState() {
+        (0, jira_db_1.reconcileSupersededTransitions)(this.db);
         const counts = (0, jira_db_1.countOutboxByState)(this.db);
         this.broadcast({ type: 'jira.outbox_changed', projectId: this.projectId, pending: counts.pending + counts.inflight, dead: counts.dead });
     }
@@ -1309,11 +1316,43 @@ class JiraSyncManager {
         return (0, jira_db_1.listLinks)(this.db);
     }
     listOutbox(state) {
-        return (0, jira_db_1.listOutbox)(this.db, state ? { state } : {});
+        if ((0, jira_db_1.reconcileSupersededTransitions)(this.db) > 0)
+            this.broadcastOutboxState();
+        const links = new Map((0, jira_db_1.listLinks)(this.db).map((link) => [link.jiraIssueId, link.jiraKey]));
+        const statusMap = (0, jira_db_1.getConnection)(this.db, this.projectId)?.statusMap;
+        const logicalStates = ['todo', 'in_progress', 'on_review', 'done', 'cancelled'];
+        return (0, jira_db_1.listOutbox)(this.db, state ? { state } : {}).map((row) => {
+            let logicalState = null;
+            let targetStatus = null;
+            if (row.opType === 'transition') {
+                try {
+                    const payload = JSON.parse(row.payload);
+                    if (payload && typeof payload === 'object') {
+                        if (logicalStates.includes(payload.logicalState))
+                            logicalState = payload.logicalState;
+                        if (typeof payload.targetStatus === 'string' && payload.targetStatus.trim())
+                            targetStatus = payload.targetStatus;
+                    }
+                }
+                catch {
+                    // Historical/corrupt payloads remain visible for diagnosis.
+                }
+                targetStatus ??= logicalState ? statusMap?.[logicalState] ?? null : null;
+            }
+            return { ...row, jiraKey: links.get(row.jiraIssueId) ?? null, logicalState, targetStatus };
+        });
     }
     outboxCounts() {
+        if ((0, jira_db_1.reconcileSupersededTransitions)(this.db) > 0)
+            this.broadcastOutboxState();
         return (0, jira_db_1.countOutboxByState)(this.db);
     }
+    retryOutbox(id) {
+        const disposition = (0, jira_db_1.retryDeadOutbox)(this.db, id);
+        if (disposition)
+            this.broadcastOutboxState();
+        return disposition;
+    }
 }
 exports.JiraSyncManager = JiraSyncManager;
 // ─── Error envelope for thrown client failures inside the walk ─────────────────

package/server/dist/jira-router.js

@@ -1,37 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJiraRouter = createJiraRouter;
 const express_1 = require("express");
@@ -201,26 +168,26 @@ function createJiraRouter() {
     router.get('/outbox', (req, res) => {
         const c = ctx(req);
         const state = req.query.state;
-        const valid = ['pending', 'inflight', 'done', 'dead'];
+        const valid = ['pending', 'inflight', 'done', 'dead', 'superseded'];
         const filter = valid.includes(state) ? state : undefined;
         res.json({ ops: c.jiraSyncManager.listOutbox(filter), counts: c.jiraSyncManager.outboxCounts() });
     });
     // POST /outbox/:id/retry — re-queue a dead-lettered op for a manual retry.
     router.post('/outbox/:id/retry', async (req, res) => {
         const c = ctx(req);
-        const id = parseInt(req.params.id, 10);
-        if (Number.isNaN(id)) {
+        const id = Number(req.params.id);
+        if (!Number.isSafeInteger(id) || id <= 0) {
             res.status(400).json({ error: 'Invalid op id' });
             return;
         }
-        const { retryDeadOutbox } = await Promise.resolve().then(() => __importStar(require('./jira/jira-db')));
-        const ok = retryDeadOutbox(c.db, id);
-        if (!ok) {
+        const disposition = c.jiraSyncManager.retryOutbox(id);
+        if (!disposition) {
             res.status(404).json({ error: 'Op not found or not in dead state' });
             return;
         }
-        void c.jiraSyncManager.drainOnce().catch(() => undefined);
-        res.json({ ok: true });
+        if (disposition === 'pending')
+            void c.jiraSyncManager.drainOnce().catch(() => undefined);
+        res.json({ ok: true, disposition });
     });
     // POST /specs — Add Spec when the project source is Jira: create the issue in
     // Jira and materialize it locally. Keeps the generic local ticket-create path

package/server/dist/modules/agent-runtime/runtime/agent-runtime-bridge.js

@@ -10,7 +10,7 @@ exports.runAgentRuntimeControl = runAgentRuntimeControl;
 const agent_runtime_verification_suggestions_1 = require("./agent-runtime-verification-suggestions");
 const agent_runtime_history_1 = require("./agent-runtime-history");
 const agent_runtime_repositories_1 = require("./agent-runtime-repositories");
-const node_util_1 = require("node:util");
+const agent_runtime_verification_log_1 = require("./agent-runtime-verification-log");
 const agent_runtime_effective_config_1 = require("./agent-runtime-effective-config");
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
@@ -93,66 +93,6 @@ function requiresConfiguredChecks(value) {
     return Object.values(body.nodes ?? {}).some(node => node.kind === 'verify' && node.params?.commands === 'configured' && !node.params.additionalCommandsFrom && node.params.unverified !== true)
         || Object.values(body.components ?? {}).some(requiresConfiguredChecks);
 }
-/** Keep TAP failure diagnostics and totals in the readable log. The unfiltered
- * event stream remains available as runtime evidence. State is invocation-local. */
-function verificationLogFilter() {
-    const streams = new Map();
-    return text => (0, node_util_1.stripVTControlCharacters)(text).split(/(?<=\n)/).flatMap(line => {
-        const match = line.match(/^(\[verification [^\]]+\] )?(.*?)(?:\n)?$/);
-        if (!match)
-            return [line];
-        const key = match[1] ?? '', body = match[2].trim();
-        const state = streams.get(key) ?? { tap: false, failed: false, yaml: false, inputLines: null };
-        streams.set(key, state);
-        if (/AssertionError\b.*\bInput:\s*$/.test(body))
-            state.inputLines = 0;
-        else if (state.inputLines !== null) {
-            // Node prints assert.match's entire source input as quoted concatenation
-            // lines. Bound only that block; stacks, expected values and other streams
-            // remain visible and original events remain intact.
-            if (/^["'`]/.test(body)) {
-                state.inputLines++;
-                if (state.inputLines > 2)
-                    return state.inputLines === 3 ? [key + '[Assertion input shortened; inspect raw evidence]\n'] : [];
-            }
-            else if (!body)
-                return [];
-            else
-                state.inputLines = null;
-        }
-        if (/^[✔✓]\s/.test(body))
-            return [];
-        if (/^[✖✗]\s/.test(body)) {
-            state.failed = true;
-            return [line];
-        }
-        if (/^TAP version |^# Subtest:/.test(body)) {
-            state.tap = true;
-            return [];
-        }
-        if (/^(?:not )?ok \d+\b/.test(body)) {
-            state.tap = true;
-            state.failed = body.startsWith('not ok');
-            state.yaml = false;
-            return state.failed ? [line] : [];
-        }
-        if (!state.tap)
-            return [line];
-        if (body === '---') {
-            state.yaml = true;
-            return state.failed ? [line] : [];
-        }
-        if (body === '...') {
-            state.yaml = false;
-            return state.failed ? [line] : [];
-        }
-        if (state.yaml)
-            return state.failed ? [line] : [];
-        if (/^1\.\.\d+$/.test(body) || !body)
-            return [];
-        return [line];
-    }).map(line => line.length > 2_000 ? line.slice(0, 1_900) + '\n[Long diagnostic line shortened; inspect raw evidence]\n' : line).join('');
-}
 exports.RUNTIME_HOST_ENV_KEYS = [
     'SPECRAILS_REPO_DIR', 'SPECRAILS_GIT_AUTO', 'SPECRAILS_REPO_MAP_PATH',
     'SPECRAILS_EXECUTION_CONTEXT', 'SPECRAILS_EXECUTION_MANIFEST', 'SPECRAILS_REPOSITORIES',
@@ -356,7 +296,13 @@ async function runAgentRuntimeInvocation(options) {
             callback?.();
         }
         catch { /* Logging cannot replay a workflow. */ } };
-        const readableVerification = verificationLogFilter();
+        const readableVerification = (0, agent_runtime_verification_log_1.createVerificationLogProjection)();
+        const readableLines = (lines) => {
+            for (const line of lines)
+                observe(() => line.attemptId
+                    ? options.onLine?.(line.text, 'stdout', { attemptId: line.attemptId })
+                    : options.onLine?.(line.text));
+        };
         const lines = (0, node_readline_1.createInterface)({ input: child.stdout });
         lines.on('line', line => {
             if (line.length > 2_000_000) {
@@ -388,6 +334,10 @@ async function runAgentRuntimeInvocation(options) {
                     (0, win_spawn_1.treeKillSafe)(child.pid, 'SIGKILL');
                 return;
             }
+            const boundary = event.type === 'workflow-event' || event.type === 'runtime-result';
+            // Flush buffered output before the projection advances the current step.
+            if (boundary)
+                readableLines(readableVerification.project(event));
             try {
                 options.onRuntimeEvent?.(event);
             }
@@ -400,6 +350,8 @@ async function runAgentRuntimeInvocation(options) {
             if (event.type === 'runtime-graph')
                 graph = event;
             observe(() => options.onRawLine?.(event.repositories ? JSON.stringify(event) : line));
+            if (!boundary)
+                readableLines(readableVerification.project(event));
             if (event.type === 'runtime-result') {
                 if (result)
                     invalidProtocol = true;
@@ -435,11 +387,6 @@ async function runAgentRuntimeInvocation(options) {
                     observe(() => options.onLine?.(`[${role}]${scope} ${payload.tool}${payload.detail ? ' ' + payload.detail : ''}\n`));
                 }
             }
-            else if (event.type === 'verification-output' && typeof event.text === 'string') {
-                const readable = readableVerification(String(event.text));
-                if (readable)
-                    observe(() => options.onLine?.(readable));
-            }
             else if (event.type === 'span') {
                 // Trace spans are telemetry; the raw line is already recorded for diagnostics.
             }
@@ -461,6 +408,7 @@ async function runAgentRuntimeInvocation(options) {
             if (timer)
                 clearTimeout(timer);
             lines.close();
+            readableLines(readableVerification.flush());
             const usage = result?.invocationUsage;
             const known = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
             const cost = known(usage?.costUsd), tokensIn = known(usage?.inputTokens), tokensOut = known(usage?.outputTokens);

package/server/dist/modules/agent-runtime/runtime/agent-runtime-controls.js

@@ -26,6 +26,7 @@ const agent_runtime_bridge_1 = require("./agent-runtime-bridge");
 const core_node_runtime_1 = require("../../../core-node-runtime");
 const win_spawn_1 = require("../../../util/win-spawn");
 const workspace_resolution_1 = require("../../../workspace-resolution");
+const project_env_1 = require("../../../project-env");
 const loop_runs_store_1 = require("../../loops/runtime/loop-runs-store");
 const multi_repo_execution_store_1 = require("../../delivery/runtime/multi-repo-execution-store");
 const db_1 = require("../../../db");
@@ -309,7 +310,7 @@ class AgentRuntimeControls {
         const host = JSON.parse(node_fs_1.default.readFileSync(hostFile, 'utf8'));
         if (host.schemaVersion !== 1 || typeof host.cwd !== 'string' || ![frozen.backlogRoot, ...frozen.repositories.map((repository) => repository.path)].includes(host.cwd) || !host.env || typeof host.env !== 'object' || Array.isArray(host.env) || Object.entries(host.env).some(([key, value]) => !agent_runtime_bridge_1.RUNTIME_HOST_ENV_KEYS.includes(key) || typeof value !== 'string'))
             throw new RuntimeControlError(409, 'runtime_host_invalid', 'The saved runtime host settings are invalid');
-        const env = { ...(0, workspace_resolution_1.resolveLoopBaseEnv)(this.ctx.project) };
+        const env = { ...(0, workspace_resolution_1.resolveLoopBaseEnv)(this.ctx.project, undefined, (0, project_env_1.applyWorktreeEnvPassthrough)(this.ctx.db, process.env)) };
         for (const key of agent_runtime_bridge_1.RUNTIME_HOST_ENV_KEYS)
             delete env[key];
         Object.assign(env, host.env, { SPECRAILS_EXECUTION_CONTEXT: file });
@@ -541,15 +542,17 @@ class AgentRuntimeControls {
                 loopDurationBaseline: previous.total_duration_ms, completedDurationMs: 0,
                 iterationCount: previous.iteration_count, activeTurnStartedAtMs: startedAtMs, lastActivityAtMs: startedAtMs,
             });
-            const logLine = (line, source = 'stdout') => {
+            const logLine = (line, source = 'stdout', metadata) => {
                 if (this.disposed)
                     return;
+                const attemptId = metadata?.attemptId;
+                const attribution = typeof attemptId === 'string' && attemptId.trim() && attemptId.length <= 256 ? { attemptId } : {};
                 try {
-                    (0, db_1.appendEvent)(this.ctx.db, runId, ++sequence, { event_type: 'log', source, payload: JSON.stringify({ line: line.replace(/\n$/, '') }) });
+                    (0, db_1.appendEvent)(this.ctx.db, runId, ++sequence, { event_type: 'log', source, payload: JSON.stringify({ line: line.replace(/\n$/, ''), ...attribution }) });
                 }
                 catch { /* events table best-effort */ }
                 try {
-                    this.ctx.broadcast?.({ type: 'log', source, line, timestamp: new Date().toISOString(), processId: runId });
+                    this.ctx.broadcast?.({ type: 'log', source, line, timestamp: new Date().toISOString(), processId: runId, ...attribution });
                 }
                 catch { /* persisted log remains authoritative */ }
             };

package/server/dist/modules/agent-runtime/runtime/agent-runtime-verification-log.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVerificationLogProjection = createVerificationLogProjection;
+const node_util_1 = require("node:util");
+const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const text = (value) => typeof value === 'string' ? value : '';
+const display = (value, limit = 512) => (0, node_util_1.stripVTControlCharacters)(value).replace(/[\r\n]/g, ' ').slice(0, limit);
+const attemptId = (event) => typeof event.attemptId === 'string' && event.attemptId.length <= 256 && event.attemptId.trim() ? event.attemptId : undefined;
+const output = (value, id) => ({ text: value, ...(id ? { attemptId: id } : {}) });
+const scope = (event) => JSON.stringify([event.runId, event.scopeId, event.nodePath, event.attemptId, event.attempt, event.visit]
+    .map(value => typeof value === 'string' && value.length <= 512 || typeof value === 'number' && Number.isSafeInteger(value) ? value : null));
+const reference = 'Details → Verification evidence (stdout/stderr; retained evidence may be truncated)';
+const shortPrefix = (value) => value.length > 96 ? value.slice(0, 92) + '…] ' : value;
+/** This is presentation only. Neither its heuristics nor check progress can
+ * certify a candidate; original runtime events and command evidence are untouched. */
+function createVerificationLogProjection() {
+    const streams = new Map();
+    const active = new Map();
+    let overflow = false;
+    const binding = (event, repository) => JSON.stringify([scope(event), repository]);
+    function get(key, event, prefix) {
+        let state = streams.get(key);
+        if (!state && streams.size < 64) {
+            state = { scope: scope(event), attemptId: attemptId(event), prefix: shortPrefix(prefix), tap: false, failed: false, yaml: false, inputLines: null, inputShortened: false,
+                headLines: 0, headChars: 0, shown: new Set(), diagnostics: [[], [], [], []], summaries: new Map(), tail: [], previous: [], context: 0, omitted: 0, announced: false };
+            streams.set(key, state);
+        }
+        return state;
+    }
+    function omitted(state) {
+        state.omitted++;
+        if (state.announced)
+            return '';
+        state.announced = true;
+        return state.prefix + '[Verbose output omitted; ' + reference + ']\n';
+    }
+    function diagnostic(state, line, priority) {
+        const bounded = line.slice(0, priority === 3 ? 256 : 512), bucket = state.diagnostics[priority];
+        if (state.shown.has(line) || bucket.includes(bounded))
+            return;
+        // First fact plus three recent facts in each class; warnings cannot consume
+        // the compiler/assertion budget, and later failures remain represented.
+        if (bucket.length === (priority === 3 ? 2 : 4))
+            bucket.splice(1, 1);
+        bucket.push(bounded);
+    }
+    function priority(body) {
+        if (/^(?!['"`]|(?:actual|expected|source):).+(?:\(\d+,\d+\)|:\d+(?::\d+)?)(?::|\s+-)?\s+(?:fatal\s+)?error\b/i.test(body)
+            || /^(?:fatal\s+)?error\s+[A-Z]+\d+\s*:/.test(body)
+            || /^(?:AssertionError|TypeError|ReferenceError|SyntaxError|RangeError)\b/.test(body))
+            return 0;
+        if (/^(?:FAIL\s|not ok \d+\b|[✖✗]\s|(?:fatal\s+)?error(?:\s*\[[^\]]+\])?\s*:)/i.test(body)
+            && !/\b0 errors?\b/i.test(body))
+            return 1;
+        if (/^(?:expected|actual|operator|test at|location)\s*[: ]/i.test(body))
+            return 2;
+        return undefined;
+    }
+    function summary(body) {
+        if (/^Ran all test suites[.\s]*$/.test(body))
+            return 'ran';
+        const match = body.match(/^(Test Suites|Test Files|Tests|Snapshots|Time|Duration|Ran all test suites)\s*:?\s/i)
+            ?? body.match(/^(?:#|ℹ)\s*(tests|suites|pass|fail|cancelled|skipped|todo|duration_ms|duration)\b/i);
+        return match?.[1].toLowerCase();
+    }
+    function line(state, original, body) {
+        let value = original;
+        if (/AssertionError\b.*\bInput:\s*$/.test(body))
+            state.inputLines = 0;
+        else if (state.inputLines !== null) {
+            if (/^["'`]/.test(body)) {
+                state.inputLines++;
+                if (state.inputLines > 2) {
+                    if (state.inputShortened)
+                        return '';
+                    state.inputShortened = true;
+                    return state.prefix + '[Assertion input shortened; inspect raw evidence]\n';
+                }
+            }
+            else if (!body)
+                return '';
+            else
+                state.inputLines = null;
+        }
+        if (/^[✔✓]\s/.test(body))
+            return '';
+        if (/^PASS\s/.test(body))
+            return omitted(state);
+        if (/^[✖✗]\s/.test(body))
+            state.failed = true;
+        if (/^TAP version |^# Subtest:/.test(body)) {
+            state.tap = true;
+            return '';
+        }
+        if (/^(?:not )?ok \d+\b/.test(body)) {
+            state.tap = true;
+            state.failed = body.startsWith('not ok');
+            state.yaml = false;
+            if (!state.failed)
+                return '';
+        }
+        if (state.tap) {
+            if (body === '---') {
+                state.yaml = true;
+                if (!state.failed)
+                    return '';
+            }
+            if (body === '...') {
+                state.yaml = false;
+                if (!state.failed)
+                    return '';
+            }
+            if (state.yaml && !state.failed)
+                return '';
+            if (/^1\.\.\d+$/.test(body))
+                return '';
+        }
+        if (!body)
+            return '';
+        if (value.length > 2_000)
+            value = value.slice(0, 1_900) + '\n[Long diagnostic line shortened; inspect raw evidence]';
+        const total = summary(body);
+        if (total) {
+            // Known totals have a fixed key set, so repeated progress updates do not
+            // become another unbounded stream or evict diagnostics.
+            state.summaries.set(total, state.prefix + body.slice(0, 128));
+            return '';
+        }
+        const rank = priority(body.slice(0, 2_000));
+        if (state.headLines < 24 && state.headChars + value.length <= 3_500) {
+            state.headLines++;
+            state.headChars += value.length;
+            state.shown.add(value);
+            state.previous.push(value);
+            if (state.previous.length > 2)
+                state.previous.shift();
+            return value + '\n';
+        }
+        if (rank !== undefined) {
+            if (rank < 2) {
+                for (const preceding of state.previous)
+                    diagnostic(state, preceding, 3);
+                state.context = 3;
+            }
+            diagnostic(state, value, rank);
+        }
+        else if (state.context > 0) {
+            diagnostic(state, value, 3);
+            state.context--;
+        }
+        state.previous.push(value);
+        if (state.previous.length > 2)
+            state.previous.shift();
+        state.tail.push(value.slice(0, 256));
+        if (state.tail.length > 6)
+            state.tail.shift();
+        return omitted(state);
+    }
+    function flush(key) {
+        const result = [];
+        for (const [id, state] of streams) {
+            if (key !== undefined && id !== key)
+                continue;
+            let content = '';
+            const pending = [...state.diagnostics.flat(), ...state.tail, ...state.summaries.values()];
+            const seen = new Set(state.shown);
+            for (const value of pending)
+                if (!seen.has(value)) {
+                    seen.add(value);
+                    content += value + '\n';
+                }
+            if (state.omitted)
+                content += state.prefix + `[${state.omitted} output lines compacted; ${reference}]\n`;
+            if (content)
+                result.push(output(content, state.attemptId));
+            streams.delete(id);
+            for (const [name, activeId] of active)
+                if (activeId === id)
+                    active.delete(name);
+        }
+        return result;
+    }
+    function project(event) {
+        if (event.type === 'verification-output' && typeof event.text === 'string') {
+            const result = [];
+            for (const value of (0, node_util_1.stripVTControlCharacters)(event.text).split('\n')) {
+                if (!value)
+                    continue;
+                const match = value.match(/^(\[verification ([^/\]]+)\/[^\]]+\] )?(.*)$/);
+                const prefix = match?.[1] ?? '', repository = match?.[2] ?? '', body = (match?.[3] ?? value).trim();
+                const key = active.get(binding(event, repository)) ?? JSON.stringify([scope(event), prefix.slice(0, 1024)]);
+                const state = get(key, event, prefix);
+                if (state) {
+                    const content = line(state, shortPrefix(prefix) + (match?.[3] ?? value), body);
+                    if (content)
+                        result.push(output(content, state.attemptId));
+                }
+                else if (!overflow) {
+                    overflow = true;
+                    result.push(output(`[Additional verification output omitted; ${reference}]\n`, attemptId(event)));
+                }
+            }
+            return result;
+        }
+        if (event.type === 'runtime-efficiency-event') {
+            const data = object(event.payload) ? { ...event, ...event.payload } : event;
+            const kind = text(data.kind), id = text(data.executionId), repository = text(data.repositoryId), label = text(data.label);
+            if (!['check-started', 'check-finished', 'check-reused', 'check-invalidated'].includes(kind) || !id || id.length > 256 || !repository || repository.length > 256 || !label || label.length > 4096)
+                return [];
+            const prefix = `[verification ${display(repository)}/${display(label)}] `;
+            const key = JSON.stringify([scope(data), id]), name = binding(data, repository);
+            if (kind === 'check-started') {
+                if (active.get(name) === key)
+                    return [];
+                const result = active.has(name) ? flush(active.get(name)) : [];
+                if (get(key, data, prefix))
+                    active.set(name, key);
+                result.push(output(prefix + 'started\n', attemptId(data)));
+                return result;
+            }
+            if (kind === 'check-invalidated')
+                return [output(prefix + 'evidence invalidated' + (typeof data.reason === 'string' ? ': ' + display(data.reason) : '') + '\n', attemptId(data))];
+            if (!Number.isSafeInteger(data.exitCode) || typeof data.durationMs !== 'number' || !Number.isFinite(data.durationMs) || data.durationMs < 0)
+                return [];
+            const result = flush(key);
+            return [...result, output(prefix + `${kind === 'check-reused' ? 'reused' : data.exitCode === 0 ? 'command passed' : 'command failed'} (exit ${data.exitCode}, ${(data.durationMs / 1000).toFixed(1)} s)\n`, attemptId(data))];
+        }
+        if (event.type === 'runtime-result')
+            return flush();
+        if (event.type === 'workflow-event' && object(event.event)) {
+            const data = event.event, kind = text(data.type);
+            if (/^workflow_(?:succeeded|failed|cancelled|paused)$/.test(kind))
+                return flush();
+            if (!/^step_(?:started|succeeded|failed|cancelled|interrupted)$/.test(kind))
+                return [];
+            const result = [];
+            for (const [key, state] of streams) {
+                const identity = JSON.parse(state.scope);
+                // Older transports lack attempt identity. Flush them before a phase
+                // boundary; v2 flushes only the ending attempt, leaving siblings intact.
+                const legacy = identity[2] === null && identity[3] === null;
+                const sameAttempt = typeof data.attemptId === 'string' && identity[3] === data.attemptId;
+                const sameNode = !data.attemptId && (data.nodePath ?? data.stepId) === identity[2] && (!data.scopeId || data.scopeId === identity[1]);
+                if (legacy || (kind !== 'step_started' && (sameAttempt || sameNode)))
+                    result.push(...flush(key));
+            }
+            return result;
+        }
+        return [];
+    }
+    return { project, flush };
+}

package/server/dist/modules/delivery/runtime/rail-relaunch.js

@@ -104,8 +104,16 @@ function resolveRailRelaunch(c, railIndex, sourceId) {
             config.baseBranch = row.base_branch;
         if (delivery.executionManifest) {
             config.repositoryIds = delivery.executionManifest.selectedRepositoryIds;
-            config.workspaceSelection = savedConfig?.workspaceSelection ?? Object.fromEntries(delivery.executionManifest.repositories
-                .filter(repo => repo.selectedWorkspacePaths).map(repo => [repo.repositoryId, repo.selectedWorkspacePaths]));
+            if (savedConfig?.workspaceSelection === undefined) {
+                const entries = delivery.executionManifest.repositories
+                    .filter(repo => repo.selectedWorkspacePaths !== undefined).map(repo => [repo.repositoryId, repo.selectedWorkspacePaths]);
+                // No recorded narrowing means registered defaults, represented by
+                // absence. Explicit values remain subject to ordinary launch validation.
+                if (entries.length)
+                    config.workspaceSelection = Object.fromEntries(entries);
+                else
+                    delete config.workspaceSelection;
+            }
         }
     }
     if (!Array.isArray(ticketIds) || !ticketIds.length || ticketIds.some(id => !Number.isSafeInteger(id) || id <= 0))

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

@@ -950,13 +950,15 @@ class LoopRunManager {
             openStep = null;
             emitRunEvent('loop_step_end', payload);
         };
-        const logLine = (line, source = 'stdout') => {
+        const logLine = (line, source = 'stdout', metadata) => {
+            const attemptId = metadata?.attemptId;
+            const attribution = typeof attemptId === 'string' && attemptId.trim() && attemptId.length <= 256 ? { attemptId } : {};
             const s = takeSeq();
             try {
-                (0, db_1.appendEvent)(this.db, runId, s, { event_type: 'log', source, payload: JSON.stringify({ line }) });
+                (0, db_1.appendEvent)(this.db, runId, s, { event_type: 'log', source, payload: JSON.stringify({ line, ...attribution }) });
             }
             catch { /* events table best-effort */ }
-            this._emit({ type: 'log', source, line, timestamp: new Date(this.now()).toISOString(), processId: runId });
+            this._emit({ type: 'log', source, line, timestamp: new Date(this.now()).toISOString(), processId: runId, ...attribution });
         };
         // Forward a RAW provider stdout line (claude/codex JSONL) as an `event` —
         // identical to QueueManager — so JobStatusPanel parses real activity