@flyingrobots/graft 0.5.0 → 0.6.0

package/src/mcp/persisted-local-history.ts

@@ -2,18 +2,21 @@ import * as crypto from "node:crypto";
 import * as path from "node:path";
 import { z } from "zod";
 import {
+  actorSchema,
   attributionSummarySchema,
   attributionConfidenceSchema,
+  causalFootprintSchema,
+  causalRegionSchema,
   readEventSchema,
   stageEventSchema,
   transitionEventSchema,
   evidenceSchema,
-  getMaximumConfidenceForEvidence,
   localHistoryContinuityOperationSchema,
   type AttributionSummary,
   type AttributionConfidence,
-  type CausalFootprint,
+  type Actor,
   type CausalEvent,
+  type CausalFootprint,
   type Evidence,
   type LocalHistoryContinuityOperation,
   type SourceLayer,
@@ -22,12 +25,33 @@ import type { JsonCodec } from "../ports/codec.js";
 import type { FileSystem } from "../ports/filesystem.js";
 import type { RepoObservation } from "./repo-state.js";
 import {
-  buildRepoConcurrencyContributorKey,
-  buildRepoConcurrencyTouches,
+  type PersistedLocalHistoryGraphContext,
+  writeCausalEventToGraph,
+  writeContinuityRecordToGraph,
+} from "./persisted-local-history-graph.js";
+import {
   deriveRepoConcurrencySummary,
   type RepoConcurrencySummary,
-  type RepoConcurrencyWorktreeHistory,
 } from "./repo-concurrency.js";
+import {
+  buildPersistedLocalActivityWindow,
+  emptyPersistedLocalActivityWindow,
+  emptyPersistedLocalHistorySummary,
+  findRecord,
+  summarizeContinuityState,
+  toRepoConcurrencyWorktreeHistory,
+} from "./persisted-local-history-views.js";
+import {
+  buildAttachDeclarationEvidence,
+  buildGitTransitionEvidence,
+  buildUnknownAttributionForActorId,
+  classifyContinuityOperation,
+  createContinuityRecord,
+  createReadEvent,
+  createStageEvent,
+  createTransitionEvent,
+  deriveContinuityAttribution,
+} from "./persisted-local-history-policy.js";
 import type { GitTransitionHookEvent } from "./runtime-workspace-overlay.js";
 import type { RuntimeCausalContext } from "./runtime-causal-context.js";
 import type { RuntimeStagedTargetFullFile } from "./runtime-staged-target.js";
@@ -75,7 +99,7 @@ const continuityRecordSchema = z.object({
   attribution: attributionSummarySchema,
 }).strict();
 
-type ContinuityRecord = z.infer<typeof continuityRecordSchema>;
+export type ContinuityRecord = z.infer<typeof continuityRecordSchema>;
 
 const continuityStateSchema = z.object({
   continuityKey: z.string().min(1),
@@ -88,7 +112,7 @@ const continuityStateSchema = z.object({
   transitionEvents: z.array(transitionEventSchema),
 }).strict();
 
-type ContinuityState = z.infer<typeof continuityStateSchema>;
+export type ContinuityState = z.infer<typeof continuityStateSchema>;
 
 export interface PersistedLocalHistoryContext {
   readonly repoId: string;
@@ -152,7 +176,7 @@ export interface PersistedLocalHistorySummaryNone {
 export interface PersistedLocalHistorySummaryPresent {
   readonly availability: "present";
   readonly persistence: "persisted_local_history";
-  readonly historyPath: string;
+  readonly historyPath: string | null;
   readonly totalContinuityRecords: number;
   readonly active: boolean;
   readonly lastOperation: LocalHistoryContinuityOperation;
@@ -223,28 +247,6 @@ export function buildContinuityKey(repoId: string, worktreeId: string): string {
   return stableId("continuity", `${repoId}:${worktreeId}`);
 }
 
-function buildRecordId(
-  continuityKey: string,
-  operation: LocalHistoryContinuityOperation,
-  context: PersistedLocalHistoryContext,
-  previousRecordId: string | null,
-  additionalEvidenceIds: readonly string[],
-): string {
-  return stableId(
-    "history",
-    JSON.stringify({
-      continuityKey,
-      operation,
-      occurredAt: context.observedAt,
-      causalSessionId: context.causalSessionId,
-      strandId: context.strandId,
-      workspaceSliceId: context.workspaceSliceId,
-      previousRecordId,
-      additionalEvidenceIds,
-    }),
-  );
-}
-
 function buildEvidenceId(
   operation: LocalHistoryContinuityOperation,
   kind: Evidence["evidenceKind"],
@@ -278,18 +280,11 @@ function createEmptyState(continuityKey: string, repoId: string, worktreeId: str
   };
 }
 
-function findRecord(state: ContinuityState, recordId: string | null): ContinuityRecord | null {
-  if (recordId === null) return null;
-  for (let index = state.records.length - 1; index >= 0; index--) {
-    const record = state.records[index];
-    if (record?.recordId === recordId) {
-      return record;
-    }
-  }
-  return null;
-}
-
 function appendRecord(state: ContinuityState, record: ContinuityRecord, activeAfter: boolean): void {
+  if (state.records.at(-1)?.recordId === record.recordId) {
+    state.activeRecordId = activeAfter ? record.recordId : null;
+    return;
+  }
   state.records = [...state.records, record].slice(-MAX_CONTINUITY_RECORDS);
   state.activeRecordId = activeAfter ? record.recordId : null;
 }
@@ -298,19 +293,778 @@ function keepRecent<T>(items: readonly T[], limit: number): T[] {
   return items.slice(-limit);
 }
 
-function buildUnknownAttribution(): AttributionSummary {
+function compareByOccurredAtThenId(
+  left: { readonly occurredAt: string; readonly id: string },
+  right: { readonly occurredAt: string; readonly id: string },
+): number {
+  const byTime = left.occurredAt.localeCompare(right.occurredAt);
+  if (byTime !== 0) {
+    return byTime;
+  }
+  return left.id.localeCompare(right.id);
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function asNullableString(value: unknown): string | null | undefined {
+  if (value === null) {
+    return null;
+  }
+  return asString(value);
+}
+
+function asStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+  const strings: string[] = [];
+  for (const entry of value) {
+    if (typeof entry !== "string" || entry.length === 0) {
+      return undefined;
+    }
+    strings.push(entry);
+  }
+  return strings;
+}
+
+function asUnknownRecord(value: unknown): Record<string, unknown> | undefined {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  return value as Record<string, unknown>;
+}
+
+interface ObservedLocalHistoryNode {
+  readonly id: string;
+  readonly props: Record<string, unknown>;
+}
+
+interface ObservedLocalHistoryEdge {
+  readonly from: string;
+  readonly to: string;
+  readonly label: string;
+}
+
+interface ObservedLocalHistoryGraphSnapshot {
+  readonly nodesById: ReadonlyMap<string, ObservedLocalHistoryNode>;
+  readonly outgoingEdges: ReadonlyMap<string, readonly ObservedLocalHistoryEdge[]>;
+}
+
+const LOCAL_HISTORY_GRAPH_MATCH = ["lh:*"] as const;
+const LOCAL_HISTORY_GRAPH_EXPOSE = [
+  "actorId",
+  "actorKind",
+  "authority",
+  "authorityScope",
+  "attributionBasis",
+  "attributionConfidence",
+  "capturedAt",
+  "causalSessionId",
+  "checkoutEpochId",
+  "continuityKey",
+  "continuityOperation",
+  "continuedFromCausalSessionId",
+  "continuedFromEventId",
+  "continuedFromStrandId",
+  "details",
+  "displayName",
+  "entityKind",
+  "eventId",
+  "eventKind",
+  "evidenceId",
+  "evidenceKind",
+  "fromRef",
+  "occurredAt",
+  "path",
+  "paths",
+  "phase",
+  "projection",
+  "reason",
+  "repoId",
+  "selectionKind",
+  "semanticKind",
+  "source",
+  "sourceLayer",
+  "startLine",
+  "endLine",
+  "strandId",
+  "strength",
+  "summary",
+  "surface",
+  "symbols",
+  "targetId",
+  "toRef",
+  "transitionKind",
+  "transportSessionId",
+  "workspaceOverlayId",
+  "workspaceSliceId",
+  "worktreeId",
+  "createdCheckoutEpochId",
+] as const;
+
+function sortEvidence(evidence: readonly Evidence[]): Evidence[] {
+  return [...evidence].sort((left, right) => {
+    const byCapturedAt = left.capturedAt.localeCompare(right.capturedAt);
+    if (byCapturedAt !== 0) {
+      return byCapturedAt;
+    }
+    return left.evidenceId.localeCompare(right.evidenceId);
+  });
+}
+
+function sortEvents<T extends { readonly occurredAt: string; readonly eventId: string }>(events: readonly T[]): T[] {
+  return [...events].sort((left, right) => compareByOccurredAtThenId(
+    { occurredAt: left.occurredAt, id: left.eventId },
+    { occurredAt: right.occurredAt, id: right.eventId },
+  ));
+}
+
+function sortContinuityRecords(records: readonly ContinuityRecord[]): ContinuityRecord[] {
+  return [...records].sort((left, right) => {
+    const byTime = left.occurredAt.localeCompare(right.occurredAt);
+    if (byTime !== 0) {
+      return byTime;
+    }
+    if (left.continuedFromRecordId === right.recordId) {
+      return 1;
+    }
+    if (right.continuedFromRecordId === left.recordId) {
+      return -1;
+    }
+    if (left.operation !== right.operation) {
+      if (left.operation === "park") {
+        return -1;
+      }
+      if (right.operation === "park") {
+        return 1;
+      }
+    }
+    return left.recordId.localeCompare(right.recordId);
+  });
+}
+
+function outgoingTargets(
+  snapshot: ObservedLocalHistoryGraphSnapshot,
+  nodeId: string,
+  label: string,
+): string[] {
+  return (snapshot.outgoingEdges.get(nodeId) ?? [])
+    .filter((edge) => edge.label === label)
+    .map((edge) => edge.to);
+}
+
+async function loadObservedLocalHistoryGraph(
+  graph: PersistedLocalHistoryGraphContext | null | undefined,
+): Promise<ObservedLocalHistoryGraphSnapshot | null> {
+  if (graph === null || graph === undefined) {
+    return null;
+  }
+
+  const observer = await graph.warp.observer({
+    match: [...LOCAL_HISTORY_GRAPH_MATCH],
+    expose: [...LOCAL_HISTORY_GRAPH_EXPOSE],
+  });
+  const nodeIds = await observer.getNodes();
+  if (nodeIds.length === 0) {
+    return null;
+  }
+
+  const nodesById = new Map<string, ObservedLocalHistoryNode>();
+  for (const nodeId of nodeIds) {
+    const props = await observer.getNodeProps(nodeId);
+    const record = asUnknownRecord(props);
+    if (record !== undefined) {
+      nodesById.set(nodeId, { id: nodeId, props: record });
+    }
+  }
+
+  if (nodesById.size === 0) {
+    return null;
+  }
+
+  const outgoing = new Map<string, ObservedLocalHistoryEdge[]>();
+  for (const edge of await observer.getEdges()) {
+    if (!nodesById.has(edge.from) || !nodesById.has(edge.to)) {
+      continue;
+    }
+    const bucket = outgoing.get(edge.from) ?? [];
+    bucket.push(edge);
+    outgoing.set(edge.from, bucket);
+  }
+
+  return {
+    nodesById,
+    outgoingEdges: outgoing,
+  };
+}
+
+function readEvidenceNode(
+  snapshot: ObservedLocalHistoryGraphSnapshot,
+  nodeId: string,
+): Evidence | null {
+  const node = snapshot.nodesById.get(nodeId);
+  if (node === undefined || asString(node.props["entityKind"]) !== "evidence") {
+    return null;
+  }
+  const parsed = evidenceSchema.safeParse({
+    evidenceId: asString(node.props["evidenceId"]),
+    evidenceKind: asString(node.props["evidenceKind"]),
+    source: asString(node.props["source"]),
+    capturedAt: asString(node.props["capturedAt"]),
+    strength: asString(node.props["strength"]),
+    details: asUnknownRecord(node.props["details"]) ?? {},
+  });
+  return parsed.success ? parsed.data : null;
+}
+
+function readActorNode(
+  snapshot: ObservedLocalHistoryGraphSnapshot,
+  nodeId: string,
+): Actor | null {
+  const node = snapshot.nodesById.get(nodeId);
+  if (node === undefined || asString(node.props["entityKind"]) !== "actor") {
+    return null;
+  }
+  const parsed = actorSchema.safeParse({
+    actorId: asString(node.props["actorId"]),
+    actorKind: asString(node.props["actorKind"]),
+    displayName: asString(node.props["displayName"]),
+    source: asString(node.props["source"]),
+    authorityScope: asString(node.props["authorityScope"]),
+  });
+  return parsed.success ? parsed.data : null;
+}
+
+function readFootprint(
+  snapshot: ObservedLocalHistoryGraphSnapshot,
+  eventNodeId: string,
+): CausalFootprint {
+  const footprintNodeId = outgoingTargets(snapshot, eventNodeId, "has_footprint")[0];
+  const footprintNode = footprintNodeId === undefined ? undefined : snapshot.nodesById.get(footprintNodeId);
+  const regions = (footprintNodeId === undefined ? [] : outgoingTargets(snapshot, footprintNodeId, "has_region"))
+    .map((regionNodeId) => {
+      const regionNode = snapshot.nodesById.get(regionNodeId);
+      if (regionNode === undefined) {
+        return null;
+      }
+      const parsed = causalRegionSchema.safeParse({
+        path: asString(regionNode.props["path"]),
+        startLine: regionNode.props["startLine"],
+        endLine: regionNode.props["endLine"],
+      });
+      return parsed.success ? parsed.data : null;
+    })
+    .filter((region): region is z.infer<typeof causalRegionSchema> => region !== null);
+
+  const parsed = causalFootprintSchema.safeParse({
+    paths: footprintNode === undefined ? [] : asStringArray(footprintNode.props["paths"]) ?? [],
+    symbols: footprintNode === undefined ? [] : asStringArray(footprintNode.props["symbols"]) ?? [],
+    regions,
+  });
+  if (parsed.success) {
+    return parsed.data;
+  }
   return {
-    actor: {
-      actorId: "unknown",
-      actorKind: "unknown",
-      displayName: "Unknown",
-      source: "persisted_local_history.fallback",
-      authorityScope: "inferred",
+    paths: [],
+    symbols: [],
+    regions: [],
+  };
+}
+
+function readSupportedEvidence(
+  snapshot: ObservedLocalHistoryGraphSnapshot,
+  eventNodeId: string,
+): Evidence[] {
+  return sortEvidence(
+    outgoingTargets(snapshot, eventNodeId, "supported_by")
+      .map((nodeId) => readEvidenceNode(snapshot, nodeId))
+      .filter((evidence): evidence is Evidence => evidence !== null),
+  );
+}
+
+function readEventAttribution(
+  snapshot: ObservedLocalHistoryGraphSnapshot,
+  eventNode: ObservedLocalHistoryNode,
+  input: {
+    readonly continuityOperation?: LocalHistoryContinuityOperation | undefined;
+    readonly evidence: readonly Evidence[];
+  },
+): AttributionSummary {
+  if (input.continuityOperation !== undefined) {
+    return deriveContinuityAttribution(input.continuityOperation, input.evidence);
+  }
+
+  const actorNodeId = outgoingTargets(snapshot, eventNode.id, "attributed_to")[0];
+  const actor = actorNodeId === undefined ? null : readActorNode(snapshot, actorNodeId);
+  const parsed = attributionSummarySchema.safeParse({
+    actor: actor ?? buildUnknownAttributionForActorId(asString(eventNode.props["actorId"])).actor,
+    confidence: asString(eventNode.props["attributionConfidence"]) ?? "unknown",
+    basis: asString(eventNode.props["attributionBasis"]) ?? "unknown_fallback",
+    evidence: [...input.evidence],
+  });
+  return parsed.success ? parsed.data : buildUnknownAttributionForActorId(asString(eventNode.props["actorId"]));
+}
+
+function readContinuityRecordFromGraph(
+  snapshot: ObservedLocalHistoryGraphSnapshot,
+  node: ObservedLocalHistoryNode,
+): ContinuityRecord | null {
+  if (
+    asString(node.props["entityKind"]) !== "local_history_event" ||
+    asString(node.props["eventKind"]) !== "continuity"
+  ) {
+    return null;
+  }
+  const operation = localHistoryContinuityOperationSchema.safeParse(asString(node.props["continuityOperation"]));
+  const repoId = asString(node.props["repoId"]);
+  const worktreeId = asString(node.props["worktreeId"]);
+  const recordId = asString(node.props["eventId"]);
+  const occurredAt = asString(node.props["occurredAt"]);
+  const continuityEvidence = readSupportedEvidence(snapshot, node.id);
+  if (!operation.success || repoId === undefined || worktreeId === undefined || recordId === undefined || occurredAt === undefined) {
+    return null;
+  }
+  const parsed = continuityRecordSchema.safeParse({
+    recordId,
+    continuityKey: asString(node.props["continuityKey"]) ?? buildContinuityKey(repoId, worktreeId),
+    operation: operation.data,
+    repoId,
+    worktreeId,
+    transportSessionId: asString(node.props["transportSessionId"]),
+    workspaceSliceId: asString(node.props["workspaceSliceId"]),
+    causalSessionId: asString(node.props["causalSessionId"]),
+    strandId: asString(node.props["strandId"]),
+    checkoutEpochId: asString(node.props["checkoutEpochId"]),
+    workspaceOverlayId: asNullableString(node.props["workspaceOverlayId"]) ?? null,
+    occurredAt,
+    continuedFromRecordId: asNullableString(node.props["continuedFromEventId"]) ?? null,
+    continuedFromCausalSessionId: asNullableString(node.props["continuedFromCausalSessionId"]) ?? null,
+    continuedFromStrandId: asNullableString(node.props["continuedFromStrandId"]) ?? null,
+    continuityConfidence: asString(node.props["attributionConfidence"]) ?? "unknown",
+    continuityEvidence,
+    attribution: readEventAttribution(snapshot, node, {
+      continuityOperation: operation.data,
+      evidence: continuityEvidence,
+    }),
+  });
+  return parsed.success ? parsed.data : null;
+}
+
+function readReadEventFromGraph(
+  snapshot: ObservedLocalHistoryGraphSnapshot,
+  node: ObservedLocalHistoryNode,
+): Extract<CausalEvent, { eventKind: "read" }> | null {
+  if (asString(node.props["entityKind"]) !== "local_history_event" || asString(node.props["eventKind"]) !== "read") {
+    return null;
+  }
+  const evidence = readSupportedEvidence(snapshot, node.id);
+  const parsed = readEventSchema.safeParse({
+    eventId: asString(node.props["eventId"]),
+    eventKind: "read",
+    repoId: asString(node.props["repoId"]),
+    worktreeId: asString(node.props["worktreeId"]),
+    checkoutEpochId: asString(node.props["checkoutEpochId"]),
+    workspaceOverlayId: asNullableString(node.props["workspaceOverlayId"]) ?? null,
+    transportSessionId: asString(node.props["transportSessionId"]),
+    workspaceSliceId: asString(node.props["workspaceSliceId"]),
+    causalSessionId: asString(node.props["causalSessionId"]),
+    strandId: asString(node.props["strandId"]),
+    actorId: asString(node.props["actorId"]) ?? "unknown",
+    confidence: asString(node.props["attributionConfidence"]) ?? "unknown",
+    evidenceIds: evidence.map((item) => item.evidenceId),
+    attribution: readEventAttribution(snapshot, node, { evidence }),
+    footprint: readFootprint(snapshot, node.id),
+    occurredAt: asString(node.props["occurredAt"]),
+    payload: {
+      surface: asString(node.props["surface"]),
+      projection: asString(node.props["projection"]),
+      sourceLayer: asString(node.props["sourceLayer"]),
+      reason: asString(node.props["reason"]),
     },
-    confidence: "unknown",
-    basis: "unknown_fallback",
-    evidence: [],
+  });
+  return parsed.success ? parsed.data : null;
+}
+
+function readStageEventFromGraph(
+  snapshot: ObservedLocalHistoryGraphSnapshot,
+  node: ObservedLocalHistoryNode,
+): Extract<CausalEvent, { eventKind: "stage" }> | null {
+  if (asString(node.props["entityKind"]) !== "local_history_event" || asString(node.props["eventKind"]) !== "stage") {
+    return null;
+  }
+  const evidence = readSupportedEvidence(snapshot, node.id);
+  const footprint = readFootprint(snapshot, node.id);
+  const parsed = stageEventSchema.safeParse({
+    eventId: asString(node.props["eventId"]),
+    eventKind: "stage",
+    repoId: asString(node.props["repoId"]),
+    worktreeId: asString(node.props["worktreeId"]),
+    checkoutEpochId: asString(node.props["checkoutEpochId"]),
+    workspaceOverlayId: asNullableString(node.props["workspaceOverlayId"]) ?? null,
+    transportSessionId: asString(node.props["transportSessionId"]),
+    workspaceSliceId: asString(node.props["workspaceSliceId"]),
+    causalSessionId: asString(node.props["causalSessionId"]),
+    strandId: asString(node.props["strandId"]),
+    actorId: asString(node.props["actorId"]) ?? "unknown",
+    confidence: asString(node.props["attributionConfidence"]) ?? "unknown",
+    evidenceIds: evidence.map((item) => item.evidenceId),
+    attribution: readEventAttribution(snapshot, node, { evidence }),
+    footprint,
+    occurredAt: asString(node.props["occurredAt"]),
+    payload: {
+      targetId: asString(node.props["targetId"]),
+      footprint,
+      selectionKind: asString(node.props["selectionKind"]),
+    },
+  });
+  return parsed.success ? parsed.data : null;
+}
+
+function readTransitionEventFromGraph(
+  snapshot: ObservedLocalHistoryGraphSnapshot,
+  node: ObservedLocalHistoryNode,
+): Extract<CausalEvent, { eventKind: "transition" }> | null {
+  if (
+    asString(node.props["entityKind"]) !== "local_history_event" ||
+    asString(node.props["eventKind"]) !== "transition"
+  ) {
+    return null;
+  }
+  const evidence = readSupportedEvidence(snapshot, node.id);
+  const parsed = transitionEventSchema.safeParse({
+    eventId: asString(node.props["eventId"]),
+    eventKind: "transition",
+    repoId: asString(node.props["repoId"]),
+    worktreeId: asString(node.props["worktreeId"]),
+    checkoutEpochId: asString(node.props["checkoutEpochId"]),
+    workspaceOverlayId: asNullableString(node.props["workspaceOverlayId"]) ?? null,
+    transportSessionId: asString(node.props["transportSessionId"]),
+    workspaceSliceId: asString(node.props["workspaceSliceId"]),
+    causalSessionId: asString(node.props["causalSessionId"]),
+    strandId: asString(node.props["strandId"]),
+    actorId: asString(node.props["actorId"]) ?? "unknown",
+    confidence: asString(node.props["attributionConfidence"]) ?? "unknown",
+    evidenceIds: evidence.map((item) => item.evidenceId),
+    attribution: readEventAttribution(snapshot, node, { evidence }),
+    footprint: readFootprint(snapshot, node.id),
+    occurredAt: asString(node.props["occurredAt"]),
+    payload: {
+      semanticKind: asString(node.props["semanticKind"]),
+      authority: asString(node.props["authority"]),
+      phase: asNullableString(node.props["phase"]) ?? null,
+      summary: asString(node.props["summary"]),
+      transitionKind: asNullableString(node.props["transitionKind"]) ?? null,
+      fromRef: asNullableString(node.props["fromRef"]) ?? null,
+      toRef: asNullableString(node.props["toRef"]) ?? null,
+      createdCheckoutEpochId: asNullableString(node.props["createdCheckoutEpochId"]) ?? null,
+    },
+  });
+  return parsed.success ? parsed.data : null;
+}
+
+function loadStateFromGraphSnapshot(
+  snapshot: ObservedLocalHistoryGraphSnapshot,
+  repoId: string,
+  worktreeId: string,
+): ContinuityState | null {
+  const continuityRecords = sortContinuityRecords(
+    [...snapshot.nodesById.values()]
+      .map((node) => readContinuityRecordFromGraph(snapshot, node))
+      .filter((record): record is ContinuityRecord =>
+        record !== null && record.repoId === repoId && record.worktreeId === worktreeId
+      ),
+  );
+
+  const readEvents = sortEvents(
+    [...snapshot.nodesById.values()]
+      .map((node) => readReadEventFromGraph(snapshot, node))
+      .filter((event): event is Extract<CausalEvent, { eventKind: "read" }> =>
+        event !== null && event.repoId === repoId && event.worktreeId === worktreeId
+      ),
+  );
+  const stageEvents = sortEvents(
+    [...snapshot.nodesById.values()]
+      .map((node) => readStageEventFromGraph(snapshot, node))
+      .filter((event): event is Extract<CausalEvent, { eventKind: "stage" }> =>
+        event !== null && event.repoId === repoId && event.worktreeId === worktreeId
+      ),
+  );
+  const transitionEvents = sortEvents(
+    [...snapshot.nodesById.values()]
+      .map((node) => readTransitionEventFromGraph(snapshot, node))
+      .filter((event): event is Extract<CausalEvent, { eventKind: "transition" }> =>
+        event !== null && event.repoId === repoId && event.worktreeId === worktreeId
+      ),
+  );
+
+  if (
+    continuityRecords.length === 0 &&
+    readEvents.length === 0 &&
+    stageEvents.length === 0 &&
+    transitionEvents.length === 0
+  ) {
+    return null;
+  }
+
+  const lastRecord = continuityRecords.at(-1) ?? null;
+  return {
+    continuityKey: lastRecord?.continuityKey ?? buildContinuityKey(repoId, worktreeId),
+    repoId,
+    worktreeId,
+    activeRecordId: lastRecord === null || lastRecord.operation === "park" ? null : lastRecord.recordId,
+    records: continuityRecords,
+    readEvents,
+    stageEvents,
+    transitionEvents,
+  };
+}
+
+async function loadStateFromGraph(
+  graph: PersistedLocalHistoryGraphContext | null | undefined,
+  repoId: string,
+  worktreeId: string,
+): Promise<ContinuityState | null> {
+  const snapshot = await loadObservedLocalHistoryGraph(graph);
+  if (snapshot === null) {
+    return null;
+  }
+  return loadStateFromGraphSnapshot(snapshot, repoId, worktreeId);
+}
+
+async function loadStatesForRepoFromGraph(
+  graph: PersistedLocalHistoryGraphContext | null | undefined,
+  repoId: string,
+): Promise<ContinuityState[] | null> {
+  const snapshot = await loadObservedLocalHistoryGraph(graph);
+  if (snapshot === null) {
+    return null;
+  }
+
+  const worktreeIds = new Set(
+    [...snapshot.nodesById.values()]
+      .filter((node) => asString(node.props["repoId"]) === repoId)
+      .map((node) => asString(node.props["worktreeId"]))
+      .filter((value): value is string => value !== undefined),
+  );
+
+  const states = [...worktreeIds]
+    .map((worktreeId) => loadStateFromGraphSnapshot(snapshot, repoId, worktreeId))
+    .filter((state): state is ContinuityState => state !== null);
+
+  return states.length > 0 ? states : null;
+}
+
+interface LegacyPersistedLocalHistoryArtifact {
+  readonly filePath: string;
+  readonly state: ContinuityState;
+}
+
+export interface PersistedLocalHistoryMigrationResult {
+  graftDir: string;
+  discoveredArtifacts: number;
+  migratedArtifacts: number;
+  malformedArtifacts: number;
+  importedContinuityRecords: number;
+  importedReadEvents: number;
+  importedStageEvents: number;
+  importedTransitionEvents: number;
+  skippedContinuityRecords: number;
+  skippedReadEvents: number;
+  skippedStageEvents: number;
+  skippedTransitionEvents: number;
+}
+
+async function loadLegacyPersistedLocalHistoryArtifacts(input: {
+  readonly fs: FileSystem;
+  readonly codec: JsonCodec;
+  readonly graftDir: string;
+}): Promise<{
+  readonly artifacts: readonly LegacyPersistedLocalHistoryArtifact[];
+  readonly malformedArtifacts: number;
+}> {
+  const historyDir = path.join(input.graftDir, "local-history");
+  let filenames: string[];
+  try {
+    filenames = await input.fs.readdir(historyDir);
+  } catch {
+    return {
+      artifacts: [],
+      malformedArtifacts: 0,
+    };
+  }
+
+  const artifacts: LegacyPersistedLocalHistoryArtifact[] = [];
+  let malformedArtifacts = 0;
+
+  for (const filename of filenames) {
+    if (!filename.endsWith(".json")) {
+      continue;
+    }
+    const filePath = path.join(historyDir, filename);
+    try {
+      const raw = await input.fs.readFile(filePath, "utf-8");
+      const state = continuityStateSchema.parse(input.codec.decode(raw));
+      artifacts.push({ filePath, state });
+    } catch {
+      malformedArtifacts += 1;
+    }
+  }
+
+  return {
+    artifacts,
+    malformedArtifacts,
+  };
+}
+
+function buildLegacyMigrationSequence(state: ContinuityState): {
+  readonly kind: "continuity" | "read" | "stage" | "transition";
+  readonly occurredAt: string;
+  readonly sequence: number;
+  readonly id: string;
+  readonly record?: ContinuityRecord;
+  readonly event?: Extract<CausalEvent, { eventKind: "read" | "stage" | "transition" }>;
+}[] {
+  const sequence = [
+    ...state.records.map((record, sequenceIndex) => ({
+      kind: "continuity" as const,
+      occurredAt: record.occurredAt,
+      sequence: sequenceIndex,
+      id: record.recordId,
+      record,
+    })),
+    ...state.readEvents.map((event, sequenceIndex) => ({
+      kind: "read" as const,
+      occurredAt: event.occurredAt,
+      sequence: sequenceIndex,
+      id: event.eventId,
+      event,
+    })),
+    ...state.stageEvents.map((event, sequenceIndex) => ({
+      kind: "stage" as const,
+      occurredAt: event.occurredAt,
+      sequence: sequenceIndex,
+      id: event.eventId,
+      event,
+    })),
+    ...state.transitionEvents.map((event, sequenceIndex) => ({
+      kind: "transition" as const,
+      occurredAt: event.occurredAt,
+      sequence: sequenceIndex,
+      id: event.eventId,
+      event,
+    })),
+  ];
+
+  const priority = { continuity: 0, read: 1, stage: 2, transition: 3 } as const;
+
+  return sequence.sort((left, right) => {
+    const byTime = left.occurredAt.localeCompare(right.occurredAt);
+    if (byTime !== 0) {
+      return byTime;
+    }
+    const byPriority = priority[left.kind] - priority[right.kind];
+    if (byPriority !== 0) {
+      return byPriority;
+    }
+    const bySequence = left.sequence - right.sequence;
+    if (bySequence !== 0) {
+      return bySequence;
+    }
+    return left.id.localeCompare(right.id);
+  });
+}
+
+async function hasLocalHistoryEventNode(
+  graph: PersistedLocalHistoryGraphContext,
+  eventId: string,
+): Promise<boolean> {
+  return graph.warp.hasNode(`lh:event:${eventId}`);
+}
+
+export async function migrateLegacyPersistedLocalHistoryToGraph(input: {
+  readonly fs: FileSystem;
+  readonly codec: JsonCodec;
+  readonly graftDir: string;
+  readonly graph: PersistedLocalHistoryGraphContext;
+}): Promise<PersistedLocalHistoryMigrationResult> {
+  const { artifacts, malformedArtifacts } = await loadLegacyPersistedLocalHistoryArtifacts(input);
+  const result: PersistedLocalHistoryMigrationResult = {
+    graftDir: input.graftDir,
+    discoveredArtifacts: artifacts.length,
+    migratedArtifacts: 0,
+    malformedArtifacts,
+    importedContinuityRecords: 0,
+    importedReadEvents: 0,
+    importedStageEvents: 0,
+    importedTransitionEvents: 0,
+    skippedContinuityRecords: 0,
+    skippedReadEvents: 0,
+    skippedStageEvents: 0,
+    skippedTransitionEvents: 0,
   };
+
+  for (const artifact of artifacts) {
+    const importedState = createEmptyState(
+      artifact.state.continuityKey,
+      artifact.state.repoId,
+      artifact.state.worktreeId,
+    );
+
+    for (const item of buildLegacyMigrationSequence(artifact.state)) {
+      if (item.kind === "continuity" && item.record !== undefined) {
+        const previousEventId = findLatestEventIdForStrand(importedState, item.record.strandId);
+        if (await hasLocalHistoryEventNode(input.graph, item.record.recordId)) {
+          result.skippedContinuityRecords += 1;
+        } else {
+          await writeContinuityRecordToGraph(input.graph, {
+            record: item.record,
+            previousEventId,
+          });
+          result.importedContinuityRecords += 1;
+        }
+        importedState.records.push(item.record);
+        if (artifact.state.activeRecordId === item.record.recordId) {
+          importedState.activeRecordId = item.record.recordId;
+        }
+        continue;
+      }
+
+      if (item.event === undefined) {
+        continue;
+      }
+
+      const previousEventId = item.event.strandId === null
+        ? null
+        : findLatestEventIdForStrand(importedState, item.event.strandId);
+      if (await hasLocalHistoryEventNode(input.graph, item.event.eventId)) {
+        if (item.kind === "read") result.skippedReadEvents += 1;
+        if (item.kind === "stage") result.skippedStageEvents += 1;
+        if (item.kind === "transition") result.skippedTransitionEvents += 1;
+      } else {
+        await writeCausalEventToGraph(input.graph, {
+          event: item.event,
+          previousEventId,
+        });
+        if (item.kind === "read") result.importedReadEvents += 1;
+        if (item.kind === "stage") result.importedStageEvents += 1;
+        if (item.kind === "transition") result.importedTransitionEvents += 1;
+      }
+
+      if (item.kind === "read") {
+        importedState.readEvents.push(item.event as Extract<CausalEvent, { eventKind: "read" }>);
+      } else if (item.kind === "stage") {
+        importedState.stageEvents.push(item.event as Extract<CausalEvent, { eventKind: "stage" }>);
+      } else {
+        importedState.transitionEvents.push(item.event as Extract<CausalEvent, { eventKind: "transition" }>);
+      }
+    }
+
+    result.migratedArtifacts += 1;
+  }
+
+  return result;
 }
 
 export class PersistedLocalHistoryStore {
@@ -325,145 +1079,220 @@ export class PersistedLocalHistoryStore {
   async noteBinding(input: {
     readonly current: PersistedLocalHistoryContext;
     readonly previous?: PersistedLocalHistoryContext | null;
+    readonly currentGraph?: PersistedLocalHistoryGraphContext | null;
+    readonly previousGraph?: PersistedLocalHistoryGraphContext | null;
   }): Promise<void> {
     const previous = input.previous ?? null;
     const currentKey = buildContinuityKey(input.current.repoId, input.current.worktreeId);
 
-    if (previous !== null) {
+    if (previous !== null && input.previousGraph !== null && input.previousGraph !== undefined) {
       const previousKey = buildContinuityKey(previous.repoId, previous.worktreeId);
       if (previousKey !== currentKey) {
-        const previousState = await this.loadState(previousKey, previous.repoId, previous.worktreeId);
+        const previousState = await this.loadWritableState(
+          input.previousGraph,
+          previousKey,
+          previous.repoId,
+          previous.worktreeId,
+        );
         const previousActive = findRecord(previousState, previousState.activeRecordId);
         if (previousActive !== null) {
+          const parkRecord = createContinuityRecord({
+            operation: "park",
+            continuityKey: previousKey,
+            context: previous,
+            previous: previousActive,
+          });
+          const previousEventId = findLatestEventIdForStrand(previousState, previous.strandId);
           appendRecord(
             previousState,
-            this.createRecord("park", previousKey, previous, previousActive),
+            parkRecord,
             false,
           );
-          await this.saveState(previousState);
+          await writeContinuityRecordToGraph(input.previousGraph, {
+            record: parkRecord,
+            previousEventId,
+          });
         }
       }
     }
 
-    const currentState = await this.loadState(currentKey, input.current.repoId, input.current.worktreeId);
+    const currentState = await this.loadWritableState(
+      input.currentGraph,
+      currentKey,
+      input.current.repoId,
+      input.current.worktreeId,
+    );
     const previousCurrentActive = findRecord(currentState, currentState.activeRecordId);
+    let latestCurrentEventId = findLatestEventIdForStrand(currentState, input.current.strandId);
     if (previousCurrentActive !== null) {
+      const parkRecord = createContinuityRecord({
+        operation: "park",
+        continuityKey: currentKey,
+        context: input.current,
+        previous: previousCurrentActive,
+      });
+      const parkPreviousEventId = latestCurrentEventId;
       appendRecord(
         currentState,
-        this.createRecord("park", currentKey, input.current, previousCurrentActive),
+        parkRecord,
         false,
       );
+      if (parkRecord.strandId === input.current.strandId) {
+        latestCurrentEventId = parkRecord.recordId;
+      }
+      if (input.currentGraph !== null && input.currentGraph !== undefined) {
+        await writeContinuityRecordToGraph(input.currentGraph, {
+          record: parkRecord,
+          previousEventId: parkPreviousEventId,
+        });
+      }
     }
 
-    const operation = this.classifyOperation(previousCurrentActive, input.current);
+    const operation = classifyContinuityOperation(previousCurrentActive, input.current);
+    const currentRecord = createContinuityRecord({
+      operation,
+      continuityKey: currentKey,
+      context: input.current,
+      previous: previousCurrentActive,
+    });
     appendRecord(
       currentState,
-      this.createRecord(operation, currentKey, input.current, previousCurrentActive),
+      currentRecord,
       true,
     );
-    await this.saveState(currentState);
+    if (input.currentGraph !== null && input.currentGraph !== undefined) {
+      await writeContinuityRecordToGraph(input.currentGraph, {
+        record: currentRecord,
+        previousEventId: latestCurrentEventId,
+      });
+    }
   }
 
   async noteCheckoutBoundary(input: {
     readonly previous: PersistedLocalHistoryContext;
     readonly current: PersistedLocalHistoryContext;
+    readonly graph?: PersistedLocalHistoryGraphContext | null;
   }): Promise<void> {
     const continuityKey = buildContinuityKey(input.current.repoId, input.current.worktreeId);
-    const state = await this.loadState(continuityKey, input.current.repoId, input.current.worktreeId);
+    const state = await this.loadWritableState(
+      input.graph,
+      continuityKey,
+      input.current.repoId,
+      input.current.worktreeId,
+    );
     const activeRecord = findRecord(state, state.activeRecordId);
     const baseRecord = activeRecord ?? state.records.at(-1) ?? null;
     if (baseRecord === null) {
+      const startRecord = createContinuityRecord({
+        operation: "start",
+        continuityKey,
+        context: input.current,
+        previous: null,
+      });
       appendRecord(
         state,
-        this.createRecord("start", continuityKey, input.current, null),
+        startRecord,
         true,
       );
-      await this.saveState(state);
+      if (input.graph !== null && input.graph !== undefined) {
+        await writeContinuityRecordToGraph(input.graph, {
+          record: startRecord,
+          previousEventId: null,
+        });
+      }
       return;
     }
     if (baseRecord.checkoutEpochId === input.current.checkoutEpochId) {
       return;
     }
 
-    const transitionEvidence = this.buildGitTransitionEvidence("fork", input.current);
+    const transitionEvidence = buildGitTransitionEvidence("fork", input.current);
+    const parkPreviousEventId = findLatestEventIdForStrand(state, input.previous.strandId);
+    const parkRecord = createContinuityRecord({
+      operation: "park",
+      continuityKey,
+      context: { ...input.previous, observedAt: input.current.observedAt },
+      previous: baseRecord,
+      additionalEvidence: transitionEvidence,
+    });
     appendRecord(
       state,
-      this.createRecord(
-        "park",
-        continuityKey,
-        { ...input.previous, observedAt: input.current.observedAt },
-        baseRecord,
-        transitionEvidence,
-      ),
+      parkRecord,
       false,
     );
+    const forkRecord = createContinuityRecord({
+      operation: "fork",
+      continuityKey,
+      context: input.current,
+      previous: baseRecord,
+      additionalEvidence: transitionEvidence,
+    });
     appendRecord(
       state,
-      this.createRecord("fork", continuityKey, input.current, baseRecord, transitionEvidence),
+      forkRecord,
       true,
     );
-    await this.saveState(state);
+    if (input.graph !== null && input.graph !== undefined) {
+      await writeContinuityRecordToGraph(input.graph, {
+        record: parkRecord,
+        previousEventId: parkPreviousEventId,
+      });
+      await writeContinuityRecordToGraph(input.graph, {
+        record: forkRecord,
+        previousEventId: null,
+      });
+    }
   }
 
-  async summarize(status: WorkspaceStatus, causalContext: RuntimeCausalContext): Promise<PersistedLocalHistorySummary> {
+  async summarize(
+    status: WorkspaceStatus,
+    causalContext: RuntimeCausalContext,
+    graph?: PersistedLocalHistoryGraphContext | null,
+  ): Promise<PersistedLocalHistorySummary> {
     if (status.repoId === null || status.worktreeId === null) {
-      return this.emptySummary();
+      return emptyPersistedLocalHistorySummary({
+        preserves: PERSISTED_LOCAL_HISTORY_PRESERVES,
+        excludes: PERSISTED_LOCAL_HISTORY_EXCLUDES,
+      });
     }
 
-    const continuityKey = buildContinuityKey(status.repoId, status.worktreeId);
-    const state = await this.loadState(continuityKey, status.repoId, status.worktreeId);
-    const activeRecord = findRecord(state, state.activeRecordId);
-    const lastRecord = state.records.at(-1) ?? null;
-    if (lastRecord === null || status.graftDir === null) {
-      return this.emptySummary();
+    const graphState = await loadStateFromGraph(graph, status.repoId, status.worktreeId);
+    if (graphState === null) {
+      return emptyPersistedLocalHistorySummary({
+        preserves: PERSISTED_LOCAL_HISTORY_PRESERVES,
+        excludes: PERSISTED_LOCAL_HISTORY_EXCLUDES,
+      });
     }
-
-    const effectiveRecord = activeRecord ?? lastRecord;
-    return {
-      availability: "present",
-      persistence: "persisted_local_history",
-      historyPath: this.historyPathFor(continuityKey),
-      totalContinuityRecords: state.records.length,
-      active: activeRecord !== null,
-      lastOperation: lastRecord.operation,
-      lastObservedAt: lastRecord.occurredAt,
-      continuityKey,
-      causalSessionId: effectiveRecord.causalSessionId,
-      strandId: effectiveRecord.strandId,
-      checkoutEpochId: effectiveRecord.checkoutEpochId,
-      continuedFromCausalSessionId: lastRecord.continuedFromCausalSessionId,
-      continuityConfidence: lastRecord.continuityConfidence,
-      continuityEvidence: lastRecord.continuityEvidence,
-      attribution: effectiveRecord.attribution,
-      latestReadEvent: state.readEvents.at(-1) ?? null,
-      latestStageEvent: state.stageEvents.at(-1) ?? null,
-      latestTransitionEvent: state.transitionEvents.at(-1) ?? null,
+    return summarizeContinuityState({
+      state: graphState,
+      causalContext,
       preserves: PERSISTED_LOCAL_HISTORY_PRESERVES,
       excludes: PERSISTED_LOCAL_HISTORY_EXCLUDES,
-      nextAction: activeRecord?.causalSessionId === causalContext.causalSessionId
-        ? (lastRecord.operation === "fork"
-            ? "review_transition_boundary_before_continuing"
-            : "continue_active_causal_workspace")
-        : "inspect_or_resume_local_history",
-    };
+    });
   }
 
-  async summarizeRepoConcurrency(status: WorkspaceStatus): Promise<RepoConcurrencySummary | null> {
+  async summarizeRepoConcurrency(
+    status: WorkspaceStatus,
+    graph?: PersistedLocalHistoryGraphContext | null,
+  ): Promise<RepoConcurrencySummary | null> {
     if (status.repoId === null || status.worktreeId === null) {
       return null;
     }
 
-    const continuityKey = buildContinuityKey(status.repoId, status.worktreeId);
-    const currentState = await this.loadState(continuityKey, status.repoId, status.worktreeId);
-    const repoStates = await this.loadStatesForRepo(status.repoId);
+    const currentState = await loadStateFromGraph(graph, status.repoId, status.worktreeId);
+    if (currentState === null) {
+      return null;
+    }
+    const graphStates = await loadStatesForRepoFromGraph(graph, status.repoId);
+    const repoStates = graphStates ?? [currentState];
 
     return deriveRepoConcurrencySummary({
       currentWorktreeId: status.worktreeId,
       histories: [
-        this.toWorktreeHistory(currentState),
+        toRepoConcurrencyWorktreeHistory(currentState),
         ...repoStates
           .filter((state) => state.continuityKey !== currentState.continuityKey)
-          .map((state) => this.toWorktreeHistory(state)),
+          .map((state) => toRepoConcurrencyWorktreeHistory(state)),
       ],
     });
   }
@@ -472,148 +1301,158 @@ export class PersistedLocalHistoryStore {
     status: WorkspaceStatus,
     causalContext: RuntimeCausalContext,
     limit: number,
+    graph?: PersistedLocalHistoryGraphContext | null,
   ): Promise<PersistedLocalActivityWindow> {
-    if (status.repoId === null || status.worktreeId === null || status.graftDir === null) {
-      return {
-        historyPath: null,
-        limit,
-        totalMatchingItems: 0,
-        truncated: false,
-        items: [],
-      };
+    if (status.repoId === null || status.worktreeId === null) {
+      return emptyPersistedLocalActivityWindow(limit);
     }
 
-    const continuityKey = buildContinuityKey(status.repoId, status.worktreeId);
-    const state = await this.loadState(continuityKey, status.repoId, status.worktreeId);
-    const activeRecord = findRecord(state, state.activeRecordId);
-    const effectiveCheckoutEpochId =
-      activeRecord?.checkoutEpochId
-      ?? state.records.at(-1)?.checkoutEpochId
-      ?? causalContext.checkoutEpochId;
-
-    const continuityItems: PersistedLocalActivityContinuityItem[] = state.records
-      .filter((record) => record.checkoutEpochId === effectiveCheckoutEpochId)
-      .map((record) => ({
-        itemKind: "continuity",
-        recordId: record.recordId,
-        operation: record.operation,
-        occurredAt: record.occurredAt,
-        causalSessionId: record.causalSessionId,
-        strandId: record.strandId,
-        attribution: record.attribution,
-        continuedFromCausalSessionId: record.continuedFromCausalSessionId,
-        continuedFromStrandId: record.continuedFromStrandId,
-      }));
-
-    const eventItems: PersistedLocalActivityItem[] = [
-      ...state.readEvents,
-      ...state.stageEvents,
-      ...state.transitionEvents,
-    ].filter((event) => event.checkoutEpochId === effectiveCheckoutEpochId);
-
-    const allItems = [...continuityItems, ...eventItems].sort((left, right) => {
-      const byTime = right.occurredAt.localeCompare(left.occurredAt);
-      if (byTime !== 0) {
-        return byTime;
-      }
-      const leftId = "recordId" in left ? left.recordId : left.eventId;
-      const rightId = "recordId" in right ? right.recordId : right.eventId;
-      return rightId.localeCompare(leftId);
-    });
-
-    return {
-      historyPath: this.historyPathFor(continuityKey),
+    const graphState = await loadStateFromGraph(graph, status.repoId, status.worktreeId);
+    if (graphState === null) {
+      return emptyPersistedLocalActivityWindow(limit);
+    }
+    return buildPersistedLocalActivityWindow({
+      state: graphState,
+      causalContext,
       limit,
-      totalMatchingItems: allItems.length,
-      truncated: allItems.length > limit,
-      items: allItems.slice(0, limit),
-    };
+    });
   }
 
   async declareAttach(input: {
     readonly current: PersistedLocalHistoryContext;
     readonly declaration: PersistedLocalHistoryAttachDeclaration;
+    readonly graph?: PersistedLocalHistoryGraphContext | null;
   }): Promise<void> {
     const continuityKey = buildContinuityKey(input.current.repoId, input.current.worktreeId);
-    const state = await this.loadState(continuityKey, input.current.repoId, input.current.worktreeId);
+    const state = await this.loadWritableState(
+      input.graph,
+      continuityKey,
+      input.current.repoId,
+      input.current.worktreeId,
+    );
     const activeRecord = findRecord(state, state.activeRecordId);
     const baseRecord = activeRecord ?? state.records.at(-1) ?? null;
     if (baseRecord?.continuedFromRecordId === null || baseRecord === null) {
       throw new PersistedLocalHistoryAttachUnavailableError();
     }
 
+    const attachRecord = createContinuityRecord({
+      operation: "attach",
+      continuityKey,
+      context: input.current,
+      previous: baseRecord,
+      additionalEvidence: buildAttachDeclarationEvidence(input.current, input.declaration),
+    });
     appendRecord(
       state,
-      this.createRecord(
-        "attach",
-        continuityKey,
-        input.current,
-        baseRecord,
-        this.buildAttachDeclarationEvidence(input.current, input.declaration),
-      ),
+      attachRecord,
       true,
     );
-    await this.saveState(state);
+    if (input.graph !== null && input.graph !== undefined) {
+      const previousEventId = findLatestEventIdForStrand(
+        {
+          ...state,
+          records: state.records.slice(0, -1),
+        },
+        input.current.strandId,
+      );
+      await writeContinuityRecordToGraph(input.graph, {
+        record: attachRecord,
+        previousEventId,
+      });
+    }
   }
 
   async declareSharedAttach(input: {
     readonly current: PersistedLocalHistoryContext;
     readonly declaration: PersistedLocalHistoryAttachDeclaration;
     readonly source: PersistedLocalHistorySharedAttachSource;
+    readonly graph?: PersistedLocalHistoryGraphContext | null;
   }): Promise<void> {
     const continuityKey = buildContinuityKey(input.current.repoId, input.current.worktreeId);
-    const state = await this.loadState(continuityKey, input.current.repoId, input.current.worktreeId);
+    const state = await this.loadWritableState(
+      input.graph,
+      continuityKey,
+      input.current.repoId,
+      input.current.worktreeId,
+    );
     const baseRecord = findRecord(state, state.activeRecordId) ?? state.records.at(-1) ?? null;
     if (baseRecord === null) {
       throw new PersistedLocalHistoryAttachUnavailableError();
     }
 
-    appendRecord(
-      state,
-      this.createRecord(
-        "attach",
-        continuityKey,
-        input.current,
-        baseRecord,
-        [
-          ...this.buildAttachDeclarationEvidence(input.current, input.declaration),
-          {
-            evidenceId: buildEvidenceId("attach", "daemon_session_observation", input.current, 400),
-            evidenceKind: "daemon_session_observation",
-            source: "daemon_control_plane.shared_attach",
-            capturedAt: input.current.observedAt,
-            strength: "strong",
-            details: {
-              sourceSessionId: input.source.sourceSessionId,
-              sourceCausalSessionId: input.source.causalSessionId,
-              sourceStrandId: input.source.strandId,
-              handoffKind: "cross_session_same_worktree",
-            },
-          },
-        ],
+    const attachRecord = createContinuityRecord({
+      operation: "attach",
+      continuityKey,
+      context: input.current,
+      previous: baseRecord,
+      additionalEvidence: [
+        ...buildAttachDeclarationEvidence(input.current, input.declaration),
         {
-          continuedFromCausalSessionId: input.source.causalSessionId,
-          continuedFromStrandId: input.source.strandId,
+          evidenceId: buildEvidenceId("attach", "daemon_session_observation", input.current, 400),
+          evidenceKind: "daemon_session_observation",
+          source: "daemon_control_plane.shared_attach",
+          capturedAt: input.current.observedAt,
+          strength: "strong",
+          details: {
+            sourceSessionId: input.source.sourceSessionId,
+            sourceCausalSessionId: input.source.causalSessionId,
+            sourceStrandId: input.source.strandId,
+            handoffKind: "cross_session_same_worktree",
+          },
         },
-      ),
+      ],
+      overrides: {
+        continuedFromCausalSessionId: input.source.causalSessionId,
+        continuedFromStrandId: input.source.strandId,
+      },
+    });
+    appendRecord(
+      state,
+      attachRecord,
       true,
     );
-    await this.saveState(state);
+    if (input.graph !== null && input.graph !== undefined) {
+      const previousEventId = findLatestEventIdForStrand(
+        {
+          ...state,
+          records: state.records.slice(0, -1),
+        },
+        input.current.strandId,
+      );
+      await writeContinuityRecordToGraph(input.graph, {
+        record: attachRecord,
+        previousEventId,
+      });
+    }
   }
 
   async noteStageObservation(input: {
     readonly current: PersistedLocalHistoryContext;
     readonly stagedTarget: RuntimeStagedTargetFullFile;
     readonly attribution: AttributionSummary;
+    readonly graph?: PersistedLocalHistoryGraphContext | null;
   }): Promise<void> {
     const continuityKey = buildContinuityKey(input.current.repoId, input.current.worktreeId);
-    const state = await this.loadState(continuityKey, input.current.repoId, input.current.worktreeId);
-    const event = this.createStageEvent(input.current, input.stagedTarget, input.attribution);
+    const state = await this.loadWritableState(
+      input.graph,
+      continuityKey,
+      input.current.repoId,
+      input.current.worktreeId,
+    );
+    const event = createStageEvent(input.current, input.stagedTarget, input.attribution);
     if (state.stageEvents.at(-1)?.eventId === event.eventId) {
       return;
     }
+    const previousEventId = findLatestEventIdForStrand(state, input.current.strandId);
     state.stageEvents = keepRecent([...state.stageEvents, event], MAX_STAGE_EVENTS);
-    await this.saveState(state);
+    if (input.graph !== null && input.graph !== undefined) {
+      await writeCausalEventToGraph(input.graph, {
+        event,
+        previousEventId,
+        stagedTarget: input.stagedTarget,
+      });
+    }
   }
 
   async noteReadObservation(input: {
@@ -624,11 +1463,27 @@ export class PersistedLocalHistoryStore {
     readonly sourceLayer: SourceLayer;
     readonly reason: string;
     readonly footprint: CausalFootprint;
+    readonly graph?: PersistedLocalHistoryGraphContext | null;
   }): Promise<void> {
     const continuityKey = buildContinuityKey(input.current.repoId, input.current.worktreeId);
-    const state = await this.loadState(continuityKey, input.current.repoId, input.current.worktreeId);
-    state.readEvents = keepRecent([...state.readEvents, this.createReadEvent(input)], MAX_READ_EVENTS);
-    await this.saveState(state);
+    const state = await this.loadWritableState(
+      input.graph,
+      continuityKey,
+      input.current.repoId,
+      input.current.worktreeId,
+    );
+    const event = createReadEvent(input);
+    if (state.readEvents.at(-1)?.eventId === event.eventId) {
+      return;
+    }
+    const previousEventId = findLatestEventIdForStrand(state, input.current.strandId);
+    state.readEvents = keepRecent([...state.readEvents, event], MAX_READ_EVENTS);
+    if (input.graph !== null && input.graph !== undefined) {
+      await writeCausalEventToGraph(input.graph, {
+        event,
+        previousEventId,
+      });
+    }
   }
 
   async noteSemanticTransitionObservation(input: {
@@ -636,15 +1491,27 @@ export class PersistedLocalHistoryStore {
     readonly semanticTransition: NonNullable<RepoObservation["semanticTransition"]>;
     readonly transition: RepoObservation["lastTransition"];
     readonly attribution: AttributionSummary;
+    readonly graph?: PersistedLocalHistoryGraphContext | null;
   }): Promise<void> {
     const continuityKey = buildContinuityKey(input.current.repoId, input.current.worktreeId);
-    const state = await this.loadState(continuityKey, input.current.repoId, input.current.worktreeId);
-    const event = this.createTransitionEvent(input);
+    const state = await this.loadWritableState(
+      input.graph,
+      continuityKey,
+      input.current.repoId,
+      input.current.worktreeId,
+    );
+    const event = createTransitionEvent(input);
     if (state.transitionEvents.at(-1)?.eventId === event.eventId) {
       return;
     }
+    const previousEventId = findLatestEventIdForStrand(state, input.current.strandId);
     state.transitionEvents = keepRecent([...state.transitionEvents, event], MAX_TRANSITION_EVENTS);
-    await this.saveState(state);
+    if (input.graph !== null && input.graph !== undefined) {
+      await writeCausalEventToGraph(input.graph, {
+        event,
+        previousEventId,
+      });
+    }
   }
 
   buildContext(
@@ -675,572 +1542,80 @@ export class PersistedLocalHistoryStore {
     };
   }
 
-  private classifyOperation(
-    previous: ContinuityRecord | null,
-    current: PersistedLocalHistoryContext,
-  ): LocalHistoryContinuityOperation {
-    if (previous === null) {
-      return "start";
-    }
-    if (previous.transportSessionId === current.transportSessionId) {
-      return "resume";
-    }
-    if (previous.checkoutEpochId === current.checkoutEpochId) {
-      return "attach";
-    }
-    return "fork";
-  }
-
-  private createRecord(
-    operation: LocalHistoryContinuityOperation,
+  private async loadWritableState(
+    graph: PersistedLocalHistoryGraphContext | null | undefined,
     continuityKey: string,
-    context: PersistedLocalHistoryContext,
-    previous: ContinuityRecord | null,
-    additionalEvidence: readonly Evidence[] = [],
-    overrides: {
-      readonly continuedFromCausalSessionId?: string | null;
-      readonly continuedFromStrandId?: string | null;
-    } = {},
-  ): ContinuityRecord {
-    const continuityEvidence = [
-      ...this.buildContinuityEvidence(operation, context, previous),
-      ...additionalEvidence,
-    ];
-    return {
-      recordId: buildRecordId(
-        continuityKey,
-        operation,
-        context,
-        previous?.recordId ?? null,
-        additionalEvidence.map((evidence) => evidence.evidenceId),
-      ),
-      continuityKey,
-      operation,
-      repoId: context.repoId,
-      worktreeId: context.worktreeId,
-      transportSessionId: context.transportSessionId,
-      workspaceSliceId: context.workspaceSliceId,
-      causalSessionId: context.causalSessionId,
-      strandId: context.strandId,
-      checkoutEpochId: context.checkoutEpochId,
-      workspaceOverlayId: context.workspaceOverlayId,
-      occurredAt: context.observedAt,
-      continuedFromRecordId: previous?.recordId ?? null,
-      continuedFromCausalSessionId: overrides.continuedFromCausalSessionId ?? previous?.causalSessionId ?? null,
-      continuedFromStrandId: overrides.continuedFromStrandId ?? previous?.strandId ?? null,
-      continuityConfidence: getMaximumConfidenceForEvidence(
-        continuityEvidence.map((evidence) => evidence.strength),
-      ),
-      continuityEvidence,
-      attribution: this.deriveAttribution(operation, continuityEvidence),
-    };
-  }
-
-  private buildContinuityEvidence(
-    operation: LocalHistoryContinuityOperation,
-    context: PersistedLocalHistoryContext,
-    previous: ContinuityRecord | null,
-  ): Evidence[] {
-    const evidence: Evidence[] = [];
-
-    evidence.push({
-      evidenceId: buildEvidenceId(operation, "mcp_transport_binding", context, evidence.length),
-      evidenceKind: "mcp_transport_binding",
-      source: "persisted_local_history.transport_binding",
-      capturedAt: context.observedAt,
-      strength: operation === "start" || operation === "resume" ? "direct" : "strong",
-      details: {
-        operation,
-        transportSessionId: context.transportSessionId,
-        workspaceSliceId: context.workspaceSliceId,
-      },
-    });
-
-    evidence.push({
-      evidenceId: buildEvidenceId(operation, "worktree_fs_observation", context, evidence.length),
-      evidenceKind: "worktree_fs_observation",
-      source: "persisted_local_history.workspace_footing",
-      capturedAt: context.observedAt,
-      strength: "strong",
-      details: {
-        repoId: context.repoId,
-        worktreeId: context.worktreeId,
-        checkoutEpochId: context.checkoutEpochId,
-        workspaceOverlayId: context.workspaceOverlayId,
-        previousCheckoutEpochId: previous?.checkoutEpochId ?? null,
-        previousCausalSessionId: previous?.causalSessionId ?? null,
-      },
-    });
-
-    evidence.push({
-      evidenceId: buildEvidenceId(operation, "writer_lane_identity", context, evidence.length),
-      evidenceKind: "writer_lane_identity",
-      source: "persisted_local_history.writer_lane",
-      capturedAt: context.observedAt,
-      strength: "strong",
-      details: {
-        warpWriterId: context.warpWriterId,
-        causalSessionId: context.causalSessionId,
-        strandId: context.strandId,
-      },
-    });
-
-    return evidence;
+    repoId: string,
+    worktreeId: string,
+  ): Promise<ContinuityState> {
+    return await loadStateFromGraph(graph, repoId, worktreeId) ?? createEmptyState(continuityKey, repoId, worktreeId);
   }
+}
 
-  private buildGitTransitionEvidence(
-    operation: LocalHistoryContinuityOperation,
-    context: PersistedLocalHistoryContext,
-  ): Evidence[] {
-    const evidence: Evidence[] = [];
-
-    if (context.transitionKind !== null) {
-      evidence.push({
-        evidenceId: buildEvidenceId(operation, "git_transition_observation", context, 500),
-        evidenceKind: "git_transition_observation",
-        source: "persisted_local_history.checkout_transition",
-        capturedAt: context.observedAt,
-        strength: "strong",
-        details: {
-          operation,
-          transitionKind: context.transitionKind,
-          reflogSubject: context.transitionReflogSubject,
-        },
-      });
-    }
-
-    if (context.hookTransitionName !== null) {
-      evidence.push({
-        evidenceId: buildEvidenceId(operation, "git_hook_transition", context, 501),
-        evidenceKind: "git_hook_transition",
-        source: "persisted_local_history.checkout_transition_hook",
-        capturedAt: context.hookTransitionObservedAt ?? context.observedAt,
-        strength: "direct",
-        details: {
-          operation,
-          hookName: context.hookTransitionName,
-          hookArgs: context.hookTransitionArgs,
-        },
+function findLatestEventIdForStrand(state: ContinuityState, strandId: string): string | null {
+  const items: {
+    readonly id: string;
+    readonly occurredAt: string;
+    readonly priority: number;
+    readonly sequence: number;
+  }[] = [];
+
+  for (const [index, record] of state.records.entries()) {
+    if (record.strandId === strandId) {
+      items.push({
+        id: record.recordId,
+        occurredAt: record.occurredAt,
+        priority: 0,
+        sequence: index,
       });
     }
-
-    return evidence;
   }
-
-  private buildAttachDeclarationEvidence(
-    context: PersistedLocalHistoryContext,
-    declaration: PersistedLocalHistoryAttachDeclaration,
-  ): Evidence[] {
-    const evidence: Evidence[] = [];
-    const declarationKind = declaration.actorKind === "human"
-      ? "explicit_user_declaration"
-      : "explicit_agent_declaration";
-
-    evidence.push({
-      evidenceId: buildEvidenceId("attach", declarationKind, context, evidence.length + 100),
-      evidenceKind: declarationKind,
-      source: "causal_attach.declaration",
-      capturedAt: context.observedAt,
-      strength: "direct",
-      details: {
-        actorKind: declaration.actorKind,
-        actorId: declaration.actorId ?? null,
-        note: declaration.note ?? null,
-      },
-    });
-
-    if (declaration.fromActorId !== undefined) {
-      evidence.push({
-        evidenceId: buildEvidenceId("attach", "explicit_handoff", context, evidence.length + 100),
-        evidenceKind: "explicit_handoff",
-        source: "causal_attach.handoff",
-        capturedAt: context.observedAt,
-        strength: "direct",
-        details: {
-          actorKind: declaration.actorKind,
-          actorId: declaration.actorId ?? null,
-          fromActorId: declaration.fromActorId,
-          note: declaration.note ?? null,
-        },
+  for (const [index, event] of state.readEvents.entries()) {
+    if (event.strandId === strandId) {
+      items.push({
+        id: event.eventId,
+        occurredAt: event.occurredAt,
+        priority: 1,
+        sequence: index,
       });
     }
-
-    return evidence;
   }
-
-  private deriveAttribution(
-    operation: LocalHistoryContinuityOperation,
-    continuityEvidence: readonly Evidence[],
-  ): AttributionSummary {
-    const explicitUserEvidence = continuityEvidence.filter((evidence) => evidence.evidenceKind === "explicit_user_declaration");
-    const explicitAgentEvidence = continuityEvidence.filter((evidence) => evidence.evidenceKind === "explicit_agent_declaration");
-
-    if (explicitUserEvidence.length > 0 && explicitAgentEvidence.length > 0) {
-      return {
-        actor: {
-          actorId: "unknown",
-          actorKind: "unknown",
-          displayName: "Conflicting actor signals",
-          source: "persisted_local_history.conflict",
-          authorityScope: "mixed",
-        },
-        confidence: "unknown",
-        basis: "conflicting_signals",
-        evidence: [...continuityEvidence],
-      };
-    }
-
-    if (explicitUserEvidence.length > 0 || explicitAgentEvidence.length > 0) {
-      const declarationEvidence = explicitUserEvidence.length > 0 ? explicitUserEvidence : explicitAgentEvidence;
-      const primary = declarationEvidence[0];
-      const actorKind = explicitUserEvidence.length > 0 ? "human" : "agent";
-      const actorId = typeof primary?.details["actorId"] === "string" && primary.details["actorId"].length > 0
-        ? primary.details["actorId"]
-        : `${actorKind}:declared`;
-      return {
-        actor: {
-          actorId,
-          actorKind,
-          displayName: actorKind === "human" ? "Declared human actor" : "Declared agent actor",
-          source: "causal_attach.declaration",
-          authorityScope: "declared",
-        },
-        confidence: getMaximumConfidenceForEvidence(
-          declarationEvidence.map((evidence) => evidence.strength),
-        ),
-        basis: "explicit_declaration",
-        evidence: continuityEvidence.filter((evidence) =>
-          evidence.evidenceKind === "explicit_user_declaration" ||
-          evidence.evidenceKind === "explicit_agent_declaration" ||
-          evidence.evidenceKind === "explicit_handoff"
-        ),
-      };
-    }
-
-    const gitEvidence = continuityEvidence.filter((evidence) =>
-      evidence.evidenceKind === "git_transition_observation" ||
-      evidence.evidenceKind === "git_hook_transition"
-    );
-    if (gitEvidence.length > 0 && (operation === "fork" || operation === "park")) {
-      return {
-        actor: {
-          actorId: "git:transition",
-          actorKind: "git",
-          displayName: "Git transition",
-          source: "persisted_local_history.checkout_transition",
-          authorityScope: "inferred",
-        },
-        confidence: getMaximumConfidenceForEvidence(
-          gitEvidence.map((evidence) => evidence.strength),
-        ),
-        basis: "git_transition",
-        evidence: gitEvidence,
-      };
+  for (const [index, event] of state.stageEvents.entries()) {
+    if (event.strandId === strandId) {
+      items.push({
+        id: event.eventId,
+        occurredAt: event.occurredAt,
+        priority: 2,
+        sequence: index,
+      });
     }
-
-    return buildUnknownAttribution();
-  }
-
-  private emptySummary(): PersistedLocalHistorySummaryNone {
-    return {
-      availability: "none",
-      persistence: "persisted_local_history",
-      historyPath: null,
-      totalContinuityRecords: 0,
-      active: false,
-      lastOperation: null,
-      lastObservedAt: null,
-      continuityKey: null,
-      causalSessionId: null,
-      strandId: null,
-      checkoutEpochId: null,
-      continuedFromCausalSessionId: null,
-      continuityConfidence: "unknown",
-      continuityEvidence: [],
-      attribution: buildUnknownAttribution(),
-      latestReadEvent: null,
-      latestStageEvent: null,
-      latestTransitionEvent: null,
-      preserves: PERSISTED_LOCAL_HISTORY_PRESERVES,
-      excludes: PERSISTED_LOCAL_HISTORY_EXCLUDES,
-      nextAction: "bind_workspace_to_begin_local_history",
-    };
-  }
-
-  private createStageEvent(
-    context: PersistedLocalHistoryContext,
-    stagedTarget: RuntimeStagedTargetFullFile,
-    attribution: AttributionSummary,
-  ): Extract<CausalEvent, { eventKind: "stage" }> {
-    const footprint = {
-      paths: stagedTarget.target.selectionEntries.map((entry) => entry.path),
-      symbols: stagedTarget.target.selectionEntries.flatMap((entry) => entry.symbols),
-      regions: stagedTarget.target.selectionEntries.flatMap((entry) => entry.regions),
-    };
-
-    return {
-      eventId: stableId(
-        "event",
-        JSON.stringify({
-          eventKind: "stage",
-          targetId: stagedTarget.target.targetId,
-          actorId: attribution.actor.actorId,
-          confidence: attribution.confidence,
-          evidenceIds: attribution.evidence.map((evidence) => evidence.evidenceId),
-        }),
-      ),
-      eventKind: "stage",
-      repoId: context.repoId,
-      worktreeId: context.worktreeId,
-      checkoutEpochId: context.checkoutEpochId,
-      workspaceOverlayId: context.workspaceOverlayId,
-      transportSessionId: context.transportSessionId,
-      workspaceSliceId: context.workspaceSliceId,
-      causalSessionId: context.causalSessionId,
-      strandId: context.strandId,
-      actorId: attribution.actor.actorId,
-      confidence: attribution.confidence,
-      evidenceIds: attribution.evidence.map((evidence) => evidence.evidenceId),
-      attribution,
-      footprint,
-      occurredAt: context.observedAt,
-      payload: {
-        targetId: stagedTarget.target.targetId,
-        footprint,
-        selectionKind: stagedTarget.target.selectionKind,
-      },
-    };
   }
-
-  private createReadEvent(input: {
-    readonly current: PersistedLocalHistoryContext;
-    readonly attribution: AttributionSummary;
-    readonly surface: string;
-    readonly projection: string;
-    readonly sourceLayer: SourceLayer;
-    readonly reason: string;
-    readonly footprint: CausalFootprint;
-  }): Extract<CausalEvent, { eventKind: "read" }> {
-    return {
-      eventId: stableId(
-        "event",
-        JSON.stringify({
-          eventKind: "read",
-          occurredAt: input.current.observedAt,
-          surface: input.surface,
-          projection: input.projection,
-          sourceLayer: input.sourceLayer,
-          reason: input.reason,
-          footprint: input.footprint,
-          actorId: input.attribution.actor.actorId,
-          confidence: input.attribution.confidence,
-          evidenceIds: input.attribution.evidence.map((evidence) => evidence.evidenceId),
-        }),
-      ),
-      eventKind: "read",
-      repoId: input.current.repoId,
-      worktreeId: input.current.worktreeId,
-      checkoutEpochId: input.current.checkoutEpochId,
-      workspaceOverlayId: input.current.workspaceOverlayId,
-      transportSessionId: input.current.transportSessionId,
-      workspaceSliceId: input.current.workspaceSliceId,
-      causalSessionId: input.current.causalSessionId,
-      strandId: input.current.strandId,
-      actorId: input.attribution.actor.actorId,
-      confidence: input.attribution.confidence,
-      evidenceIds: input.attribution.evidence.map((evidence) => evidence.evidenceId),
-      attribution: input.attribution,
-      footprint: input.footprint,
-      occurredAt: input.current.observedAt,
-      payload: {
-        surface: input.surface,
-        projection: input.projection,
-        sourceLayer: input.sourceLayer,
-        reason: input.reason,
-      },
-    };
-  }
-
-  private createTransitionEvent(input: {
-    readonly current: PersistedLocalHistoryContext;
-    readonly semanticTransition: NonNullable<RepoObservation["semanticTransition"]>;
-    readonly transition: RepoObservation["lastTransition"];
-    readonly attribution: AttributionSummary;
-  }): Extract<CausalEvent, { eventKind: "transition" }> {
-    const transition = input.transition;
-    const semanticTransition = input.semanticTransition;
-    const footprint = {
-      paths: [],
-      symbols: [],
-      regions: [],
-    };
-
-    return {
-      eventId: stableId(
-        "event",
-        JSON.stringify({
-          eventKind: "transition",
-          checkoutEpochId: input.current.checkoutEpochId,
-          workspaceOverlayId: input.current.workspaceOverlayId,
-          semanticKind: semanticTransition.kind,
-          authority: semanticTransition.authority,
-          phase: semanticTransition.phase,
-          summary: semanticTransition.summary,
-          transitionKind: transition?.kind ?? null,
-          fromRef: transition?.fromRef ?? null,
-          toRef: transition?.toRef ?? null,
-          actorId: input.attribution.actor.actorId,
-          confidence: input.attribution.confidence,
-          evidenceIds: input.attribution.evidence.map((evidence) => evidence.evidenceId),
-        }),
-      ),
-      eventKind: "transition",
-      repoId: input.current.repoId,
-      worktreeId: input.current.worktreeId,
-      checkoutEpochId: input.current.checkoutEpochId,
-      workspaceOverlayId: input.current.workspaceOverlayId,
-      transportSessionId: input.current.transportSessionId,
-      workspaceSliceId: input.current.workspaceSliceId,
-      causalSessionId: input.current.causalSessionId,
-      strandId: input.current.strandId,
-      actorId: input.attribution.actor.actorId,
-      confidence: input.attribution.confidence,
-      evidenceIds: input.attribution.evidence.map((evidence) => evidence.evidenceId),
-      attribution: input.attribution,
-      footprint,
-      occurredAt: input.current.observedAt,
-      payload: {
-        semanticKind: semanticTransition.kind,
-        authority: semanticTransition.authority,
-        phase: semanticTransition.phase,
-        summary: semanticTransition.summary,
-        transitionKind: transition?.kind ?? null,
-        fromRef: transition?.fromRef ?? null,
-        toRef: transition?.toRef ?? null,
-        createdCheckoutEpochId: transition !== null ? input.current.checkoutEpochId : null,
-      },
-    };
-  }
-
-  private historyPathFor(continuityKey: string): string {
-    return path.join(this.deps.graftDir, "local-history", `${continuityKey}.json`);
-  }
-
-  private async loadStatesForRepo(repoId: string): Promise<ContinuityState[]> {
-    const historyDir = path.join(this.deps.graftDir, "local-history");
-    let filenames: string[];
-    try {
-      filenames = await this.deps.fs.readdir(historyDir);
-    } catch {
-      return [];
-    }
-
-    const states: ContinuityState[] = [];
-    for (const filename of filenames) {
-      if (!filename.endsWith(".json")) {
-        continue;
-      }
-      try {
-        const raw = await this.deps.fs.readFile(path.join(historyDir, filename), "utf-8");
-        const state = continuityStateSchema.parse(this.deps.codec.decode(raw));
-        if (state.repoId === repoId) {
-          states.push(state);
-        }
-      } catch {
-        // Ignore malformed local-history artifacts.
-      }
+  for (const [index, event] of state.transitionEvents.entries()) {
+    if (event.strandId === strandId) {
+      items.push({
+        id: event.eventId,
+        occurredAt: event.occurredAt,
+        priority: 3,
+        sequence: index,
+      });
     }
-
-    return states;
   }
 
-  private toWorktreeHistory(state: ContinuityState): RepoConcurrencyWorktreeHistory {
-    const effectiveRecord = findRecord(state, state.activeRecordId) ?? state.records.at(-1) ?? null;
-    const checkoutEpochId = effectiveRecord?.checkoutEpochId ?? null;
-    const recordsForEpoch = checkoutEpochId === null
-      ? []
-      : state.records.filter((record) => record.checkoutEpochId === checkoutEpochId);
-    const eventsForEpoch = checkoutEpochId === null
-      ? []
-      : [...state.readEvents, ...state.stageEvents, ...state.transitionEvents]
-        .filter((event) => event.checkoutEpochId === checkoutEpochId);
-
-    const contributorKeys = new Set<string>();
-    const actorIds = new Set<string>();
-    const causalSessionIds = new Set<string>();
-
-    for (const record of recordsForEpoch) {
-      causalSessionIds.add(record.causalSessionId);
-      if (record.continuedFromCausalSessionId !== null) {
-        causalSessionIds.add(record.continuedFromCausalSessionId);
-      }
-      const contributorKey = buildRepoConcurrencyContributorKey({
-        actorId: record.attribution.actor.actorId,
-        attribution: record.attribution,
-        causalSessionId: record.causalSessionId,
-        transportSessionId: record.transportSessionId,
-      });
-      if (contributorKey !== null) {
-        contributorKeys.add(contributorKey);
-      }
-      if (record.continuedFromCausalSessionId !== null) {
-        contributorKeys.add(`causal:${record.continuedFromCausalSessionId}`);
-      }
-      if (record.attribution.actor.actorKind === "human" || record.attribution.actor.actorKind === "agent") {
-        actorIds.add(record.attribution.actor.actorId);
-      }
+  items.sort((left, right) => {
+    const byTime = left.occurredAt.localeCompare(right.occurredAt);
+    if (byTime !== 0) {
+      return byTime;
     }
-
-    for (const event of eventsForEpoch) {
-      if (event.causalSessionId !== null) {
-        causalSessionIds.add(event.causalSessionId);
-      }
-      const contributorKey = buildRepoConcurrencyContributorKey({
-        actorId: event.actorId,
-        attribution: event.attribution,
-        causalSessionId: event.causalSessionId,
-        transportSessionId: event.transportSessionId,
-      });
-      if (contributorKey !== null) {
-        contributorKeys.add(contributorKey);
-      }
-      if (event.attribution.actor.actorKind === "human" || event.attribution.actor.actorKind === "agent") {
-        actorIds.add(event.attribution.actor.actorId);
-      }
+    const byPriority = left.priority - right.priority;
+    if (byPriority !== 0) {
+      return byPriority;
     }
-
-    return {
-      worktreeId: state.worktreeId,
-      active: state.activeRecordId !== null,
-      checkoutEpochId,
-      causalSessionIds: [...causalSessionIds],
-      actorIds: [...actorIds],
-      contributorKeys: [...contributorKeys],
-      explicitHandoff: recordsForEpoch.some((record) =>
-        record.continuityEvidence.some((evidence) =>
-          evidence.evidenceKind === "explicit_handoff"
-        )
-      ),
-      touches: buildRepoConcurrencyTouches(eventsForEpoch),
-    };
-  }
-
-  private async loadState(
-    continuityKey: string,
-    repoId: string,
-    worktreeId: string,
-  ): Promise<ContinuityState> {
-    try {
-      const raw = await this.deps.fs.readFile(this.historyPathFor(continuityKey), "utf-8");
-      return continuityStateSchema.parse(this.deps.codec.decode(raw));
-    } catch {
-      return createEmptyState(continuityKey, repoId, worktreeId);
+    const bySequence = left.sequence - right.sequence;
+    if (bySequence !== 0) {
+      return bySequence;
     }
-  }
+    return left.id.localeCompare(right.id);
+  });
 
-  private async saveState(state: ContinuityState): Promise<void> {
-    const filePath = this.historyPathFor(state.continuityKey);
-    await this.deps.fs.mkdir(path.dirname(filePath), { recursive: true });
-    await this.deps.fs.writeFile(filePath, this.deps.codec.encode(state), "utf-8");
-  }
+  return items.at(-1)?.id ?? null;
 }