harnery 0.34.1 → 0.36.0

package/src/core/agents/state/live-coordination-view.ts

@@ -1,12 +1,5 @@
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  renameSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import type { Adapter } from "../../adapter.ts";
 import {
   type CoordinationGenerationViewV3,
@@ -17,9 +10,9 @@ import {
 import {
   liveInstanceIdV3,
   nativeInstanceIdV3,
-  resolveLiveEventLedgerRouteV3,
-} from "../../events/v3/live-routing.ts";
-import { type Heartbeat, readHeartbeat } from "./heartbeat-writer.ts";
+  observeLiveEventLedgerRouteV3,
+} from "../../events/v3/live-route-observer.ts";
+import { type Heartbeat, readHeartbeat } from "./heartbeat-reader.ts";
 import { resolveName } from "./names.ts";
 
 /**
@@ -36,7 +29,7 @@ export interface V3HeartbeatMaterialization extends Heartbeat {
 
 /** Read the live coordination rows through the hard-cut ledger route. */
 export function readLiveCoordinationRows(coordRoot: string): V3HeartbeatMaterialization[] {
-  const route = resolveLiveEventLedgerRouteV3(coordRoot);
+  const route = observeLiveEventLedgerRouteV3(coordRoot);
   if (route.state === "blocked") return [];
   let view: CoordinationViewV3;
   try {
@@ -69,7 +62,7 @@ export function readLiveCoordinationRow(
   coordRoot: string,
   nativeInstanceId: string,
 ): V3HeartbeatMaterialization | null {
-  const route = resolveLiveEventLedgerRouteV3(coordRoot);
+  const route = observeLiveEventLedgerRouteV3(coordRoot);
   if (route.state === "blocked") return null;
   try {
     const view = requireAuthoritySafeCoordinationViewV3(readCoordinationViewV3(coordRoot));
@@ -84,7 +77,7 @@ export function readLiveCoordinationRow(
     return projectHeartbeatV3(
       coordRoot,
       generation,
-      isCurrentCache(cache, generation) ? cache : undefined,
+      isCurrentV3HeartbeatCache(cache, generation) ? cache : undefined,
       nativeInstanceId,
       parent,
     );
@@ -102,64 +95,18 @@ export function liveCoordinationAdapterV3(
   coordRoot: string,
   nativeInstanceId: string,
 ): Adapter | null {
-  const route = resolveLiveEventLedgerRouteV3(coordRoot);
+  const route = observeLiveEventLedgerRouteV3(coordRoot);
   if (route.state === "blocked") throw new Error(`event_v3_coordination_view:${route.reason}`);
   const view = requireAuthoritySafeCoordinationViewV3(readCoordinationViewV3(coordRoot));
   const generation = view.instances[liveInstanceIdV3(nativeInstanceId)];
   if (!generation?.authority_eligible) return null;
-  const adapter = observedAdapter(generation);
-  if (!isAdapter(adapter)) {
+  const adapter = observedAdapterV3(generation);
+  if (!isAdapterV3(adapter)) {
     throw new Error("event_v3_coordination_view:adapter_not_observed");
   }
   return adapter;
 }
 
-/**
- * Ensure the current V3 generation has a mutation target. The resulting file
- * is explicitly generation-bound and disposable: V3 remains the source of
- * truth, while the cache gives the crash-safe authority outbox an atomic local
- * state to reconcile.
- */
-export function ensureLiveCoordinationHeartbeat(
-  coordRoot: string,
-  nativeInstanceId: string,
-  nativeSessionId: string,
-  _adapter: Adapter,
-  model?: string,
-): Heartbeat | null {
-  const route = resolveLiveEventLedgerRouteV3(coordRoot);
-  if (route.state === "blocked") throw new Error(`event_v3_coordination_view:${route.reason}`);
-  const view = requireAuthoritySafeCoordinationViewV3(readCoordinationViewV3(coordRoot));
-  const generation = view.instances[liveInstanceIdV3(nativeInstanceId)];
-  if (!generation?.authority_eligible) return null;
-  const generationAdapter = observedAdapter(generation);
-  if (!isAdapter(generationAdapter)) {
-    throw new Error("event_v3_coordination_view:adapter_not_observed");
-  }
-  const current = readHeartbeat(coordRoot, nativeInstanceId);
-  if (isCurrentCache(current, generation) && current.platform === generationAdapter) return current;
-
-  const resolved = resolveName(coordRoot, nativeInstanceId, nativeSessionId);
-  const projected = projectHeartbeatV3(coordRoot, generation, undefined, nativeInstanceId);
-  const materialized: V3HeartbeatMaterialization = {
-    ...projected,
-    schema_version: 2,
-    instance_id: nativeInstanceId,
-    session_id: nativeSessionId,
-    name: resolved?.name ?? "",
-    kind: resolved?.kind ?? projected.kind,
-    agent_id: resolved?.agent_id ?? (resolved?.kind === "subagent" ? nativeInstanceId : ""),
-    model: projected.model ?? model ?? "",
-    platform: generationAdapter,
-    v3_instance_id: generation.instance_id as `inst_${string}`,
-    v3_generation_id: generation.generation_id as `gen_${string}`,
-    v3_projection_event_id: generation.last_event_id,
-    v3_task_state: generation.task_state === "set" ? "set" : "cleared",
-  };
-  writeHeartbeatCache(coordRoot, nativeInstanceId, materialized);
-  return materialized;
-}
-
 function readCacheRows(coordRoot: string): Heartbeat[] {
   const dir = join(coordRoot, ".harnery", "active");
   if (!existsSync(dir)) return [];
@@ -185,10 +132,10 @@ function matchingCache(
   caches: Heartbeat[],
   generation: CoordinationGenerationViewV3,
 ): Heartbeat | undefined {
-  return caches.find((cache) => isCurrentCache(cache, generation));
+  return caches.find((cache) => isCurrentV3HeartbeatCache(cache, generation));
 }
 
-function isCurrentCache(
+export function isCurrentV3HeartbeatCache(
   cache: Heartbeat | null | undefined,
   generation: CoordinationGenerationViewV3,
 ): cache is Heartbeat {
@@ -199,14 +146,14 @@ function isCurrentCache(
   );
 }
 
-function projectHeartbeatV3(
+export function projectHeartbeatV3(
   coordRoot: string,
   generation: CoordinationGenerationViewV3,
   cache: Heartbeat | undefined,
   nativeInstanceId: string | undefined,
   parent?: CoordinationGenerationViewV3,
 ): V3HeartbeatMaterialization {
-  const adapter = observedAdapter(generation) ?? cache?.platform ?? "unknown";
+  const adapter = observedAdapterV3(generation) ?? cache?.platform ?? "unknown";
   const model = observedModel(generation) ?? cache?.model ?? "";
   const instanceId =
     nativeInstanceId ?? cache?.instance_id ?? nativeInstanceIdV3(generation.instance_id);
@@ -260,12 +207,12 @@ function projectHeartbeatV3(
   };
 }
 
-function observedAdapter(generation: CoordinationGenerationViewV3): string | undefined {
+export function observedAdapterV3(generation: CoordinationGenerationViewV3): string | undefined {
   const observation = generation.runtime_attestation.adapter;
   return observation.state === "observed" ? observation.value.id : undefined;
 }
 
-function isAdapter(value: string | undefined): value is Adapter {
+export function isAdapterV3(value: string | undefined): value is Adapter {
   return value === "claude-code" || value === "cursor" || value === "codex";
 }
 
@@ -277,14 +224,3 @@ function observedModel(generation: CoordinationGenerationViewV3): string | undef
 function isLifecycleState(value: string | undefined): value is "active" | "blocked" | "done" {
   return value === "active" || value === "blocked" || value === "done";
 }
-
-function writeHeartbeatCache(coordRoot: string, instanceId: string, heartbeat: Heartbeat): void {
-  if (!/^[a-zA-Z0-9._-]{1,128}$/.test(instanceId)) {
-    throw new Error("instance_id is unsafe for heartbeat materialization");
-  }
-  const path = join(coordRoot, ".harnery", "active", `${instanceId}.json`);
-  mkdirSync(dirname(path), { recursive: true });
-  const temporary = `${path}.tmp.${process.pid}`;
-  writeFileSync(temporary, JSON.stringify(heartbeat, null, 2), "utf8");
-  renameSync(temporary, path);
-}

package/src/core/agents/state/live-coordination-writer.ts

@@ -0,0 +1,141 @@
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { Adapter } from "../../adapter.ts";
+import {
+  readCoordinationViewV3,
+  requireAuthoritySafeCoordinationViewV3,
+} from "../../events/v3/coordination-view.ts";
+import { liveInstanceIdV3, resolveLiveEventLedgerRouteV3 } from "../../events/v3/live-routing.ts";
+import { type Heartbeat, readHeartbeat } from "./heartbeat-reader.ts";
+import {
+  isAdapterV3,
+  isCurrentV3HeartbeatCache,
+  observedAdapterV3,
+  projectHeartbeatV3,
+  type V3HeartbeatMaterialization,
+} from "./live-coordination-view.ts";
+import { resolveName } from "./names.ts";
+
+/**
+ * Ensure the current V3 generation has a mutation target. The resulting file
+ * is explicitly generation-bound and disposable: V3 remains the source of
+ * truth, while the cache gives the crash-safe authority outbox an atomic local
+ * state to reconcile.
+ */
+export function ensureLiveCoordinationHeartbeat(
+  coordRoot: string,
+  nativeInstanceId: string,
+  nativeSessionId: string,
+  _adapter: Adapter,
+  model?: string,
+): Heartbeat | null {
+  return materializeLiveCoordinationHeartbeat(
+    coordRoot,
+    nativeInstanceId,
+    nativeSessionId,
+    _adapter,
+    model,
+    false,
+  );
+}
+
+/** Rebuild a disposable cache from V3 even when its generation markers look current. */
+export function repairLiveCoordinationHeartbeat(
+  coordRoot: string,
+  nativeInstanceId: string,
+  nativeSessionId: string,
+  adapter: Adapter,
+  model?: string,
+): Heartbeat | null {
+  return materializeLiveCoordinationHeartbeat(
+    coordRoot,
+    nativeInstanceId,
+    nativeSessionId,
+    adapter,
+    model,
+    true,
+  );
+}
+
+function materializeLiveCoordinationHeartbeat(
+  coordRoot: string,
+  nativeInstanceId: string,
+  nativeSessionId: string,
+  _adapter: Adapter,
+  model: string | undefined,
+  force: boolean,
+): Heartbeat | null {
+  const route = resolveLiveEventLedgerRouteV3(coordRoot);
+  if (route.state === "blocked") throw new Error(`event_v3_coordination_view:${route.reason}`);
+  const view = requireAuthoritySafeCoordinationViewV3(readCoordinationViewV3(coordRoot));
+  const generation = view.instances[liveInstanceIdV3(nativeInstanceId)];
+  if (!generation?.authority_eligible) return null;
+  const generationAdapter = observedAdapterV3(generation);
+  if (!isAdapterV3(generationAdapter)) {
+    throw new Error("event_v3_coordination_view:adapter_not_observed");
+  }
+  const current = readHeartbeat(coordRoot, nativeInstanceId);
+  if (
+    !force &&
+    isCurrentV3HeartbeatCache(current, generation) &&
+    current.platform === generationAdapter
+  ) {
+    return current;
+  }
+
+  const resolved = resolveName(coordRoot, nativeInstanceId, nativeSessionId);
+  const projected = projectHeartbeatV3(coordRoot, generation, undefined, nativeInstanceId);
+  // A generation reopen (resume, mid-flight onboarding) discards the stale
+  // cache, but the adapter tab it names is unchanged: same native session,
+  // same agent identity. Rebuilding without the naming evidence re-mints a
+  // fresh suggested name on the next set-task, so a multi-day session
+  // accumulates titles it is asked to display over and over. Carry the
+  // naming evidence across generations; everything else re-projects from V3.
+  // Same native session id means the same adapter tab; drop the carry only
+  // when the durable identity observably changed (a reassumed name would make
+  // the old "Agent <name> - …" block wrong for the new owner).
+  const identityUnchanged = !resolved?.name || !current?.name || resolved.name === current.name;
+  const carriedNaming =
+    current && current.session_id === nativeSessionId && identityUnchanged
+      ? {
+          ...(current.suggested_session_name
+            ? { suggested_session_name: current.suggested_session_name }
+            : {}),
+          ...(current.session_name_seen_for
+            ? { session_name_seen_for: current.session_name_seen_for }
+            : {}),
+          ...(current.session_name_seen_at
+            ? { session_name_seen_at: current.session_name_seen_at }
+            : {}),
+        }
+      : {};
+  const materialized: V3HeartbeatMaterialization = {
+    ...projected,
+    ...carriedNaming,
+    schema_version: 2,
+    instance_id: nativeInstanceId,
+    session_id: nativeSessionId,
+    name: resolved?.name ?? "",
+    kind: resolved?.kind ?? projected.kind,
+    agent_id: resolved?.agent_id ?? (resolved?.kind === "subagent" ? nativeInstanceId : ""),
+    model: projected.model ?? model ?? "",
+    platform: generationAdapter,
+    v3_instance_id: generation.instance_id as `inst_${string}`,
+    v3_generation_id: generation.generation_id as `gen_${string}`,
+    v3_projection_event_id: generation.last_event_id,
+    v3_task_state: generation.task_state === "set" ? "set" : "cleared",
+  };
+  writeHeartbeatCache(coordRoot, nativeInstanceId, materialized);
+  return materialized;
+}
+
+function writeHeartbeatCache(coordRoot: string, instanceId: string, heartbeat: Heartbeat): void {
+  if (!/^[a-zA-Z0-9._-]{1,128}$/.test(instanceId)) {
+    throw new Error("instance_id is unsafe for heartbeat materialization");
+  }
+  const path = join(coordRoot, ".harnery", "active", `${instanceId}.json`);
+  mkdirSync(dirname(path), { recursive: true });
+  const temporary = `${path}.tmp.${process.pid}`;
+  writeFileSync(temporary, JSON.stringify(heartbeat, null, 2), "utf8");
+  renameSync(temporary, path);
+}