feat(8.0): u64 BigInt graph provider contract — punch list a-d,g,h

GraphIndexProvider now speaks BigInt at the boundary (D.2 mirror):
- getNeighbors/getVerbIdsBySource/getVerbIdsByTarget take entity ints and
  return entity/verb ints as bigint[]
- new REQUIRED verbIntsToIds(bigint[]) batch reverse resolver (L.7
  identity-fingerprint design — verb ids are UUIDs by contract, so the
  provider-side interning is losslessly reversible)
- addVerb(verb, sourceInt, targetInt) returns the interned verb int;
  removeVerb(verbId) joins the contract

Coordinator (brainy.ts) owns ALL UUID <-> int conversion: getOrAssign on
writes, getInt on reads (unmapped UUID -> empty result without calling the
provider), getUuid / verbIntsToIds on returns, plus a bounded ~100k-entry
insertion-order warm cache for verb-int -> verb-id pairs fed by addVerb
returns and resolver results. GraphVerb gains derived sourceInt/targetInt
(populated at add time, never persisted). findConnectedSubtype gains a
native fast path that routes single-type single-subtype outgoing BFS
through the provider when available.

JS GraphAdjacencyIndex satisfies the contract while staying string/u32-keyed
internally: entity ints resolve through the shared entity-id mapper (threaded
in by the coordinator on init/fork/checkout), verb ints come from an
in-process append-only interning map re-derived from storage on
rebuild/cold-start. ColumnStoreProvider widens the same way: addEntity/
removeEntity take bigint, sortTopK/filteredSortTopK return bigint[].

relate() now rejects a caller-supplied id with a teaching error — verb ids
are brainy-generated UUIDs by contract in 8.0 (previously a passed id was
silently ignored). No Roaring64 provider-boundary decode site exists yet;
the JS-internal column store stays Roaring32 and the Treemap decoder lands
with the first consumer of provider-returned filter buffers.

Public brain API unchanged. 1413 tests green (+10 new BigInt contract tests).

src/transaction/operations/IndexOperations.ts

@@ -11,7 +11,7 @@
 
 import type { JsHnswVectorIndex } from '../../hnsw/hnswIndex.js'
 import type { MetadataIndexManager } from '../../utils/metadataIndex.js'
-import type { GraphAdjacencyIndex } from '../../graph/graphAdjacencyIndex.js'
+import type { GraphIndexProvider } from '../../plugin.js'
 import type { GraphVerb } from '../../coreTypes.js'
 import type { Operation, RollbackAction } from '../types.js'
 
@@ -152,18 +152,35 @@ export class RemoveFromMetadataIndexOperation implements Operation {
  *
  * Rollback strategy:
  * - Remove verb from graph index
+ *
+ * 8.0 u64 contract: the coordinator resolves both endpoint ints via the
+ * shared idMapper (`getOrAssign`) and passes them alongside the verb; the
+ * provider returns the interned verb int, which is surfaced through the
+ * optional `onVerbInt` callback so the coordinator can feed its warm cache.
  */
 export class AddToGraphIndexOperation implements Operation {
   readonly name = 'AddToGraphIndex'
 
+  /**
+   * @param index - The graph-index provider (JS baseline or native).
+   * @param verb - The verb to index (`sourceInt`/`targetInt` mirrored on it).
+   * @param sourceInt - The source entity's interned int.
+   * @param targetInt - The target entity's interned int.
+   * @param onVerbInt - Optional hook invoked with the interned verb int
+   *   returned by the provider (feeds the coordinator's verb-int warm cache).
+   */
   constructor(
-    private readonly index: GraphAdjacencyIndex,
-    private readonly verb: GraphVerb
+    private readonly index: GraphIndexProvider,
+    private readonly verb: GraphVerb,
+    private readonly sourceInt: bigint,
+    private readonly targetInt: bigint,
+    private readonly onVerbInt?: (verbInt: bigint) => void
   ) {}
 
   async execute(): Promise<RollbackAction> {
     // Add verb to graph index
-    await this.index.addVerb(this.verb)
+    const verbInt = await this.index.addVerb(this.verb, this.sourceInt, this.targetInt)
+    this.onVerbInt?.(verbInt)
 
     // Return rollback action
     return async () => {
@@ -178,13 +195,25 @@ export class AddToGraphIndexOperation implements Operation {
  *
  * Rollback strategy:
  * - Re-add verb to graph index
+ *
+ * 8.0 u64 contract: rollback re-adds through `addVerb(verb, sourceInt,
+ * targetInt)`, so the coordinator resolves the endpoint ints up front
+ * (while the entity → int mappings are guaranteed to still exist).
  */
 export class RemoveFromGraphIndexOperation implements Operation {
   readonly name = 'RemoveFromGraphIndex'
 
+  /**
+   * @param index - The graph-index provider (JS baseline or native).
+   * @param verb - The verb being removed (required for rollback re-add).
+   * @param sourceInt - The source entity's interned int (rollback re-add).
+   * @param targetInt - The target entity's interned int (rollback re-add).
+   */
   constructor(
-    private readonly index: GraphAdjacencyIndex,
-    private readonly verb: GraphVerb // Required for rollback
+    private readonly index: GraphIndexProvider,
+    private readonly verb: GraphVerb, // Required for rollback
+    private readonly sourceInt: bigint,
+    private readonly targetInt: bigint
   ) {}
 
   async execute(): Promise<RollbackAction> {
@@ -194,7 +223,7 @@ export class RemoveFromGraphIndexOperation implements Operation {
     // Return rollback action
     return async () => {
       // Re-add verb with original data
-      await this.index.addVerb(this.verb)
+      await this.index.addVerb(this.verb, this.sourceInt, this.targetInt)
     }
   }
 }