harnery 0.43.0 → 0.44.0

package/src/core/context/observation.ts

@@ -0,0 +1,29 @@
+/**
+ * Repository observation contract shared by context recovery and workflow proof.
+ *
+ * This module has no runtime imports so read-only consumers (the Codec
+ * dashboard, proof readers) can use it without reaching the Git-running
+ * snapshot code in ./index.ts.
+ */
+
+export type RepoObservation = "ok" | "unavailable" | "partial";
+
+export interface RepoSnapshot {
+  cwd: string;
+  observation: RepoObservation;
+  /** Bounded explanation of an unavailable or incomplete observation. */
+  observation_detail?: string;
+  root?: string;
+  branch?: string;
+  head?: string;
+  dirty_paths: string[];
+  dirty_paths_truncated?: boolean;
+}
+
+/** Only explicitly successful observations can establish repository drift. */
+export function observationsComparable(
+  a: { observation?: string },
+  b: { observation?: string },
+): boolean {
+  return a.observation === "ok" && b.observation === "ok";
+}

package/src/core/diagnostics/bundle.ts

@@ -134,12 +134,12 @@ export function captureDiagnosticBundle(
   const aggregateStats: SanitizationStats = { sanitized_value_count: 0, omitted_value_count: 0 };
   const sources = [
     ...SOURCE_SPECS.map(([sourceKind, relativePath]) =>
-      readCapturedSource(repoRoot, sourceKind, relativePath, aggregateStats),
+      readCapturedSource(repoRoot, sourceKind, relativePath),
     ),
-    readShadowAdmissionSource(repoRoot, capturedAt, aggregateStats),
+    readShadowAdmissionSource(repoRoot, capturedAt),
   ];
   const selection = diagnosticSelection(input, sources, now);
-  const observations: DiagnosticObservations = {
+  const rawObservations: DiagnosticObservations = {
     schema_version: DIAGNOSTIC_INPUT_SCHEMA_VERSION,
     captured_at: capturedAt,
     selection,
@@ -156,7 +156,23 @@ export function captureDiagnosticBundle(
       pressure_policy: PRESSURE_POLICY,
     },
   };
-  const expected = deriveCapturedExpected(observations, thresholds);
+  // Freeze the producer's actual output before sanitization. The replay must
+  // independently preserve that output, rather than share a transformed oracle.
+  const rawExpected = deriveCapturedExpected(rawObservations, thresholds);
+  const sanitizedExpected = sanitizeDiagnosticValue(JSON.parse(JSON.stringify(rawExpected)));
+  aggregateStats.sanitized_value_count += sanitizedExpected.stats.sanitized_value_count;
+  aggregateStats.omitted_value_count += sanitizedExpected.stats.omitted_value_count;
+  const observations: DiagnosticObservations = {
+    ...rawObservations,
+    sources: rawObservations.sources.map((source) => {
+      if (source.value === undefined) return source;
+      const sanitized = sanitizeDiagnosticValue(source.value);
+      aggregateStats.sanitized_value_count += sanitized.stats.sanitized_value_count;
+      aggregateStats.omitted_value_count += sanitized.stats.omitted_value_count;
+      return { ...source, value: sanitized.value };
+    }),
+  };
+  const expected = sanitizedExpected.value as typeof rawExpected;
   if (input.findingId && !expected.findings.some((finding) => finding.id === input.findingId)) {
     throw new Error(
       `finding "${input.findingId}" is not present in the captured findings projection`,
@@ -446,7 +462,6 @@ function readCapturedSource(
   repoRoot: string,
   sourceKind: string,
   relativePath: string,
-  aggregateStats: SanitizationStats,
 ): DiagnosticCapturedSource {
   const path = join(repoRoot, relativePath);
   if (!existsSync(path)) {
@@ -462,10 +477,7 @@ function readCapturedSource(
         : (() => {
             throw new Error("source_is_not_regular_file");
           })();
-    const sanitized = sanitizeDiagnosticValue(parsed);
-    aggregateStats.sanitized_value_count += sanitized.stats.sanitized_value_count;
-    aggregateStats.omitted_value_count += sanitized.stats.omitted_value_count;
-    const value = sanitized.value;
+    const value = parsed;
     const record = object(value);
     return {
       source_kind: sourceKind,
@@ -483,11 +495,7 @@ function readCapturedSource(
   }
 }
 
-function readShadowAdmissionSource(
-  repoRoot: string,
-  capturedAt: string,
-  aggregateStats: SanitizationStats,
-): DiagnosticCapturedSource {
+function readShadowAdmissionSource(repoRoot: string, capturedAt: string): DiagnosticCapturedSource {
   const sourceKind = "workflow.diagnostic-admission";
   const workflowsRoot = join(repoRoot, ".harnery", "workflows");
   if (!existsSync(workflowsRoot)) {
@@ -545,15 +553,12 @@ function readShadowAdmissionSource(
       invalid_run_count: invalidCount,
       records,
     };
-    const sanitized = sanitizeDiagnosticValue(projection);
-    aggregateStats.sanitized_value_count += sanitized.stats.sanitized_value_count;
-    aggregateStats.omitted_value_count += sanitized.stats.omitted_value_count;
     return {
       source_kind: sourceKind,
       capability: omittedCount > 0 || invalidCount > 0 ? "partial" : "supported",
       schema_version: 1,
       observed_at: records[0]?.ended_at as string | undefined,
-      value: sanitized.value,
+      value: projection,
       ...(omittedCount > 0
         ? { reason_code: "bounded_workflow_window_truncated" }
         : invalidCount > 0

package/src/core/diagnostics/path-identity.ts

@@ -0,0 +1,15 @@
+import { createHash } from "node:crypto";
+
+const HOME_PATH =
+  /(?:[A-Za-z]:[\\/]Users[\\/](?:[^\\/\r\n\0:"<>|]+(?=[\\/])|[^\\/\s\0:]+)|\/home\/[^/\s\0:]+|\/Users\/[^/\s\0:]+)/g;
+
+/** One stable representation for private home paths in values and identity inputs. */
+export function canonicalizeDiagnosticIdentity(value: string): string {
+  return value.replace(HOME_PATH, (home) => {
+    const digest = createHash("sha256")
+      .update("harnery-diagnostic-home-v1\0")
+      .update(home)
+      .digest("hex");
+    return `[REDACTED:home:${digest}]`;
+  });
+}

package/src/core/diagnostics/sanitize.ts

@@ -2,7 +2,6 @@ const SENSITIVE_KEY =
   /(?:authorization|cookie|credential|password|passwd|private[_-]?key|secret|session[_-]?token|access[_-]?token|refresh[_-]?token|api[_-]?key)/i;
 const OMITTED_CONTENT_KEY =
   /(?:^|[_-])(?:environment|env|prompt|prompts|tool[_-]?payload|tool[_-]?result|transcript|transcripts)(?:$|[_-])/i;
-const HOME_PATH = /(?:[A-Za-z]:\\Users\\[^\\\s]+|\/home\/[^/\s]+|\/Users\/[^/\s]+)/g;
 const BEARER_VALUE = /\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi;
 const URL_CREDENTIALS = /([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/gi;
 const PRIVATE_KEY = /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g;
@@ -76,7 +75,8 @@ function sanitize(value: unknown, stats: SanitizationStats, depth: number): unkn
 }
 
 function sanitizeString(value: string, stats: SanitizationStats): string {
-  let next = value;
+  let next = canonicalizeDiagnosticIdentity(value);
+  if (next !== value) stats.sanitized_value_count += 1;
   const replacements: Array<[RegExp, string | ((...args: string[]) => string)]> = [
     [PRIVATE_KEY, "[REDACTED:private-key]"],
     [BEARER_VALUE, "Bearer [REDACTED:token]"],
@@ -86,7 +86,6 @@ function sanitizeString(value: string, stats: SanitizationStats): string {
     [SENSITIVE_ENV, "$1[REDACTED]"],
     [SENSITIVE_ARGUMENT, "$1[REDACTED]"],
     [URL_CREDENTIALS, (_match, scheme: string) => `${scheme}[REDACTED]@`],
-    [HOME_PATH, "[REDACTED:home]"],
   ];
   for (const [pattern, replacement] of replacements) {
     const replaced = next.replace(pattern, replacement as never);
@@ -95,3 +94,5 @@ function sanitizeString(value: string, stats: SanitizationStats): string {
   }
   return next;
 }
+
+import { canonicalizeDiagnosticIdentity } from "./path-identity.ts";

package/src/core/events/v3/authority-outbox.ts

@@ -16,6 +16,7 @@ import { fsyncParentDirectory } from "../../workflow/durable-record.ts";
 import { canonicalJsonV3, sha256V3 } from "./canonical.ts";
 import type { EventV3 } from "./contract.ts";
 import { liveGenesisIdV3 } from "./control.ts";
+import { assertCurrentGenerationV3, withGenerationCustodyV3 } from "./generation-custody.ts";
 import { assertEventV3 } from "./validate.ts";
 import { ensureEventV3Layout, eventV3Paths, writeEventV3 } from "./writer.ts";
 
@@ -154,9 +155,32 @@ export function publishAuthorityTransactionV3(
   coordRoot: string,
   transaction: AuthorityTransactionV3,
   fence: AuthorityEpochFenceV3 = {},
+): AuthorityTransactionV3 {
+  return withGenerationCustodyV3(
+    coordRoot,
+    [transaction.actor_instance_id, transaction.subject_instance_id],
+    () => publishAuthorityTransactionWithCustodyV3(coordRoot, transaction, fence),
+  );
+}
+
+function publishAuthorityTransactionWithCustodyV3(
+  coordRoot: string,
+  transaction: AuthorityTransactionV3,
+  fence: AuthorityEpochFenceV3,
 ): AuthorityTransactionV3 {
   validateTransaction(transaction);
   const paths = ensureEventV3Layout(coordRoot);
+  const committedPath = authorityCommittedPath(paths.authorityOutbox, transaction.transaction_id);
+  if (existsSync(committedPath)) {
+    if (
+      readAuthorityReceiptV3(committedPath).transaction_digest !==
+      sha256V3(`${canonicalJsonV3(transaction)}\n`)
+    ) {
+      throw new Error("authority committed transaction conflicts with this transaction");
+    }
+    return transaction;
+  }
+  assertTransactionGeneration(coordRoot, transaction);
   if (fence.expectedGenesisId && liveGenesisIdV3(coordRoot) !== fence.expectedGenesisId) {
     throw new Error("authority transaction epoch was replaced before publication");
   }
@@ -185,6 +209,26 @@ export function reconcileAuthorityTransactionV3(
   transactionId: string,
   reconciler: AuthorityReconcilerV3,
   fence: AuthorityEpochFenceV3 = {},
+): AuthorityReceiptV3 {
+  assertTransactionId(transactionId);
+  const paths = ensureEventV3Layout(coordRoot);
+  const committedPath = authorityCommittedPath(paths.authorityOutbox, transactionId);
+  if (existsSync(committedPath)) return readAuthorityReceiptV3(committedPath);
+  const transaction = readAuthorityTransactionV3(
+    authorityReadyPath(paths.authorityOutbox, transactionId),
+  );
+  return withGenerationCustodyV3(
+    coordRoot,
+    [transaction.actor_instance_id, transaction.subject_instance_id],
+    () => reconcileAuthorityTransactionWithCustodyV3(coordRoot, transactionId, reconciler, fence),
+  );
+}
+
+function reconcileAuthorityTransactionWithCustodyV3(
+  coordRoot: string,
+  transactionId: string,
+  reconciler: AuthorityReconcilerV3,
+  fence: AuthorityEpochFenceV3,
 ): AuthorityReceiptV3 {
   assertTransactionId(transactionId);
   const paths = ensureEventV3Layout(coordRoot);
@@ -192,8 +236,10 @@ export function reconcileAuthorityTransactionV3(
   if (existsSync(committedPath)) return readAuthorityReceiptV3(committedPath);
   const readyPath = authorityReadyPath(paths.authorityOutbox, transactionId);
   const transaction = readAuthorityTransactionV3(readyPath);
+  assertTransactionGeneration(coordRoot, transaction);
   const current = reconciler.readStateDigest();
   if (current === transaction.expected_prior_state_digest) {
+    assertTransactionGeneration(coordRoot, transaction);
     reconciler.apply(transaction.mutation, transaction.transaction_id);
   } else if (current !== transaction.desired_state_digest) {
     throw new Error("authority transaction prior state conflicts with current state");
@@ -201,6 +247,7 @@ export function reconcileAuthorityTransactionV3(
   if (reconciler.readStateDigest() !== transaction.desired_state_digest) {
     throw new Error("authority transaction did not reach its declared desired state");
   }
+  assertTransactionGeneration(coordRoot, transaction);
   const event = JSON.parse(transaction.event_row) as unknown;
   assertEventV3(event);
   const durability = writeEventV3(coordRoot, event, {
@@ -230,6 +277,15 @@ export function reconcileAuthorityTransactionV3(
   return receipt;
 }
 
+function assertTransactionGeneration(coordRoot: string, transaction: AuthorityTransactionV3): void {
+  const event = JSON.parse(transaction.event_row) as EventV3;
+  assertCurrentGenerationV3(
+    coordRoot,
+    transaction.actor_instance_id,
+    "generation_id" in event.scope ? event.scope.generation_id : undefined,
+  );
+}
+
 export function listPendingAuthorityTransactionsV3(coordRoot: string): AuthorityTransactionV3[] {
   const outbox = eventV3Paths(coordRoot).authorityOutbox;
   if (!existsSync(outbox)) return [];

package/src/core/events/v3/generation-custody.ts

@@ -0,0 +1,59 @@
+import { createHash } from "node:crypto";
+import { hostname } from "node:os";
+import { join, resolve } from "node:path";
+import { acquireNoClobberLease } from "../../workflow/workspaces/leases.ts";
+import { readHookProducerStateByInstanceV3 } from "./producers/recorder.ts";
+
+const held = new Set<string>();
+
+/** Serialize synchronous authority work with generation changes for these instances only. */
+export function withGenerationCustodyV3<T>(
+  coordRoot: string,
+  instanceIds: readonly string[],
+  operation: () => T,
+): T {
+  const ids = [...new Set(instanceIds)].sort();
+  for (const id of ids) {
+    if (!/^inst_[a-zA-Z0-9._-]{1,128}$/.test(id)) {
+      throw new Error("generation custody instance is invalid");
+    }
+  }
+  const enter = (index: number): T => {
+    const id = ids[index];
+    if (id === undefined) return operation();
+    const key = `${resolve(coordRoot)}\0${id}`;
+    if (held.has(key)) return enter(index + 1);
+    const authority = createHash("sha256").update(key).digest("hex");
+    const lease = acquireNoClobberLease({
+      // Custody spans epoch rotation; the ledger directory itself is archived.
+      path: join(coordRoot, ".harnery", "private", "event-v3-generation-custody", authority),
+      scope: "event-v3-generation-custody",
+      authoritySha256: authority,
+      // Expiry never permits stealing a live/unknown owner. A dead local process
+      // can be recovered immediately, including after a cache-handoff crash.
+      staleAfterMs: 1,
+      validateStaleOwner: (owner) =>
+        owner.host === hostname() && owner.authority_sha256 === authority,
+    });
+    held.add(key);
+    try {
+      return enter(index + 1);
+    } finally {
+      held.delete(key);
+      lease.release();
+    }
+  };
+  return enter(0);
+}
+
+/** The event already durably binds the generation; replay must not rebind its actor. */
+export function assertCurrentGenerationV3(
+  coordRoot: string,
+  instanceId: string,
+  generationId: string | undefined,
+): void {
+  const current = readHookProducerStateByInstanceV3(coordRoot, instanceId as `inst_${string}`);
+  if (!generationId || !current || current.generation_id !== generationId) {
+    throw new Error("authority_generation_changed");
+  }
+}

package/src/core/events/v3/producers/coordination-recorder.ts

@@ -33,6 +33,7 @@ import { markObservedClockRegressionV3 } from "../clock-order.ts";
 import type { EventV3 } from "../contract.ts";
 import { type EventV3WriteMode, readEventV3ControlState } from "../control.ts";
 import { fingerprintContextV3 } from "../fingerprint-keys.ts";
+import { assertCurrentGenerationV3, withGenerationCustodyV3 } from "../generation-custody.ts";
 import { clockIdV3, spanIdV3 } from "../ids.ts";
 import { closeSpanStateV3, type OpenSpanStateV3, openSpanStateV3 } from "../span-state.ts";
 import { EVENT_V3_LEDGER_RELATIVE_ROOT } from "../writer.ts";
@@ -103,6 +104,7 @@ export interface RecordCoordinationAuthorityV3Input<
   bridge?: "codex-wsl";
   expected_prior_state_digest: `sha256:${string}`;
   desired_state_digest: `sha256:${string}`;
+  expected_generation_id?: `gen_${string}`;
   monotonic_ns?: string;
   observed_at?: string;
   reconciler: AuthorityReconcilerV3;
@@ -129,6 +131,16 @@ export type RecordCoordinationAuthorityV3Result =
  */
 export function recordCoordinationAuthorityV3<S extends CoordinationAuthoritySignalV3>(
   input: RecordCoordinationAuthorityV3Input<S>,
+): RecordCoordinationAuthorityV3Result {
+  return withGenerationCustodyV3(
+    input.coordRoot,
+    [input.actor_instance_id, input.subject_instance_id],
+    () => recordCoordinationAuthorityWithCustodyV3(input),
+  );
+}
+
+function recordCoordinationAuthorityWithCustodyV3<S extends CoordinationAuthoritySignalV3>(
+  input: RecordCoordinationAuthorityV3Input<S>,
 ): RecordCoordinationAuthorityV3Result {
   const control = readEventV3ControlState(input.coordRoot);
   if (control.state !== input.mode) return { state: "gate_closed", reason: control.state };
@@ -141,6 +153,8 @@ export function recordCoordinationAuthorityV3<S extends CoordinationAuthoritySig
   if (
     !hook ||
     hook.terminal ||
+    (input.expected_generation_id !== undefined &&
+      hook.generation_id !== input.expected_generation_id) ||
     hook.instance_id !== input.actor_instance_id ||
     !hook.last_event_id
   ) {
@@ -328,6 +342,7 @@ export function recordCoordinationAuthorityV3<S extends CoordinationAuthoritySig
       mutation: normalized.mutation,
       event: normalized.event,
     });
+    assertCurrentGenerationV3(input.coordRoot, state.actor_instance_id, state.generation_id);
     if (input.signal === "wait-ended" && waitId) delete state.open_waits[waitId];
     state.pending = { source_id: sourceId, transaction };
     publishCoordinationState(path, state);

package/src/core/events/v3/producers/recorder.ts

@@ -43,6 +43,7 @@ import { markObservedClockRegressionV3 } from "../clock-order.ts";
 import type { EventV3 } from "../contract.ts";
 import { type EventV3WriteMode, readEventV3ControlState } from "../control.ts";
 import { fingerprintContextV3 } from "../fingerprint-keys.ts";
+import { withGenerationCustodyV3 } from "../generation-custody.ts";
 import {
   attestationIdV3,
   clockIdV3,
@@ -658,6 +659,17 @@ function processHookSignalLocked(
   input: RecordHookSignalV3Input,
   sessionHash: `hid_${string}`,
   path: string,
+): RecordHookSignalV3Result {
+  return withGenerationCustodyV3(input.coordRoot, [input.instance_id], () =>
+    processHookSignalWithCustodyLocked(control, input, sessionHash, path),
+  );
+}
+
+function processHookSignalWithCustodyLocked(
+  control: OpenHookControlStateV3,
+  input: RecordHookSignalV3Input,
+  sessionHash: `hid_${string}`,
+  path: string,
 ): RecordHookSignalV3Result {
   const behavior = adapterBehavior(input.adapter);
   const rootId = control.genesis.event.scope.root_id as `root_${string}`;
@@ -3209,6 +3221,14 @@ function suppressClosedSpanSignal(
  */
 export function recordApprovedSessionEndV3(
   input: RecordApprovedSessionEndV3Input,
+): RecordApprovedSessionEndV3Result {
+  return withGenerationCustodyV3(input.coordRoot, [input.instance_id], () =>
+    recordApprovedSessionEndWithCustodyV3(input),
+  );
+}
+
+function recordApprovedSessionEndWithCustodyV3(
+  input: RecordApprovedSessionEndV3Input,
 ): RecordApprovedSessionEndV3Result {
   const control = readEventV3ControlState(input.coordRoot);
   if (control.state !== input.mode) {
@@ -3556,77 +3576,81 @@ export function reanchorArchivedHookProducersV3(
   for (const archived of listArchivedHookProducerStatesV3(input.archivedEpoch)) {
     const previous = archived.state;
     if (previous.terminal || !previous.started_event_id) continue;
-    const path = producerStatePath(input.coordRoot, previous.adapter, archived.sessionHash);
-    const lease = acquireStateLeaseWithRetry(input.coordRoot, path, 40);
-    if (!lease) {
-      throw new Error(`event_v3_rotation_reanchor_busy:${previous.instance_id}`);
-    }
-    try {
-      if (existsSync(path)) {
-        const current = readProducerState(path);
-        if (current.epoch_genesis_id === genesisId) continue;
+    withGenerationCustodyV3(input.coordRoot, [previous.instance_id], () => {
+      const path = producerStatePath(input.coordRoot, previous.adapter, archived.sessionHash);
+      const lease = acquireStateLeaseWithRetry(input.coordRoot, path, 40);
+      if (!lease) {
+        throw new Error(`event_v3_rotation_reanchor_busy:${previous.instance_id}`);
       }
-      const sourceEvent = `${previous.adapter}.epoch-rotation-reanchor`;
-      const rotationInput: RecordHookSignalV3Input = {
-        coordRoot: input.coordRoot,
-        mode: input.mode,
-        signal: "session-start",
-        payload: {
-          raw: {},
-          ...(previous.current_native_turn_id ? { turn_id: previous.current_native_turn_id } : {}),
-          ...(adapterBehavior(previous.adapter).tracksExecutionMode && previous.cursor_mode
-            ? { cursor_mode: previous.cursor_mode }
-            : {}),
-        },
-        adapter: previous.adapter,
-        instance_id: previous.instance_id,
-        producer_id: "prd_agent-hook",
-        build_id: input.build_id,
-        platform: input.platform,
-        observed_at: observedAt,
-        writerOptions: { expectedGenesisId: genesisId },
-      };
-      const state = newProducerState(
-        rotationInput,
-        previous.session_id,
-        epochId,
-        boundaryEventId as `evt_${string}`,
-        genesisId,
-      );
-      const sessionStart = buildMidFlightSessionStart(rotationInput, state, rootId);
-      if (sessionStart.event_type !== "session.started") {
-        throw new Error("rotation re-anchor session start could not be normalized");
-      }
-      sessionStart.provenance = {
-        ...sessionStart.provenance,
-        source_event: sourceEvent,
-        attestation: "derived",
-        confidence: "high",
-        attribution: {
-          method: "session_env",
-          state: "verified",
-          subject_instance_id: state.instance_id,
-        },
-      };
-      sessionStart.payload.resume = {
-        state: "unknown",
-        reason: "epoch_rotation_reanchor",
-      };
-      assertEventV3(sessionStart);
-      commitEventLocked(rotationInput, state, path, sessionStart);
-      sessions += 1;
-
-      if (previous.current_turn_id && previous.current_turn_span) {
-        commitMidFlightTurnStart(rotationInput, state, path, rootId, {
+      try {
+        if (existsSync(path)) {
+          const current = readProducerState(path);
+          if (current.epoch_genesis_id === genesisId) return;
+        }
+        const sourceEvent = `${previous.adapter}.epoch-rotation-reanchor`;
+        const rotationInput: RecordHookSignalV3Input = {
+          coordRoot: input.coordRoot,
+          mode: input.mode,
+          signal: "session-start",
+          payload: {
+            raw: {},
+            ...(previous.current_native_turn_id
+              ? { turn_id: previous.current_native_turn_id }
+              : {}),
+            ...(adapterBehavior(previous.adapter).tracksExecutionMode && previous.cursor_mode
+              ? { cursor_mode: previous.cursor_mode }
+              : {}),
+          },
+          adapter: previous.adapter,
+          instance_id: previous.instance_id,
+          producer_id: "prd_agent-hook",
+          build_id: input.build_id,
+          platform: input.platform,
+          observed_at: observedAt,
+          writerOptions: { expectedGenesisId: genesisId },
+        };
+        const state = newProducerState(
+          rotationInput,
+          previous.session_id,
+          epochId,
+          boundaryEventId as `evt_${string}`,
+          genesisId,
+        );
+        const sessionStart = buildMidFlightSessionStart(rotationInput, state, rootId);
+        if (sessionStart.event_type !== "session.started") {
+          throw new Error("rotation re-anchor session start could not be normalized");
+        }
+        sessionStart.provenance = {
+          ...sessionStart.provenance,
           source_event: sourceEvent,
+          attestation: "derived",
           confidence: "high",
-          attribution_method: "session_env",
-        });
-        turns += 1;
+          attribution: {
+            method: "session_env",
+            state: "verified",
+            subject_instance_id: state.instance_id,
+          },
+        };
+        sessionStart.payload.resume = {
+          state: "unknown",
+          reason: "epoch_rotation_reanchor",
+        };
+        assertEventV3(sessionStart);
+        commitEventLocked(rotationInput, state, path, sessionStart);
+        sessions += 1;
+
+        if (previous.current_turn_id && previous.current_turn_span) {
+          commitMidFlightTurnStart(rotationInput, state, path, rootId, {
+            source_event: sourceEvent,
+            confidence: "high",
+            attribution_method: "session_env",
+          });
+          turns += 1;
+        }
+      } finally {
+        lease.release();
       }
-    } finally {
-      lease.release();
-    }
+    });
   }
   return { sessions, turns };
 }
@@ -3864,7 +3888,9 @@ export function readJoinableHookProducerStateV3(
   instanceId: `inst_${string}`,
 ): HookProducerStateV3 | undefined {
   const direct = readHookProducerStateV3(coordRoot, adapter, nativeSessionId);
-  if (direct?.instance_id === instanceId && !direct.terminal) return direct;
+  // A terminal native session belonging to this actor is stale authority,
+  // not permission to adopt a replacement published under the same instance.
+  if (direct?.instance_id === instanceId) return direct.terminal ? undefined : direct;
   const byInstance = readHookProducerStateByInstanceV3(coordRoot, instanceId);
   return byInstance?.adapter === adapter && !byInstance.terminal ? byInstance : undefined;
 }

package/src/core/governor/planning.ts

@@ -124,6 +124,7 @@ export async function runGovernorPlanner(
     if (recovered) return recovered;
   }
   let proposalWritten = false;
+  let invalidProposal = false;
   try {
     const reviewRunId = reviewWorkflowRunId(request.id);
     const resumingReview = Boolean(
@@ -153,14 +154,22 @@ export async function runGovernorPlanner(
             onLog: input.onLog,
           })
         ).result;
-    const proposal = normalizeProposal(
-      request.id,
-      rawProposal,
-      input.record,
-      history.materialized_work_ids.length,
-      request.trigger ?? "recovery",
-      reviewInput ? persistedProposalTimestamp(reviewInput.candidate) : undefined,
-    );
+    let proposal: GovernorPlanProposal;
+    try {
+      proposal = normalizeProposal(
+        request.id,
+        rawProposal,
+        input.record,
+        history.materialized_work_ids.length,
+        request.trigger ?? "recovery",
+        reviewInput ? persistedProposalTimestamp(reviewInput.candidate) : undefined,
+      );
+    } catch (error) {
+      // A fresh invalid proposal can consume a replan without aborting the run.
+      // Corrupt persisted review input still requires investigation.
+      invalidProposal = !reviewInput;
+      throw error;
+    }
     if (policy.review) {
       if (proposal.decision === "attention") {
         appendPlanEvent(coordRoot, input.record.intent.id, request.id, {
@@ -258,6 +267,9 @@ export async function runGovernorPlanner(
       reason: bounded((error as Error).message, "plan failure", MAX_REASON),
       ...(failureClass ? { class: failureClass } : {}),
     });
+    if (invalidProposal) {
+      return outcome(readGovernorPlan(coordRoot, input.record.intent.id, request.id));
+    }
     throw error;
   }
 }