vericify 1.0.2 → 1.2.0

package/src/projection/runs.js

@@ -7,6 +7,7 @@ import {
   checkpointTriggerFromStatusEvent,
   checkpointTriggerFromWorkspaceSummary,
 } from "../checkpoints/policy.js";
+import { collapseAndScoreActivityItems, compareRunsByAttention, deriveRunLiveSignal } from "./live-signal.js";
 
 function sortByUpdatedDescending(items) {
   return [...items].sort((left, right) => String(right.updated_at).localeCompare(String(left.updated_at)));
@@ -61,6 +62,85 @@ function statusFromProcessPostKind(kind) {
   return "running";
 }
 
+const OBSERVER_STATUS_EVENT_TYPES = new Set([
+  "HUB_RUN_FOCUSED",
+  "HUB_VIEW_CHANGED",
+  "HUB_REFRESHED",
+  "HUB_COMMAND_WRITTEN",
+  "HUB_SESSION_STARTED",
+  "HUB_SESSION_STOPPED",
+  "HUB_SESSION_RESUMED",
+]);
+
+const OBSERVER_LEDGER_CATEGORIES = new Set([
+  "operator_focus",
+  "operator_view",
+  "operator_refresh",
+  "operator_write",
+]);
+
+const PRIMARY_PROCESS_POST_KINDS = new Set([
+  "blocker",
+  "completion",
+  "handoff_note",
+  "operator_note",
+  "intervention",
+  "stale_ack",
+]);
+
+function isObserverStatusEvent(event) {
+  return event?.payload?.observer_telemetry === true ||
+    (event?.source_module === "vericify-hub" && OBSERVER_STATUS_EVENT_TYPES.has(event?.event_type));
+}
+
+function isObserverLedgerEntry(entry) {
+  return entry?.metadata?.observer_telemetry === true ||
+    (entry?.tool === "vericify-hub" && OBSERVER_LEDGER_CATEGORIES.has(entry?.category));
+}
+
+function recordSourceMetadata(record) {
+  return {
+    record_source: record.record_source,
+    record_source_kind: record.record_source_kind,
+    record_source_path: record.record_source_path,
+    record_sources: Array.isArray(record.record_sources) ? record.record_sources : [],
+  };
+}
+
+function signalPolicyForProcessPost(post) {
+  return {
+    signal_class: PRIMARY_PROCESS_POST_KINDS.has(post.kind) ? "primary" : "secondary",
+    visible_by_default: true,
+  };
+}
+
+function signalPolicyForStatusEvent(event) {
+  if (isObserverStatusEvent(event)) {
+    return {
+      signal_class: "background",
+      visible_by_default: false,
+    };
+  }
+  const normalizedStatus = statusFromEventStatus(event.status);
+  return {
+    signal_class: normalizedStatus === "blocked" || normalizedStatus === "completed" ? "primary" : "secondary",
+    visible_by_default: true,
+  };
+}
+
+function signalPolicyForLedgerEntry(entry) {
+  if (isObserverLedgerEntry(entry)) {
+    return {
+      signal_class: "background",
+      visible_by_default: false,
+    };
+  }
+  return {
+    signal_class: entry.category === "regression" ? "primary" : "secondary",
+    visible_by_default: true,
+  };
+}
+
 function humanizeToken(value) {
   return String(value ?? "")
     .replace(/[-_]+/g, " ")
@@ -80,6 +160,8 @@ function activityItemFromProcessPost(post) {
     status: statusFromProcessPostKind(post.kind),
     summary: post.summary,
     refs: unique([...asArray(post.evidence_refs), ...asArray(post.tool_refs)]),
+    ...recordSourceMetadata(post),
+    ...signalPolicyForProcessPost(post),
   };
 }
 
@@ -96,6 +178,8 @@ function activityItemFromStatusEvent(runId, event) {
     status: statusFromEventStatus(event.status),
     summary: event.payload?.summary ?? event.event_type,
     refs: asArray(event.payload?.evidence_ref),
+    ...recordSourceMetadata(event),
+    ...signalPolicyForStatusEvent(event),
   };
 }
 
@@ -112,6 +196,8 @@ function activityItemFromLedgerEntry(runId, entry) {
     status: statusFromLedgerCategory(entry.category),
     summary: entry.message,
     refs: asArray(entry.artifacts),
+    ...recordSourceMetadata(entry),
+    ...signalPolicyForLedgerEntry(entry),
   };
 }
 
@@ -140,6 +226,12 @@ function activityItemFromLaneHeartbeat(runDetail, lane, latestActivity) {
     status: lane.status,
     summary: summarizeLaneHeartbeat(lane, latestActivity),
     refs: latestActivity?.refs ?? [],
+    record_source: "derived",
+    record_source_kind: "lane_heartbeat",
+    record_source_path: undefined,
+    record_sources: [],
+    signal_class: "continuity",
+    visible_by_default: false,
   };
 }
 
@@ -227,7 +319,7 @@ function deltaBetween(left, right, id) {
   };
 }
 
-function summarizeRun(run, branches, lanes, nodes, handoffs, checkpoints, neighbors) {
+function summarizeRun(run, branches, lanes, nodes, handoffs, checkpoints, neighbors, liveSignal) {
   const latestCheckpoint = checkpoints[checkpoints.length - 1];
   return {
     run_id: run.run_id,
@@ -241,6 +333,19 @@ function summarizeRun(run, branches, lanes, nodes, handoffs, checkpoints, neighb
     updated_at: run.updated_at,
     similar_runs: neighbors,
     latest_checkpoint: latestCheckpoint,
+    attention_class: liveSignal?.attention_class,
+    attention_reason: liveSignal?.attention_reason,
+    attention_score: liveSignal?.attention_score,
+    attention_rank: liveSignal?.attention_rank,
+    freshness_class: liveSignal?.freshness_class,
+    expected_next_event: liveSignal?.expected_next_event,
+    overdue_at: liveSignal?.overdue_at,
+    current_actor_id: liveSignal?.current_actor_id,
+    waiting_on_actor_id: liveSignal?.waiting_on_actor_id,
+    needs_narrative: liveSignal?.needs_narrative,
+    recommended_post_kind: liveSignal?.recommended_post_kind,
+    signal_confidence: liveSignal?.signal_confidence,
+    partner_dependency_class: liveSignal?.partner_dependency_class,
   };
 }
 
@@ -326,16 +431,18 @@ function buildHandoffRun(handoff, workspace) {
 }
 
 function buildWorkspaceRun(workspaceState, workspace) {
+  const meaningfulEvents = workspaceState.statusEvents.filter((event) => !isObserverStatusEvent(event));
+  const meaningfulLedger = workspaceState.ledgerEntries.filter((entry) => !isObserverLedgerEntry(entry));
   if (
     workspaceState.todoNodes.length === 0 &&
-    workspaceState.statusEvents.length === 0 &&
-    workspaceState.ledgerEntries.length === 0 &&
+    meaningfulEvents.length === 0 &&
+    meaningfulLedger.length === 0 &&
     workspaceState.processPosts.length === 0
   ) return null;
   const runId = "workspace:current";
   const branchId = `${runId}:main`;
-  const activeEvents = workspaceState.statusEvents.slice(-25);
-  const activeLedger = workspaceState.ledgerEntries.slice(-12);
+  const activeEvents = meaningfulEvents.slice(-25);
+  const activeLedger = meaningfulLedger.slice(-12);
   const activePosts = workspaceState.processPosts.slice(-12);
   const laneMap = new Map();
   for (const event of activeEvents) {
@@ -402,11 +509,16 @@ function buildWorkspaceRun(workspaceState, workspace) {
     title: "Workspace Current",
     objective: "Current workspace execution state",
     status: branch.status,
-    created_at: workspaceState.statusEvents[0]?.timestamp ?? isoNow(),
+    created_at: firstDefined(
+      meaningfulEvents[0]?.timestamp,
+      activePosts[0]?.timestamp,
+      meaningfulLedger[0]?.timestamp_utc,
+      isoNow()
+    ),
     updated_at: firstDefined(
       workspaceState.processPosts[workspaceState.processPosts.length - 1]?.timestamp,
-      workspaceState.statusEvents[workspaceState.statusEvents.length - 1]?.timestamp,
-      workspaceState.ledgerEntries[workspaceState.ledgerEntries.length - 1]?.timestamp_utc,
+      meaningfulEvents[meaningfulEvents.length - 1]?.timestamp,
+      meaningfulLedger[meaningfulLedger.length - 1]?.timestamp_utc,
       isoNow()
     ),
     branch_ids: [branchId],
@@ -441,18 +553,22 @@ function buildObjectiveRuns(workspaceState, workspace) {
     grouped.get(key).push(event);
   }
   return [...grouped.entries()].map(([runId, events]) => {
+    if (runId === "workspace:current") return null;
     const sortedEvents = sortByTimestamp(events, (event) => event.timestamp ?? "");
-    const branchIds = unique(sortedEvents.map((event) => explicitBranchId(runId, event)));
-    const laneIds = unique(sortedEvents.map((event) => explicitLaneId(runId, event)));
+    const meaningfulEvents = sortedEvents.filter((event) => !isObserverStatusEvent(event));
+    if (!meaningfulEvents.length) return null;
+    const latestMeaningfulEvent = meaningfulEvents[meaningfulEvents.length - 1];
+    const branchIds = unique(meaningfulEvents.map((event) => explicitBranchId(runId, event)));
+    const laneIds = unique(meaningfulEvents.map((event) => explicitLaneId(runId, event)));
     const branches = branchIds.map((branchId) => ({
       branch_id: branchId,
       run_id: runId,
       name: branchId === `${runId}:main` ? "main" : branchId.split(":").at(-1) ?? "branch",
-      status: statusFromEventStatus(sortedEvents[sortedEvents.length - 1]?.status),
+      status: statusFromEventStatus(latestMeaningfulEvent?.status),
       lane_ids: laneIds.filter((laneId) => laneId.startsWith(branchId) || branchId === `${runId}:main`),
     }));
     const lanes = laneIds.map((laneId) => {
-      const related = sortedEvents.filter((event) => explicitLaneId(runId, event) === laneId);
+      const related = meaningfulEvents.filter((event) => explicitLaneId(runId, event) === laneId);
       const latest = related[related.length - 1];
       return {
         lane_id: laneId,
@@ -463,7 +579,7 @@ function buildObjectiveRuns(workspaceState, workspace) {
         updated_at: latest.timestamp ?? isoNow(),
       };
     });
-    const checkpoints = sortedEvents.map((event, index) => checkpointFromSummary({
+    const checkpoints = meaningfulEvents.map((event, index) => checkpointFromSummary({
       checkpointId: `${runId}:cp:${index + 1}`,
       runId,
       branchId: explicitBranchId(runId, event),
@@ -473,7 +589,7 @@ function buildObjectiveRuns(workspaceState, workspace) {
       taskDelta: event.payload?.summary ?? event.event_type,
       evidenceRefs: event.payload?.evidence_ref ? [event.payload.evidence_ref] : [],
       gitCommitSha: firstDefined(event.git_commit_sha, event.payload?.git_commit_sha, event.metadata?.git_commit_sha),
-      checkpointMeta: checkpointTriggerFromStatusEvent(event, sortedEvents[index - 1]),
+      checkpointMeta: checkpointTriggerFromStatusEvent(event, meaningfulEvents[index - 1]),
     }));
     const deltas = checkpoints.length > 1
       ? checkpoints.slice(1).map((checkpoint, index) => deltaBetween(checkpoints[index], checkpoint, `${runId}:delta:${index + 1}`))
@@ -481,11 +597,11 @@ function buildObjectiveRuns(workspaceState, workspace) {
     const run = {
       run_id: runId,
       workspace,
-      title: sortedEvents[sortedEvents.length - 1]?.payload?.summary ?? runId,
-      objective: sortedEvents[0]?.objective_id ?? sortedEvents[0]?.trace_id ?? runId,
-      status: statusFromEventStatus(sortedEvents[sortedEvents.length - 1]?.status),
-      created_at: sortedEvents[0]?.timestamp ?? isoNow(),
-      updated_at: sortedEvents[sortedEvents.length - 1]?.timestamp ?? isoNow(),
+      title: latestMeaningfulEvent?.payload?.summary ?? runId,
+      objective: meaningfulEvents[0]?.objective_id ?? meaningfulEvents[0]?.trace_id ?? runId,
+      status: statusFromEventStatus(latestMeaningfulEvent?.status),
+      created_at: meaningfulEvents[0]?.timestamp ?? isoNow(),
+      updated_at: latestMeaningfulEvent?.timestamp ?? isoNow(),
       branch_ids: branches.map((branch) => branch.branch_id),
       lane_ids: lanes.map((lane) => lane.lane_id),
       checkpoint_ids: checkpoints.map((checkpoint) => checkpoint.checkpoint_id),
@@ -502,7 +618,7 @@ function buildObjectiveRuns(workspaceState, workspace) {
       activity_items: [],
       similarity: { target_run_id: runId, neighbors: [] },
     };
-  });
+  }).filter(Boolean);
 }
 
 function ensureBranch(runDetail, branchId) {
@@ -678,7 +794,9 @@ function attachActivityItems(runs, workspaceState) {
 
 function attachLaneHeartbeats(runs) {
   for (const runDetail of runs) {
-    const sourceItems = (runDetail.activity_items ?? []).filter((item) => item.source_kind !== "lane_heartbeat");
+    const sourceItems = (runDetail.activity_items ?? []).filter((item) =>
+      item.source_kind !== "lane_heartbeat" && item.visible_by_default !== false
+    );
     for (const lane of runDetail.lanes ?? []) {
       const latestActivity = sortByTimestamp(
         sourceItems.filter((item) => item.lane_id === lane.lane_id || (!item.lane_id && item.actor_id === lane.agent_id)),
@@ -689,9 +807,16 @@ function attachLaneHeartbeats(runs) {
   }
 }
 
+function collapseActivityItems(runs, now) {
+  for (const runDetail of runs) {
+    runDetail.activity_items = collapseAndScoreActivityItems(runDetail.activity_items ?? [], { now });
+  }
+}
+
 function attachLedgerEntries(runs, workspaceState) {
   const byId = new Map(runs.map((run) => [run.run.run_id, run]));
   for (const entry of sortByTimestamp(workspaceState.ledgerEntries, (item) => item.timestamp_utc ?? "")) {
+    if (isObserverLedgerEntry(entry)) continue;
     const runId = runIdFromLedgerEntry(entry);
     if (!runId) continue;
     const runDetail = byId.get(runId);
@@ -769,6 +894,16 @@ function attachSimilarity(runs) {
       target_run_id: run.run.run_id,
       neighbors,
     };
+  }
+}
+
+function attachLiveSignals(runs, now) {
+  for (const run of runs) {
+    run.live_signal = deriveRunLiveSignal(run, { now });
+  }
+  const ranked = [...runs].sort(compareRunsByAttention);
+  ranked.forEach((run, index) => {
+    run.live_signal.attention_rank = index + 1;
     run.run_summary = summarizeRun(
       run.run,
       run.branches,
@@ -776,12 +911,15 @@ function attachSimilarity(runs) {
       run.nodes,
       run.handoff_timeline.items,
       run.recent_checkpoints,
-      neighbors
+      run.similarity?.neighbors ?? [],
+      run.live_signal
     );
-  }
+  });
+  return ranked;
 }
 
-export function projectWorkspaceState(workspaceState) {
+export function projectWorkspaceState(workspaceState, options = {}) {
+  const now = options.now ?? isoNow();
   const workspace = workspaceRef(workspaceState.workspaceRoot);
   const runs = [
     ...workspaceState.handoffs.map((handoff) => buildHandoffRun(handoff, workspace)),
@@ -791,19 +929,36 @@ export function projectWorkspaceState(workspaceState) {
   if (workspaceRun) runs.push(workspaceRun);
   attachProcessPosts(runs, workspaceState, workspace);
   attachActivityItems(runs, workspaceState);
-  attachLaneHeartbeats(runs);
   attachLedgerEntries(runs, workspaceState);
+  collapseActivityItems(runs, now);
+  attachLaneHeartbeats(runs);
   finalizeRunDetails(runs);
   attachSimilarity(runs);
-  const sorted = sortByUpdatedDescending(runs.map((run) => ({
-    ...run,
-    updated_at: run.run.updated_at,
-  }))).map(({ updated_at, ...rest }) => rest);
+  const sorted = attachLiveSignals(runs, now);
   return {
-    generated_at: isoNow(),
+    generated_at: now,
     workspace,
     adapter_profiles: workspaceState.adapterProfiles ?? [],
     run_summaries: sorted.map((run) => run.run_summary),
     runs: sorted,
+    attention_items: sorted.map((run) => ({
+      run_id: run.run.run_id,
+      title: run.run.title,
+      status: run.run.status,
+      attention_rank: run.live_signal?.attention_rank,
+      attention_class: run.live_signal?.attention_class,
+      attention_reason: run.live_signal?.attention_reason,
+      attention_score: run.live_signal?.attention_score,
+      why_now: run.live_signal?.why_now,
+      expected_next_event: run.live_signal?.expected_next_event,
+      overdue_at: run.live_signal?.overdue_at,
+      recommended_owner_action: run.live_signal?.recommended_owner_action,
+      recommended_post_kind: run.live_signal?.recommended_post_kind,
+      needs_narrative: run.live_signal?.needs_narrative,
+      freshness_class: run.live_signal?.freshness_class,
+      signal_confidence: run.live_signal?.signal_confidence,
+      current_actor_id: run.live_signal?.current_actor_id,
+      waiting_on_actor_id: run.live_signal?.waiting_on_actor_id,
+    })),
   };
 }

package/src/tui/app.js

@@ -280,6 +280,7 @@ export async function runHub({ workspaceRoot, feedFile, loadState, watchedPaths
         summary,
         run_id: runId,
         workspace_root: workspaceRoot,
+        observer_telemetry: true,
       },
     });
   };

package/src/tui/panels.js

@@ -42,6 +42,10 @@ function activityBadge(sourceKind) {
   return "pp";
 }
 
+function displaySummary(item) {
+  return item.collapse_summary ?? item.display_summary ?? item.summary;
+}
+
 export function layoutTierForWidth(width) {
   if (width < 110) return "narrow";
   if (width < 170) return "medium";
@@ -63,7 +67,19 @@ function globalActivity(projected) {
         run_status: run.run.status,
       }))
     )
-    .sort((left, right) => String(right.timestamp).localeCompare(String(left.timestamp)));
+    .sort((left, right) => {
+      const scoreDelta = (right.score ?? 0) - (left.score ?? 0);
+      if (scoreDelta !== 0) return scoreDelta;
+      return String(right.timestamp).localeCompare(String(left.timestamp));
+    });
+}
+
+function visibleActivity(items) {
+  return items.filter((item) => item.visible_by_default !== false);
+}
+
+function meaningfulActivity(items) {
+  return visibleActivity(items).filter((item) => item.signal_class === "primary" || item.signal_class === "secondary");
 }
 
 function latestDelta(run) {
@@ -127,84 +143,59 @@ function buildLaneDetailRows(run, tier) {
 
 function buildRunTriageRows(run) {
   if (!run) return ["No run selected."];
+  const signal = run.live_signal ?? {};
   const rows = [];
-  const blockedNodes = (run.nodes ?? []).filter((node) => node.status === "blocked");
-  if (blockedNodes.length) {
-    rows.push(`P1 blocked nodes ${blockedNodes.length}: ${top(blockedNodes.map((node) => node.title), 2).join(", ")}`);
+  rows.push(`P${signal.attention_score >= 140 ? 1 : 2} ${signal.attention_class ?? "observe_only"}: ${signal.attention_reason ?? "No immediate action required."}`);
+  rows.push(`Why now: ${signal.why_now ?? "No meaningful movement yet."}`);
+  rows.push(`Next: ${signal.expected_next_event ?? "observe_only"} | owner action ${signal.recommended_owner_action ?? "observe_only"}`);
+  if (signal.needs_narrative) {
+    rows.push(`Narrative required: ${signal.recommended_post_kind} | ${signal.recommended_summary_template}`);
   }
+  const blockedNodes = (run.nodes ?? []).filter((node) => node.status === "blocked");
+  if (blockedNodes.length) rows.push(`Blocked nodes ${blockedNodes.length}: ${top(blockedNodes.map((node) => node.title), 2).join(", ")}`);
   const queuedHandoffs = (run.handoff_timeline?.items ?? []).filter((handoff) => handoff.status === "open" || handoff.status === "blocked");
-  if (queuedHandoffs.length) {
-    rows.push(`P1 handoff queue ${queuedHandoffs.length}: ${top(queuedHandoffs.map((handoff) => handoff.handoff_id), 2).join(", ")}`);
-  }
-  const staleLanes = (run.lanes ?? [])
-    .filter((lane) => lane.status !== "completed")
-    .sort((left, right) => String(left.updated_at).localeCompare(String(right.updated_at)));
-  if (staleLanes.length) {
-    const lane = staleLanes[0];
-    rows.push(`P2 stale lane: ${lane.agent_id} last signaled ${relativeTimeFromNow(lane.updated_at)}`);
-  }
+  if (queuedHandoffs.length) rows.push(`Open handoffs ${queuedHandoffs.length}: ${top(queuedHandoffs.map((handoff) => handoff.handoff_id), 2).join(", ")}`);
   const blockedNeighbor = (run.similarity?.neighbors ?? []).find((neighbor) => neighbor.outcome === "blocked");
   if (blockedNeighbor) {
-    rows.push(`P2 failure echo: compare with ${blockedNeighbor.run_id} at ${(blockedNeighbor.score * 100).toFixed(0)}%`);
+    rows.push(`Failure echo: compare with ${blockedNeighbor.run_id} at ${(blockedNeighbor.score * 100).toFixed(0)}%`);
   }
   const recoveryNeighbor = (run.similarity?.neighbors ?? []).find((neighbor) => neighbor.outcome === "completed");
   if (recoveryNeighbor) {
-    rows.push(`OK recovery path: ${recoveryNeighbor.run_id} reached done from a ${(recoveryNeighbor.score * 100).toFixed(0)}% similar path`);
+    rows.push(`Recovery path: ${recoveryNeighbor.run_id} reached done from a ${(recoveryNeighbor.score * 100).toFixed(0)}% similar path`);
   }
   return rows.length ? rows : ["No acute risks. Run is flowing."];
 }
 
 function buildGlobalTriageRows(projected, selectedRun) {
-  const rows = [];
-  const blockedRuns = (projected.runs ?? []).filter((run) => run.run.status === "blocked");
-  if (blockedRuns.length) {
-    rows.push(`P1 blocked runs ${blockedRuns.length}: ${top(blockedRuns.map((run) => run.run.title), 3).join(", ")}`);
-  }
-  const openHandoffs = (projected.runs ?? [])
-    .flatMap((run) => run.handoff_timeline?.items ?? [])
-    .filter((handoff) => handoff.status === "open" || handoff.status === "blocked");
-  if (openHandoffs.length) {
-    rows.push(`P1 handoffs awaiting movement ${openHandoffs.length}: ${top(openHandoffs.map((handoff) => handoff.handoff_id), 3).join(", ")}`);
-  }
-  const blockedNodes = (projected.runs ?? []).flatMap((run) => run.nodes ?? []).filter((node) => node.status === "blocked");
-  if (blockedNodes.length) {
-    rows.push(`P1 blocked nodes ${blockedNodes.length}: ${top(blockedNodes.map((node) => node.title), 3).join(", ")}`);
-  }
-  const staleLanes = (projected.runs ?? [])
-    .flatMap((run) => (run.lanes ?? []).map((lane) => ({ run, lane })))
-    .filter(({ lane }) => lane.status !== "completed")
-    .sort((left, right) => String(left.lane.updated_at).localeCompare(String(right.lane.updated_at)));
-  if (staleLanes.length) {
-    const { run, lane } = staleLanes[0];
-    rows.push(`P2 stale lane ${lane.agent_id} in ${run.run.title}: last signal ${relativeTimeFromNow(lane.updated_at)}`);
-  }
+  const attention = top((projected.attention_items ?? []).filter((item) => item.attention_class !== "observe_only"), 5);
+  const rows = attention.map((item) =>
+    `P${item.attention_score >= 140 ? 1 : 2} ${compactStatus(item.status)} ${item.title} | ${item.attention_reason} | next ${item.expected_next_event ?? "observe_only"}`
+  );
   const blockedNeighbor = selectedRun?.similarity?.neighbors?.find((neighbor) => neighbor.outcome === "blocked");
   if (blockedNeighbor) {
-    rows.push(`P2 compare now: selected run resembles blocked ${blockedNeighbor.run_id} at ${(blockedNeighbor.score * 100).toFixed(0)}%`);
+    rows.push(`Compare now: selected run resembles blocked ${blockedNeighbor.run_id} at ${(blockedNeighbor.score * 100).toFixed(0)}%`);
   }
   return rows.length ? rows : ["No hot triage. Traffic is flowing."];
 }
 
 function buildSelectedRunRadar(selectedRun) {
   if (!selectedRun) return ["No selected run."];
+  const signal = selectedRun.live_signal ?? {};
   const checkpoint = latestCheckpoint(selectedRun);
   const delta = latestDelta(selectedRun);
-  const nextNode = activeNodeLabels(selectedRun)[0];
-  const queuedHandoff = (selectedRun.handoff_timeline?.items ?? []).find((handoff) => handoff.status === "open" || handoff.status === "blocked");
-  const risk = buildRunTriageRows(selectedRun)[0];
   return [
     `${compactStatus(selectedRun.run.status)} ${selectedRun.run.title}`,
     `NOW  ${checkpoint ? checkpoint.process_summary.split("\n")[0] : "No checkpoint yet."}`,
-    `NEXT ${queuedHandoff ? `${queuedHandoff.to_agent} for ${queuedHandoff.node_ref ?? queuedHandoff.handoff_id}` : nextNode ? `advance ${nextNode}` : "await new movement"}`,
-    `RISK ${risk}`,
+    `NEXT ${signal.expected_next_event ?? activeNodeLabels(selectedRun)[0] ?? "await new movement"} | action ${signal.recommended_owner_action ?? "observe_only"}`,
+    `PULSE ${signal.why_now ?? "No meaningful movement yet."}`,
     `PATH ${delta ? delta.layers.join(" / ") : "entry only"} | confidence ${((selectedRun.run_summary?.completion_confidence ?? 0) * 100).toFixed(0)}%`,
   ];
 }
 
 function buildTrafficRows(projected, tier) {
   const limit = tier === "narrow" ? 6 : 10;
-  return top(globalActivity(projected), limit).map((item) =>
-    `${formatTimestamp(item.timestamp)} [${activityBadge(item.source_kind)}] ${urgencyBadge(item.status)} ${item.run_title} | ${item.actor_id} | ${item.summary}`
+  return top(meaningfulActivity(globalActivity(projected)), limit).map((item) =>
+    `${formatTimestamp(item.timestamp)} [${activityBadge(item.source_kind)}] ${urgencyBadge(item.status)} ${item.run_title} | ${item.actor_id} | ${displaySummary(item)}`
   );
 }
 
@@ -230,6 +221,37 @@ function historyCueRows(projected, selectedRun) {
   ];
 }
 
+function buildPresenceRows(run) {
+  if (!run) return ["No run selected."];
+  const signal = run.live_signal ?? {};
+  const captureCommand = signal.recommended_post_kind
+    ? `/ post --run-id ${run.run.run_id} --agent-id ${signal.current_actor_id ?? "operator"} --kind ${signal.recommended_post_kind} --summary "${signal.recommended_summary_template}"`
+    : undefined;
+  return [
+    `Owner ${signal.current_actor_id ?? "-"} | waiting ${signal.waiting_on_actor_id ?? "-"} | source ${signal.presence_source ?? "-"}`,
+    `Freshness ${signal.freshness_class ?? "-"} | last response ${signal.last_response_at ? relativeTimeFromNow(signal.last_response_at) : "-"}`,
+    `Next ${signal.expected_next_event ?? "observe_only"} | late ${signal.overdue_at ? relativeTimeFromNow(signal.overdue_at) : "-"} | confidence ${signal.signal_confidence ? `${(signal.signal_confidence * 100).toFixed(0)}%` : "-"}`,
+    captureCommand ? `Capture ${captureCommand}` : `Action ${signal.recommended_owner_action ?? "observe_only"}`,
+  ];
+}
+
+function buildQueueRows(projected) {
+  const queue = (projected.runs ?? [])
+    .flatMap((run) => (run.handoff_timeline?.items ?? []).map((handoff) => ({ run, handoff })))
+    .filter(({ handoff }) => handoff.status === "open" || handoff.status === "accepted" || handoff.status === "blocked")
+    .sort((left, right) => String(right.handoff.updated_at ?? right.handoff.created_at).localeCompare(String(left.handoff.updated_at ?? left.handoff.created_at)));
+  return top(queue, 6).map(({ run, handoff }) =>
+    `${urgencyBadge(handoff.status)} ${handoff.status} ${handoff.from_agent} -> ${handoff.to_agent} | ${run.run.title} | ${handoff.node_ref ?? handoff.handoff_id}`
+  );
+}
+
+function buildQuietContextRows(projected, selectedRun) {
+  return [
+    ...compareCueRows(selectedRun),
+    ...historyCueRows(projected, selectedRun),
+  ];
+}
+
 function buildCompareSummaryRows(report) {
   if (!report) return ["No comparable run available."];
   return [
@@ -291,8 +313,8 @@ function buildRecoveryCueRows(report) {
 
 function buildHistoryTimelineRows(projected, selectedRun, tier) {
   const activity = selectedRun
-    ? top([...(selectedRun.activity_items ?? [])].sort((left, right) => String(right.timestamp).localeCompare(String(left.timestamp))), tier === "narrow" ? 6 : 8)
-    : top(globalActivity(projected), tier === "narrow" ? 6 : 8);
+    ? top(visibleActivity([...(selectedRun.activity_items ?? [])].sort((left, right) => String(right.timestamp).localeCompare(String(left.timestamp)))), tier === "narrow" ? 6 : 8)
+    : top(visibleActivity(globalActivity(projected)), tier === "narrow" ? 6 : 8);
   return activity.map((item) =>
     `${formatTimestamp(item.timestamp)} [${activityBadge(item.source_kind)}] ${item.actor_id} | ${item.summary}`
   );
@@ -326,16 +348,18 @@ export function buildHubMetrics(projected, options = {}) {
   const lanes = runs.flatMap((run) => run.lanes ?? []);
   const nodes = runs.flatMap((run) => run.nodes ?? []);
   const handoffs = runs.flatMap((run) => run.handoff_timeline?.items ?? []);
-  const activityCount = runs.reduce((sum, run) => sum + (run.activity_items?.length ?? 0), 0);
+  const activityCount = runs.reduce((sum, run) => sum + meaningfulActivity(run.activity_items ?? []).length, 0);
   const runningRuns = runs.filter((run) => run.run.status === "running").length;
   const blockedRuns = runs.filter((run) => run.run.status === "blocked").length;
+  const staleRuns = runs.filter((run) => ["stale", "stale_acknowledged", "archival"].includes(run.live_signal?.freshness_class)).length;
+  const narrativeGaps = runs.filter((run) => run.live_signal?.needs_narrative).length;
   const liveLanes = lanes.filter((lane) => lane.status === "running").length;
   const blockedNodes = nodes.filter((node) => node.status === "blocked").length;
   const openHandoffs = handoffs.filter((handoff) => handoff.status === "open" || handoff.status === "blocked").length;
   if (tier === "narrow") {
-    return `Runs ${runs.length} | Live ${runningRuns} | Blkd ${blockedRuns} | Lanes ${liveLanes}/${lanes.length} | HOs ${openHandoffs} | Nodes ${blockedNodes} | Act ${activityCount}`;
+    return `Runs ${runs.length} | Live ${runningRuns} | Blkd ${blockedRuns} | Stale ${staleRuns} | Notes ${narrativeGaps} | HOs ${openHandoffs} | Act ${activityCount}`;
   }
-  return `Runs ${runs.length} | Live ${runningRuns} | Blocked ${blockedRuns} | Lanes ${lanes.length}/${liveLanes} live | Handoffs ${openHandoffs} open | Nodes ${blockedNodes} blocked | Activity ${activityCount}`;
+  return `Runs ${runs.length} | Live ${runningRuns} | Blocked ${blockedRuns} | Stale ${staleRuns} | Narrative ${narrativeGaps} | Handoffs ${openHandoffs} open | Nodes ${blockedNodes} blocked | Activity ${activityCount}`;
 }
 
 export function buildRunBoardSection(projected, selectedRun, options = {}) {
@@ -343,7 +367,7 @@ export function buildRunBoardSection(projected, selectedRun, options = {}) {
   const rows = top(projected.run_summaries ?? [], tier === "narrow" ? 6 : 8).map((summary) => {
     const isSelected = summary.run_id === selectedRun?.run?.run_id ? ">" : " ";
     const node = summary.current_node_labels?.[0] ?? "steady";
-    return `${isSelected} ${urgencyBadge(summary.status)} ${compactStatus(summary.status)} ${summary.title} | br ${summary.branch_count} | ln ${summary.lane_count} | node ${node} | ${relativeTimeFromNow(summary.updated_at)}`;
+    return `${isSelected} ${urgencyBadge(summary.status)} ${compactStatus(summary.status)} ${summary.title} | ${summary.attention_class ?? "observe_only"} | ${summary.freshness_class ?? "-"} | node ${node} | ${relativeTimeFromNow(summary.updated_at)}`;
   });
   return {
     title: "Run Board",
@@ -428,11 +452,12 @@ export function buildAdaptersSections(projected, options = {}) {
 export function buildHubSections(projected, selectedRun, options = {}) {
   const { tier = "wide" } = options;
   return [
-    { title: "Triage Shelf", rows: buildGlobalTriageRows(projected, selectedRun), tone: "HOT" },
-    { title: "Selected Run Radar", rows: buildSelectedRunRadar(selectedRun), tone: selectedRun?.run?.status === "blocked" ? "HOT" : "LIVE" },
-    { title: "Network Traffic", rows: buildTrafficRows(projected, tier), tone: "FLOW", fullWidth: tier === "wide" },
-    { title: "Compare Cue", rows: compareCueRows(selectedRun), tone: "DIFF" },
-    { title: "History Cue", rows: historyCueRows(projected, selectedRun), tone: "TRACE" },
+    { title: "Pulse", rows: buildSelectedRunRadar(selectedRun ?? projected.runs?.[0]), tone: selectedRun?.run?.status === "blocked" ? "HOT" : "LIVE" },
+    { title: "Attention", rows: buildGlobalTriageRows(projected, selectedRun), tone: "HOT" },
+    { title: "Latest Meaningful Change", rows: buildTrafficRows(projected, tier), tone: "FLOW", fullWidth: tier === "wide" },
+    { title: "Presence", rows: buildPresenceRows(selectedRun ?? projected.runs?.[0]), tone: "STATUS" },
+    { title: "Queue", rows: buildQueueRows(projected), tone: "QUEUE" },
+    { title: "Quiet Context", rows: buildQuietContextRows(projected, selectedRun), tone: "TRACE", fullWidth: tier === "wide" },
   ];
 }
 
@@ -451,8 +476,8 @@ export function buildInspectSections(run, options = {}) {
     const delta = index > 0 ? run.deltas?.find((candidate) => candidate.to_checkpoint_id === checkpoint.checkpoint_id) : undefined;
     return `${formatTimestamp(checkpoint.timestamp)} | ${checkpoint.process_summary.split("\n")[0]} | ${delta ? delta.layers.join("/") : "entry"}`;
   });
-  const activityRows = (run.activity_items ?? []).slice(-12).map((item) =>
-    `${formatTimestamp(item.timestamp)} [${activityBadge(item.source_kind)}] ${urgencyBadge(item.status)} ${item.actor_id} | ${item.summary}`
+  const activityRows = meaningfulActivity(run.activity_items ?? []).slice(-12).map((item) =>
+    `${formatTimestamp(item.timestamp)} [${activityBadge(item.source_kind)}] ${urgencyBadge(item.status)} ${item.actor_id} | ${displaySummary(item)}`
   );
   const similarityRows = (run.similarity?.neighbors ?? []).slice(0, 4).map((neighbor) => summarizeNeighbor(run, neighbor));
 
@@ -463,11 +488,13 @@ export function buildInspectSections(run, options = {}) {
         `${compactStatus(run.run.status)} ${run.run.title}`,
         `Objective: ${run.run.objective ?? "-"}`,
         `Updated: ${formatTimestamp(run.run.updated_at)} (${relativeTimeFromNow(run.run.updated_at)})`,
+        `Attention: ${run.live_signal?.attention_class ?? "observe_only"} | freshness ${run.live_signal?.freshness_class ?? "-"}`,
       ],
       tone: run.run.status === "blocked" ? "HOT" : "LIVE",
     },
-    { title: "Lane Skyline", rows: buildLaneSkylineRows(run, tier), tone: "FLOW" },
-    { title: "Triage Shelf", rows: buildRunTriageRows(run), tone: "HOT" },
+    { title: "Pulse", rows: buildSelectedRunRadar(run), tone: "FLOW" },
+    { title: "Attention", rows: buildRunTriageRows(run), tone: "HOT" },
+    { title: "Presence", rows: buildPresenceRows(run), tone: "STATUS" },
     { title: "Handoff Queue", rows: handoffRows.length ? handoffRows : ["No queued handoffs."], tone: "QUEUE" },
     { title: "Branch Divergence", rows: branchRows(run), tone: "FORK" },
     { title: "Lane Detail", rows: buildLaneDetailRows(run, tier), tone: "FLOW" },

package/src/tui/runtime-activity.js

@@ -54,6 +54,7 @@ export function createRuntimeRecorder({
         view,
         source,
         interactive: true,
+        observer_telemetry: true,
         ...payload,
       },
     });
@@ -67,6 +68,7 @@ export function createRuntimeRecorder({
         view,
         source,
         interactive: true,
+        observer_telemetry: true,
         ...metadata,
       },
     });