harnery 0.45.0 → 0.45.1

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

@@ -88,7 +88,6 @@ interface LiveAuthorityBaseV3 {
   nativeSessionId: string;
   adapter: Adapter;
   observationId?: string;
-  expectedGenerationId?: `gen_${string}`;
 }
 
 /**
@@ -649,13 +648,6 @@ function recordLiveAuthority<S extends CoordinationAuthoritySignalV3>(
     platform: livePlatformV3(),
     expected_prior_state_digest: coordinationAuthorityStateDigestV3(expected),
     desired_state_digest: coordinationAuthorityStateDigestV3(desired),
-    expected_generation_id:
-      input.expectedGenerationId ??
-      ((subject === input.owner
-        ? expected.v3_generation_id
-        : readLiveCoordinationRow(input.coordRoot, input.owner)?.v3_generation_id) as
-        | `gen_${string}`
-        | undefined),
     reconciler: {
       readStateDigest: () => {
         const heartbeat = readHeartbeat(input.coordRoot, subject);
@@ -689,12 +681,6 @@ export function liveCoordinationWriteModeV3(coordRoot: string): EventV3WriteMode
 }
 
 function requireHeartbeat(input: LiveAuthorityBaseV3, owner: string): Heartbeat {
-  if (
-    input.expectedGenerationId &&
-    readLiveCoordinationRow(input.coordRoot, owner)?.v3_generation_id !== input.expectedGenerationId
-  ) {
-    throw new LiveCoordinationAuthorityV3Error("expected_generation_changed");
-  }
   const heartbeat = ensureLiveCoordinationHeartbeat(
     input.coordRoot,
     owner,
@@ -702,9 +688,6 @@ function requireHeartbeat(input: LiveAuthorityBaseV3, owner: string): Heartbeat
     input.adapter,
   );
   if (!heartbeat) throw new LiveCoordinationAuthorityV3Error(`heartbeat_missing:${owner}`);
-  if (input.expectedGenerationId && heartbeat.v3_generation_id !== input.expectedGenerationId) {
-    throw new LiveCoordinationAuthorityV3Error("expected_generation_changed");
-  }
   return heartbeat;
 }
 

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

@@ -5,7 +5,6 @@ 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 { withGenerationCustodyV3 } from "../events/v3/generation-custody.ts";
 import {
   liveInstanceIdV3,
   livePlatformV3,
@@ -26,34 +25,17 @@ interface LiveLifecycleObservationBaseV3 {
   observedAt?: string;
 }
 
-interface LiveSweepObservationV3Input extends LiveLifecycleObservationBaseV3 {
-  expectedGenerationId: `gen_${string}` | null;
-  observation: "stale_heartbeat" | "killed" | "unparseable_heartbeat" | "missing_timestamp";
-  ageMs: number;
-}
-
 export function recordLiveSweepObservationV3(
-  input: LiveSweepObservationV3Input,
+  input: LiveLifecycleObservationBaseV3 & {
+    observation: "stale_heartbeat" | "killed" | "unparseable_heartbeat" | "missing_timestamp";
+    ageMs: number;
+  },
 ): LiveLifecycleObservationV3Result {
-  input = { ...input };
-  // Reject stale observations before preparing durable custody state. The
-  // in-custody checks cover replacement while acquiring custody and reentry.
-  requireSweepHookState(input);
-  return withGenerationCustodyV3(input.coordRoot, [liveInstanceIdV3(input.owner)], () => {
-    requireSweepHookState(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)),
-      },
-      () => {
-        requireSweepHookState(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)),
   });
 }
 
@@ -62,16 +44,11 @@ export function recordLiveResumeObservationV3(
 ): 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",
-    },
-    () => {},
-  );
+  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">(
@@ -89,7 +66,6 @@ function recordObservation<T extends "lifecycle.sweep_observed" | "session.resum
         continuity: "native";
         evidence_reference: string;
       },
-  beforeWrite: () => void,
 ): LiveLifecycleObservationV3Result {
   const route = resolveLiveEventLedgerRouteV3(input.coordRoot);
   if (route.state === "blocked") throw new LiveCoordinationAuthorityV3Error(route.reason);
@@ -145,7 +121,6 @@ function recordObservation<T extends "lifecycle.sweep_observed" | "session.resum
     monotonic_ns: process.hrtime.bigint().toString(),
   };
   const event = buildEventV3(eventType, { ...common, payload } as never) as EventV3;
-  beforeWrite();
   const durability = writeEventV3(input.coordRoot, event, {
     expectedGenesisId: control.genesis.event.payload.genesis_id as `gex_${string}`,
   });
@@ -155,19 +130,6 @@ function recordObservation<T extends "lifecycle.sweep_observed" | "session.resum
   return { state: "recorded", event };
 }
 
-function requireSweepHookState(input: LiveSweepObservationV3Input): void {
-  if (
-    typeof input.expectedGenerationId !== "string" ||
-    !/^gen_[a-zA-Z0-9._-]+$/.test(input.expectedGenerationId)
-  ) {
-    throw new LiveCoordinationAuthorityV3Error("hook_generation_not_joinable");
-  }
-  const hook = requireHookState(withAttestedAdapter(input));
-  if (hook.generation_id !== input.expectedGenerationId) {
-    throw new LiveCoordinationAuthorityV3Error("expected_generation_changed");
-  }
-}
-
 function withAttestedAdapter<T extends LiveLifecycleObservationBaseV3>(input: T): T {
   const adapter = liveCoordinationAdapterV3(input.coordRoot, input.owner);
   if (!adapter) return input;

package/src/core/agents/state/heartbeat-writer.ts

@@ -24,11 +24,6 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
-import {
-  assertCurrentGenerationV3,
-  withGenerationCustodyV3,
-} from "../../events/v3/generation-custody.ts";
-import { liveInstanceIdV3 } from "../../events/v3/live-routing.ts";
 import { canonicalClaimPath } from "../claim-path.ts";
 import { type Heartbeat, heartbeatPath, readHeartbeat } from "./heartbeat-reader.ts";
 import type { TaskState } from "./session-state.ts";
@@ -68,15 +63,12 @@ function mutate(
   instanceId: string,
   fn: (hb: Heartbeat) => Heartbeat,
 ): Heartbeat | null {
-  return withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(instanceId)], () => {
-    const hb = readHeartbeat(coordRoot, instanceId);
-    if (!hb) return null;
-    const next = fn(hb);
-    next.last_heartbeat = nowIsoSeconds();
-    assertCurrentGenerationV3(coordRoot, liveInstanceIdV3(instanceId), hb.v3_generation_id);
-    atomicWrite(heartbeatPath(coordRoot, instanceId), JSON.stringify(next, null, 2));
-    return next;
-  });
+  const hb = readHeartbeat(coordRoot, instanceId);
+  if (!hb) return null;
+  const next = fn(hb);
+  next.last_heartbeat = nowIsoSeconds();
+  atomicWrite(heartbeatPath(coordRoot, instanceId), JSON.stringify(next, null, 2));
+  return next;
 }
 
 export function setTask(coordRoot: string, instanceId: string, task: string): Heartbeat | null {
@@ -108,15 +100,12 @@ export function setIdentityCache(
   name: string,
   agentId: string,
 ): Heartbeat | null {
-  return withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(instanceId)], () => {
-    const heartbeat = readHeartbeat(coordRoot, instanceId);
-    if (!heartbeat) return null;
-    heartbeat.name = name;
-    heartbeat.agent_id = agentId;
-    assertCurrentGenerationV3(coordRoot, liveInstanceIdV3(instanceId), heartbeat.v3_generation_id);
-    atomicWrite(heartbeatPath(coordRoot, instanceId), JSON.stringify(heartbeat, null, 2));
-    return heartbeat;
-  });
+  const heartbeat = readHeartbeat(coordRoot, instanceId);
+  if (!heartbeat) return null;
+  heartbeat.name = name;
+  heartbeat.agent_id = agentId;
+  atomicWrite(heartbeatPath(coordRoot, instanceId), JSON.stringify(heartbeat, null, 2));
+  return heartbeat;
 }
 
 /** Restore the pool-assigned display name on a generation that was
@@ -339,12 +328,6 @@ export function clearCoordinationCache(coordRoot: string, instanceId: string): b
 }
 
 export function healPidmap(coordRoot: string, instanceId: string, pid: number): void {
-  withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(instanceId)], () =>
-    healPidmapUnderCustody(coordRoot, instanceId, pid),
-  );
-}
-
-function healPidmapUnderCustody(coordRoot: string, instanceId: string, pid: number): void {
   const dir = join(coordRoot, ".harnery", "pid-map");
   mkdirSync(dir, { recursive: true });
   const hb = readHeartbeat(coordRoot, instanceId);

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

@@ -5,10 +5,6 @@ import {
   readCoordinationViewV3,
   requireAuthoritySafeCoordinationViewV3,
 } from "../../events/v3/coordination-view.ts";
-import {
-  assertCurrentGenerationV3,
-  withGenerationCustodyV3,
-} from "../../events/v3/generation-custody.ts";
 import { liveInstanceIdV3, resolveLiveEventLedgerRouteV3 } from "../../events/v3/live-routing.ts";
 import { type Heartbeat, readHeartbeat } from "./heartbeat-reader.ts";
 import {
@@ -68,26 +64,6 @@ function materializeLiveCoordinationHeartbeat(
   _adapter: Adapter,
   model: string | undefined,
   force: boolean,
-): Heartbeat | null {
-  return withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(nativeInstanceId)], () =>
-    materializeHeartbeatUnderCustody(
-      coordRoot,
-      nativeInstanceId,
-      nativeSessionId,
-      _adapter,
-      model,
-      force,
-    ),
-  );
-}
-
-function materializeHeartbeatUnderCustody(
-  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}`);
@@ -157,11 +133,6 @@ function materializeHeartbeatUnderCustody(
     v3_projection_event_id: generation.last_event_id,
     v3_task_state: generation.task_state === "set" ? "set" : "cleared",
   };
-  assertCurrentGenerationV3(
-    coordRoot,
-    liveInstanceIdV3(nativeInstanceId),
-    generation.generation_id,
-  );
   writeHeartbeatCache(coordRoot, nativeInstanceId, materialized);
   return materialized;
 }

package/src/core/agents/state/pidmap.ts

@@ -24,8 +24,6 @@ import {
   writeFileSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
-import { withGenerationCustodyV3 } from "../../events/v3/generation-custody.ts";
-import { liveInstanceIdV3 } from "../../events/v3/live-routing.ts";
 import { checkPidToken, processStartToken } from "./proc-start.ts";
 
 /**
@@ -128,17 +126,6 @@ export function writePidmapRow(
   pid: number,
   instanceId: string,
   platform: string,
-): void {
-  withGenerationCustodyV3(coordRoot, [liveInstanceIdV3(instanceId)], () =>
-    writePidmapRowUnderCustody(coordRoot, pid, instanceId, platform),
-  );
-}
-
-function writePidmapRowUnderCustody(
-  coordRoot: string,
-  pid: number,
-  instanceId: string,
-  platform: string,
 ): void {
   const dir = join(coordRoot, ".harnery", "pid-map");
   const path = join(dir, String(pid));