harnery 0.33.0 → 0.34.0

package/src/core/agents/live-lifecycle-v3.ts

@@ -0,0 +1,140 @@
+import { randomUUID } from "node:crypto";
+import type { Adapter } from "../adapter.ts";
+import { buildEventV3 } from "../events/v3/builder.ts";
+import { normalizeNativeIdV3 } from "../events/v3/canonical.ts";
+import type { EventV3 } from "../events/v3/contract.ts";
+import { readEventV3ControlState } from "../events/v3/control.ts";
+import { fingerprintContextV3 } from "../events/v3/fingerprint-keys.ts";
+import {
+  liveInstanceIdV3,
+  livePlatformV3,
+  resolveLiveEventLedgerRouteV3,
+} from "../events/v3/live-routing.ts";
+import { readHookProducerStateV3 } from "../events/v3/producers/recorder.ts";
+import { writeEventV3 } from "../events/v3/writer.ts";
+import { LiveCoordinationAuthorityV3Error } from "./live-authority-v3.ts";
+import { liveCoordinationAdapterV3 } from "./state/live-coordination-view.ts";
+
+export type LiveLifecycleObservationV3Result = { state: "recorded"; event: EventV3 };
+
+interface LiveLifecycleObservationBaseV3 {
+  coordRoot: string;
+  owner: string;
+  nativeSessionId: string;
+  adapter: Adapter;
+  observedAt?: string;
+}
+
+export function recordLiveSweepObservationV3(
+  input: LiveLifecycleObservationBaseV3 & {
+    observation: "stale_heartbeat" | "killed" | "unparseable_heartbeat" | "missing_timestamp";
+    ageMs: number;
+  },
+): LiveLifecycleObservationV3Result {
+  return recordObservation(input, "lifecycle.sweep_observed", {
+    subject_instance_id: liveInstanceIdV3(input.owner),
+    observation: input.observation,
+    provisional: true,
+    age_ms: Math.max(0, Math.floor(input.ageMs)),
+  });
+}
+
+export function recordLiveResumeObservationV3(
+  input: LiveLifecycleObservationBaseV3,
+): LiveLifecycleObservationV3Result {
+  const normalized = withAttestedAdapter(input);
+  const hook = requireHookState(normalized);
+  return recordObservation(normalized, "session.resumed", {
+    prior_generation_id: hook.generation_id,
+    continuity: "native",
+    evidence_reference: "heartbeat_recreated",
+  });
+}
+
+function recordObservation<T extends "lifecycle.sweep_observed" | "session.resumed">(
+  input: LiveLifecycleObservationBaseV3,
+  eventType: T,
+  payload: T extends "lifecycle.sweep_observed"
+    ? {
+        subject_instance_id: `inst_${string}`;
+        observation: string;
+        provisional: true;
+        age_ms: number;
+      }
+    : {
+        prior_generation_id: `gen_${string}`;
+        continuity: "native";
+        evidence_reference: string;
+      },
+): LiveLifecycleObservationV3Result {
+  const route = resolveLiveEventLedgerRouteV3(input.coordRoot);
+  if (route.state === "blocked") throw new LiveCoordinationAuthorityV3Error(route.reason);
+  input = withAttestedAdapter(input);
+  const control = readEventV3ControlState(input.coordRoot);
+  if (control.state !== route.mode) {
+    throw new LiveCoordinationAuthorityV3Error("control_state_changed");
+  }
+  const hook = requireHookState(input);
+  if (!hook.last_event_id) throw new LiveCoordinationAuthorityV3Error("generation_has_no_event");
+  const rootId = control.genesis.event.scope.root_id as `root_${string}`;
+  const context = fingerprintContextV3(
+    input.coordRoot,
+    rootId,
+    hook.generation_id,
+    control.genesis.profile.privacy_key_epoch,
+  );
+  const nativeObservationId = `${eventType}\0${input.owner}\0${input.observedAt ?? "now"}\0${JSON.stringify(payload)}`;
+  const common = {
+    producer: {
+      producer_id: "prd_agent-coord-lifecycle" as const,
+      boot_id: `boot_${randomUUID()}` as const,
+      sequence: 1,
+      component: "agent-coord" as const,
+      build_id: route.build_id,
+      platform: livePlatformV3(),
+    },
+    scope: {
+      root_id: rootId,
+      instance_id: hook.instance_id,
+      session_id: hook.session_id,
+      generation_id: hook.generation_id,
+    },
+    attestation_id: hook.attestation_id,
+    links: { caused_by: [hook.last_event_id] },
+    provenance: {
+      source_event: `agent-coord.${eventType}`,
+      attestation: "derived" as const,
+      confidence: "exact" as const,
+      source_record_id: normalizeNativeIdV3(
+        context,
+        `agent-coord.${eventType}`,
+        nativeObservationId,
+      ),
+      attribution: {
+        method: "heartbeat_match" as const,
+        state: "verified" as const,
+        observer_instance_id: hook.instance_id,
+        subject_instance_id: hook.instance_id,
+      },
+    },
+    observed_at: input.observedAt,
+    monotonic_ns: process.hrtime.bigint().toString(),
+  };
+  const event = buildEventV3(eventType, { ...common, payload } as never) as EventV3;
+  writeEventV3(input.coordRoot, event);
+  return { state: "recorded", event };
+}
+
+function withAttestedAdapter<T extends LiveLifecycleObservationBaseV3>(input: T): T {
+  const adapter = liveCoordinationAdapterV3(input.coordRoot, input.owner);
+  if (!adapter) return input;
+  return { ...input, adapter };
+}
+
+function requireHookState(input: LiveLifecycleObservationBaseV3) {
+  const hook = readHookProducerStateV3(input.coordRoot, input.adapter, input.nativeSessionId);
+  if (!hook || hook.instance_id !== liveInstanceIdV3(input.owner)) {
+    throw new LiveCoordinationAuthorityV3Error("hook_generation_not_joinable");
+  }
+  return hook;
+}

package/src/core/agents/live-observation-v3.ts

@@ -0,0 +1,216 @@
+import { randomUUID } from "node:crypto";
+import type { Adapter } from "../adapter.ts";
+import { buildEventV3 } from "../events/v3/builder.ts";
+import {
+  canonicalJsonV3,
+  fingerprintV3,
+  normalizeNativeIdV3,
+  sha256V3,
+} from "../events/v3/canonical.ts";
+import type { EventTypeV3, EventV3 } from "../events/v3/contract.ts";
+import { readEventV3ControlState } from "../events/v3/control.ts";
+import { readCoordinationViewV3 } from "../events/v3/coordination-view.ts";
+import { fingerprintContextV3 } from "../events/v3/fingerprint-keys.ts";
+import type { LiveCoordinationObservationV3 } from "../events/v3/live-observation.ts";
+import {
+  liveInstanceIdV3,
+  livePlatformV3,
+  resolveLiveEventLedgerRouteV3,
+} from "../events/v3/live-routing.ts";
+import { readHookProducerStateV3 } from "../events/v3/producers/recorder.ts";
+import { writeEventV3 } from "../events/v3/writer.ts";
+import { LiveCoordinationAuthorityV3Error } from "./live-authority-v3.ts";
+import { liveCoordinationAdapterV3 } from "./state/live-coordination-view.ts";
+
+export type { LiveCoordinationObservationV3 } from "../events/v3/live-observation.ts";
+
+export interface RecordLiveCoordinationObservationV3Input {
+  coordRoot: string;
+  owner: string;
+  nativeSessionId: string;
+  adapter: Adapter;
+  observation: LiveCoordinationObservationV3;
+  observationId?: string;
+  observedAt?: string;
+}
+
+export interface RecordLiveCoordinationObservationV3Result {
+  state: "recorded";
+  event: EventV3;
+}
+
+/**
+ * Append a non-authority coordination observation against one attested live
+ * generation. Raw message and record bodies are used only to derive keyed
+ * fingerprints or content digests; they never enter the ledger payload.
+ */
+export function recordLiveCoordinationObservationV3(
+  input: RecordLiveCoordinationObservationV3Input,
+): RecordLiveCoordinationObservationV3Result {
+  const route = resolveLiveEventLedgerRouteV3(input.coordRoot);
+  if (route.state === "blocked") throw new LiveCoordinationAuthorityV3Error(route.reason);
+  const control = readEventV3ControlState(input.coordRoot);
+  if (control.state !== route.mode) {
+    throw new LiveCoordinationAuthorityV3Error("control_state_changed");
+  }
+  const adapter = liveCoordinationAdapterV3(input.coordRoot, input.owner) ?? input.adapter;
+  const hook = readHookProducerStateV3(input.coordRoot, adapter, input.nativeSessionId);
+  if (
+    !hook ||
+    hook.terminal ||
+    !hook.last_event_id ||
+    hook.instance_id !== liveInstanceIdV3(input.owner)
+  ) {
+    throw new LiveCoordinationAuthorityV3Error("hook_generation_not_joinable");
+  }
+
+  const rootId = control.genesis.event.scope.root_id as `root_${string}`;
+  const fingerprintContext = fingerprintContextV3(
+    input.coordRoot,
+    rootId,
+    hook.generation_id,
+    control.genesis.profile.privacy_key_epoch,
+  );
+  const observationId = input.observationId ?? `${input.observation.event_type}-${randomUUID()}`;
+  const subject =
+    "subject" in input.observation && input.observation.subject
+      ? liveInstanceIdV3(input.observation.subject)
+      : hook.instance_id;
+  const common = {
+    producer: {
+      producer_id: "prd_agent-coord-observation" as const,
+      boot_id: `boot_${randomUUID()}` as const,
+      sequence: 1,
+      component: "agent-coord" as const,
+      build_id: route.build_id,
+      platform: livePlatformV3(),
+    },
+    scope: {
+      root_id: rootId,
+      instance_id: hook.instance_id,
+      session_id: hook.session_id,
+      generation_id: hook.generation_id,
+    },
+    attestation_id: hook.attestation_id,
+    links: { caused_by: [hook.last_event_id] },
+    provenance: {
+      source_event: `agent-coord.${input.observation.event_type}`,
+      attestation: "derived" as const,
+      confidence: "exact" as const,
+      source_record_id: normalizeNativeIdV3(
+        fingerprintContext,
+        "agent-coord.observation",
+        observationId,
+      ),
+      attribution: {
+        method: "session_env" as const,
+        state: "verified" as const,
+        observer_instance_id: hook.instance_id,
+        subject_instance_id: subject,
+      },
+    },
+    observed_at: input.observedAt,
+    monotonic_ns: process.hrtime.bigint().toString(),
+  };
+
+  const observation = input.observation;
+  let event: EventV3;
+  switch (observation.event_type) {
+    case "coord.status_observed":
+      event = buildEventV3("coord.status_observed", {
+        ...common,
+        payload: {
+          observer_instance_id: hook.instance_id,
+          subject_instance_id: subject,
+          status: safeToken(observation.status),
+        },
+      });
+      break;
+    case "coord.presence_changed": {
+      // The ledger projection, not the independently versioned presence file,
+      // owns the canonical prior state. Omitting an unknown first prior keeps
+      // the transition honest and avoids manufacturing a history.
+      const projectedPrior = readCoordinationViewV3(input.coordRoot).instances[hook.instance_id]
+        ?.presence_state;
+      event = buildEventV3("coord.presence_changed", {
+        ...common,
+        payload: {
+          actor_instance_id: hook.instance_id,
+          subject_instance_id: hook.instance_id,
+          ...(projectedPrior ? { prior_state: safeToken(projectedPrior) } : {}),
+          new_state: safeToken(observation.new_state),
+          reason: reasonCode(observation.reason),
+          authority: {},
+        },
+      });
+      break;
+    }
+    case "coord.message_observed":
+      event = buildEventV3("coord.message_observed", {
+        ...common,
+        payload: {
+          message_id: safeToken(observation.message_id ?? `msg_${randomUUID()}`),
+          direction: observation.direction,
+          peer_instance_id: subject,
+          body_length: Buffer.byteLength(observation.body, "utf8"),
+          body_fingerprint: fingerprintV3(
+            fingerprintContext,
+            "coord.message.body",
+            observation.body,
+            "generation",
+          ),
+        },
+      });
+      break;
+    case "council.state_changed":
+      event = buildEventV3("council.state_changed", {
+        ...common,
+        payload: {
+          council_id: safeToken(observation.council_id),
+          ...(observation.prior_state ? { prior_state: safeToken(observation.prior_state) } : {}),
+          new_state: safeToken(observation.new_state),
+          record_digest: sha256V3(canonicalJsonV3(observation.record)),
+        },
+      });
+      break;
+    case "decision.state_changed": {
+      const projectedDecisionPrior = readCoordinationViewV3(input.coordRoot).decisions[
+        observation.decision_id
+      ];
+      event = buildEventV3("decision.state_changed", {
+        ...common,
+        payload: {
+          decision_id: safeToken(observation.decision_id),
+          ...(projectedDecisionPrior ? { prior_state: safeToken(projectedDecisionPrior) } : {}),
+          new_state: safeToken(observation.new_state),
+          record_digest: sha256V3(canonicalJsonV3(observation.record)),
+          authority: { record_id: safeToken(observation.decision_id) },
+        },
+      });
+      break;
+    }
+  }
+  writeEventV3(input.coordRoot, event);
+  return { state: "recorded", event };
+}
+
+function safeToken(value: string): string {
+  const normalized = value.normalize("NFC");
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._:/+-]{0,127}$/.test(normalized)) {
+    throw new LiveCoordinationAuthorityV3Error(`invalid_safe_token:${value}`);
+  }
+  return normalized;
+}
+
+function reasonCode(value: string): string {
+  const normalized = value.normalize("NFC");
+  if (!/^[a-z0-9][a-z0-9._-]{0,79}$/.test(normalized)) {
+    throw new LiveCoordinationAuthorityV3Error(`invalid_reason_code:${value}`);
+  }
+  return normalized;
+}
+
+export type LiveCoordinationObservationEventTypeV3 = Extract<
+  EventTypeV3,
+  LiveCoordinationObservationV3["event_type"]
+>;

package/src/core/agents/render/prompt-context.ts

@@ -3,7 +3,7 @@
  * council-pending hash-dedup, the cross-adapter first-session naming nudge,
  * the Cursor/Codex set-task staleness nudge, and the Codex status-footer
  * reminder.
- * agent-hook's user_prompt.submit post-emit handler calls this
+ * agent-hook's turn.started post-emit handler calls this
  * and forwards the result as the adapter-shaped additionalContext payload.
  *
  * Four subsections combined into one additionalContext payload:
@@ -12,9 +12,9 @@
  *      + sorted(files_touched) + platform, sorted by instance_id).
  *   2. Council pending: pending open-council IDs hashed; re-emits when the
  *      ID set changes.
- *   3. Focus nudge. Until the session has produced its suggested name (first
- *      non-empty set-task), tells every adapter — on every prompt, undeduped —
- *      to reproduce set-task's suggested session name in a fenced code block.
+ *   3. Focus nudge. Until the session has displayed its current suggested
+ *      name, tells every adapter on every prompt to send the exact fenced block
+ *      before prose or another tool call.
  *      Cursor/Codex additionally get the existing unset/stale-task reminder
  *      because their Stop hooks do not enforce task declarations as reliably
  *      as Claude Code's.
@@ -45,6 +45,11 @@ import { join } from "node:path";
 import { coordEnv } from "../../../lib/env.ts";
 import { endOfTurnStatusCommand, resolveBinName } from "../../config.ts";
 import { type RemoteMachine, readRemoteMachines } from "../../presence/index.ts";
+import { sessionNameDisplayBlock, sessionNameDisplayPending } from "../session-name-display.ts";
+import {
+  readLiveCoordinationRow,
+  readLiveCoordinationRows,
+} from "../state/live-coordination-view.ts";
 import type { AgentActivity, TaskState } from "../state/session-state.ts";
 import { formatPendingCouncils } from "./session-context.ts";
 
@@ -55,18 +60,15 @@ interface HeartbeatRow {
   session_id?: string;
   started_at?: string;
   last_heartbeat?: string;
-  last_tool?: string;
-  last_tool_target?: string;
   files_touched?: string[];
   platform?: string;
   task?: string;
   activity?: AgentActivity;
   task_state?: TaskState;
   task_state_reason?: string;
-  task_updated_at?: string;
+  task_updated_at?: string | null;
   suggested_session_name?: string;
   session_name_seen_for?: string;
-  turn_summary?: string;
   workflow_run_id?: string;
 }
 
@@ -160,7 +162,7 @@ function renderTurnRitualReminder(
   selfInstanceId: string,
   adapter: string,
 ): string {
-  const hb = readHeartbeat(join(coordRoot, ".harnery", "active", `${selfInstanceId}.json`));
+  const hb = readLiveCoordinationRow(coordRoot, selfInstanceId);
   if (!hb || hb.kind === "subagent" || hb.kind === "transient" || hb.workflow_run_id) return "";
 
   const bin = resolveBinName(coordRoot);
@@ -178,7 +180,7 @@ function renderTurnRitualReminder(
 }
 
 function renderStatusFooterReminder(coordRoot: string, selfInstanceId: string): string {
-  const hb = readHeartbeat(join(coordRoot, ".harnery", "active", `${selfInstanceId}.json`));
+  const hb = readLiveCoordinationRow(coordRoot, selfInstanceId);
   if (!hb || hb.kind === "subagent" || hb.kind === "transient" || hb.workflow_run_id) return "";
 
   const statusCommand = endOfTurnStatusCommand(coordRoot);
@@ -200,14 +202,8 @@ function computeFocusNudgeIfChanged(
   selfInstanceId: string,
   opts: { sessionNameNudge: boolean; taskNudge: boolean },
 ): string {
-  const hbPath = join(coordRoot, ".harnery", "active", `${selfInstanceId}.json`);
-  if (!existsSync(hbPath)) return "";
-  let hb: HeartbeatRow;
-  try {
-    hb = JSON.parse(readFileSync(hbPath, "utf8"));
-  } catch {
-    return "";
-  }
+  const hb = readLiveCoordinationRow(coordRoot, selfInstanceId);
+  if (!hb) return "";
 
   const hashFile = join(coordRoot, ".harnery", `.last-task-nudge-hash.${selfInstanceId}`);
   // Subagents and workflow children have no human-owned session/tab to rename.
@@ -223,20 +219,16 @@ function computeFocusNudgeIfChanged(
   let message = "";
   let nudgeKind = "";
 
-  if (
-    opts.sessionNameNudge &&
-    (!hb.suggested_session_name ||
-      (hb.session_name_seen_for !== undefined &&
-        hb.suggested_session_name !== hb.session_name_seen_for))
-  ) {
+  const pendingSessionName = sessionNameDisplayPending(hb);
+  if (opts.sessionNameNudge && (!hb.suggested_session_name || pendingSessionName)) {
     // Keyed on "a name was ever produced", not task_updated_at: a bare clear
     // as the first declaration must not end the naming window.
     needsNudge = true;
     nudgeKind = "session-name";
-    message = hb.suggested_session_name
-      ? `This session's lifecycle changed its suggested name. Reproduce this value by itself inside a fenced code block at the very top of your reply so the operator can one-click-copy it as the session/tab title: ${hb.suggested_session_name}`
+    message = pendingSessionName
+      ? `This session name is still pending display. Before any prose or another tool call, send this exact block as your next assistant text:\n\n${sessionNameDisplayBlock(pendingSessionName)}`
       : `This session has no name yet: run \`${bin} agents set-task "<2-5 word session topic>"\` as your first tool call. ` +
-        "When it returns `first_of_session: true`, reproduce its `suggested_session_name` value by itself inside a fenced code block at the very top of your reply so the operator can one-click-copy it as the session/tab title. " +
+        "When it returns `first_of_session: true`, send its `suggested_session_name` as the exact fenced block requested by the PostToolUse instruction before any prose or another tool call. " +
         "Then continue with the task; that `set-task` also satisfies this turn's focus declaration.";
   } else if (opts.taskNudge && !taskValue) {
     needsNudge = true;
@@ -287,25 +279,21 @@ function computePeerTableIfChanged(
   selfInstanceId: string,
   selfSessionIdFallback: string,
 ): string {
-  const activeDir = join(coordRoot, ".harnery", "active");
-  if (!existsSync(activeDir)) return "";
-
   // Read self heartbeat for session_id (group key); fall back to the caller's hint.
   let mySessionId = selfSessionIdFallback;
-  const selfHb = readHeartbeat(join(activeDir, `${selfInstanceId}.json`));
+  const rows = readLiveCoordinationRows(coordRoot);
+  const selfHb = readLiveCoordinationRow(coordRoot, selfInstanceId);
   if (selfHb?.session_id) mySessionId = selfHb.session_id;
   if (!mySessionId) return "";
 
-  // Collect peer heartbeats.
-  const peers: HeartbeatRow[] = [];
-  for (const f of readdirSync(activeDir)) {
-    if (!f.endsWith(".json")) continue;
-    const hb = readHeartbeat(join(activeDir, f));
-    if (!hb?.instance_id || hb.instance_id === selfInstanceId) continue;
-    peers.push(hb);
-  }
+  // Collect peers from the selected ledger route. Under V3 this is the
+  // canonical projection, never the legacy active directory.
+  const peers: HeartbeatRow[] = rows.filter(
+    (heartbeat) => heartbeat.instance_id && heartbeat.instance_id !== selfInstanceId,
+  );
   // Cross-machine presence (ADR 0016): sessions on other machines, from the
-  // locally-fetched presence refs. Advisory (no claim blocking in v1).
+  // locally-fetched presence refs. Advisory only; remote presence never grants
+  // claim authority.
   const remote = readRemoteMachinesSafe(coordRoot);
   if (peers.length === 0 && remote.length === 0) return "";
 
@@ -448,14 +436,6 @@ function computeCouncilPendingIfChanged(
 
 /* ---------- helpers ---------- */
 
-function readHeartbeat(path: string): HeartbeatRow | null {
-  try {
-    return JSON.parse(readFileSync(path, "utf8")) as HeartbeatRow;
-  } catch {
-    return null;
-  }
-}
-
 function safeRead(path: string): string {
   try {
     return readFileSync(path, "utf8").trim();
@@ -555,12 +535,10 @@ function formatRow(r: HeartbeatRow & { display_files: string[] }, nowSec: number
   const startedSec = parseIsoSec(r.started_at) ?? parseIsoSec(r.last_heartbeat);
   const ageFrom = startedSec === null ? "age unknown" : fmtAge(nowSec - startedSec);
   const filesPart = fmtFiles(r.display_files);
-  const lastActivity = fmtLastActivity(r, nowSec);
-  const turnSummary = r.turn_summary ? `\n    last turn: ${r.turn_summary.slice(0, 80)}` : "";
   // Prefer a short instance_id over a bare "unknown" so an incomplete row is
   // still identifiable.
   const label = r.name ?? (r.instance_id ? r.instance_id.slice(0, 8) : "unknown");
-  return `  - agent-${label}${taskPart}   (${statePart}, ${ageFrom}, ${filesPart}${lastActivity})${turnSummary}`;
+  return `  - agent-${label}${taskPart}   (${statePart}, ${ageFrom}, ${filesPart})`;
 }
 
 function formatState(r: HeartbeatRow): string {
@@ -577,15 +555,6 @@ function fmtFiles(files: string[]): string {
   return `holds: ${files.slice(0, 3).join(", ")}, +${files.length - 3} more`;
 }
 
-function fmtLastActivity(r: HeartbeatRow, nowSec: number): string {
-  if (!r.last_tool) return "";
-  const lastTs = parseIsoSec(r.last_heartbeat) ?? parseIsoSec(r.started_at);
-  const tail = r.last_tool_target ? ` ${r.last_tool_target.slice(0, 60)}` : "";
-  // No valid timestamp → render the tool without an absurd age.
-  if (lastTs === null) return `, last: ${r.last_tool}${tail}`;
-  return `, last: ${r.last_tool}${tail} ${fmtAge(nowSec - lastTs)}`;
-}
-
 /** Epoch-seconds for an ISO string, or null when missing/unparseable (so callers
  * can render "age unknown" instead of an epoch-derived absurd age). */
 function parseIsoSec(iso: string | undefined): number | null {

package/src/core/agents/render/session-context.ts

@@ -1,6 +1,6 @@
 /**
  * SessionStart UX renderer: combines the peer table, the wiring check, and
- * the pending-council formatter so agent-hook session.start can emit the
+ * the pending-council formatter so agent-hook session.started can emit the
  * combined `systemMessage` JSON directly.
  *
  * Outputs a Claude Code SessionStart hookSpecificOutput.additionalContext
@@ -13,6 +13,7 @@ import { join } from "node:path";
 import { resolveBinName, resolveHooksSetupHint } from "../../config.ts";
 import { harneryVersion, loadAdapterWiring } from "../../hooks/adapter/wiring.ts";
 import { readRemoteMachines } from "../../presence/index.ts";
+import { readLiveCoordinationRows } from "../state/live-coordination-view.ts";
 import { readForkParent } from "../state/names.ts";
 import type { AgentActivity, TaskState } from "../state/session-state.ts";
 
@@ -23,15 +24,12 @@ interface HeartbeatRow {
   session_id?: string;
   started_at?: string;
   last_heartbeat?: string;
-  last_tool?: string;
-  last_tool_target?: string;
   files_touched?: string[];
   platform?: string;
   task?: string;
   activity?: AgentActivity;
   task_state?: TaskState;
   task_state_reason?: string;
-  turn_summary?: string;
 }
 
 export interface RenderOpts {
@@ -154,22 +152,11 @@ function formatRemoteMachines(coordRoot: string): string {
   }
 }
 
-/** Read all peer heartbeats from .harnery/active/, excluding self. */
+/** Read peers from the selected ledger route, excluding self. */
 function readActivePeers(coordRoot: string, selfInstanceId: string): HeartbeatRow[] {
-  const out: HeartbeatRow[] = [];
-  const dir = join(coordRoot, ".harnery", "active");
-  if (!existsSync(dir)) return out;
-  for (const f of readdirSync(dir)) {
-    if (!f.endsWith(".json")) continue;
-    try {
-      const hb = JSON.parse(readFileSync(join(dir, f), "utf8")) as HeartbeatRow;
-      if (!hb.instance_id || hb.instance_id === selfInstanceId) continue;
-      out.push(hb);
-    } catch {
-      /* skip */
-    }
-  }
-  return out;
+  return readLiveCoordinationRows(coordRoot).filter(
+    (heartbeat) => heartbeat.instance_id && heartbeat.instance_id !== selfInstanceId,
+  );
 }
 
 /**
@@ -244,9 +231,7 @@ function formatRow(r: HeartbeatRow & { display_files: string[] }, nowSec: number
     lifecycle === "blocked" && r.task_state_reason ? `: ${r.task_state_reason.slice(0, 80)}` : "";
   const ageFrom = fmtAge(nowSec - parseIsoSec(r.started_at));
   const filesPart = fmtFiles(r.display_files);
-  const lastActivity = fmtLastActivity(r, nowSec);
-  const turnSummary = r.turn_summary ? `\n    last turn: ${r.turn_summary.slice(0, 80)}` : "";
-  return `  - agent-${r.name ?? "unknown"}${taskPart}   (activity=${activity}, lifecycle=${lifecycle}${reason}, ${ageFrom}, ${filesPart}${lastActivity})${turnSummary}`;
+  return `  - agent-${r.name ?? "unknown"}${taskPart}   (activity=${activity}, lifecycle=${lifecycle}${reason}, ${ageFrom}, ${filesPart})`;
 }
 
 function fmtFiles(files: string[]): string {
@@ -255,14 +240,6 @@ function fmtFiles(files: string[]): string {
   return `holds: ${files.slice(0, 3).join(", ")}, +${files.length - 3} more`;
 }
 
-function fmtLastActivity(r: HeartbeatRow, nowSec: number): string {
-  if (!r.last_tool) return "";
-  const lastTs = parseIsoSec(r.last_heartbeat ?? r.started_at);
-  const ageSec = nowSec - lastTs;
-  const tail = r.last_tool_target ? ` ${r.last_tool_target.slice(0, 60)}` : "";
-  return `, last: ${r.last_tool}${tail} ${fmtAge(ageSec)}`;
-}
-
 function parseIsoSec(iso: string | undefined): number {
   if (!iso) return 0;
   const ms = Date.parse(iso);
@@ -360,7 +337,9 @@ function extractFirstSubmodule(gitmodulesPath: string): string | null {
  * superproject) via a `git rev-parse --git-dir` vs `--git-common-dir` check.
  */
 function isLinkedWorktree(coordRoot: string): boolean {
-  const dir = spawnSync("git", ["-C", coordRoot, "rev-parse", "--git-dir"], { encoding: "utf8" });
+  const dir = spawnSync("git", ["-C", coordRoot, "rev-parse", "--git-dir"], {
+    encoding: "utf8",
+  });
   const common = spawnSync("git", ["-C", coordRoot, "rev-parse", "--git-common-dir"], {
     encoding: "utf8",
   });