brainclaw 1.5.5 → 1.7.0

package/dist/core/claims.js

@@ -6,7 +6,7 @@ import { mutate } from './mutation-pipeline.js';
 import { nowISO } from './ids.js';
 import { JsonStore } from './json-store.js';
 import { loadConfig } from './config.js';
-import { createWorktree } from './worktree.js';
+import { createWorktree, resetWorktreeToRef } from './worktree.js';
 import { appendAuditEntry } from './audit.js';
 import { refreshLiveCompanions } from '../commands/export.js';
 import { loadSessionById } from './identity.js';
@@ -59,6 +59,35 @@ export function saveClaim(claim, cwd) {
         catch { /* best-effort */ }
     });
 }
+/**
+ * Atomically check for an active claim on `scope` and save a new one if absent.
+ *
+ * Atomicity is provided by running both operations inside a single mutate() call;
+ * the mutation-pipeline mutex serializes filesystem writes on the claims store.
+ */
+export function acquireClaimScope(input, cwd) {
+    return mutate({ cwd }, () => {
+        const conflictingClaim = listClaims(cwd).find((claim) => claim.status === 'active' && claim.scope === input.scope);
+        if (conflictingClaim) {
+            return { acquired: false, conflicting_claim: conflictingClaim };
+        }
+        const claim = {
+            id: generateClaimId(),
+            agent: input.agent,
+            agent_id: input.agent_id,
+            user: input.user,
+            session_id: input.session_id,
+            scope: input.scope,
+            description: input.description,
+            created_at: nowISO(),
+            status: 'active',
+            plan_id: input.plan_id,
+            model: input.model,
+        };
+        saveClaim(claim, cwd);
+        return { acquired: true, claim };
+    });
+}
 export function loadClaim(id, cwd) {
     return claimStore(cwd).load(id);
 }
@@ -378,10 +407,28 @@ export function createCoordinatorClaim(options) {
     const existingScopeClaim = listClaims(options.cwd).find((claim) => claim.status === 'active' && claim.scope === options.scope);
     if (existingScopeClaim) {
         if (existingScopeClaim.agent === options.agent) {
-            // Same agent already has this scope — reuse the claim (backward compat, same-agent multi-call).
+            // Same agent already has this scope — reuse the claim (backward compat,
+            // same-agent multi-call). If the caller pinned a base ref, the reused
+            // worktree MUST be re-pointed to it; otherwise a dispatch that relied on
+            // the ref (e.g. the dirty-guard bypass) would run the worker on a stale
+            // worktree — the same silent false-negative the guard exists to prevent
+            // (pln#520 Tier 2 / codex r2).
+            let reuseWarning;
+            if (options.worktreeBaseRef) {
+                if (existingScopeClaim.worktree_path) {
+                    const reset = resetWorktreeToRef(existingScopeClaim.worktree_path, options.worktreeBaseRef);
+                    if (!reset.ok) {
+                        reuseWarning = `Reused claim ${existingScopeClaim.id} pinned to ref "${options.worktreeBaseRef}": ${reset.stderr.trim()}`;
+                    }
+                }
+                else {
+                    reuseWarning = `Reused claim ${existingScopeClaim.id} has no worktree to pin to ref "${options.worktreeBaseRef}".`;
+                }
+            }
             return {
                 claimId: existingScopeClaim.id,
                 worktreePath: existingScopeClaim.worktree_path,
+                worktreeWarning: reuseWarning,
                 reusedExisting: true,
             };
         }
@@ -406,7 +453,11 @@ export function createCoordinatorClaim(options) {
             sessionId: options.sessionId,
             agent: options.agent,
             baseRef: options.worktreeBaseRef,
-            resetExistingBranch: options.resetExistingWorktreeBranch,
+            // A pinned base ref implies the branch must be reset to it: createWorktree
+            // otherwise reuses a pre-existing feat/<scope> branch and ignores baseRef.
+            // Deriving it here (not only at the call site) keeps the invariant — "a
+            // pinned ref ⇒ the worktree reflects that ref" — owned by this chokepoint.
+            resetExistingBranch: options.resetExistingWorktreeBranch || Boolean(options.worktreeBaseRef),
         });
     }
     catch (err) {

package/dist/core/dirty-scope.js

@@ -0,0 +1,242 @@
+/**
+ * Scope-aware dirty-working-tree guard for dispatch (pln#520 Tier 2, trp#371).
+ *
+ * The original guard (can_30c295b4) refused review/assign/consult/ideate the
+ * moment ANY uncommitted file existed in the source repo — repo-global, no
+ * comparison to the dispatch scope. In multi-agent use (codex/claude leave
+ * uncommitted files around) that hard-blocks legitimate dispatches, and the
+ * coordination store itself (`.brainclaw/`) is rewritten on every dispatch so
+ * a second `bclaw_coordinate` in the same session ALWAYS saw a dirty tree.
+ *
+ * This helper makes the decision scope-aware. The cardinal rule (converged
+ * across the Tier 2 ideation loop lop_5fc24cc8707992ea): never turn a noisy,
+ * visible false-positive (block a legitimate dispatch) into a SILENT
+ * false-negative (let a worker review/edit stale code with no signal). So
+ * when the scope cannot be proven disjoint from the dirty files, we still
+ * block — `allow_dirty=true` remains the explicit, auditable override.
+ *
+ * Empirical grounding: of ~450 real claim scopes in the store, only 4 contain
+ * a glob and ~60% are not resolvable to paths at all (plan-ids, loop-refs,
+ * prose). So the resolver optimises for the path-prefix case and treats
+ * anything ambiguous as `unknown` (→ conservative block when dirty), rather
+ * than building a glob engine. The rare real globs are delegated to git.
+ */
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+/** Top-level directories that read as code paths even when not yet on disk. */
+const KNOWN_TOP_LEVEL = new Set([
+    'src', 'lib', 'docs', 'doc', 'test', 'tests', 'packages', 'app', 'apps',
+    'scripts', 'bin', 'public', 'assets', 'examples', 'config',
+]);
+/** Entity-id / loop-ref prefixes that are never file paths. */
+const ENTITY_ID_RE = /^(pln|clm|asg|asgn|run|lop|dec|cst|con|trp|han|can|rtn|rn|seq|sess|agt|art|lsl)[_#]/i;
+function defaultRunGit(cwd, args) {
+    try {
+        const probe = spawnSync('git', ['-C', cwd, ...args], { encoding: 'utf8', timeout: 5000 });
+        if (probe.status !== 0 || typeof probe.stdout !== 'string') {
+            return { ok: false, stdout: '' };
+        }
+        return { ok: true, stdout: probe.stdout };
+    }
+    catch {
+        // Never block a dispatch because git hiccuped — surface as "not probeable".
+        return { ok: false, stdout: '' };
+    }
+}
+/** True for coordination/store paths that are dirty as a side effect of dispatching. */
+export function isSystemDirtyPath(p) {
+    const norm = p.replace(/\\/g, '/');
+    return norm === '.brainclaw'
+        || norm.startsWith('.brainclaw/')
+        || norm === '.git'
+        || norm.startsWith('.git/');
+}
+/**
+ * Parse `git status --porcelain=v1 -z` output into a flat list of paths.
+ *
+ * NUL-separated entries avoid the quoting/newline pitfalls of line parsing.
+ * Rename/copy entries (`R`/`C`) carry the NEW path in the status field and the
+ * ORIGINAL path in the following NUL field — we keep BOTH, because a move out
+ * of scope that creates a file in scope (or vice versa) is a relevant change.
+ */
+export function parsePorcelainZ(stdout) {
+    const parts = stdout.split('\0').filter((p) => p.length > 0);
+    const paths = [];
+    for (let i = 0; i < parts.length; i++) {
+        const entry = parts[i];
+        if (entry.length < 4)
+            continue; // malformed; "XY p" is the minimum
+        const status = entry.slice(0, 2);
+        const newPath = entry.slice(3); // skip "XY " (2 status chars + 1 separator)
+        paths.push(newPath);
+        if (status[0] === 'R' || status[0] === 'C') {
+            const origPath = parts[i + 1];
+            if (origPath !== undefined) {
+                paths.push(origPath);
+                i++; // consume the original-path field
+            }
+        }
+    }
+    return paths;
+}
+/**
+ * Resolve a free-string scope into git pathspecs, or `unknown` when it cannot
+ * be proven to denote file paths. All-or-nothing across comma-separated
+ * tokens: a single unresolvable token marks the whole scope unknown, so the
+ * guard never blocks on a partial (and therefore misleading) view.
+ */
+export function resolveScopeToPathspecs(scope, cwd) {
+    if (!scope || !scope.trim()) {
+        return { kind: 'unknown', reason: 'no scope provided' };
+    }
+    const tokens = scope.split(',').map((t) => t.trim()).filter(Boolean);
+    if (tokens.length === 0) {
+        return { kind: 'unknown', reason: 'empty scope' };
+    }
+    const pathspecs = [];
+    for (const token of tokens) {
+        if (ENTITY_ID_RE.test(token) || /^review-loop:/i.test(token)) {
+            return { kind: 'unknown', reason: `token "${token}" is an entity id, not a path` };
+        }
+        if (/\s/.test(token)) {
+            return { kind: 'unknown', reason: `token "${token}" contains whitespace (prose, not a path)` };
+        }
+        const normalized = token.replace(/\\/g, '/').replace(/^\.\//, '');
+        if (/[*?[\]]/.test(normalized)) {
+            // Delegate the rare real glob to git's native pathspec matcher.
+            pathspecs.push(`:(glob)${normalized}`);
+            continue;
+        }
+        const exists = fs.existsSync(path.resolve(cwd, normalized));
+        const topLevel = normalized.split('/')[0];
+        if (exists || KNOWN_TOP_LEVEL.has(topLevel)) {
+            pathspecs.push(normalized);
+            continue;
+        }
+        return {
+            kind: 'unknown',
+            reason: `token "${token}" is not a resolvable path (no such file/dir and not a known top-level)`,
+        };
+    }
+    return { kind: 'pathspecs', pathspecs };
+}
+/** Cap a file list for human-readable messages. */
+function summariseFiles(files, max = 10) {
+    if (files.length <= max)
+        return files.join(', ');
+    return `${files.slice(0, max).join(', ')} (and ${files.length - max} more)`;
+}
+/**
+ * Decide whether a dispatch may proceed given the source repo's dirty state and
+ * the dispatch scope. See the module header for the cardinal rule.
+ */
+export function assessDirtyDispatchGuard(input) {
+    const runGit = input.runGit ?? defaultRunGit;
+    const resolution = resolveScopeToPathspecs(input.scope, input.cwd);
+    // 1. Global probe — is the tree dirty at all (ignoring the coordination store)?
+    const global = runGit(input.cwd, ['status', '--porcelain=v1', '-z', '--untracked-files=normal']);
+    if (!global.ok) {
+        return {
+            decision: 'allow',
+            reason: 'source cwd is not a git repo (or git is unavailable) — dirty guard skipped',
+            dirtyCount: 0,
+            overlapping: [],
+            ignoredSystemDirty: [],
+            scopeResolution: resolution.kind,
+        };
+    }
+    const allPaths = parsePorcelainZ(global.stdout);
+    const ignoredSystemDirty = allPaths.filter(isSystemDirtyPath);
+    const realDirty = allPaths.filter((p) => !isSystemDirtyPath(p));
+    if (realDirty.length === 0) {
+        return {
+            decision: 'allow',
+            reason: ignoredSystemDirty.length > 0
+                ? `working tree clean apart from ${ignoredSystemDirty.length} coordination-store file(s) (.brainclaw/, .git/) which the worker rebuilds itself`
+                : 'working tree clean',
+            dirtyCount: 0,
+            overlapping: [],
+            ignoredSystemDirty,
+            scopeResolution: resolution.kind,
+        };
+    }
+    // 2. Explicit ref → the worktree is built from that ref (the dispatch path
+    //    forces resetExistingWorktreeBranch so a pre-existing branch is reset to
+    //    the ref, not silently reused), so uncommitted working-tree changes are
+    //    intentionally out of scope. Only bypass when the ref actually resolves —
+    //    a bogus/unresolvable ref must NOT widen the allow; fall through to the
+    //    scope-aware check below so a dirty in-scope file still blocks.
+    if (input.checkoutRef) {
+        const refResolves = runGit(input.cwd, ['rev-parse', '--verify', '--quiet', `${input.checkoutRef}^{commit}`]).ok;
+        if (refResolves) {
+            return {
+                decision: 'allow',
+                reason: `dispatch builds its worktree from explicit ref "${input.checkoutRef}"; ${realDirty.length} uncommitted working-tree file(s) are intentionally out of scope`,
+                dirtyCount: realDirty.length,
+                overlapping: [],
+                ignoredSystemDirty,
+                scopeResolution: resolution.kind,
+            };
+        }
+        // else: ref does not resolve → continue to the scope-aware evaluation.
+    }
+    // 3. Scope-aware intersection (delegated to git for glob + segment-boundary correctness).
+    if (resolution.kind === 'pathspecs') {
+        const scoped = runGit(input.cwd, [
+            'status', '--porcelain=v1', '-z', '--untracked-files=normal',
+            '--', ...resolution.pathspecs, ':(exclude).brainclaw/', ':(exclude).git/',
+        ]);
+        // If the scoped probe fails for any reason, fall back conservatively:
+        // treat the whole real-dirty set as potentially overlapping.
+        const overlapping = scoped.ok ? parsePorcelainZ(scoped.stdout).filter((p) => !isSystemDirtyPath(p)) : realDirty;
+        if (overlapping.length === 0) {
+            return {
+                decision: 'allow',
+                reason: `${realDirty.length} uncommitted file(s) but none overlap the dispatch scope`,
+                dirtyCount: realDirty.length,
+                overlapping: [],
+                ignoredSystemDirty,
+                scopeResolution: resolution.kind,
+            };
+        }
+        if (input.allowDirty) {
+            return {
+                decision: 'warn',
+                reason: `allow_dirty=true: proceeding despite ${overlapping.length} dirty file(s) overlapping the dispatch scope: ${summariseFiles(overlapping)}`,
+                dirtyCount: realDirty.length,
+                overlapping,
+                ignoredSystemDirty,
+                scopeResolution: resolution.kind,
+            };
+        }
+        return {
+            decision: 'block',
+            reason: `${overlapping.length} uncommitted file(s) overlap the dispatch scope and the worker spawns from HEAD, so it will not see them: ${summariseFiles(overlapping)}. Commit or stash these, or pass allow_dirty=true to override.`,
+            dirtyCount: realDirty.length,
+            overlapping,
+            ignoredSystemDirty,
+            scopeResolution: resolution.kind,
+        };
+    }
+    // 4. Scope not resolvable to paths → cannot prove disjointness → conservative.
+    if (input.allowDirty) {
+        return {
+            decision: 'warn',
+            reason: `allow_dirty=true: proceeding despite ${realDirty.length} uncommitted file(s); dispatch scope is not resolvable to paths (${resolution.reason}) so overlap could not be ruled out`,
+            dirtyCount: realDirty.length,
+            overlapping: [],
+            ignoredSystemDirty,
+            scopeResolution: resolution.kind,
+        };
+    }
+    return {
+        decision: 'block',
+        reason: `${realDirty.length} uncommitted file(s) and the dispatch scope is not resolvable to file paths (${resolution.reason}), so overlap cannot be ruled out; the worker spawns from HEAD and will not see them: ${summariseFiles(realDirty)}. Commit or stash, pass a resolvable file scope, or pass allow_dirty=true to override.`,
+        dirtyCount: realDirty.length,
+        overlapping: [],
+        ignoredSystemDirty,
+        scopeResolution: resolution.kind,
+    };
+}
+//# sourceMappingURL=dirty-scope.js.map

package/dist/core/dispatch-status.js

@@ -0,0 +1,219 @@
+/**
+ * Consolidated dispatch status (pln#503 phase 3.1).
+ *
+ * Resolves a single dispatch reference (`asgn_…`, `clm_…`, `lop_…`, `run_…`)
+ * into the full set of linked entities — assignment, claim, loop, agent_run —
+ * plus on-disk artefacts (brief-ack sentinel, stdout/stderr logs) and a
+ * pid-liveness check, then computes a health verdict + a recommended next
+ * action for the caller.
+ *
+ * The motivating use case: an agent who just called `bclaw_coordinate` and
+ * got `execution_status: "delivered_and_started"` should be able to verify
+ * the dispatch is alive without running five separate `bclaw_find` calls.
+ * The `verify_with` hint added in phase 3.3 already points callers at this
+ * tool by name.
+ *
+ * See docs/concepts/dispatch-lifecycle.md for the full entity-relationship
+ * and FSM model.
+ *
+ * @module
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadAssignment, listAssignments } from './assignments.js';
+import { loadAgentRun, listAgentRuns } from './agentruns.js';
+import { loadClaim } from './claims.js';
+import { getLoop, listLoops } from './loops/store.js';
+import { isProcessAlive } from './agentrun-reconciler.js';
+const DEFAULT_TAIL = 20;
+const DEFAULT_STALL_MS = 5 * 60_000;
+// ── Internal helpers ──────────────────────────────────────────────────────
+function readLogTail(filePath, lines) {
+    try {
+        const stat = fs.statSync(filePath);
+        if (lines <= 0) {
+            return { path: filePath, exists: true, size_bytes: stat.size };
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const all = content.split(/\r?\n/);
+        // Strip trailing empty line from final \n
+        if (all.length > 0 && all[all.length - 1] === '')
+            all.pop();
+        return {
+            path: filePath,
+            exists: true,
+            size_bytes: stat.size,
+            tail: all.slice(-lines),
+        };
+    }
+    catch {
+        return { path: filePath, exists: false, size_bytes: 0 };
+    }
+}
+function findLoopByAssignmentId(assignmentId, cwd) {
+    for (const loop of listLoops({}, cwd)) {
+        if (loop.slots.some((s) => s.assignment_id === assignmentId))
+            return loop;
+    }
+    return undefined;
+}
+function resolveTarget(targetId, cwd) {
+    if (targetId.startsWith('asgn_')) {
+        return { resolved_from: 'assignment_id', assignment_id: targetId };
+    }
+    if (targetId.startsWith('run_')) {
+        const run = loadAgentRun(targetId, cwd);
+        if (run)
+            return { resolved_from: 'run_id', assignment_id: run.assignment_id, agent_run: run };
+        return { resolved_from: 'unresolved' };
+    }
+    if (targetId.startsWith('clm_')) {
+        const assignments = listAssignments(cwd, { claim_id: targetId });
+        if (assignments.length > 0) {
+            // Pick the most recent assignment for this claim (latest created_at).
+            const recent = [...assignments].sort((a, b) => b.created_at.localeCompare(a.created_at))[0];
+            return { resolved_from: 'claim_id', assignment_id: recent.id };
+        }
+        return { resolved_from: 'claim_id' };
+    }
+    if (targetId.startsWith('lop_')) {
+        const loop = getLoop(targetId, cwd);
+        if (loop) {
+            // Prefer the slot in the current_phase with an assignment_id; fall back
+            // to any slot's assignment_id.
+            const phaseSlot = loop.slots.find((s) => s.phase === loop.current_phase && s.assignment_id);
+            const anySlot = loop.slots.find((s) => s.assignment_id);
+            const slot = phaseSlot ?? anySlot;
+            if (slot?.assignment_id) {
+                return { resolved_from: 'loop_id', assignment_id: slot.assignment_id };
+            }
+            return { resolved_from: 'loop_id' };
+        }
+        return { resolved_from: 'unresolved' };
+    }
+    return { resolved_from: 'unresolved' };
+}
+const TERMINAL_RUN_STATUSES = new Set([
+    'completed', 'failed', 'cancelled', 'timed_out', 'interrupted',
+]);
+function computeDiagnosis(assignment, agentRun, runtime, options) {
+    if (!assignment && !agentRun) {
+        return {
+            health: 'unknown',
+            summary: 'target_id did not resolve to any assignment or agent_run',
+            recommended_next_action: 'Verify the target_id is correct (asgn_/clm_/lop_/run_). Use bclaw_find(entity="assignment") to list available assignments.',
+        };
+    }
+    if (!agentRun) {
+        return {
+            health: 'not_dispatched',
+            summary: `assignment exists (status=${assignment?.status}) but no agent_run record — the spawn never produced a process, or the assignment is still waiting to be picked up`,
+            recommended_next_action: assignment?.status === 'offered'
+                ? 'Wait for the target agent to accept, or reroute via bclaw_coordinate(intent="reroute", scope=…).'
+                : 'Re-dispatch with bclaw_coordinate or check for an earlier spawn error.',
+        };
+    }
+    if (TERMINAL_RUN_STATUSES.has(agentRun.status)) {
+        const isSuccess = agentRun.status === 'completed';
+        return {
+            health: 'terminal',
+            summary: `agent_run already terminal (status=${agentRun.status})${agentRun.status_reason ? `: ${agentRun.status_reason}` : ''}`,
+            recommended_next_action: isSuccess
+                ? 'Harvest artifacts and move on; if the assignment is still open, transition it to completed.'
+                : 'Read stderr log (path in runtime.log_files.stderr) for the failure detail; reroute or retry if appropriate.',
+        };
+    }
+    // status is running / launching / waiting_input / blocked → check liveness
+    const lastEventMs = new Date(agentRun.last_event_at ?? agentRun.started_at ?? agentRun.created_at).getTime();
+    const stallAge = options.nowMs - lastEventMs;
+    if (runtime.pid_alive === false) {
+        return {
+            health: 'silent_death',
+            summary: `agent_run.status="${agentRun.status}" but pid ${runtime.pid} is dead — worker exited without self-reporting; lazy reconciler will mark it failed after the stale window (default 30min)`,
+            recommended_next_action: '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) {
+        return {
+            health: 'stalled',
+            summary: `agent_run alive (pid=${runtime.pid}) but no activity for ${Math.round(stallAge / 1000)}s; last_event_at=${agentRun.last_event_at ?? '(never)'}`,
+            recommended_next_action: 'Tail the stdout/stderr log to see whether the worker is doing useful work; if truly hung, kill the pid and reroute.',
+        };
+    }
+    if (runtime.pid_alive === true) {
+        return {
+            health: 'healthy',
+            summary: `agent_run.status="${agentRun.status}", pid ${runtime.pid} alive, last activity ${Math.round(stallAge / 1000)}s ago`,
+            recommended_next_action: 'No action — the dispatch is alive and recent. Re-check periodically until terminal.',
+        };
+    }
+    // pid_alive undefined → cannot determine (no pid tracked, or signal failed)
+    return {
+        health: 'unknown',
+        summary: `agent_run.status="${agentRun.status}" but pid liveness could not be determined (pid=${agentRun.pid ?? '(none)'})`,
+        recommended_next_action: 'Read the stdout/stderr log for life signs; or wait for the lazy reconciler to converge based on commit / claim / assignment evidence.',
+    };
+}
+// ── Public API ─────────────────────────────────────────────────────────────
+export function getDispatchStatus(options) {
+    const cwd = options.cwd;
+    const tailLines = options.tail_log_lines ?? DEFAULT_TAIL;
+    const stallMs = options.stall_threshold_ms ?? DEFAULT_STALL_MS;
+    const nowMs = options.nowMs ?? Date.now();
+    const resolved = resolveTarget(options.target_id, cwd);
+    const assignmentId = resolved.assignment_id;
+    const assignment = assignmentId ? loadAssignment(assignmentId, cwd) : undefined;
+    const claim = assignment?.claim_id ? loadClaim(assignment.claim_id, cwd) : undefined;
+    // Prefer the pre-resolved agent_run (when target_id was a run_…); otherwise
+    // look up by assignment_id and pick the most recent attempt.
+    let agentRun = resolved.agent_run;
+    if (!agentRun && assignmentId) {
+        const runs = listAgentRuns(cwd, { assignment_id: assignmentId });
+        agentRun = [...runs].sort((a, b) => b.created_at.localeCompare(a.created_at))[0];
+    }
+    let loop;
+    if (resolved.resolved_from === 'loop_id') {
+        loop = getLoop(options.target_id, cwd);
+    }
+    else if (assignmentId) {
+        loop = findLoopByAssignmentId(assignmentId, cwd);
+    }
+    // Runtime artefacts (ack file + log files) — all under the project's
+    // coordination root. Use the cwd or the runtime cwd as the anchor; the
+    // dispatcher writes them under cwd/.brainclaw/coordination/runtime/...
+    const projectRoot = cwd ?? process.cwd();
+    const runtimeRoot = path.join(projectRoot, '.brainclaw', 'coordination', 'runtime');
+    const ackPath = assignmentId ? path.join(runtimeRoot, 'ack', `${assignmentId}.ack`) : undefined;
+    const stdoutPath = assignmentId ? path.join(runtimeRoot, 'log', `${assignmentId}.stdout.log`) : undefined;
+    const stderrPath = assignmentId ? path.join(runtimeRoot, 'log', `${assignmentId}.stderr.log`) : undefined;
+    const runtime = {
+        pid: agentRun?.pid,
+        pid_alive: isProcessAlive(agentRun?.pid),
+        ack_file: {
+            exists: ackPath ? fs.existsSync(ackPath) : false,
+            path: ackPath,
+        },
+        log_files: {
+            stdout: stdoutPath ? readLogTail(stdoutPath, tailLines) : undefined,
+            stderr: stderrPath ? readLogTail(stderrPath, tailLines) : undefined,
+        },
+    };
+    const diagnosis = computeDiagnosis(assignment, agentRun, runtime, { stallMs, nowMs });
+    return {
+        target_id: options.target_id,
+        resolved_from: resolved.resolved_from,
+        entities: {
+            assignment_id: assignmentId,
+            claim_id: assignment?.claim_id,
+            loop_id: loop?.id,
+            run_id: agentRun?.id,
+        },
+        assignment,
+        claim,
+        loop,
+        agent_run: agentRun,
+        runtime,
+        diagnosis,
+    };
+}
+//# sourceMappingURL=dispatch-status.js.map