@lsctech/polaris 0.1.0

package/dist/loop/status.js

@@ -0,0 +1,665 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasWorkerAcknowledged = hasWorkerAcknowledged;
+exports.canSessionBeAttached = canSessionBeAttached;
+exports.runLoopStatus = runLoopStatus;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const checkpoint_js_1 = require("./checkpoint.js");
+const loader_js_1 = require("../config/loader.js");
+/**
+ * Find dispatch evidence for the active child.
+ * Searches cluster-scoped layout and open_children_meta.
+ */
+function findDispatchEvidence(repoRoot, clusterId, activeChild, openChildrenMeta) {
+    if (!activeChild)
+        return null;
+    // First check open_children_meta for dispatch_record
+    const childMeta = openChildrenMeta?.[activeChild];
+    const dispatchRecord = childMeta?.dispatch_record;
+    if (dispatchRecord) {
+        // Check if result file exists
+        const resultPresent = (0, node_fs_1.existsSync)(dispatchRecord.expected_result_path);
+        return {
+            child_id: dispatchRecord.child_id,
+            dispatch_id: dispatchRecord.dispatch_id,
+            packet_path: dispatchRecord.packet_path,
+            expected_result_path: dispatchRecord.expected_result_path,
+            result_present: resultPresent,
+            dispatch_status: dispatchRecord.status,
+            provider: dispatchRecord.provider,
+            dispatched_at: dispatchRecord.dispatched_at,
+            dispatch_mode: dispatchRecord.dispatch_mode,
+            runtime_state: dispatchRecord.runtime_state,
+            last_heartbeat_at: dispatchRecord.last_heartbeat_at,
+            last_heartbeat_step: dispatchRecord.last_heartbeat_step,
+            worker_assignment: dispatchRecord.worker_assignment,
+        };
+    }
+    // Fallback: scan cluster packets directory for matching files
+    const packetDir = (0, node_path_1.join)(repoRoot, ".polaris", "clusters", clusterId, "packets");
+    if (!(0, node_fs_1.existsSync)(packetDir))
+        return null;
+    // Look for files matching <child-id>-*.json pattern
+    const files = (0, node_fs_1.readdirSync)(packetDir).filter((f) => f.startsWith(`${activeChild}-`) && f.endsWith(".json"));
+    if (files.length === 0)
+        return null;
+    // Use the most recent file (sorted by name, which includes timestamp/UUID)
+    const latestFile = files.sort().at(-1);
+    const packetPath = (0, node_path_1.join)(packetDir, latestFile);
+    // Derive result path from packet path
+    const resultDir = (0, node_path_1.join)(repoRoot, ".polaris", "clusters", clusterId, "results");
+    const resultPath = (0, node_path_1.join)(resultDir, latestFile);
+    // Check if result exists
+    const resultPresent = (0, node_fs_1.existsSync)(resultPath);
+    // Extract dispatch ID from filename (format: <child-id>-<dispatch-id>.json)
+    const dispatchId = latestFile.replace(`${activeChild}-`, "").replace(".json", "");
+    return {
+        child_id: activeChild,
+        dispatch_id: dispatchId,
+        packet_path: packetPath,
+        expected_result_path: resultPath,
+        result_present: resultPresent,
+        dispatch_status: resultPresent ? "completed" : "dispatched",
+        dispatched_at: "unknown", // Cannot determine from file alone
+    };
+}
+/**
+ * Get relative path from repo root if path is inside repo.
+ */
+function getRelativePath(repoRoot, absolutePath) {
+    if (absolutePath.startsWith(repoRoot + "/")) {
+        return absolutePath.slice(repoRoot.length + 1);
+    }
+    return absolutePath;
+}
+function classifyCurrentStateSurface(repoRoot, stateFile) {
+    const relativePath = getRelativePath(repoRoot, stateFile);
+    const normalizedPath = relativePath.split(node_path_1.sep).join("/");
+    const targetPath = (0, node_path_1.join)(".polaris", "runs", "current-state.json").split(node_path_1.sep).join("/");
+    if (normalizedPath === targetPath) {
+        return {
+            path: relativePath,
+            role: "legacy/transitional current-state snapshot",
+            classification: "legacy",
+            exists: (0, node_fs_1.existsSync)(stateFile),
+        };
+    }
+    return {
+        path: relativePath,
+        role: "compatibility/debug current-state surface",
+        classification: "compatibility",
+        exists: (0, node_fs_1.existsSync)(stateFile),
+    };
+}
+function buildRuntimeArtifactSurfaces(repoRoot, clusterId, stateFile, bootstrapDir, telemetryFile) {
+    const clusterStatePath = (0, node_path_1.join)(repoRoot, ".polaris", "clusters", clusterId, "cluster-state.json");
+    return {
+        cluster_state: {
+            path: getRelativePath(repoRoot, clusterStatePath),
+            role: "live execution authority",
+            classification: "canonical",
+            exists: (0, node_fs_1.existsSync)(clusterStatePath),
+        },
+        current_state: classifyCurrentStateSurface(repoRoot, stateFile),
+        bootstrap_packets: {
+            path: getRelativePath(repoRoot, bootstrapDir),
+            role: "sealed handoff snapshots",
+            classification: "derived",
+            exists: (0, node_fs_1.existsSync)(bootstrapDir),
+        },
+        telemetry: {
+            path: getRelativePath(repoRoot, telemetryFile),
+            role: "append-only audit/debug stream",
+            classification: "debug",
+            exists: (0, node_fs_1.existsSync)(telemetryFile),
+        },
+    };
+}
+/**
+ * Find latest worker heartbeat for active child from telemetry.
+ */
+function findWorkerHeartbeat(telemetryFile, activeChild) {
+    if (!activeChild || !(0, node_fs_1.existsSync)(telemetryFile))
+        return null;
+    try {
+        const content = (0, node_fs_1.readFileSync)(telemetryFile, "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        // Parse from most recent to find latest heartbeat for this child
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const event = JSON.parse(lines[i]);
+                if (event.event === "worker-heartbeat" && event.child_id === activeChild) {
+                    return event;
+                }
+            }
+            catch {
+                continue; // Skip malformed lines
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+/**
+ * Format heartbeat for display.
+ */
+function formatHeartbeat(heartbeat) {
+    const time = new Date(heartbeat.timestamp).toLocaleTimeString();
+    let status = heartbeat.step_cursor;
+    if (heartbeat.progress_pct !== undefined) {
+        status += ` (${heartbeat.progress_pct}%)`;
+    }
+    if (heartbeat.current_file) {
+        status += ` - ${heartbeat.current_file}`;
+    }
+    return `${time}: ${status}`;
+}
+/**
+ * Find latest worker-blocked event for active child.
+ */
+function findWorkerBlocked(telemetryFile, activeChild) {
+    if (!activeChild || !(0, node_fs_1.existsSync)(telemetryFile))
+        return null;
+    try {
+        const content = (0, node_fs_1.readFileSync)(telemetryFile, "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            try {
+                const event = JSON.parse(lines[i]);
+                if (event.event === "worker-blocked" && event.child_id === activeChild) {
+                    return event;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+/**
+ * Format blocked event for display.
+ */
+function formatBlockedEvent(event) {
+    const time = new Date(event.timestamp).toLocaleTimeString();
+    let msg = `${time}: ${event.reason}`;
+    if (event.approval_type) {
+        msg += ` (${event.approval_type})`;
+    }
+    if (event.description) {
+        msg += ` - ${event.description.slice(0, 60)}${event.description.length > 60 ? "..." : ""}`;
+    }
+    return msg;
+}
+/**
+ * Find all auto-approved events for active child.
+ */
+function findAutoApprovedEvents(telemetryFile, activeChild) {
+    if (!activeChild || !(0, node_fs_1.existsSync)(telemetryFile))
+        return [];
+    const events = [];
+    try {
+        const content = (0, node_fs_1.readFileSync)(telemetryFile, "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        for (const line of lines) {
+            try {
+                const event = JSON.parse(line);
+                if (event.event === "worker-auto-approved" && event.child_id === activeChild) {
+                    events.push(event);
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    catch {
+        return [];
+    }
+    return events;
+}
+/**
+ * States that indicate the worker has acknowledged the dispatch packet.
+ * These are states at or after the "acknowledged" lifecycle stage.
+ */
+const ACKNOWLEDGED_OR_LATER_STATES = new Set([
+    "acknowledged",
+    "running",
+    "waiting-for-approval",
+    "blocked",
+    "completed",
+    "failed",
+    "orphaned",
+]);
+/**
+ * Check whether the worker for the given dispatch has acknowledged the packet.
+ *
+ * Primary: checks runtime_state on the ChildDispatchRecord against the set of
+ * states at or after "acknowledged".
+ * Fallback: scans telemetry log for a worker-acknowledged event with a matching
+ * dispatch_id.
+ *
+ * Returns false for unknown dispatch_id (does not throw).
+ */
+function hasWorkerAcknowledged(dispatch_id, state, telemetryFile) {
+    // Search all open_children_meta for a matching dispatch record
+    const meta = state.open_children_meta ?? {};
+    for (const childKey of Object.keys(meta)) {
+        const record = meta[childKey]?.dispatch_record;
+        if (record && record.dispatch_id === dispatch_id) {
+            // Primary check: runtime_state
+            if (record.runtime_state && ACKNOWLEDGED_OR_LATER_STATES.has(record.runtime_state)) {
+                return true;
+            }
+            break; // Found the record but not acknowledged by state; try telemetry fallback
+        }
+    }
+    // Fallback: scan telemetry log for worker-acknowledged event
+    if (telemetryFile && (0, node_fs_1.existsSync)(telemetryFile)) {
+        try {
+            const content = (0, node_fs_1.readFileSync)(telemetryFile, "utf-8");
+            const lines = content.trim().split("\n").filter(Boolean);
+            for (const line of lines) {
+                try {
+                    const event = JSON.parse(line);
+                    if (event.event === "worker-acknowledged" && event.dispatch_id === dispatch_id) {
+                        return true;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    return false;
+}
+/**
+ * Check whether a session can be attached to the worker for the given dispatch.
+ *
+ * Returns true only when attachment_capable === true AND session_id is non-null/undefined
+ * on the ChildDispatchRecord. Does NOT scan telemetry.
+ *
+ * Returns false for unknown dispatch_id (does not throw).
+ */
+function canSessionBeAttached(dispatch_id, state) {
+    const meta = state.open_children_meta ?? {};
+    for (const childKey of Object.keys(meta)) {
+        const record = meta[childKey]?.dispatch_record;
+        if (record && record.dispatch_id === dispatch_id) {
+            return record.attachment_capable === true &&
+                record.session_id !== null &&
+                record.session_id !== undefined;
+        }
+    }
+    return false;
+}
+function getCurrentBranch(repoRoot) {
+    try {
+        return (0, node_child_process_1.execFileSync)("git", ["branch", "--show-current"], {
+            cwd: repoRoot,
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch {
+        return "unknown";
+    }
+}
+function computeStateSha(stateFile) {
+    const content = (0, node_fs_1.readFileSync)(stateFile, "utf-8");
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex");
+}
+function findLatestPacket(bootstrapDir, runId) {
+    let entries;
+    try {
+        entries = (0, node_fs_1.readdirSync)(bootstrapDir).filter((f) => f.endsWith(".json"));
+    }
+    catch {
+        return null;
+    }
+    if (entries.length === 0)
+        return null;
+    const candidates = runId
+        ? entries.filter((f) => f.startsWith(`${runId}-`)).sort()
+        : entries.sort();
+    if (candidates.length === 0)
+        return null;
+    const latest = candidates.at(-1);
+    const fullPath = (0, node_path_1.join)(bootstrapDir, latest);
+    try {
+        const raw = (0, node_fs_1.readFileSync)(fullPath, "utf-8");
+        return { path: fullPath, packet: JSON.parse(raw) };
+    }
+    catch {
+        return null;
+    }
+}
+function runLoopStatus(options) {
+    const { repoRoot } = options;
+    const config = (0, loader_js_1.loadConfig)(repoRoot);
+    const bootstrapDir = (0, node_path_1.resolve)(repoRoot, config.loop.bootstrapOutputPath ?? ".polaris/bootstrap");
+    const stateFile = options.stateFile ?? (0, node_path_1.join)(repoRoot, ".polaris", "runs", "current-state.json");
+    let state;
+    try {
+        const raw = (0, checkpoint_js_1.readState)(stateFile);
+        const errors = (0, checkpoint_js_1.validateState)(raw);
+        if (errors.length > 0) {
+            console.error(`current-state.json invalid:\n${errors.join("\n")}`);
+            process.exit(1);
+        }
+        state = raw;
+    }
+    catch (err) {
+        console.error(`Error: cannot read state file ${stateFile}: ${err instanceof Error ? err.message : String(err)}`);
+        process.exit(1);
+    }
+    const branch = getCurrentBranch(repoRoot);
+    const openChildren = state.open_children ?? [];
+    const blockedChildren = state["blocked_children"] ?? [];
+    const packetResult = findLatestPacket(bootstrapDir, state.run_id);
+    let packetFresh = null;
+    let packetPathDisplay = null;
+    let stateSha = null;
+    if (packetResult) {
+        try {
+            stateSha = computeStateSha(stateFile);
+            packetFresh = packetResult.packet.current_state_sha === stateSha;
+            packetPathDisplay = packetResult.path.startsWith(repoRoot + "/")
+                ? packetResult.path.slice(repoRoot.length + 1)
+                : packetResult.path;
+        }
+        catch {
+            packetFresh = false;
+        }
+    }
+    const isDeadlock = openChildren.length > 0 &&
+        blockedChildren.length > 0 &&
+        openChildren.every((c) => blockedChildren.includes(c));
+    // ── Find dispatch evidence for active child ────────────────────────────────
+    const dispatchEvidence = findDispatchEvidence(repoRoot, state.cluster_id, state.active_child || null, state.open_children_meta);
+    // ── Find worker heartbeat for active child ──────────────────────────────────
+    const artifactDir = state.artifact_dir ?? (0, node_path_1.join)(repoRoot, ".taskchain_artifacts", "polaris-run");
+    const telemetryFile = (0, node_path_1.join)(artifactDir, "runs", state.run_id, "telemetry.jsonl");
+    const runtimeArtifacts = buildRuntimeArtifactSurfaces(repoRoot, state.cluster_id, stateFile, bootstrapDir, telemetryFile);
+    const workerHeartbeat = findWorkerHeartbeat(telemetryFile, state.active_child || null);
+    const workerBlocked = findWorkerBlocked(telemetryFile, state.active_child || null);
+    // ── Role context from active dispatch record ───────────────────────────────
+    const activeDispatch = state.open_children_meta?.[state.active_child]?.dispatch_record;
+    if (options.json) {
+        console.log(JSON.stringify({
+            run_id: state.run_id,
+            cluster_id: state.cluster_id,
+            branch,
+            session_type: state.session_type ?? null,
+            active_child: state.active_child || null,
+            step_cursor: state.step_cursor,
+            status: state.status,
+            context_budget: state.context_budget,
+            completed_children: state.completed_children,
+            open_children: openChildren,
+            blocked_children: blockedChildren,
+            deadlock: isDeadlock,
+            bootstrap_packet: packetPathDisplay
+                ? { path: packetPathDisplay, fresh: packetFresh }
+                : null,
+            runtime_artifacts: runtimeArtifacts,
+            state_sha: stateSha ? stateSha.slice(0, 12) : null,
+            role_context: activeDispatch?.role ? {
+                role: activeDispatch.role,
+                role_authority: activeDispatch.role_authority ?? null,
+                may_implement: activeDispatch.may_implement ?? null,
+                session_type: activeDispatch.session_type ?? null,
+            } : null,
+            dispatch: dispatchEvidence
+                ? {
+                    child_id: dispatchEvidence.child_id,
+                    dispatch_status: dispatchEvidence.dispatch_status,
+                    packet_path: getRelativePath(repoRoot, dispatchEvidence.packet_path),
+                    expected_result_path: getRelativePath(repoRoot, dispatchEvidence.expected_result_path),
+                    result_present: dispatchEvidence.result_present,
+                    provider: dispatchEvidence.provider ?? null,
+                    dispatched_at: dispatchEvidence.dispatched_at,
+                    dispatch_mode: dispatchEvidence.dispatch_mode ?? null,
+                    // Derive runtime state: delegated mode defaults to "delegated", else "unknown"
+                    runtime_state: dispatchEvidence.runtime_state ??
+                        ((dispatchEvidence.dispatch_mode ?? "delegated") === "delegated" ? "delegated" : "unknown"),
+                    last_heartbeat_at: dispatchEvidence.last_heartbeat_at ?? null,
+                    last_heartbeat_step: dispatchEvidence.last_heartbeat_step ?? null,
+                    worker_assignment: dispatchEvidence.worker_assignment ?? null,
+                    worker_acknowledged: hasWorkerAcknowledged(dispatchEvidence.dispatch_id, state, telemetryFile),
+                    session_attachable: canSessionBeAttached(dispatchEvidence.dispatch_id, state),
+                }
+                : null,
+            worker: workerHeartbeat
+                ? {
+                    child_id: workerHeartbeat.child_id,
+                    step_cursor: workerHeartbeat.step_cursor,
+                    last_seen: workerHeartbeat.timestamp,
+                    progress_pct: workerHeartbeat.progress_pct ?? null,
+                    files_changed: workerHeartbeat.files_changed ?? null,
+                    current_file: workerHeartbeat.current_file ?? null,
+                }
+                : null,
+            blocked: workerBlocked
+                ? {
+                    reason: workerBlocked.reason,
+                    approval_type: workerBlocked.approval_type ?? null,
+                    description: workerBlocked.description ?? null,
+                    blocker_id: workerBlocked.blocker_id ?? null,
+                    timestamp: workerBlocked.timestamp,
+                }
+                : null,
+        }, null, 2));
+        return;
+    }
+    const maxChildren = state.context_budget.max_children_per_session ?? 3;
+    const completed = state.context_budget.children_completed;
+    const remaining = Math.max(0, maxChildren - completed);
+    // ── Role block ────────────────────────────────────────────────────────────
+    const roleLines = [];
+    if (activeDispatch?.role) {
+        const roleName = activeDispatch.role.charAt(0).toUpperCase() + activeDispatch.role.slice(1);
+        const authorityLabel = activeDispatch.role_authority ?? "(unknown)";
+        const mayImpl = activeDispatch.may_implement === true ? "Yes" : activeDispatch.may_implement === false ? "No" : "(unknown)";
+        const mayAssign = activeDispatch.role === "foreman" ? "Yes" : activeDispatch.role === "worker" ? "No" : "(unknown)";
+        roleLines.push("", "Role Context:");
+        roleLines.push(`  Role:               ${roleName}`);
+        roleLines.push(`  Authority:          ${authorityLabel}`);
+        roleLines.push(`  May Implement:      ${mayImpl}`);
+        roleLines.push(`  May Assign Workers: ${mayAssign}`);
+    }
+    const lines = [
+        "Polaris Loop Status",
+        "───────────────────",
+        `Run ID:          ${state.run_id}`,
+        `Cluster:         ${state.cluster_id}`,
+        `Branch:          ${branch}`,
+        `Session type:    ${state.session_type ?? "(not set)"}`,
+        `Active child:    ${state.active_child || "(none)"}`,
+        `Step cursor:     ${state.step_cursor ?? "(none)"}`,
+        `Context budget:  ${completed}/${maxChildren} children completed (${remaining} remaining)`,
+        "",
+        `Completed:       ${state.completed_children.length > 0 ? state.completed_children.join(", ") + ` (${state.completed_children.length})` : "none"}`,
+        `Open:            ${openChildren.length > 0 ? openChildren.join(", ") + ` (${openChildren.length})` : "none"}`,
+        `Blocked:         ${blockedChildren.length > 0 ? blockedChildren.join(", ") : "none"}`,
+    ];
+    lines.push(...roleLines);
+    lines.push("");
+    lines.push("Runtime Artifacts:");
+    lines.push(`  Cluster state:    ${runtimeArtifacts.cluster_state.path} (${runtimeArtifacts.cluster_state.classification}; ${runtimeArtifacts.cluster_state.role}; ${runtimeArtifacts.cluster_state.exists ? "exists" : "missing"})`);
+    lines.push(`  Current state:    ${runtimeArtifacts.current_state.path} (${runtimeArtifacts.current_state.classification}; ${runtimeArtifacts.current_state.role}; ${runtimeArtifacts.current_state.exists ? "exists" : "missing"})`);
+    lines.push(`  Bootstrap dir:    ${runtimeArtifacts.bootstrap_packets.path} (${runtimeArtifacts.bootstrap_packets.classification}; ${runtimeArtifacts.bootstrap_packets.role}; ${runtimeArtifacts.bootstrap_packets.exists ? "exists" : "missing"})`);
+    lines.push(`  Telemetry:        ${runtimeArtifacts.telemetry.path} (${runtimeArtifacts.telemetry.classification}; ${runtimeArtifacts.telemetry.role}; ${runtimeArtifacts.telemetry.exists ? "exists" : "missing"})`);
+    if (packetPathDisplay) {
+        const freshLabel = packetFresh
+            ? "(fresh)"
+            : "(stale — re-run `polaris loop continue`)";
+        lines.push("");
+        lines.push(`Bootstrap packet: ${packetPathDisplay} ${freshLabel}`);
+        if (stateSha) {
+            const matchLabel = packetFresh
+                ? "matches current-state.json ✓"
+                : "MISMATCH — state has changed";
+            lines.push(`State SHA:        ${stateSha.slice(0, 12)}... (${matchLabel})`);
+        }
+    }
+    else {
+        lines.push("");
+        lines.push("Bootstrap packet: (none found)");
+    }
+    // ── Dispatch evidence ─────────────────────────────────────────────────────
+    if (dispatchEvidence) {
+        lines.push("");
+        lines.push("Dispatch Evidence:");
+        lines.push(`  Child:            ${dispatchEvidence.child_id}`);
+        // Show dispatch mode and runtime state
+        const mode = dispatchEvidence.dispatch_mode ?? "delegated";
+        // Derive runtime state: for delegated mode without explicit state, default to "delegated"
+        // for direct-worker mode without explicit state, default to "unknown"
+        const runtimeState = dispatchEvidence.runtime_state ??
+            (mode === "delegated" ? "delegated" : "unknown");
+        lines.push(`  Mode:             ${mode}`);
+        lines.push(`  Runtime state:    ${runtimeState}`);
+        if (dispatchEvidence.provider) {
+            lines.push(`  Provider:         ${dispatchEvidence.provider}`);
+        }
+        // Show mode-specific messaging
+        if (mode === "delegated") {
+            lines.push(`  Visibility:       limited (orchestrator-owned)`);
+            // Show worker assignment info if available
+            if (dispatchEvidence.worker_assignment) {
+                const wa = dispatchEvidence.worker_assignment;
+                lines.push(`  Assignment:       ${wa.assignment_type}`);
+                if (wa.assignment_type === "subagent" && wa.subagent_session_id) {
+                    lines.push(`  Subagent session: ${wa.subagent_session_id}`);
+                }
+                else if (wa.assignment_type === "external-process" && wa.process_pid) {
+                    lines.push(`  Process PID:      ${wa.process_pid}`);
+                }
+                else if (wa.assignment_type === "pending-escalation" && wa.escalation_reason) {
+                    lines.push(`  Escalation:       ${wa.escalation_reason}`);
+                }
+                lines.push(`  Assigned at:      ${wa.assigned_at}`);
+            }
+            else {
+                // No assignment yet - Foreman seal compliance notice
+                lines.push(`  Assignment:       (none yet)`);
+            }
+        }
+        lines.push(`  Packet:           ${getRelativePath(repoRoot, dispatchEvidence.packet_path)}`);
+        lines.push(`  Expected result:  ${getRelativePath(repoRoot, dispatchEvidence.expected_result_path)}`);
+        lines.push(`  Result present:   ${dispatchEvidence.result_present ? "✓ yes" : "✗ no"}`);
+        // Show heartbeat info if available
+        if (dispatchEvidence.last_heartbeat_at) {
+            const heartbeatAge = Math.round((Date.now() - new Date(dispatchEvidence.last_heartbeat_at).getTime()) / 1000);
+            lines.push(`  Last heartbeat:   ${heartbeatAge}s ago${dispatchEvidence.last_heartbeat_step ? ` (${dispatchEvidence.last_heartbeat_step})` : ""}`);
+        }
+        else if (mode === "direct-worker" && !dispatchEvidence.result_present) {
+            lines.push(`  Last heartbeat:   (none yet)`);
+        }
+        lines.push(`  Dispatched at:    ${dispatchEvidence.dispatched_at}`);
+        // Show state-specific warnings
+        if (runtimeState === "waiting-for-approval") {
+            lines.push("");
+            lines.push("  ⏳ Waiting for approval - worker is blocked");
+        }
+        else if (runtimeState === "orphaned") {
+            lines.push("");
+            lines.push("  ⚠ Worker appears orphaned - no recent heartbeats");
+        }
+        else if (runtimeState === "blocked") {
+            lines.push("");
+            lines.push("  ⚠ Worker blocked - no heartbeat within expected interval");
+        }
+        // Foreman seal compliance notice for delegated mode without assignment
+        if (mode === "delegated" && !dispatchEvidence.worker_assignment && !dispatchEvidence.result_present) {
+            lines.push("");
+            lines.push("  📋 Foreman Seal Compliance:");
+            lines.push("     Foreman coordinates; Foreman does NOT implement.");
+            lines.push("     A worker must be assigned or escalated.");
+            if (!dispatchEvidence.worker_assignment) {
+                lines.push("");
+                lines.push("     ⚠️  No worker assigned - implementation would violate seal");
+                lines.push("     Action: Assign worker or escalate to manual dispatch");
+            }
+        }
+    }
+    else if (state.active_child) {
+        lines.push("");
+        lines.push("⚠ No dispatch evidence found for active child");
+        lines.push(`  Child ${state.active_child} is active but no packet/result artifacts exist.`);
+        lines.push("  This may indicate a dispatch failure or orphaned state.");
+    }
+    // ── Worker blocked (needs approval) ───────────────────────────────────────
+    if (workerBlocked) {
+        lines.push("");
+        lines.push("🛑 WORKER BLOCKED - AWAITING APPROVAL");
+        lines.push(`  Reason:      ${workerBlocked.reason}`);
+        if (workerBlocked.approval_type) {
+            lines.push(`  Type:        ${workerBlocked.approval_type}`);
+        }
+        if (workerBlocked.description) {
+            lines.push(`  Details:     ${workerBlocked.description}`);
+        }
+        if (workerBlocked.blocker_id) {
+            lines.push(`  Blocker ID:  ${workerBlocked.blocker_id}`);
+        }
+        lines.push(`  Blocked at:  ${formatBlockedEvent(workerBlocked)}`);
+        lines.push("");
+        lines.push("To resolve:");
+        lines.push(`  1. Read the packet: cat ${dispatchEvidence?.packet_path ?? "<packet path>"}`);
+        lines.push(`  2. Check worker context in the packet instructions`);
+        lines.push(`  3. Either:`);
+        lines.push(`     a) Approve: Append approval response to telemetry and resume`);
+        lines.push(`     b) Abort: Run 'polaris loop abort --child ${state.active_child}' to unblock`);
+        lines.push("");
+        lines.push("⚠️  DO NOT dispatch another worker until this block is resolved!");
+    }
+    // ── Worker heartbeat (progress) ───────────────────────────────────────────
+    else if (workerHeartbeat) {
+        lines.push("");
+        lines.push("Worker Progress (last heartbeat):");
+        lines.push(`  Step:      ${workerHeartbeat.step_cursor}`);
+        if (workerHeartbeat.progress_pct !== undefined) {
+            lines.push(`  Progress:  ${workerHeartbeat.progress_pct}%`);
+        }
+        if (workerHeartbeat.files_changed !== undefined) {
+            lines.push(`  Files:     ${workerHeartbeat.files_changed} changed`);
+        }
+        if (workerHeartbeat.current_file) {
+            lines.push(`  Current:   ${workerHeartbeat.current_file}`);
+        }
+        lines.push(`  Last seen: ${formatHeartbeat(workerHeartbeat)}`);
+    }
+    else if (dispatchEvidence && !dispatchEvidence.result_present) {
+        lines.push("");
+        lines.push("⚠ No worker heartbeats detected");
+        lines.push(`  Worker for ${dispatchEvidence.child_id} has not emitted any progress telemetry.`);
+        lines.push("  Worker may be:");
+        lines.push("    - Starting up (heartbeats start after packet read)");
+        lines.push("    - Stuck or crashed (no heartbeats in telemetry.jsonl)");
+        lines.push("    - Blocked on approval (old worker version without block telemetry)");
+        lines.push("    - Running without heartbeat compliance (old worker version)");
+    }
+    if (isDeadlock) {
+        lines.push("");
+        lines.push("⚠ DEADLOCK DETECTED");
+        lines.push("Blocked children:");
+        for (const c of blockedChildren) {
+            lines.push(`  ${c} — blocked`);
+        }
+        lines.push("Resolve blockers in Linear, then run: polaris loop resume");
+    }
+    console.log(lines.join("\n"));
+}