vericify 1.0.1 → 1.1.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

@@ -11,6 +11,7 @@ import { upsertTodoNode } from "../store/todo-state.js";
 import { formatTimestamp } from "../core/util.js";
 import { completeCommand, executeCommand } from "./commands.js";
 import {
+  buildAdaptersSections,
   buildCompareSections,
   buildHistorySections,
   buildHubMetrics,
@@ -165,7 +166,9 @@ export async function runHub({ workspaceRoot, feedFile, loadState, watchedPaths
           ? buildInspectSections(selected, { tier })
           : state.view === "history"
             ? buildHistorySections(state.projected, selected, { tier })
-            : buildHubSections(state.projected, selected, { tier })),
+            : state.view === "adapters"
+              ? buildAdaptersSections(state.projected, { tier })
+              : buildHubSections(state.projected, selected, { tier })),
     ];
 
     line(boxTitle(` Vericify Hub | ${state.mode} | ${workspaceRoot} `, width));
@@ -175,7 +178,7 @@ export async function runHub({ workspaceRoot, feedFile, loadState, watchedPaths
     renderPanelGrid(sections, width, tier);
     const prompt = state.mode === "command"
       ? `/${state.commandBuffer}`
-      : "[q quit] [j/k move] [Enter inspect] [c compare] [y history] [r refresh] [/ command] [h hub]";
+      : "[q quit] [j/k move] [Enter inspect] [c compare] [y history] [a adapters] [r refresh] [/ command] [h hub]";
     line(truncate(prompt, width));
     line(boxFooter(width));
   };
@@ -277,6 +280,7 @@ export async function runHub({ workspaceRoot, feedFile, loadState, watchedPaths
         summary,
         run_id: runId,
         workspace_root: workspaceRoot,
+        observer_telemetry: true,
       },
     });
   };
@@ -512,6 +516,13 @@ export async function runHub({ workspaceRoot, feedFile, loadState, watchedPaths
       recordInteractiveTransition(before, { source: "keyboard" });
       return;
     }
+    if (key.name === "a") {
+      const before = captureRuntimeState();
+      state.view = "adapters";
+      rerender();
+      recordInteractiveTransition(before, { source: "keyboard" });
+      return;
+    }
     if (key.name === "r") {
       const before = captureRuntimeState();
       refresh();

package/src/tui/commands.js

@@ -1,5 +1,5 @@
 export function completeCommand(input, runIds) {
-  const commands = ["help", "quit", "refresh", "hub", "run", "inspect", "compare", "history", "select", "next", "prev", "focus", "post", "handoff", "todo", "ledger", "event"];
+  const commands = ["help", "quit", "refresh", "hub", "run", "inspect", "compare", "history", "adapters", "select", "next", "prev", "focus", "post", "handoff", "todo", "ledger", "event"];
   const parts = input.split(/\s+/);
   const token = parts.at(-1) ?? "";
   const options = parts.length > 1 ? [...runIds, ...commands] : [...commands, ...runIds];
@@ -107,6 +107,9 @@ export function executeCommand(command, state) {
     const compareTarget = positionals[0];
     return { patch: { view: "compare", compareTarget }, message: "Switched to compare view." };
   }
+  if (name === "adapters") {
+    return { patch: { view: "adapters" }, message: "Switched to adapters view." };
+  }
   if (name === "history") {
     return { patch: { view: "history" }, message: "Switched to history view." };
   }