harnery 0.32.0 → 0.34.0

package/dist/core/agents/live-lifecycle-v3.js

@@ -0,0 +1,91 @@
+import { randomUUID } from "node:crypto";
+import { buildEventV3 } from "../events/v3/builder.js";
+import { normalizeNativeIdV3 } from "../events/v3/canonical.js";
+import { readEventV3ControlState } from "../events/v3/control.js";
+import { fingerprintContextV3 } from "../events/v3/fingerprint-keys.js";
+import { liveInstanceIdV3, livePlatformV3, resolveLiveEventLedgerRouteV3, } from "../events/v3/live-routing.js";
+import { readHookProducerStateV3 } from "../events/v3/producers/recorder.js";
+import { writeEventV3 } from "../events/v3/writer.js";
+import { LiveCoordinationAuthorityV3Error } from "./live-authority-v3.js";
+import { liveCoordinationAdapterV3 } from "./state/live-coordination-view.js";
+export function recordLiveSweepObservationV3(input) {
+    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) {
+    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(input, eventType, payload) {
+    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;
+    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",
+            boot_id: `boot_${randomUUID()}`,
+            sequence: 1,
+            component: "agent-coord",
+            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",
+            confidence: "exact",
+            source_record_id: normalizeNativeIdV3(context, `agent-coord.${eventType}`, nativeObservationId),
+            attribution: {
+                method: "heartbeat_match",
+                state: "verified",
+                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 });
+    writeEventV3(input.coordRoot, event);
+    return { state: "recorded", event };
+}
+function withAttestedAdapter(input) {
+    const adapter = liveCoordinationAdapterV3(input.coordRoot, input.owner);
+    if (!adapter)
+        return input;
+    return { ...input, adapter };
+}
+function requireHookState(input) {
+    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/dist/core/agents/live-observation-v3.d.ts

@@ -0,0 +1,25 @@
+import type { Adapter } from "../adapter.js";
+import type { EventTypeV3, EventV3 } from "../events/v3/contract.js";
+import type { LiveCoordinationObservationV3 } from "../events/v3/live-observation.js";
+export type { LiveCoordinationObservationV3 } from "../events/v3/live-observation.js";
+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 declare function recordLiveCoordinationObservationV3(input: RecordLiveCoordinationObservationV3Input): RecordLiveCoordinationObservationV3Result;
+export type LiveCoordinationObservationEventTypeV3 = Extract<EventTypeV3, LiveCoordinationObservationV3["event_type"]>;
+//# sourceMappingURL=live-observation-v3.d.ts.map

package/dist/core/agents/live-observation-v3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-observation-v3.d.ts","sourceRoot":"","sources":["../../../src/core/agents/live-observation-v3.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAQ7C,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAIrE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,kCAAkC,CAAC;AAWtF,YAAY,EAAE,6BAA6B,EAAE,MAAM,kCAAkC,CAAC;AAEtF,MAAM,WAAW,wCAAwC;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,6BAA6B,CAAC;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,yCAAyC;IACxD,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,wCAAwC,GAC9C,yCAAyC,CAkJ3C;AAkBD,MAAM,MAAM,sCAAsC,GAAG,OAAO,CAC1D,WAAW,EACX,6BAA6B,CAAC,YAAY,CAAC,CAC5C,CAAC"}

package/dist/core/agents/live-observation-v3.js

@@ -0,0 +1,157 @@
+import { randomUUID } from "node:crypto";
+import { buildEventV3 } from "../events/v3/builder.js";
+import { canonicalJsonV3, fingerprintV3, normalizeNativeIdV3, sha256V3, } from "../events/v3/canonical.js";
+import { readEventV3ControlState } from "../events/v3/control.js";
+import { readCoordinationViewV3 } from "../events/v3/coordination-view.js";
+import { fingerprintContextV3 } from "../events/v3/fingerprint-keys.js";
+import { liveInstanceIdV3, livePlatformV3, resolveLiveEventLedgerRouteV3, } from "../events/v3/live-routing.js";
+import { readHookProducerStateV3 } from "../events/v3/producers/recorder.js";
+import { writeEventV3 } from "../events/v3/writer.js";
+import { LiveCoordinationAuthorityV3Error } from "./live-authority-v3.js";
+import { liveCoordinationAdapterV3 } from "./state/live-coordination-view.js";
+/**
+ * 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) {
+    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;
+    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",
+            boot_id: `boot_${randomUUID()}`,
+            sequence: 1,
+            component: "agent-coord",
+            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",
+            confidence: "exact",
+            source_record_id: normalizeNativeIdV3(fingerprintContext, "agent-coord.observation", observationId),
+            attribution: {
+                method: "session_env",
+                state: "verified",
+                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;
+    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) {
+    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) {
+    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;
+}

package/dist/core/agents/render/prompt-context.d.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.
@@ -43,6 +43,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;
 }
 /**
  * Build the combined UserPromptSubmit additionalContext string. Returns "" when

package/dist/core/agents/render/prompt-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt-context.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/render/prompt-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAqCH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;8EAC0E;IAC1E,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;kFAC8E;IAC9E,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;uEACmE;IACnE,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CA0CnE"}
+{"version":3,"file":"prompt-context.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/render/prompt-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AA4CH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;8EAC0E;IAC1E,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;kFAC8E;IAC9E,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;uEACmE;IACnE,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;wBAIoB;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAqDnE"}

package/dist/core/agents/render/prompt-context.js

@@ -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.
@@ -35,6 +35,8 @@ import { join } from "node:path";
 import { coordEnv } from "../../../lib/env.js";
 import { endOfTurnStatusCommand, resolveBinName } from "../../config.js";
 import { readRemoteMachines } from "../../presence/index.js";
+import { sessionNameDisplayBlock, sessionNameDisplayPending } from "../session-name-display.js";
+import { readLiveCoordinationRow, readLiveCoordinationRows, } from "../state/live-coordination-view.js";
 import { formatPendingCouncils } from "./session-context.js";
 /**
  * Build the combined UserPromptSubmit additionalContext string. Returns "" when
@@ -45,7 +47,7 @@ import { formatPendingCouncils } from "./session-context.js";
  * councils are pending, matching the bash behavior).
  */
 export function renderPromptContext(opts) {
-    const { coordRoot, instanceId, sessionId, agentName, sessionNameNudge, taskNudge, statusFooterNudge, } = opts;
+    const { coordRoot, instanceId, sessionId, agentName, sessionNameNudge, taskNudge, statusFooterNudge, turnRitualNudge, } = opts;
     const sections = [];
     // 1. Peer table with hash dedup.
     const peerTable = computePeerTableIfChanged(coordRoot, instanceId, sessionId);
@@ -76,10 +78,34 @@ export function renderPromptContext(opts) {
         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, selfInstanceId, adapter) {
+    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, selfInstanceId) {
-    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);
@@ -94,16 +120,9 @@ function renderStatusFooterReminder(coordRoot, selfInstanceId) {
  * `agents set-task` uses for `first_of_session`; clears still stamp the field.
  */
 function computeFocusNudgeIfChanged(coordRoot, selfInstanceId, opts) {
-    const hbPath = join(coordRoot, ".harnery", "active", `${selfInstanceId}.json`);
-    if (!existsSync(hbPath))
+    const hb = readLiveCoordinationRow(coordRoot, selfInstanceId);
+    if (!hb)
         return "";
-    let hb;
-    try {
-        hb = JSON.parse(readFileSync(hbPath, "utf8"));
-    }
-    catch {
-        return "";
-    }
     const hashFile = join(coordRoot, ".harnery", `.last-task-nudge-hash.${selfInstanceId}`);
     // Subagents and workflow children have no human-owned session/tab to rename.
     if (hb.kind === "subagent" || hb.kind === "transient" || hb.workflow_run_id) {
@@ -116,14 +135,16 @@ function computeFocusNudgeIfChanged(coordRoot, selfInstanceId, opts) {
     let needsNudge = false;
     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. " +
+        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) {
@@ -169,28 +190,20 @@ function computeFocusNudgeIfChanged(coordRoot, selfInstanceId, opts) {
     return message;
 }
 function computePeerTableIfChanged(coordRoot, selfInstanceId, selfSessionIdFallback) {
-    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 = [];
-    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 = 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 "";
@@ -204,6 +217,9 @@ function computePeerTableIfChanged(coordRoot, selfInstanceId, selfSessionIdFallb
         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
@@ -214,6 +230,9 @@ function computePeerTableIfChanged(coordRoot, selfInstanceId, selfSessionIdFallb
             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(),
         })),
     }));
@@ -309,14 +328,6 @@ function computeCouncilPendingIfChanged(coordRoot, selfInstanceId, agentName) {
     return formatPendingCouncils(coordRoot, agentName);
 }
 /* ---------- helpers ---------- */
-function readHeartbeat(path) {
-    try {
-        return JSON.parse(readFileSync(path, "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
 function safeRead(path) {
     try {
         return readFileSync(path, "utf8").trim();
@@ -393,17 +404,22 @@ function renderSubtable(rows, header, nowSec) {
 }
 function formatRow(r, nowSec) {
     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) {
+    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) {
     if (files.length === 0)
@@ -412,16 +428,6 @@ function fmtFiles(files) {
         return `holds: ${files.join(", ")}`;
     return `holds: ${files.slice(0, 3).join(", ")}, +${files.length - 3} more`;
 }
-function fmtLastActivity(r, nowSec) {
-    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) {

package/dist/core/agents/render/session-context.d.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

package/dist/core/agents/render/session-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-context.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/render/session-context.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAyC,QAAQ,EAAE,MAAM,SAAS,CAAC;AAsB1E,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;+BAC2B;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CA6E7D;AA+ID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAwBvD;AAwDD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAiDlF;AAED;;;GAGG;AACH,eAAO,MAAM,uBAAuB,iBAAW,CAAC"}
+{"version":3,"file":"session-context.d.ts","sourceRoot":"","sources":["../../../../src/core/agents/render/session-context.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAyC,QAAQ,EAAE,MAAM,SAAS,CAAC;AAwB1E,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;+BAC2B;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CA6E7D;AAkID;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAwBvD;AA0DD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAiDlF;AAED;;;GAGG;AACH,eAAO,MAAM,uBAAuB,iBAAW,CAAC"}