@ibgib/core-gib 0.1.57 → 0.1.58

package/src/keystone/keystone-policy.schema.json

@@ -0,0 +1,51 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "KeystonePolicyConfigTemplate",
+  "type": "object",
+  "properties": {
+    "behaviorProfiles": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "size": { "type": "integer", "minimum": 1 },
+          "replenish": { "type": "string", "enum": ["top-up", "replace-all", "consume", "delete-all"] },
+          "selectSequentially": { "type": "integer", "minimum": 0 },
+          "selectRandomly": { "type": "integer", "minimum": 0 },
+          "targetBindingChars": { "type": "integer", "minimum": 0 }
+        },
+        "required": ["size", "replenish", "selectSequentially", "selectRandomly", "targetBindingChars"]
+      }
+    },
+    "pools": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "id": { "type": "string" },
+          "allowedVerbs": {
+            "type": "array",
+            "items": { "type": "string" }
+          },
+          "behaviorProfile": { "type": "string" },
+          "behaviorInline": {
+            "type": "object",
+            "properties": {
+              "size": { "type": "integer", "minimum": 1 },
+              "replenish": { "type": "string", "enum": ["top-up", "replace-all", "consume", "delete-all"] },
+              "selectSequentially": { "type": "integer", "minimum": 0 },
+              "selectRandomly": { "type": "integer", "minimum": 0 },
+              "targetBindingChars": { "type": "integer", "minimum": 0 }
+            },
+            "required": ["size", "replenish", "selectSequentially", "selectRandomly", "targetBindingChars"]
+          },
+          "algo": { "type": "string", "enum": ["SHA-256", "SHA-512"] },
+          "rounds": { "type": "integer", "minimum": 1 },
+          "type": { "type": "string", "enum": ["hash-reveal-v1"] }
+        },
+        "required": ["id", "allowedVerbs", "algo", "rounds"]
+      }
+    }
+  },
+  "required": ["pools"]
+}

package/src/keystone/keystone-service-v1.mts

@@ -256,10 +256,10 @@ export class KeystoneService_V1 {
 
     /**
      * Retrieves the latest keystone frame for the given address.
-     * 
+     *
      * Uses `metaspace.getLatestAddr` to find the actual tip instead of trusting
      * an incoming payload's `past` rel8n.
-     * 
+     *
      * @see `ibgib-get-pattern` SKILL.md
      */
     async getLatestKeystone({
@@ -274,7 +274,7 @@ export class KeystoneService_V1 {
         const lc = `${this.lc}[${this.getLatestKeystone.name}]`;
         try {
             if (logalot) { console.log(`${lc} starting...`); }
-            
+
             const latestAddr = await metaspace.getLatestAddr({ tjpAddr: addr, space });
             if (!latestAddr) {
                 throw new Error(`could not find latest addr for ${addr}`);

package/src/sync/docs/architecture.md

@@ -68,6 +68,17 @@ The protocol supports two types of data:
 
 See [Security](./security.md) documentation.
 
+### 4.1 Ephemeral Session Domain-Binding
+To prevent an ephemeral session keystone `S` from acting as a "blank check" that could authorize operations on arbitrary timelines, the protocol implements strict domain-binding:
+*   **Genesis Binding**: The first frame of the session keystone ($S^{Stjp}$) must explicitly contain a `targetAddrs` array inside its `frameDetails` mapping to the exact addresses of the ibgibs being synchronized.
+*   **Verification Boundary**: During the initial turn-based synchronization (e.g., `handleInitFrame`), the validating peer (Receiver) must extract this `targetAddrs` array from $S^{Stjp}$'s genesis `frameDetails` and verify it contains the synchronizing domain's target address, rejecting the handshake on any mismatch.
+
+## 5. Sync Peer Lifetime
+
+A `SyncPeer` is **single-saga scoped**. One peer instance services exactly one `sync(...)` call from creation through saga completion. The coordinator's `newTestPeer()` factory pattern (or equivalent in production) must create a fresh peer per saga.
+
+**Rationale**: The session keystone `S` is derived from `KDF(senderSecret, sagaId)`. Since `sagaId` is unique per saga, `S` is inherently saga-bound. A peer that outlived its saga would hold stale identity state, violating the security model.
+
 > [!WARNING]
 > ## 5. Sync Storage & Persistence Rules (Critical Security)
 >
@@ -88,3 +99,12 @@ See [Security](./security.md) documentation.
 > * **First step:** Intrinsically validate ibgibs (hashes, basic structure).
 > * **Second step:** Perform AuthN/AuthZ checks (using the session keystone).
 > * **Final step:** Once verified, saga "control" ibgibs (which only contain "soft" links to domain ibgibs) can be safely persisted to durable spaces.
+
+## 6. Transport & Framing (Naive WebSocket Implementation)
+
+> [!NOTE]
+> ### TODO: Robust WebSocket Framing & TCP Reassembly
+> The current custom WebSocket integration on the node server (`ws-helper.mts`) relies on a naive framing implementation. It assumes each socket `data` event emitted by Node's TCP stream contains exactly one complete WebSocket frame.
+> 
+> * **TCP Fragmentation Risk**: When payload sizes grow (e.g. sending larger cryptographic proofs or domain datasets), TCP will split the frame across multiple packets or buffers. The naive decoder will decode a partial frame, causing parse errors (e.g., `Unterminated string in JSON`).
+> * **Future Action**: Replace the custom, naive WebSocket framing code with a robust stateful accumulator that aggregates incoming TCP chunks until the entire frame length (indicated in the frame header) is present in memory, or transition to a fully tested, production-grade library (such as the NPM `ws` package).

package/src/sync/docs/security.md

@@ -56,11 +56,17 @@ The session keystone has **two dedicated pools**, each with a matching `poolId`
 
 Note: The `senderIdentity` Domain Keystone also uses the `"sync"` verb in its claim when it signs/authorizes the session keystone genesis during `establishSessionIdentity`.
 
+### ✅ Agreed: Sync Peer Lifetime — One Peer per Saga
+
+A `SyncPeer` instance is **scoped to exactly one sync saga**. A new peer must be created for each call to `senderCoordinator.sync(...)`. Reusing a peer across multiple sagas is not supported and would compromise the identity security model, since the session keystone `S` is saga-specific (derived from `KDF(senderSecret, sagaId)`).
+
+The `sagaId` is passed to the peer via `initializeOpts` so that `establishSessionIdentity` can derive the correct `sessionSecret` before any other phase begins.
+
 ### ✅ Agreed: `establishSessionIdentity` — Pre-Connect Phase
 
 A new `establishSessionIdentity` method on the sync peer base class is the **mandatory first step** before `connect`. It encapsulates:
 
-1. **Generate session keystone**: `sessionIdentity` genesis (S^Stjp) is created locally from `KDF(senderSecret, sagaId)`. The genesis includes metadata about `senderIdentity` TJP and the target domain.
+1. **Generate session keystone**: `sessionIdentity` genesis (S^Stjp) is created locally from `KDF(senderSecret, sagaId)`. The genesis contains the exact target domain addresses (`targetAddrs` in `frameDetails`) to cryptographically bind the session to those specific target domain timelines, preventing it from being used as a "blank check" for other domains.
 2. **Sign `senderIdentity`**: The Sender signs their own `senderIdentity` keystone with a `sync` claim targeting `S^Stjp`. The result (`newSenderIdentity`) is the evolved sender frame that proves delegation. The name `newSenderIdentity` is **only** used within `establishSessionIdentity` and its helper — after this method returns, it becomes the active `senderIdentity`.
 3. **Post to domain provider**: Both `newSenderIdentity` and `sessionIdentity` genesis are transmitted to the Receiver via a pre-connect API call (cf. `putEvolveKeystone` in `dev-tools.mts`).
 4. **Receiver validates**: The Receiver independently loads the **latest known tip** of `I^Itjp` from its own registry (never trusting `newSenderIdentity.rel8ns.past`). It validates the evolution and, if authorized, stores both keystones in the domain.
@@ -75,9 +81,10 @@ A new `establishSessionIdentity` method on the sync peer base class is the **man
 
 ### 🔲 Pending: `authenticateContext` Placement
 
-The receiver-side validation that runs on each incoming context has two steps:
+The receiver-side validation that runs on each incoming context has three steps:
 1. **Transition validity**: Replay the session keystone evolution — verify `data.n` is sequential, challenge solutions are valid, pool not exhausted, etc.
 2. **Target binding**: Verify that the incoming `signedSessionIdentity`'s proof actually targets *this* context's exact address (`proof.claim.target === contextAddr`).
+3. **Domain target binding**: Verify that the first frame of the session keystone `S` ($S^{Stjp}$) contains `targetAddrs` (array) in its `frameDetails`, and that this array contains the exact addresses of the domain ibgibs being synchronized. This must be checked at least in the first sync turn (e.g., `handleInitFrame`) to authenticate that the session is not a "blank check".
 
 **Open**: Where does this code live?
 * **On the sync peer** (e.g., as `peer.authenticateContext(...)`): the peer already knows its local durable space, which is needed to load the latest `senderIdentity` tip. This makes the tip-lookup natural.
@@ -173,4 +180,201 @@ Context ibgib now has a clean, consistent pair:
 
 **Current position**: This is likely a **higher-layer business rule** rather than a sync protocol concern. The sync protocol's job is to ensure the session is cryptographically authorized (via keystone proofs). What is stored under an authorized session is the domain owner's responsibility. Enforcement of content policies (e.g., "only ibgibs of type X are allowed") belongs in the server's `authorizeContext` hook, not in the core sync coordinator.
 
-**Tracked in**: `space-gib.sync-walkthrough.md`
+**Tracked in**: `space-gib.sync-walkthrough.md`
+
+---
+
+## Implementation Plan
+
+Each phase below is a discrete, verifiable step. We proceed **one checkbox at a time**, **reviewing/discussing** code/results before moving to the next. Each phase has two targets: **innerspace** (automated unit test) and **space-gib** (manual/integrated e2e).
+
+The innerspace tests live in `libs/core-gib/src/sync/`. The space-gib integrated tests are done via the `dev-tools.mts` UI in the browser. Separating identity phases into their own `*.respec.mts` file keeps logs clean and complexity isolated.
+
+_Note: respec-gib `*.respec.mts` files execute the **entire** file if any `respecfullyDear`/`ifWeMight` blocks are found. Within that file, any `ifWe` block (without the `Might`) will **still** execute and affect logging. `ifWeMight` **only** affects reporting pass/fail once the file is selected to execute. This is why we isolate individual files as needed._
+
+---
+
+### Phase 1 — `establishSessionIdentity` (Pre-Connect)
+
+**Goal**: Get `I^Itjp` onto the domain provider, generate `S^Stjp` locally, evolve `I → I1` with a `sync` claim targeting `S^Stjp`, and post both `I1` and `S` to the provider. Verify both keystones are in the appropriate durable spaces at the right times.
+
+`senderCoordinator.sync(...)` **will** be called; we are not mocking this out. We expect it may throw at first, and we are examining side-effects (keystone presence in durable spaces) rather than end-to-end correctness. As phases succeed and sync no longer throws, test assertions will be adjusted accordingly.
+
+#### Phase 1A — Innerspace unit test (`sync-withid.establish.respec.mts`)
+
+- [x] Create `sync-withid.establish.respec.mts` with scaffold:
+  - `Metaspace_Innerspace` + two `InnerSpace_V1` (source/dest) + `SyncSagaCoordinator` pair + `newTestPeer()` factory
+  - A `senderSecret` constant (test-only plaintext)
+  - A `KeystoneService_V1` instance (new'd inline, no injection needed)
+- [x] Add `respecfully` block: `"Phase 1: establishSessionIdentity"`
+  - [x] `ifWeMight` — `"creates sessionIdentity genesis (S) locally"`: assert `S^Stjp` was generated and exists in `sourceSpace`
+  - [x] `ifWeMight` — `"evolves senderIdentity (I → I1) with sync claim"`: assert `I1` frame has a proof whose `claim.verb === 'sync'` and `claim.target === S^Stjp`
+  - [x] `ifWeMight` — `"posts I1 and S to destSpace (receiver)"`: assert both addrs are retrievable from `destSpace`
+
+#### Phase 1B — Space-Gib integrated (manual) (`dev-tools.mts`)
+
+Add a new horizontal flexbox row dedicated to the "establish" test flow. Existing debug button rows stay as-is; the new row activates and disables the existing rows (page refresh required to reset). The new row contains:
+
+- [x] Button: **"new identity"** — creates a fresh `senderIdentity` (I) keystone locally
+- [x] Button: **"confirm sender identity"** — asserts I exists in the sender's local space
+- [x] Button: **"confirm receiver identity"** — asserts I (or its absence) in the receiver's domain registry
+- [x] Button: **"sync - establish"** — calls `sync(...)` (which internally runs `establishSessionIdentity`)
+- [x] Button: **"confirm sender identity evolved"** — asserts I1 (evolved frame) is in sender's space
+- [x] Button: **"confirm receiver identity evolved"** — asserts I1 is in receiver's domain registry
+- [x] Button: **"confirm sender session identity"** — asserts S genesis exists in sender's space
+- [x] Button: **"confirm receiver session identity"** — asserts S genesis exists in receiver's domain registry
+- [x] Clean up buttons / consolidate confirms once the flow is stable
+
+##### 1) WebSocket Peer Sender (`SyncPeerWebSocketSender_V1`)
+- [x] Define options and data types (`wsUrl` for sync, `httpEvolveUrl` for pre-connect establish routing).
+- [x] Implement `postEstablishToReceiver` to execute Phase 1 HTTP POST/PUT of evolved $I_1$ and session genesis $S$ to the registry.
+- [x] Implement `connectImpl` to:
+  - [x] Consistently load the handshake solution from local storage/memory.
+  - [x] Perform the RFC 6455 upgrade request with `sAddr` and upfront `solution` parameters.
+  - [x] Listen and respond to multi-turn JSON RPC handshake frames (`auth-challenge-init` -> `auth-init` -> `auth-challenge` -> `auth-proof` -> `auth-ok`).
+- [x] Implement `sendContextRequest` to push context and transactional payloads down the active WebSocket pipe.
+
+##### 2) WebSocket Peer Receiver (`SyncPeerWebSocketReceiver_V1`)
+- [x] Review dev-tools.mts and especially sync-upgrade.handler.mts, moving what code we can from the handler into this peer receiver.
+- [x] Define server-side receiver options matching core registry namespaces.
+- [x] Implement robust event/message routers to handle stateful context payloads during the established synchronization session.
+- [x] Design standard static/pure functions to manage Keystone verification and registration during the establish phase without requiring an active saga connection instance.
+
+##### 3) Serve-Gib Establish Handler (`KeystoneEvolveHandler`)
+- [x] Should delegate to sync peer receiver static methods or pure functions in sync-websocket-peer-helpers.mts (or whatever the exact filename turns out to be for the sync peer's websocket helper functions)
+- [x] Cleanly handle the pre-connect registry POST.
+- [x] Validate signature proof of identity evolution ($I \to I_1$) and store both $I_1$ and $S$ into the domain's server-side durable space registry.
+- [x] Ensure it remains entirely stateless, coordinating purely through persistent database/filesystem states.
+
+##### 4) Serve-Gib Connect/Sync Handler (`SyncChannelHandler`)
+- [x] Refactor and rename the WebSocket handler (moving beyond "upgrade" to reflect its status as the Sync Peer Connect & Transport Channel wrapper).
+- [x] Implement upfront picket-fence validation on upgrade (`validateUpfrontConnect`) by retrieving $S$ from durable space and checking the solution parameter.
+- [x] Manage the stateful WebSocket challenge handshake generically.
+- [x] Instantiate `SyncPeerWebSocketReceiver_V1` and wire it to the active socket stream upon successful authentication.
+
+##### 5) Downstream App Registration (`space-gib`)
+- [x] Update `server.mts` (or equivalent serve-gib orchestrator) to mount the generalized `KeystoneEvolveHandler` (Establish) and `SyncChannelHandler` (Connect/Sync) with simple, clean `regex` + `verb` routing declarations.
+- [x] Wire the Dev Tools perform-sync button to instantiate the unified `SyncSagaCoordinator` and `SyncPeerWebSocketSender_V1` to execute the full sequence.
+
+---
+
+### Phase 2 — `peer.connect()` (Transport Handshake)
+
+**Goal**: Open the transport channel (if applicable to the peer implementation) and sign/deplete S's `connect` pool as proof-of-possession.
+
+We still call `senderCoordinator.sync(...)` — the phase focus is on what `peer.connect()` does internally, not on a separate call.
+
+#### Phase 2A — Innerspace unit test (`sync-withid.connect.respec.mts`)
+
+- [x] Create `sync-withid.connect.respec.mts` (separate file to isolate connect-phase logging)
+- [x] Add `respecfully` block: `"Phase 2: connect"`
+  - [x] `ifWeMight` — `"connect completes without error"`: call sync and assert no exception at/before the connect phase
+  - [x] `ifWeMight` — `"connect pool is fully depleted after connect"`: assert `S.data.pools['connect']` is exhausted (all challenges consumed), since after connect only the `sync` pool remains active
+  - [x] 🔲 **Open question**: Does innerspace issue demanded challenge IDs for the `connect` pool, or is this behavior strictly peer-specific (WebSocket only)? Confirm during implementation — if innerspace skips challenge issuance, the depletion check may not apply and we document the asymmetry.
+
+#### Phase 2B — Space-Gib integrated (manual)
+
+- [x] Confirm WebSocket connection is established — check the browser's Network tab (WS frames) rather than adding any server-side detection endpoint (avoids introducing insecure surface)
+- [x] Confirm server issues and accepts challenge from S's `connect` pool — verify via server logs or debugger
+- [x] Confirm `connect` pool is exhausted in S after handshake (inspect S's latest frame in debugger)
+- [x] Confirm session is considered active server-side after handshake
+
+---
+
+### Phase 3 — Basic Single-Timeline Sync with Identity
+
+**Goal**: With identity fully established and transport connected, sync a single ibgib `X` from source to dest. Verify S evolves correctly per turn (`sync` pool), and X's full dependency graph arrives on dest. After commit, both sender and receiver durable spaces must contain: the same evolved I, the full S dependency graph, and the full X dependency graph.
+
+#### Phase 3A — Innerspace unit test (`sync-withid.fullsync.respec.mts`)
+
+- [ ] Create `sync-withid.fullsync.respec.mts`
+  - [ ] Create `r1_alpha_v0_source` via `TestTransformer`
+  - [ ] Call `senderCoordinator.sync({ domainIbGibs: [alpha], senderIdentity, senderSecret, ... })`
+  - [ ] `ifWeMight` — `"alpha dep graph matches on source and dest"`: use `getDependencyGraph` + `graphsAreEquivalent`
+  - [ ] `ifWeMight` — `"sessionIdentity evolved the expected number of times"`: assert `S.data.n` equals the known deterministic turn count
+    - [ ] 🔲 **TODO**: Manually inspect the full session keystone graph after a first run and count the exact number of outgoing turns (Init + Delta(s) + Commit), then hard-code that number into this assertion
+  - [ ] `ifWeMight` — `"sender durable space has I (evolved frame)"`: assert I1 addr is in `sourceSpace`
+  - [ ] `ifWeMight` — `"receiver durable space has I (evolved frame)"`: assert I1 addr is in `destSpace`
+  - [ ] `ifWeMight` — `"sender durable space has full S dep graph"`: use `getDependencyGraph` on S in `sourceSpace`
+  - [ ] `ifWeMight` — `"receiver durable space has full S dep graph"`: use `getDependencyGraph` on S in `destSpace`
+
+#### Phase 3B — Space-Gib integrated (manual)
+
+- [ ] Trigger a sync of a known test ibgib via `dev-tools.mts` (add "sync - fullsync" button to a new row)
+- [ ] Confirm S evolves on each outgoing turn (inspect frame `data.n` in debugger)
+- [ ] Confirm X's full dependency graph is present on the client after commit
+- [ ] Confirm X's full dependency graph is present on the server after commit
+- [ ] Confirm S's full dependency graph is present on the client after commit
+- [ ] Confirm S's full dependency graph is present on the server after commit
+- [ ] Confirm I's evolved frame (I1) is present on the client after commit
+- [ ] Confirm I's evolved frame (I1) is present on the server after commit
+
+
+---
+
+### Phase 1 — `establishSessionIdentity` (Pre-Connect)
+
+**Goal**: Get `I^Itjp` onto the domain provider, generate `S^Stjp` locally, evolve `I → I1` with a `sync` claim targeting `S^Stjp`, and post both `I1` and `S` to the provider. Verify the provider accepted and stored them.
+
+The sync proper will not be called. The test only cares that the pre-connect identity handoff succeeded.
+
+#### Phase 1A — Innerspace unit test
+
+- [ ] Create `sync-with-identity-basic.respec.mts` with scaffold:
+  - `Metaspace_Innerspace` + two `InnerSpace_V1` (source/dest) + `SyncSagaCoordinator` pair + `newTestPeer()` factory
+  - A `senderSecret` constant (test-only plaintext)
+  - A `KeystoneService_V1` instance (new'd inline)
+- [ ] Add `respecfully` block: `"Phase 1: establishSessionIdentity"`
+  - [ ] `ifWeMight` — `"creates sessionIdentity genesis (S) locally"`: assert `S^Stjp` was generated and exists in `sourceSpace`
+  - [ ] `ifWeMight` — `"evolves senderIdentity (I → I1) with sync claim"`: assert `I1` frame has a proof whose `claim.verb === 'sync'` and `claim.target === S^Stjp`
+  - [ ] `ifWeMight` — `"posts I1 and S to destSpace (receiver)"`: assert both addrs are retrievable from `destSpace`
+
+#### Phase 1B — Space-Gib integrated (manual)
+
+- [x] Confirm `dev-tools.mts` "Create Session Keystone (S)" button produces a valid genesis keystone (inspect in browser debugger)
+- [x] Confirm "Evolve Domain Keystone (I → I1)" button produces `I1` with correct `sync` claim targeting `S^Stjp`
+- [x] Confirm "Post Evolution" (`putEvolveKeystone`) is accepted by the server (HTTP 200 / success response)
+- [x] Confirm server stores both `I1` and `S` — verify via GET or server-side debugger
+
+---
+
+### Phase 2 — `peer.connect()` (Transport H andshake)
+
+**Goal**: Open the transport channel, if applicable, and sign session identity's `connect` pool.
+
+#### Phase 2A — Innerspace unit test
+
+- [x] Extend `sync-with-identity-basic.respec.mts` with a `respecfully` block: `"Phase 2: connect"` (Note: implemented in separate file `sync-withid.connect.respec.mts`)
+  - [x] `ifWeMight` — `"connect completes without error"`: call `peer.connect()` and assert no exception
+  - [x] `ifWeMight` — `"connect pool is depleted by exactly one challenge"`: assert `S.data.pools['connect'].used` increased by the expected count
+
+#### Phase 2B — Space-Gib integrated (manual)
+
+- [x] Confirm "Connect (WS H andshake)" button in `dev-tools.mts` opens WebSocket successfully
+- [x] Confirm server issues challenge from S's `connect` pool and accepts the solution
+- [x] Confirm session is considered active server-side after handshake
+
+---
+
+### Phase 3 — Basic Single-Timeline Sync with Identity
+
+**Goal**: With identity fully established and transport connected, sync a single ibgib `X` from source to dest. Verify S evolves correctly per turn (`sync` pool), and X's full dependency graph arrives on dest and that after sync, both sender and receiver durable spaces contain the same identity I, full session keystone S dependency graph, and full X dependency graph.
+
+#### Phase 3A — Innerspace unit test
+
+- [ ] Extend `sync-with-identity-basic.respec.mts` or create `sync-with-identity-singletimeline.respec.mts`
+  - [ ] Create `r1_alpha_v0_source` via `TestTransformer`
+  - [ ] Call `senderCoordinator.sync({ domainIbGibs: [alpha], senderIdentity, senderSecret, ... })`
+  - [ ] `ifWeMight` — `"alpha dep graph matches on source and dest"`: use `getDependencyGraph` + `graphsAreEquivalent`
+  - [ ] `ifWeMight` — `"sessionIdentity evolved once per sync turn"`: assert `S.data.n` equals number of outgoing turns
+
+#### Phase 3B — Space-Gib integrated (manual)
+
+- [ ] Trigger a sync of a known test ibgib via `dev-tools.mts` or equivalent UI
+- [ ] Confirm S evolves on each outgoing turn (inspect frame `data.n` in debugger)
+- [ ] Confirm X's full dependency graph is present on the client after commit
+- [ ] Confirm X's full dependency graph is present on the server after commit
+- [ ] Confirm S's full dependency graph is present on the client after commit
+- [ ] Confirm S's full dependency graph is present on the server after commit
+- [ ] Confirm I's full dependency graph is present on the client after commit
+- [ ] Confirm I's full dependency graph is present on the server after commit

package/src/sync/graft-info/graft-info-helpers.respec.mts

@@ -8,7 +8,7 @@ await respecfully(sir, 'Graft Info Helpers', async () => {
 
     await respecfully(sir, 'mergeTextLCS', async () => {
 
-        await ifWeMight(sir, 'mergeTextLCS should interleave unique lines (A then B)', async () => {
+        await ifWe(sir, 'mergeTextLCS should interleave unique lines (A then B)', async () => {
             const textA = "Line 1\nLine A\nLine 3";
             const textB = "Line 1\nLine B\nLine 3";
             const res = await mergeTextByLongestCommonSubsequence({ textA, textB });
@@ -16,7 +16,7 @@ await respecfully(sir, 'Graft Info Helpers', async () => {
             iReckon(sir, res).asTo('result').isGonnaBe(expected);
         });
 
-        await ifWeMight(sir, 'mergeTextLCS should handle insertions', async () => {
+        await ifWe(sir, 'mergeTextLCS should handle insertions', async () => {
             const textA = "Line 1\nLine 3";
             const textB = "Line 1\nLine 2\nLine 3";
             const res = await mergeTextByLongestCommonSubsequence({ textA, textB });
@@ -24,7 +24,7 @@ await respecfully(sir, 'Graft Info Helpers', async () => {
             iReckon(sir, res).asTo('result').isGonnaBe(expected);
         });
 
-        await ifWeMight(sir, 'mergeTextLCS should handle appends', async () => {
+        await ifWe(sir, 'mergeTextLCS should handle appends', async () => {
             const textA = "Line 1";
             const textB = "Line 1\nLine 2";
             const res = await mergeTextByLongestCommonSubsequence({ textA, textB });
@@ -32,7 +32,7 @@ await respecfully(sir, 'Graft Info Helpers', async () => {
             iReckon(sir, res).asTo('result').isGonnaBe(expected);
         });
 
-        await ifWeMight(sir, 'mergeTextLCS should handle simultaneous list additions', async () => {
+        await ifWe(sir, 'mergeTextLCS should handle simultaneous list additions', async () => {
             const textA = "- Item 1\n- Item 2\n- Item A";
             const textB = "- Item 1\n- Item 2\n- Item B";
             const res = await mergeTextByLongestCommonSubsequence({ textA, textB });
@@ -42,7 +42,7 @@ await respecfully(sir, 'Graft Info Helpers', async () => {
             iReckon(sir, res).asTo('result').isGonnaBe(expected);
         });
 
-        await ifWeMight(sir, 'mergeTextLCS should handle distinct modifications in code block', async () => {
+        await ifWe(sir, 'mergeTextLCS should handle distinct modifications in code block', async () => {
             const textA = `function foo() {
     console.log("start");
     doA();
@@ -64,7 +64,7 @@ await respecfully(sir, 'Graft Info Helpers', async () => {
             iReckon(sir, res).asTo('result').isGonnaBe(expected);
         });
 
-        await ifWeMight(sir, 'mergeTextLCS should return same string if identical', async () => {
+        await ifWe(sir, 'mergeTextLCS should return same string if identical', async () => {
             const textA = "Hello";
             const res = await mergeTextByLongestCommonSubsequence({ textA, textB: textA });
             iReckon(sir, res).asTo('result').isGonnaBe(textA);
@@ -75,7 +75,7 @@ await respecfully(sir, 'Graft Info Helpers', async () => {
     await respecfully(sir, 'graftTimelines', async () => {
         // We need a more complex setup to test this properly (mock space, etc.)
         // For now, this placeholder ensures the test file runs.
-        await ifWeMight(sir, 'graftTimelines placeholders', async () => {
+        await ifWe(sir, 'graftTimelines placeholders', async () => {
             iReckon(sir, true).isGonnaBeTrue();
         });
     });

package/src/sync/sync-conflict-adv-multitimelines.respec.mts

@@ -127,7 +127,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
     // #endregion r1 setup
 
     await respecfully(sir, `r1 verify pre`, async () => {
-        await ifWeMight(sir, 'dest should NOT have alpha', async () => {
+        await ifWe(sir, 'dest should NOT have alpha', async () => {
             const resGet = await getFromSpace({
                 space: destSpace,
                 addr: alpha_tjpAddr,
@@ -150,7 +150,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
     if (logalot) { console.log(`${lc} r1_syncSaga Complete.`); }
 
     await respecfully(sir, `r1 verify post`, async () => {
-        await ifWeMight(sir, 'dest should have alpha', async () => {
+        await ifWe(sir, 'dest should have alpha', async () => {
             // alpha's full dep graph should exist on dest
             const [alpha_dest] = await getIbGibsFromCache_fallbackToSpaces({
                 addrs: [r1_alpha_v0_source.addr],
@@ -230,7 +230,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
     // Verify Receiver has correct KV (Pre-Sync Check)
     // This ensures the conflict precondition exists.
     await respecfully(sir, `r2 verify pre`, async () => {
-        await ifWeMight(sir, 'dest has alpha v1 common', async () => {
+        await ifWe(sir, 'dest has alpha v1 common', async () => {
             try {
                 const destKV = await receiverCoordinator.getKnowledgeMap({
                     space: destSpace,
@@ -308,7 +308,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
             if (!alpha_dest_tipAddr) {
                 throw new Error(`dest Space missing timeline tip for ${alpha_tjpAddr} (E: 30b018c6349917aa28c9f538fa567826)`);
             }
-            await ifWeMight(sir, 'tip addrs', async () => {
+            await ifWe(sir, 'tip addrs', async () => {
                 iReckon(sir, alpha_source_tipAddr).asTo('source/dest have same tip addrs').isGonnaBe(alpha_dest_tipAddr);
             })
 
@@ -334,7 +334,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
             // #endregion DEBUG SANITY CHECK
 
 
-            await ifWeMight(sir, 'r2 basics of alpha merge', async () => {
+            await ifWe(sir, 'r2 basics of alpha merge', async () => {
                 iReckon(sir, alpha_source_tipAddr)
                     .asTo(`Source Tip (${alpha_source_tipAddr}) should NOT be r2_alpha_v3_source_rel8dBeta`)
                     .not.isGonnaBe(r2_alpha_v3_source_rel8dBeta.addr);
@@ -357,7 +357,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
                 iReckon(sir, gotten_alpha_source_tipIbGib.data![r2_dest_mut8Info.key!]).asTo(`New Tip has dest field ${r2_dest_mut8Info.key!}`).isGonnaBe(r2_dest_mut8Info.value!);
             });
 
-            await ifWeMight(sir, 'r2 alpha and deps synced', async () => {
+            await ifWe(sir, 'r2 alpha and deps synced', async () => {
                 // alpha's full dep graph should exist on dest, even though its
                 // timeline was grafted
                 const [alpha_dest] = await getIbGibsFromCache_fallbackToSpaces({
@@ -390,7 +390,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
                 }
             });
 
-            await ifWeMight(sir, 'r2 beta and deps synced', async () => {
+            await ifWe(sir, 'r2 beta and deps synced', async () => {
                 // beta's full dep graph should exist on dest
                 const [beta_dest] = await getIbGibsFromCache_fallbackToSpaces({
                     addrs: [r2_beta_v0_source.addr],
@@ -510,7 +510,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
     // #endregion r3 dest edits
 
     await respecfully(sir, `r3 verify pre`, async () => {
-        await ifWeMight(sir, 'dest has both alpha and beta tips (pre-conflict)', async () => {
+        await ifWe(sir, 'dest has both alpha and beta tips (pre-conflict)', async () => {
             try {
                 const destKV = await receiverCoordinator.getKnowledgeMap({
                     space: destSpace,
@@ -585,13 +585,13 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
             });
             const r3_beta_dest_tipAddr = beta_destKV_afterR3[beta_tjpAddr];
             if (!r3_beta_dest_tipAddr) {
-                await ifWeMight(sir, 'r3_beta_dest_tipAddr is falsy?', async () => {
+                await ifWe(sir, 'r3_beta_dest_tipAddr is falsy?', async () => {
                     iReckon(sir, true).asTo('fail').isGonnaBeFalse();
                 });
                 return; /* <<<< returns early */
             }
 
-            await ifWeMight(sir, 'r3 tip addrs match (both timelines)', async () => {
+            await ifWe(sir, 'r3 tip addrs match (both timelines)', async () => {
                 iReckon(sir, r3_alpha_source_tipAddr).asTo('alpha source/dest have same tip addrs').isGonnaBe(r3_alpha_dest_tipAddr);
                 iReckon(sir, r3_beta_source_tipAddr).asTo('beta source/dest have same tip addrs').isGonnaBe(r3_beta_dest_tipAddr);
             });
@@ -610,7 +610,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
             const resGet_r3_beta_tip = await getFromSpace({ space: sourceSpace, addr: r3_beta_source_tipAddr });
             const r3_beta_tipIbGib = resGet_r3_beta_tip.ibGibs![0] as IbGib_V1<TestData>;
 
-            await ifWeMight(sir, 'r3 alpha merge has all four fields (commonField, fieldA, fieldB, fieldC, fieldD)', async () => {
+            await ifWe(sir, 'r3 alpha merge has all four fields (commonField, fieldA, fieldB, fieldC, fieldD)', async () => {
                 // Should have new graft point  with different addr than before
                 iReckon(sir, r3_alpha_source_tipAddr)
                     .asTo(`Alpha R3 tip should NOT be r3_alpha_v4_source_mut8fieldC`)
@@ -631,7 +631,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
                     .isGonnaBe(r3_alpha_v4_dest_mut8Info.value!);
             });
 
-            await ifWeMight(sir, 'r3 beta merge has both fields (betaFieldA, betaFieldB)', async () => {
+            await ifWe(sir, 'r3 beta merge has both fields (betaFieldA, betaFieldB)', async () => {
                 // Should have new graft point with different addr than before
                 iReckon(sir, r3_beta_source_tipAddr)
                     .asTo(`Beta R3 tip should NOT be r3_beta_v1_source`)
@@ -652,7 +652,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
                     .isGonnaBe(r3_dest_beta_mut8Info.value!);
             });
 
-            await ifWeMight(sir, 'r3 alpha and deps synced', async () => {
+            await ifWe(sir, 'r3 alpha and deps synced', async () => {
                 const [alpha_dest] = await getIbGibsFromCache_fallbackToSpaces({
                     // addrs: [r1_alpha_v0_source.addr],
                     addrs: [r3_alpha_source_tipAddr],
@@ -684,7 +684,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
                 }
             });
 
-            await ifWeMight(sir, 'r3 beta and deps synced', async () => {
+            await ifWe(sir, 'r3 beta and deps synced', async () => {
                 const [beta_dest] = await getIbGibsFromCache_fallbackToSpaces({
                     // addrs: [r2_beta_v0_source.addr],
                     addrs: [r3_beta_dest_tipAddr],
@@ -836,7 +836,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
     // #endregion r4 dest edits
 
     await respecfully(sir, `r4 verify pre`, async () => {
-        await ifWeMight(sir, 'dest has alpha and beta post-R3 tips', async () => {
+        await ifWe(sir, 'dest has alpha and beta post-R3 tips', async () => {
             try {
                 const destKV = await receiverCoordinator.getKnowledgeMap({
                     space: destSpace,
@@ -913,7 +913,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
             });
             const r4_beta_dest_tipAddr = r4_beta_destKV[beta_tjpAddr];
             if (!r4_beta_dest_tipAddr) {
-                await ifWeMight(sir, 'r4_beta_dest_tipAddr is falsy?', async () => {
+                await ifWe(sir, 'r4_beta_dest_tipAddr is falsy?', async () => {
                     iReckon(sir, true).asTo('fail').isGonnaBeFalse();
                 });
                 return; /* <<<< returns early */
@@ -933,7 +933,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
             });
             const r4_gamma_dest_tipAddr = r4_gamma_destKV[gamma_tjpAddr];
 
-            await ifWeMight(sir, 'r4 tip addrs match (alpha, beta, gamma)', async () => {
+            await ifWe(sir, 'r4 tip addrs match (alpha, beta, gamma)', async () => {
                 iReckon(sir, r4_alpha_source_tipAddr).asTo('alpha source/dest have same tip addrs').isGonnaBe(r4_alpha_dest_tipAddr);
                 iReckon(sir, r4_beta_source_tipAddr).asTo('beta source/dest have same tip addrs').isGonnaBe(r4_beta_dest_tipAddr);
                 iReckon(sir, r4_gamma_source_tipAddr).asTo('gamma source/dest have same tip addrs').isGonnaBe(r4_gamma_dest_tipAddr);
@@ -958,7 +958,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
             const resGet_r4_gamma_tip = await getFromSpace({ space: sourceSpace, addr: r4_gamma_source_tipAddr });
             const r4_gamma_tipIbGib = resGet_r4_gamma_tip.ibGibs![0] as IbGib_V1<TestData>;
 
-            await ifWeMight(sir, 'r4 alpha has complete chain of edits and gamma relation', async () => {
+            await ifWe(sir, 'r4 alpha has complete chain of edits and gamma relation', async () => {
                 // Should have new graft point with different addr than either pre-graft version
                 iReckon(sir, r4_alpha_source_tipAddr)
                     .asTo(`Alpha R4 tip should NOT be r4_alpha_v7_source`)
@@ -994,7 +994,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
                     .isGonnaBeTrue();
             });
 
-            await ifWeMight(sir, 'r4 beta has all edits', async () => {
+            await ifWe(sir, 'r4 beta has all edits', async () => {
                 // Beta should have new graft from R4
                 iReckon(sir, r4_beta_source_tipAddr)
                     .asTo(`Beta R4 tip should NOT be r4_beta_v2_source (source version pre-graft)`)
@@ -1015,7 +1015,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
                     .isGonnaBe(r4_dest_beta_mut8Info.value!);
             });
 
-            await ifWeMight(sir, 'r4 gamma synced with deps', async () => {
+            await ifWe(sir, 'r4 gamma synced with deps', async () => {
                 const [gamma_dest] = await getIbGibsFromCache_fallbackToSpaces({
                     addrs: [r4_gamma_v0_source.addr],
                     space: destSpace,
@@ -1046,7 +1046,7 @@ await respecfully(sir, `Multi-round/timeline permutations`, async () => {
                 }
             });
 
-            await ifWeMight(sir, 'r4 all timelines dep graphs synced', async () => {
+            await ifWe(sir, 'r4 all timelines dep graphs synced', async () => {
                 // Verify alpha dep graphs
                 const [alpha_dest] = await getIbGibsFromCache_fallbackToSpaces({
                     addrs: [r4_alpha_source_tipAddr],

package/src/sync/sync-conflict-basic-divergence.respec.mts

@@ -230,7 +230,7 @@ await respecfully(sir, `Two different fields`, async () => {
 
             // Verify Receiver has correct KV (Pre-Sync Check)
             // This ensures the conflict precondition exists.
-            await ifWeMight(sir, 'verify receiver KV pre-sync', async () => {
+            await ifWe(sir, 'verify receiver KV pre-sync', async () => {
                 try {
                     const destKV = await receiverCoordinator.getKnowledgeMap({
                         space: destSpace,
@@ -304,7 +304,7 @@ await respecfully(sir, `Two different fields`, async () => {
 
             const resSourceTip = await getFromSpace({ space: sourceSpace, addr: getIbGibAddr({ ibGib: v2a }) });
 
-            await ifWeMight(sir, `verify merge`, async () => {
+            await ifWe(sir, `verify merge`, async () => {
                 // Retrieve updated KV from Source (or check what happened to v2a)
                 // Ideally, we just check the source space for the timeline tip
                 // The timeline tip for testRoot/v0 should now be NEW.