brainclaw 1.28.2 → 1.28.4

package/dist/core/code-map/backend.js

@@ -19,7 +19,8 @@ import { exportSubgraph } from './export.js';
 import { fileId } from './ids.js';
 import { resolveTraversal, aggregateFind, aggregateBrief } from './aggregate.js';
 import { defaultMemoryReader } from './memory-reader.js';
-import { listNestedProjects, refreshWorkspaceCascade } from './cascade.js';
+import { inspectNestedProjects, refreshWorkspaceCascade } from './cascade.js';
+import { latestCascadeRefreshJob, summarizeCascadeRefreshJob } from './cascade-jobs.js';
 import { loadConfig } from '../config.js';
 import { codeMapDir } from './paths.js';
 /** spec §9 caps the brief reading list at 12 files. */
@@ -112,17 +113,26 @@ function isMultiProjectWorkspace(cwd) {
 /** Per-child store recap for `status(cascade)` in a multi-project workspace. */
 function buildCascadeStatus(rootCwd) {
     const root = rootCwd ?? process.cwd();
-    const children = listNestedProjects(root).map((abs) => {
+    const discovery = inspectNestedProjects(root);
+    const children = discovery.projects.map((abs) => {
         const m = readManifest(abs);
         return {
             path: path.relative(root, abs).replace(/\\/g, '/') || '.',
             store_exists: m ? true : storeExists(abs),
             freshness: m ? m.freshness.status : 'missing_index',
             files_indexed: m ? m.stats.files_indexed : null,
+            ...(m && m.stats.files_indexed === 0 ? { reason: 'no_eligible_files' } : {}),
         };
     });
     const indexed = children.filter((c) => c.freshness !== 'missing_index').length;
-    return { children, indexed_children: indexed, total_children: children.length };
+    const latestJob = latestCascadeRefreshJob(root);
+    return {
+        children,
+        indexed_children: indexed,
+        total_children: children.length,
+        discovery_truncated: discovery.truncated,
+        ...(latestJob ? { refresh_job: summarizeCascadeRefreshJob(latestJob) } : {}),
+    };
 }
 /**
  * P0 JSONL-backed query backend. Reads the durable file store (manifest +
@@ -198,17 +208,17 @@ export class JsonlBackend {
             // A cascade is only fully "acquired" when EVERY project got its lock; if a
             // child or the root was skipped under a live writer, surface that instead
             // of reporting a clean lock_acquired=true over a partial cascade (codex review).
-            const skipped = allProjects.filter((p) => !p.lock_acquired);
+            const incomplete = allProjects.filter((p) => p.outcome === 'locked' || p.outcome === 'failed');
             return {
                 ran: allProjects.some((p) => p.ran),
                 scope,
-                lock_acquired: skipped.length === 0,
+                lock_acquired: incomplete.length === 0,
                 freshness_badge: badge(root.freshness, {
                     files_parsed: root.files_parsed,
                     children_refreshed: cascade.children_refreshed,
                 }),
-                ...(skipped.length > 0
-                    ? { lock_status: `${skipped.length} project(s) skipped (lock held): ${skipped.map((p) => p.path).join(', ')}` }
+                ...(incomplete.length > 0
+                    ? { lock_status: `${incomplete.length} project(s) incomplete: ${incomplete.map((p) => `${p.path} (${p.outcome})`).join(', ')}` }
                     : {}),
                 cascade,
             };

package/dist/core/code-map/cascade-jobs.js

@@ -0,0 +1,174 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { loadConfig } from '../config.js';
+import { writeFileAtomic } from '../io.js';
+import { codeMapDir } from './paths.js';
+import { inspectNestedProjects, refreshWorkspaceCascade } from './cascade.js';
+export function summarizeCascadeRefreshJob(job) {
+    const { result, ...summary } = job;
+    if (!result)
+        return summary;
+    const projects = [result.root_result, ...result.children];
+    const outcomeCounts = {};
+    for (const project of projects)
+        outcomeCounts[project.outcome] = (outcomeCounts[project.outcome] ?? 0) + 1;
+    const problemProjects = projects
+        .filter((project) => project.outcome !== 'indexed')
+        .map((project) => ({ path: project.path, outcome: project.outcome, ...(project.reason ? { reason: project.reason } : {}), ...(project.error ? { error: project.error } : {}) }));
+    return { ...summary, outcome_counts: outcomeCounts, ...(problemProjects.length ? { problem_projects: problemProjects } : {}) };
+}
+function jobsDir(root) {
+    return path.join(codeMapDir(root), 'cascade-jobs');
+}
+function jobPath(root, jobId) {
+    return path.join(jobsDir(root), `${jobId}.json`);
+}
+function writeJob(job) {
+    const dir = jobsDir(job.root);
+    fs.mkdirSync(dir, { recursive: true });
+    const target = jobPath(job.root, job.job_id);
+    writeFileAtomic(target, `${JSON.stringify(job, null, 2)}\n`);
+}
+export function readCascadeRefreshJob(root, jobId) {
+    try {
+        return JSON.parse(fs.readFileSync(jobPath(path.resolve(root), jobId), 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function latestCascadeRefreshJob(root) {
+    const dir = jobsDir(path.resolve(root));
+    try {
+        const jobs = fs.readdirSync(dir)
+            .filter((name) => name.endsWith('.json'))
+            .map((name) => {
+            try {
+                return JSON.parse(fs.readFileSync(path.join(dir, name), 'utf8'));
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((job) => job !== null)
+            .sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+        return jobs[0] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function processAlive(pid) {
+    if (!pid)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function startCascadeRefreshJob(root, scope) {
+    const resolvedRoot = path.resolve(root);
+    try {
+        if (loadConfig(resolvedRoot).project_mode !== 'multi-project')
+            return null;
+    }
+    catch {
+        return null;
+    }
+    const previous = latestCascadeRefreshJob(resolvedRoot);
+    if (previous && (previous.status === 'queued' || previous.status === 'running') && processAlive(previous.pid)) {
+        return previous;
+    }
+    const now = new Date().toISOString();
+    const job = {
+        job_id: `cmj_${crypto.randomBytes(8).toString('hex')}`,
+        root: resolvedRoot,
+        scope,
+        status: 'queued',
+        created_at: now,
+        updated_at: now,
+        projects_total: inspectNestedProjects(resolvedRoot).projects.length + 1,
+        projects_completed: 0,
+        current_project: null,
+    };
+    writeJob(job);
+    const worker = fileURLToPath(new URL('./cascade-worker.js', import.meta.url));
+    const child = spawn(process.execPath, [worker, resolvedRoot, job.job_id, scope], {
+        cwd: resolvedRoot,
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    const markWorkerExit = (detail) => {
+        const current = readCascadeRefreshJob(resolvedRoot, job.job_id);
+        if (!current || current.status === 'completed' || current.status === 'failed')
+            return;
+        const completed = new Date().toISOString();
+        writeJob({
+            ...current,
+            status: 'failed',
+            error: detail,
+            current_project: null,
+            completed_at: completed,
+            updated_at: completed,
+        });
+    };
+    child.once('error', (error) => {
+        markWorkerExit(`cascade worker failed to start: ${error.message}`);
+    });
+    child.once('exit', (code, signal) => {
+        // The worker writes its terminal state synchronously before exiting. If no
+        // terminal state exists here, the launch/runtime failed outside its guard.
+        markWorkerExit(`cascade worker exited before completion (code=${code ?? 'null'}, signal=${signal ?? 'none'})`);
+    });
+    child.unref();
+    const current = readCascadeRefreshJob(resolvedRoot, job.job_id) ?? job;
+    if (current.status === 'queued') {
+        current.pid = child.pid;
+        current.updated_at = new Date().toISOString();
+        writeJob(current);
+    }
+    return current;
+}
+/** Worker entry seam, exported for deterministic tests and the tiny worker file. */
+export async function runCascadeRefreshJob(root, jobId, scope) {
+    const job = readCascadeRefreshJob(root, jobId);
+    if (!job)
+        throw new Error(`cascade job not found: ${jobId}`);
+    const started = new Date().toISOString();
+    writeJob({ ...job, status: 'running', pid: process.pid, started_at: started, updated_at: started });
+    try {
+        const result = await refreshWorkspaceCascade({
+            rootCwd: root,
+            scope,
+            onProgress: (progress) => {
+                const current = readCascadeRefreshJob(root, jobId) ?? job;
+                writeJob({
+                    ...current,
+                    status: 'running',
+                    pid: process.pid,
+                    projects_total: progress.total,
+                    projects_completed: progress.completed,
+                    current_project: progress.current_project,
+                    ...(progress.last_result ? { last_result: progress.last_result } : {}),
+                    updated_at: new Date().toISOString(),
+                });
+            },
+        });
+        const current = readCascadeRefreshJob(root, jobId) ?? job;
+        const completed = new Date().toISOString();
+        writeJob({ ...current, status: 'completed', result, current_project: null, projects_completed: current.projects_total, completed_at: completed, updated_at: completed });
+    }
+    catch (error) {
+        const current = readCascadeRefreshJob(root, jobId) ?? job;
+        const completed = new Date().toISOString();
+        writeJob({ ...current, status: 'failed', error: error instanceof Error ? error.message : String(error), current_project: null, completed_at: completed, updated_at: completed });
+    }
+}
+//# sourceMappingURL=cascade-jobs.js.map

package/dist/core/code-map/cascade-worker.js

@@ -0,0 +1,15 @@
+import { runCascadeRefreshJob } from './cascade-jobs.js';
+const [root, jobId, rawScope] = process.argv.slice(2);
+if (!root || !jobId)
+    process.exit(2);
+const scope = rawScope === 'all' ? 'all' : 'changed';
+try {
+    await runCascadeRefreshJob(root, jobId, scope);
+    // Tree-sitter/native handles can keep Node's event loop alive after the
+    // durable terminal record has been flushed. This process owns no other work.
+    process.exit(0);
+}
+catch {
+    process.exit(1);
+}
+//# sourceMappingURL=cascade-worker.js.map

package/dist/core/code-map/cascade.js

@@ -20,7 +20,7 @@
  * refreshes existing brainclaw projects, it does not initialise new ones.
  */
 import path from 'node:path';
-import { scanNestedBrainclawProjects } from '../workspace-projects.js';
+import { scanNestedBrainclawProjectsDetailed } from '../workspace-projects.js';
 import { loadConfig } from '../config.js';
 import { refresh as runRefresh } from './refresh.js';
 import { readManifest } from './store.js';
@@ -54,10 +54,14 @@ function projectIdFor(cwd, fallbackId) {
  * cascade and the `status --cascade` recap so both agree on the project set.
  */
 export function listNestedProjects(rootCwd) {
+    return inspectNestedProjects(rootCwd).projects;
+}
+export function inspectNestedProjects(rootCwd) {
     const root = path.resolve(rootCwd);
-    return Array.from(new Set(scanNestedBrainclawProjects(root)
-        .map((c) => path.resolve(c.path))
-        .filter((abs) => abs !== root && isStrictlyUnder(abs, root)))).sort();
+    const discovered = scanNestedBrainclawProjectsDetailed(root);
+    return { projects: Array.from(new Set(discovered.projects
+            .map((c) => path.resolve(c.path))
+            .filter((abs) => abs !== root && isStrictlyUnder(abs, root)))).sort(), truncated: discovered.truncated };
 }
 /**
  * Refresh the whole multi-project workspace: every nested brainclaw project +
@@ -68,7 +72,8 @@ export async function refreshWorkspaceCascade(input) {
     const rootCwd = path.resolve(input.rootCwd);
     // Enumerate nested brainclaw projects strictly under the root (FS scan, so it
     // is strategy-agnostic). De-dup + sort by path for deterministic output.
-    const childAbsPaths = listNestedProjects(rootCwd);
+    const discovery = inspectNestedProjects(rootCwd);
+    const childAbsPaths = discovery.projects;
     // Every project to refresh, root first.
     const allProjects = [rootCwd, ...childAbsPaths];
     const refreshOne = async (projectCwd, isRoot) => {
@@ -77,40 +82,72 @@ export async function refreshWorkspaceCascade(input) {
         const nestedUnder = allProjects.filter((p) => p !== projectCwd && isStrictlyUnder(p, projectCwd));
         const extraIgnorePatterns = nestedUnder.map((p) => `${toPosix(path.relative(projectCwd, p))}/**`);
         const projectId = projectIdFor(projectCwd);
-        const result = await runRefresh({
-            projectId,
-            projectRoot: projectCwd,
-            scope: input.scope,
-            cwd: projectCwd,
-            extraIgnorePatterns,
-            ownerAgent: input.ownerAgent ?? null,
-            ownerAgentId: input.ownerAgentId ?? null,
-        });
-        return {
-            path: isRoot ? '.' : toPosix(path.relative(rootCwd, projectCwd)),
-            project_id: projectId,
-            is_root: isRoot,
-            ran: result.ran,
-            lock_acquired: result.lock_acquired,
-            files_parsed: result.files_parsed,
-            files_compacted: result.files_compacted,
-            freshness: result.freshness.status,
-            ...(result.lock_status ? { lock_status: result.lock_status } : {}),
-        };
+        const projectPath = isRoot ? '.' : toPosix(path.relative(rootCwd, projectCwd));
+        try {
+            const result = await runRefresh({
+                projectId,
+                projectRoot: projectCwd,
+                scope: input.scope,
+                cwd: projectCwd,
+                extraIgnorePatterns,
+                ownerAgent: input.ownerAgent ?? null,
+                ownerAgentId: input.ownerAgentId ?? null,
+            });
+            const filesIndexed = readManifest(projectCwd)?.stats.files_indexed ?? 0;
+            const outcome = !result.lock_acquired
+                ? 'locked'
+                : filesIndexed === 0 ? 'no_eligible_files' : 'indexed';
+            return {
+                path: projectPath,
+                project_id: projectId,
+                is_root: isRoot,
+                ran: result.ran,
+                lock_acquired: result.lock_acquired,
+                files_parsed: result.files_parsed,
+                files_compacted: result.files_compacted,
+                files_indexed: filesIndexed,
+                freshness: result.freshness.status,
+                outcome,
+                ...(outcome === 'no_eligible_files' ? { reason: 'no eligible source files found' } : {}),
+                ...(result.lock_status ? { lock_status: result.lock_status, reason: result.lock_status } : {}),
+            };
+        }
+        catch (error) {
+            return {
+                path: projectPath,
+                project_id: projectId,
+                is_root: isRoot,
+                ran: false,
+                lock_acquired: false,
+                files_parsed: 0,
+                files_compacted: 0,
+                files_indexed: readManifest(projectCwd)?.stats.files_indexed ?? null,
+                freshness: 'partial',
+                outcome: 'failed',
+                reason: 'refresh_failed',
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
     };
     // Children first, then the root (sequential — each holds its own project lock
     // briefly; never blocks bclaw_work, rule 8).
     const children = [];
+    const total = childAbsPaths.length + 1;
+    input.onProgress?.({ completed: 0, total, current_project: childAbsPaths[0] ? toPosix(path.relative(rootCwd, childAbsPaths[0])) : '.' });
     for (const childCwd of childAbsPaths) {
-        children.push(await refreshOne(childCwd, false));
+        const result = await refreshOne(childCwd, false);
+        children.push(result);
+        input.onProgress?.({ completed: children.length, total, current_project: children.length < childAbsPaths.length ? toPosix(path.relative(rootCwd, childAbsPaths[children.length])) : '.', last_result: result });
     }
     const rootResult = await refreshOne(rootCwd, true);
+    input.onProgress?.({ completed: total, total, current_project: null, last_result: rootResult });
     return {
         is_cascade: true,
         root: rootCwd,
         root_result: rootResult,
         children,
         children_refreshed: children.length,
+        discovery_truncated: discovery.truncated,
     };
 }
 //# sourceMappingURL=cascade.js.map

package/dist/core/code-map/query.js

@@ -232,7 +232,7 @@ export function isTestPath(p) {
 /**
  * Score a symbol index entry against the query. Matching is separator/case
  * INSENSITIVE (pln#601): an exact NORMALIZED match scores highest, then prefix,
- * then substring, then the sub-token floor. Exported symbols + components/hooks
+ * then substring; sub-token-only candidates score zero. Exported symbols + components/hooks
  * get a small boost; test-file symbols are biased DOWN so a test helper never
  * outranks the real definition of the same name (the Fable-audit brief-noise
  * companion to the find defect). Exported for focused ranking tests.
@@ -250,7 +250,7 @@ export function scoreEntry(entry, query) {
     else if (name.includes(q))
         score += 3; // substring
     else
-        score += 1; // matched only via a sub-token bucket
+        return 0; // shared-token noise is not a match
     score *= entry.score_hint; // exported (1.0) vs internal (0.8)
     if (entry.subtype === 'component' || entry.subtype === 'hook')
         score += 1;
@@ -367,6 +367,9 @@ export function findInStore(query, ctx, checker, acc) {
         const confident = validateEntry(entry, checker, acc, root, maxBytes, ctx.cwd, ctx.preferredDirName);
         if (!confident)
             continue;
+        const score = scoreEntry(entry, query);
+        if (score <= 0)
+            continue;
         ranked.push({
             match: {
                 node_id: entry.node_id,
@@ -375,7 +378,7 @@ export function findInStore(query, ctx, checker, acc) {
                 file_id: entry.file_id,
                 kind: entry.kind,
                 subtype: entry.subtype ?? null,
-                score: scoreEntry(entry, query),
+                score,
             },
             centrality: importCentrality(entry, resolutionIndex),
         });

package/dist/core/context.js

@@ -29,6 +29,19 @@ import { isTrapActive, listOperationalTraps } from './traps.js';
 import { buildEstimationReport } from '../commands/estimation-report.js';
 import { detectStaleness } from './staleness.js';
 export const CONTEXT_SCHEMA_VERSION = '1.2';
+function verificationStatus(item) {
+    const verification = item.verification;
+    if (!verification)
+        return undefined;
+    if (verification.outcome === 'fail')
+        return 'verification:fail';
+    if (verification.max_age_days !== undefined) {
+        const ageMs = Date.now() - new Date(verification.verified_at).getTime();
+        if (Number.isFinite(ageMs) && ageMs > verification.max_age_days * 86_400_000)
+            return 'verification:stale';
+    }
+    return 'verification:pass';
+}
 export function buildContext(options = {}) {
     const requestedCwd = options.cwd ?? process.cwd();
     const contextCwd = resolveContextStoreCwd(requestedCwd, options.target);
@@ -95,7 +108,7 @@ export function buildContext(options = {}) {
             related_paths: c.related_paths,
             score: 0,
             reasons: [],
-            extra: c.status,
+            extra: [c.status, verificationStatus(c)].filter(Boolean).join(', '),
             plan_id: c.plan_id,
             provenance: {
                 actor: c.author,
@@ -125,7 +138,7 @@ export function buildContext(options = {}) {
             related_paths: d.related_paths,
             score: 0,
             reasons: [],
-            extra: d.related_paths?.join(', '),
+            extra: [d.related_paths?.join(', '), verificationStatus(d)].filter(Boolean).join(', ') || undefined,
             plan_id: d.plan_id,
             provenance: {
                 actor: d.author,
@@ -155,7 +168,7 @@ export function buildContext(options = {}) {
             related_paths: t.related_paths,
             score: 0,
             reasons: [],
-            extra: `${t.severity}, visibility:${t.visibility ?? 'shared'}`,
+            extra: [`${t.severity}, visibility:${t.visibility ?? 'shared'}, status:${t.status}`, verificationStatus(t)].filter(Boolean).join(', '),
             plan_id: t.plan_id,
             provenance: {
                 actor: t.author,

package/dist/core/dispatch-status.js

@@ -28,9 +28,9 @@ import { loadClaim } from './claims.js';
 import { getLoop, listLoops } from './loops/store.js';
 import { isProcessAlive } from './agentrun-reconciler.js';
 import { findRuntimeNoteById } from './runtime.js';
-import { latestActivityMs, decodeOemAwareBuffer, getRuntimeLogPath, getRuntimeSignalPath } from './runtime-signals.js';
+import { latestActivityMs, decodeOemAwareBuffer, getRuntimeLogPath, getRuntimeSignalPath, readCompletionSignals } from './runtime-signals.js';
 import { currentAttemptRunIdForAssignment } from './loops/attempt-reservation.js';
-import { LaneResultSchema } from './schema.js';
+import { resolveLaneResultFile } from './lane-result-file.js';
 const DEFAULT_TAIL = 20;
 const DEFAULT_STALL_MS = 5 * 60_000;
 const DEFAULT_BASE_REF = 'master';
@@ -291,6 +291,23 @@ function computeDiagnosis(assignment, agentRun, runtime, options) {
                 : `Worker reported "${lr.status}". Read the LANE-RESULT summary + stderr; address the blocker or reroute.`,
         };
     }
+    if (runtime.terminal_signal) {
+        const signal = runtime.terminal_signal;
+        if (signal.status === 'contradictory') {
+            return {
+                health: 'unknown',
+                summary: 'both completed and failed terminal sentinels exist; outcome is contradictory and no terminal projection was inferred',
+                recommended_next_action: 'Inspect LANE-RESULT.json and both log files; preserve the worktree and reconcile the contradiction before retrying.',
+            };
+        }
+        return {
+            health: 'terminal',
+            summary: `worker wrapper emitted the canonical ${signal.status} terminal signal${agentRun && !TERMINAL_RUN_STATUSES.has(agentRun.status) ? ` (agent_run still ${agentRun.status})` : ''}`,
+            recommended_next_action: signal.status === 'completed'
+                ? 'Run bclaw_harvest (or `brainclaw harvest <assignment_id>`) to ingest LANE-RESULT and converge the Assignment/Claim.'
+                : 'Read stderr and LANE-RESULT if present, then replay or reroute the failed slot.',
+        };
+    }
     // pln#554 — git evidence is the #2 signal, ABOVE process sentinels and
     // administrative status: commits ahead of base with a clean tracked tree
     // means the worker delivered everything to the branch, even if its pid is
@@ -359,18 +376,11 @@ function computeDiagnosis(assignment, agentRun, runtime, options) {
                 ?? 'Read .stderr.log for the exit reason; then trigger reconciliation by calling bclaw_find(entity="agent_run") again, or cancel + reroute.',
         };
     }
-    if (runtime.pid_alive === true && stallAge > options.stallMs && fsActive) {
-        return {
-            health: 'healthy',
-            summary: `agent_run alive (pid=${runtime.pid}); last_event_at stale (${Math.round(stallAge / 1000)}s) but filesystem active ${Math.round((fsAge ?? 0) / 1000)}s ago — working through a long op without a heartbeat`,
-            recommended_next_action: 'No action — the worker is actively writing to logs/worktree. Re-check periodically until terminal.',
-        };
-    }
     if (runtime.pid_alive === true && stallAge > options.stallMs) {
         return {
             health: 'stalled',
-            summary: `agent_run alive (pid=${runtime.pid}) but no activity for ${Math.round(stallAge / 1000)}s AND no filesystem writes${fsAge !== undefined ? ` (last fs ${Math.round(fsAge / 1000)}s ago)` : ' (no logs/worktree mtime)'}; last_event_at=${agentRun.last_event_at ?? '(never)'}`,
-            recommended_next_action: 'Worker appears genuinely hung (no log/file writes). Tail stderr to confirm, then kill the pid and reroute.',
+            summary: `agent_run pid=${runtime.pid} is alive but no explicit progress/heartbeat arrived for ${Math.round(stallAge / 1000)}s${fsActive ? `; filesystem activity ${Math.round((fsAge ?? 0) / 1000)}s ago is context, not proof of worker progress` : ''}`,
+            recommended_next_action: 'Inspect stdout/stderr and the expected artifact path. If no phase artifact or progress heartbeat is advancing, replay/reroute the slot; do not treat PID or unrelated filesystem activity as health.',
         };
     }
     if (runtime.pid_alive === true) {
@@ -436,6 +446,9 @@ export function getDispatchStatus(options) {
     const stderrPath = assignmentId
         ? getRuntimeLogPath(projectRoot, assignmentId, 'stderr', runtimeRunId)
         : undefined;
+    const completionSignals = assignmentId
+        ? readCompletionSignals(projectRoot, assignmentId, runtimeRunId)
+        : {};
     // pln#527 — filesystem-activity age: max mtime across the captured logs + the
     // run's worktree files (skipping junctions). The truer liveness signal when
     // the heartbeat / last_event_at is stale during a long single operation.
@@ -460,8 +473,9 @@ export function getDispatchStatus(options) {
     let laneResult;
     let laneResultStale;
     if (worktreeForFs) {
-        try {
-            const parsed = LaneResultSchema.parse(JSON.parse(fs.readFileSync(path.join(worktreeForFs, 'LANE-RESULT.json'), 'utf-8')));
+        const resolvedLaneResult = resolveLaneResultFile(worktreeForFs, assignmentId);
+        if (resolvedLaneResult.kind === 'found') {
+            const parsed = resolvedLaneResult.lane;
             if (parsed.assignment_id === assignmentId) {
                 laneResult = { status: parsed.status, summary: parsed.summary };
             }
@@ -469,7 +483,6 @@ export function getDispatchStatus(options) {
                 laneResultStale = { assignment_id: parsed.assignment_id, status: parsed.status, summary: parsed.summary };
             }
         }
-        catch { /* no / invalid LANE-RESULT.json */ }
     }
     // pln#554 — worktree git evidence (commits ahead of base + dirty tracked files).
     const evidence = gitEvidence(worktreeForFs, options.base_ref ?? DEFAULT_BASE_REF);
@@ -480,6 +493,15 @@ export function getDispatchStatus(options) {
             exists: ackPath ? fs.existsSync(ackPath) : false,
             path: ackPath,
         },
+        ...(assignmentId && (completionSignals.completed || completionSignals.failed) ? {
+            terminal_signal: {
+                status: completionSignals.completed && completionSignals.failed
+                    ? 'contradictory'
+                    : completionSignals.completed ? 'completed' : 'failed',
+                completed_path: getRuntimeSignalPath(projectRoot, assignmentId, 'completed', runtimeRunId),
+                failed_path: getRuntimeSignalPath(projectRoot, assignmentId, 'failed', runtimeRunId),
+            },
+        } : {}),
         log_files: {
             stdout: stdoutPath ? readLogTail(stdoutPath, tailLines) : undefined,
             stderr: stderrPath ? readLogTail(stderrPath, tailLines) : undefined,