harnery 0.32.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,12 @@ 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";
 
 interface HeartbeatRow {
@@ -54,14 +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;
-  task_updated_at?: string;
+  activity?: AgentActivity;
+  task_state?: TaskState;
+  task_state_reason?: string;
+  task_updated_at?: string | null;
   suggested_session_name?: string;
-  turn_summary?: string;
+  session_name_seen_for?: string;
   workflow_run_id?: string;
 }
 
@@ -79,6 +86,12 @@ export interface PromptContextOpts {
   /** When true, append the non-deduplicated Codex status-footer reminder.
    * The caller enables this only for human-facing Codex sessions. */
   statusFooterNudge?: boolean;
+  /** Adapter id whose Stop hook ENFORCES the end-of-turn ritual (task_set +
+   * status check). When set, append a fresh per-prompt reminder of that
+   * contract so the model satisfies it before ending the turn instead of
+   * being bounced into a retry. Not hash-deduped, same rationale as the
+   * status footer. */
+  turnRitualNudge?: string;
 }
 
 /**
@@ -98,6 +111,7 @@ export function renderPromptContext(opts: PromptContextOpts): string {
     sessionNameNudge,
     taskNudge,
     statusFooterNudge,
+    turnRitualNudge,
   } = opts;
   const sections: string[] = [];
 
@@ -130,11 +144,43 @@ export function renderPromptContext(opts: PromptContextOpts): string {
     if (statusMsg) sections.push(statusMsg);
   }
 
+  // 5. Adapters whose Stop hook ENFORCES the turn ritual get a fresh reminder
+  // on every prompt. Reminding before the reply is drafted is far cheaper than
+  // the bounce-and-retry the Stop hook otherwise forces: enforcement-only
+  // compliance was measured missing on a double-digit share of turns. Not
+  // hash-deduped for the same reason as the Codex footer.
+  if (turnRitualNudge) {
+    const ritualMsg = renderTurnRitualReminder(coordRoot, instanceId, turnRitualNudge);
+    if (ritualMsg) sections.push(ritualMsg);
+  }
+
   return sections.join("\n\n");
 }
 
+function renderTurnRitualReminder(
+  coordRoot: string,
+  selfInstanceId: string,
+  adapter: string,
+): string {
+  const hb = readLiveCoordinationRow(coordRoot, selfInstanceId);
+  if (!hb || hb.kind === "subagent" || hb.kind === "transient" || hb.workflow_run_id) return "";
+
+  const bin = resolveBinName(coordRoot);
+  const statusCommand = endOfTurnStatusCommand(coordRoot);
+  // Claude Code renders the status box only if the reply carries it; Cursor
+  // shows the box inline on its own, so it is never asked for a second copy.
+  const paste =
+    adapter === "claude-code"
+      ? " and paste its output verbatim in a fenced code block at the end of your reply"
+      : "";
+  return (
+    `Turn ritual (Stop-enforced): on any turn that uses tools, run \`${bin} agents set-task "<short focus>"\` at some point during the turn (required every turn, even when the focus is unchanged; pass an empty string when there is no meaningful focus), then make \`${statusCommand}\` your final tool call${paste}. ` +
+    "A turn that ends without these is bounced by the Stop hook and costs a retry."
+  );
+}
+
 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);
@@ -156,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.
@@ -179,15 +219,17 @@ function computeFocusNudgeIfChanged(
   let message = "";
   let nudgeKind = "";
 
-  if (opts.sessionNameNudge && !hb.suggested_session_name) {
+  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 =
-      `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. " +
-      "Then continue with the task; that `set-task` also satisfies this turn's focus declaration.";
+    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`, 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;
     nudgeKind = "task-unset";
@@ -237,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 "";
 
@@ -269,6 +307,9 @@ function computePeerTableIfChanged(
       started_at: p.started_at ?? null,
       files_touched: Array.from(p.files_touched ?? []).sort(),
       platform: p.platform ?? null,
+      activity: p.activity ?? "unknown",
+      task_state: p.task_state ?? "active",
+      task_state_reason: p.task_state_reason ?? null,
     }))
     .sort((a, b) => (a.instance_id ?? "").localeCompare(b.instance_id ?? ""));
   // Remote basis: machine + per-agent identity/task/files (published_at is
@@ -279,6 +320,9 @@ function computePeerTableIfChanged(
       instance_id: a.instance_id,
       name: a.name ?? null,
       task: a.task ?? null,
+      activity: a.activity,
+      task_state: a.task_state,
+      task_state_reason: a.task_state_reason ?? null,
       files_touched: Array.from(a.files_touched ?? []).sort(),
     })),
   }));
@@ -392,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();
@@ -493,17 +529,24 @@ function renderSubtable(
 
 function formatRow(r: HeartbeatRow & { display_files: string[] }, nowSec: number): string {
   const taskPart = r.task ? ` "${r.task.slice(0, 60)}"` : "";
+  const statePart = formatState(r);
   // Fall back started_at → last_heartbeat; if neither is a valid timestamp,
   // show "age unknown" rather than the epoch-derived "20608d ago" ghost.
   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}   (${ageFrom}, ${filesPart}${lastActivity})${turnSummary}`;
+  return `  - agent-${label}${taskPart}   (${statePart}, ${ageFrom}, ${filesPart})`;
+}
+
+function formatState(r: HeartbeatRow): string {
+  const activity = r.activity ?? "unknown";
+  const lifecycle = r.task_state ?? "active";
+  const reason =
+    lifecycle === "blocked" && r.task_state_reason ? `: ${r.task_state_reason.slice(0, 80)}` : "";
+  return `activity=${activity}, lifecycle=${lifecycle}${reason}`;
 }
 
 function fmtFiles(files: string[]): string {
@@ -512,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 {