@ibgib/core-gib 0.1.42 → 0.1.43

package/src/sync/sync-conflict-text-merge.respec.mts

@@ -148,7 +148,7 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
             });
             const r1_alpha_source_tipAddr = r1_alpha_sourceKV[alpha_tjpAddr];
             if (!r1_alpha_source_tipAddr) {
-                ifWeMight(sir, 'r1_alpha_source_tipAddr is falsy?', async () => {
+                ifWe(sir, 'r1_alpha_source_tipAddr is falsy?', async () => {
                     iReckon(sir, true).asTo('fail').isGonnaBeFalse();
                 });
                 return; /* <<<< returns early */
@@ -161,17 +161,17 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
             });
             const r1_alpha_dest_tipAddr = r1_alpha_destKV[alpha_tjpAddr];
             if (!r1_alpha_dest_tipAddr) {
-                ifWeMight(sir, 'r1_alpha_dest_tipAddr is falsy?', async () => {
+                ifWe(sir, 'r1_alpha_dest_tipAddr is falsy?', async () => {
                     iReckon(sir, true).asTo('fail').isGonnaBeFalse();
                 });
                 return; /* <<<< returns early */
             }
 
-            await ifWeMight(sir, 'r1 tip addrs match', async () => {
+            await ifWe(sir, 'r1 tip addrs match', async () => {
                 iReckon(sir, r1_alpha_source_tipAddr).asTo('R1 source/dest have same tip').isGonnaBe(r1_alpha_dest_tipAddr);
             });
 
-            await ifWeMight(sir, 'r1 text synced correctly', async () => {
+            await ifWe(sir, 'r1 text synced correctly', async () => {
                 if (!r1_alpha_dest_tipAddr) {
                     throw new Error(`r1_dest_tipAddr is null/undefined (E: 1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d)`);
                 }
@@ -181,7 +181,7 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
                 iReckon(sir, destTipIbGib.data!.text).asTo('Dest has initial text').isGonnaBe(INITIAL_TEXT);
             });
 
-            await ifWeMight(sir, 'r1 dep graphs synced', async () => {
+            await ifWe(sir, 'r1 dep graphs synced', async () => {
                 const [r1_alpha_source_tip] = await getIbGibsFromCache_fallbackToSpaces({
                     addrs: [r1_alpha_source_tipAddr],
                     space: sourceSpace,
@@ -260,7 +260,7 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
     // #endregion r2 dest edits
 
     await respecfully(sir, `r2 verify pre`, async () => {
-        await ifWeMight(sir, 'texts as expected', async () => {
+        await ifWe(sir, 'texts as expected', async () => {
             // before the sync, each side only has their edit. after the sync,
             // both sides should have both prepended and appended text
             iReckon(sir, r2_alpha_v1_source_appendedText.ibGib.data?.text.includes(INITIAL_TEXT)).asTo('alpha source has initial text').isGonnaBeTrue();
@@ -296,14 +296,14 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
         const kv_dest = await senderCoordinator.getKnowledgeMap({ space: destSpace, metaspace, domainIbGibs: [r1_alpha_v0_source.ibGib] });
         const r2_alpha_source_tipAddr = kv_source[alpha_tjpAddr];
         if (!r2_alpha_source_tipAddr) {
-            await ifWeMight(sir, 'r2_alpha_source_tipAddr falsy?', async () => {
+            await ifWe(sir, 'r2_alpha_source_tipAddr falsy?', async () => {
                 iReckon(sir, true).asTo('fails').isGonnaBe(false);
             });
             return; /* <<<< returns early */
         }
         const r2_alpha_dest_tipAddr = kv_dest[alpha_tjpAddr];
         if (!r2_alpha_dest_tipAddr) {
-            await ifWeMight(sir, 'r2_alpha_dest_tipAddr falsy?', async () => {
+            await ifWe(sir, 'r2_alpha_dest_tipAddr falsy?', async () => {
                 iReckon(sir, true).asTo('fails').isGonnaBe(false);
             });
             return; /* <<<< returns early */
@@ -317,11 +317,11 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
             space: sourceSpace,
         });
 
-        await ifWeMight(sir, 'r2 tip addrs match', async () => {
+        await ifWe(sir, 'r2 tip addrs match', async () => {
             iReckon(sir, r2_alpha_source_tipAddr).asTo('alpha').isGonnaBe(r2_alpha_dest_tipAddr);
         });
 
-        await ifWeMight(sir, 'r2 text merged correctly', async () => {
+        await ifWe(sir, 'r2 text merged correctly', async () => {
             // before the sync, each side only has their edit. after the sync,
             // both sides should have both prepended and appended text
             iReckon(sir, r2_alpha_v1_source_appendedText.ibGib.data?.text.includes(INITIAL_TEXT)).asTo('alpha source has initial text').isGonnaBeTrue();
@@ -340,7 +340,7 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
             iReckon(sir, text).asTo('R2 has both prepend and append').isGonnaBe(DEST_PREPEND + INITIAL_TEXT + SOURCE_APPEND);
         });
 
-        await ifWeMight(sir, 'r2 dep graphs synced', async () => {
+        await ifWe(sir, 'r2 dep graphs synced', async () => {
             // alpha's full dep graph should exist on dest
             const depGraph_alpha_source = await getDependencyGraph({
                 ibGib: r2_alpha_source_tip,
@@ -414,7 +414,7 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
     // // #endregion r3 dest edits
 
     // await respecfully(sir, `r3 verify pre`, async () => {
-    //     await ifWeMight(sir, 'dest has alpha after R2 graft', async () => {
+    //     await ifWe(sir, 'dest has alpha after R2 graft', async () => {
     //         const kv = await receiverCoordinator.getKnowledgeMap({ space: destSpace, metaspace, domainIbGibs: [r3_v0_graft_fromDest] });
     //         iReckon(sir, !!kv[alpha_tjpAddr]).asTo('dest has tip').isGonnaBeTrue();
     //     });
@@ -445,11 +445,11 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
     //     const r3_tip_s = kv_s[alpha_tjpAddr];
     //     const r3_tip_d = kv_d[alpha_tjpAddr];
 
-    //     await ifWeMight(sir, 'r3 tip addrs match', async () => {
+    //     await ifWe(sir, 'r3 tip addrs match', async () => {
     //         iReckon(sir, r3_tip_s).asTo('R3 tips match').isGonnaBe(r3_tip_d);
     //     });
 
-    //     await ifWeMight(sir, 'r3 both paragraph edits merged', async () => {
+    //     await ifWe(sir, 'r3 both paragraph edits merged', async () => {
     //         const res = await getFromSpace({ space: sourceSpace, addr: r3_tip_s! });
     //         const tip = res.ibGibs![0] as IbGib_V1<TestData>;
     //         const mergedText = tip.data!.text!;
@@ -468,7 +468,7 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
     //             .isGonnaBeTrue();
     //     });
 
-    //     await ifWeMight(sir, 'r3 dep graphs synced', async () => {
+    //     await ifWe(sir, 'r3 dep graphs synced', async () => {
     //         const [d] = await getIbGibsFromCache_fallbackToSpaces({ addrs: [r3_tip_s!], space: destSpace });
     //         iReckon(sir, d).asTo('exists dest').isGonnaBeTruthy();
     //     });
@@ -502,7 +502,7 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
     // // #endregion r4 dest edits
 
     // await respecfully(sir, `r4 verify pre`, async () => {
-    //     await ifWeMight(sir, 'dest has alpha after R3 graft', async () => {
+    //     await ifWe(sir, 'dest has alpha after R3 graft', async () => {
     //         // TODO: Verify pre-sync state
     //     });
     // });
@@ -512,16 +512,16 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
     // // TODO: Add sync operation
 
     // await respecfully(sir, `r4 verify post`, async () => {
-    //     await ifWeMight(sir, 'r4 tip addrs match', async () => {
+    //     await ifWe(sir, 'r4 tip addrs match', async () => {
     //         // TODO: Verify tips match
     //     });
 
-    //     await ifWeMight(sir, 'r4 LCS merged both word changes', async () => {
+    //     await ifWe(sir, 'r4 LCS merged both word changes', async () => {
     //         // TODO: Verify text has both source and dest word changes
     //         // TODO: Verify LCS algorithm preserved both edits correctly
     //     });
 
-    //     await ifWeMight(sir, 'r4 dep graphs synced', async () => {
+    //     await ifWe(sir, 'r4 dep graphs synced', async () => {
     //         // TODO: Verify dep graphs
     //     });
     // });
@@ -556,7 +556,7 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
     // // #endregion r5 dest edits
 
     // await respecfully(sir, `r5 verify pre`, async () => {
-    //     await ifWeMight(sir, 'dest has alpha after R4 graft', async () => {
+    //     await ifWe(sir, 'dest has alpha after R4 graft', async () => {
     //         // TODO: Verify pre-sync state
     //     });
     // });
@@ -566,24 +566,24 @@ await respecfully(sir, `Text merge (LCS) conflict resolution`, async () => {
     // // TODO: Add sync operation
 
     // await respecfully(sir, `r5 verify post`, async () => {
-    //     await ifWeMight(sir, 'r5 tip addrs match', async () => {
+    //     await ifWe(sir, 'r5 tip addrs match', async () => {
     //         // TODO: Verify tips match
     //     });
 
-    //     await ifWeMight(sir, 'r5 text field merged', async () => {
+    //     await ifWe(sir, 'r5 text field merged', async () => {
     //         // TODO: Verify text field has both source and dest changes
     //     });
 
-    //     await ifWeMight(sir, 'r5 description field merged', async () => {
+    //     await ifWe(sir, 'r5 description field merged', async () => {
     //         // TODO: Verify description field has both source and dest changes
     //     });
 
-    //     await ifWeMight(sir, 'r5 both fields independently LCS-merged', async () => {
+    //     await ifWe(sir, 'r5 both fields independently LCS-merged', async () => {
     //         // TODO: Verify each field was merged independently
     //         // TODO: Ensure one field's merge didn't affect the other
     //     });
 
-    //     await ifWeMight(sir, 'r5 dep graphs synced', async () => {
+    //     await ifWe(sir, 'r5 dep graphs synced', async () => {
     //         // TODO: Verify dep graphs
     //     });
     // });

package/src/sync/sync-innerspace-dest-ahead-withid.respec.mts

@@ -0,0 +1,316 @@
+/**
+ * @module sync-innerspace-dest-ahead.respec
+ *
+ * Verifies Sync Scenario where the receiver is ahead, with identity enabled.
+ */
+
+import {
+    respecfully, lastOfAll, ifWe, iReckon,
+    ifWeMight
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+import { clone, delay, extractErrorMsg, pretty } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+import { IbGibAddr } from '@ibgib/ts-gib/dist/types.mjs';
+
+import { SyncSagaCoordinator } from './sync-saga-coordinator.mjs';
+import { putInSpace, getFromSpace, registerNewIbGib } from '../witness/space/space-helper.mjs';
+import { Metaspace_Innerspace } from '../witness/space/metaspace/metaspace-innerspace/metaspace-innerspace.mjs';
+import { InnerSpace_V1 } from '../witness/space/inner-space/inner-space-v1.mjs';
+import { createTimelineRootTestHelper, getTestKeystoneServiceHelper } from '../test-helpers.mjs';
+import { mut8Timeline } from '../timeline/timeline-api.mjs';
+import { DEFAULT_INNER_SPACE_DATA_V1 } from '../witness/space/inner-space/inner-space-types.mjs';
+import { toDto } from '../common/other/ibgib-helper.mjs';
+import { SyncPeerInnerspace_V1 } from './sync-peer/sync-peer-innerspace/sync-peer-innerspace-v1.mjs';
+import { SYNC_PEER_INNERSPACE_DEFAULT_DATA_V1 } from './sync-peer/sync-peer-innerspace/sync-peer-innerspace-constants.mjs';
+import { GetIbGibResult } from '../common/other/other-types.mjs';
+import { IbGibSpaceAny } from '../witness/space/space-base-v1.mjs';
+import { getDependencyGraph } from '../common/other/graph-helper.mjs';
+
+const logalot = false;
+const lc = `[sync-innerspace-dest-ahead.respec]`;
+
+await respecfully(sir, `Sync InnerSpaces (Dest Ahead)`, async () => {
+
+    let metaspace: Metaspace_Innerspace;
+    let sourceSpace: InnerSpace_V1;
+    let destSpace: InnerSpace_V1;
+
+    interface TestData {
+        type: string;
+        label?: string;
+        uuid?: string;
+        n?: number;
+    }
+
+    await respecfully(sir, `Dest Ahead (Remote Newer)`, async () => {
+        // 1. Setup Spaces
+        metaspace = new Metaspace_Innerspace(undefined);
+        await metaspace.initialize({
+            getFnAlert: () => async ({ title, msg }) => { },
+            getFnPrompt: () => async ({ title, msg }) => { return ''; },
+            getFnPromptPassword: () => async (title, msg) => { return null; },
+        });
+        while (!metaspace.initialized) { await delay(10); }
+
+        const defaultLocalUserSpace = await metaspace.getLocalUserSpace({ lock: false });
+        await defaultLocalUserSpace!.initialized;
+
+        sourceSpace = new InnerSpace_V1({
+            ...DEFAULT_INNER_SPACE_DATA_V1,
+            name: 'source',
+            uuid: 'source_uuid',
+            description: 'source test space',
+        });
+        await sourceSpace.initialized;
+
+        destSpace = new InnerSpace_V1({
+            ...DEFAULT_INNER_SPACE_DATA_V1,
+            name: 'dest',
+            uuid: 'dest_uuid',
+            description: 'dest test space',
+        });
+        await destSpace.initialized;
+
+        // 2. Seed Data
+        // Root -> V1 (Shared) -> V2 (Dest has New)
+        // Source only has V1.
+
+        const v0 = await createTimelineRootTestHelper<TestData>({
+            ib: 'timeline_root_ff',
+            data: { type: 'root', label: 'Root' },
+            space: sourceSpace,
+        });
+        const addrV0 = getIbGibAddr({ ibGib: v0 });
+        console.log(pretty(v0));
+
+        // V1 (Both have it, but we create in source and copy to dest)
+        const v1 = await mut8Timeline<TestData>({
+            timeline: v0,
+            mut8Opts: { dataToAddOrPatch: { type: 'comment', label: 'V1' } },
+            metaspace,
+            space: sourceSpace,
+        });
+        const addrV1 = getIbGibAddr({ ibGib: v1 });
+        console.log(pretty(v1));
+
+
+        // Transfer Root & V1 to Dest
+        const initialDepGraph = await getDependencyGraph({ ibGibs: [v0, v1], space: sourceSpace });
+        await putInSpace({ space: destSpace, ibGibs: Object.values(initialDepGraph) }); // Naive seeding
+        await registerNewIbGib({ space: destSpace, ibGib: v0 });
+        await registerNewIbGib({ space: destSpace, ibGib: v1 });
+
+        // V2 (Created in Dest ONLY)
+        const v2 = await mut8Timeline<TestData>({
+            timeline: v1, // v1 is in memory, linked to source, but we want to Mutate IN DEST SPACE
+            mut8Opts: { dataToAddOrPatch: { type: 'comment', label: 'V2' } },
+            metaspace,
+            space: destSpace, // Mutate in Dest
+        });
+        const addrV2 = getIbGibAddr({ ibGib: v2 });
+        console.log(pretty(v2));
+
+        const fnAddrExistsInSpace = async (addr: IbGibAddr, space: IbGibSpaceAny) => {
+            const resGet = await getFromSpace({ addr, space });
+            return resGet.success && resGet.ibGibs && resGet.ibGibs.length === 1;
+        }
+
+        await ifWeMight(sir, 'verify setup', async () => {
+            // Ensure V2 is ONLY in Dest (it is, per `space: destSpace`)
+            // Ensure Source does NOT have V2
+            iReckon(sir, await fnAddrExistsInSpace(addrV0, sourceSpace)).asTo('source has V0').isGonnaBeTrue();
+            iReckon(sir, await fnAddrExistsInSpace(addrV1, sourceSpace)).asTo('source has V1').isGonnaBeTrue();
+            iReckon(sir, await fnAddrExistsInSpace(addrV2, sourceSpace)).asTo('source has V2').isGonnaBeFalse();
+            iReckon(sir, await fnAddrExistsInSpace(addrV0, destSpace)).asTo('dest has V0').isGonnaBeTrue();
+            iReckon(sir, await fnAddrExistsInSpace(addrV1, destSpace)).asTo('dest has V1').isGonnaBeTrue();
+            iReckon(sir, await fnAddrExistsInSpace(addrV2, destSpace)).asTo('dest has V2').isGonnaBeTrue();
+        });
+
+        // 3. Setup Sync
+        const mockKeystone = await getTestKeystoneServiceHelper();
+        const senderCoordinator = new SyncSagaCoordinator(mockKeystone);
+        const receiverCoordinator = new SyncSagaCoordinator(mockKeystone);
+
+        const peer = new SyncPeerInnerspace_V1(clone(SYNC_PEER_INNERSPACE_DEFAULT_DATA_V1));
+        await peer.initialized;
+        await peer.initializeSender({
+            senderSpace: sourceSpace,   // "Client"
+            receiverSpace: destSpace,   // "Server"
+            receiverCoordinator,
+            receiverMetaspace: metaspace,
+        });
+
+        // 4. Run Sync (Source Pushes V1)
+        console.log(`${lc} Running Sync...`);
+        const { done, sagaId, updates$ } = await senderCoordinator.sync({
+            peer: peer,
+            localSpace: sourceSpace,
+            metaspace: metaspace,
+            domainIbGibs: [v1], // Source tries to push V1
+            useSessionIdentity: true,
+        });
+        await done;
+
+        // 5. Verify Sync (v2 should be in both source and dest now)
+        console.log(`${lc} Verifying Sync...`);
+
+        await ifWeMight(sir, `verify v2 now also in source`, async () => {
+            // Verify Tip (V2)
+
+            iReckon(sir, await fnAddrExistsInSpace(addrV0, sourceSpace)).asTo('source has V0').isGonnaBeTrue();
+            iReckon(sir, await fnAddrExistsInSpace(addrV1, sourceSpace)).asTo('source has V1').isGonnaBeTrue();
+            iReckon(sir, await fnAddrExistsInSpace(addrV2, sourceSpace)).asTo('source has V2').isGonnaBeTrue();
+            iReckon(sir, await fnAddrExistsInSpace(addrV0, destSpace)).asTo('dest has V0').isGonnaBeTrue();
+            iReckon(sir, await fnAddrExistsInSpace(addrV1, destSpace)).asTo('dest has V1').isGonnaBeTrue();
+            iReckon(sir, await fnAddrExistsInSpace(addrV2, destSpace)).asTo('dest has V2').isGonnaBeTrue();
+
+        });
+
+        await ifWeMight(sir, `dependency graphs the same`, async () => {
+
+            const sourceDepGraph = await getDependencyGraph({
+                ibGibAddr: addrV2,
+                space: sourceSpace,
+            });
+            const destDepGraph = await getDependencyGraph({
+                ibGibAddr: addrV2,
+                space: destSpace,
+            });
+
+            const sourceDepGraphAddrs = Object.keys(sourceDepGraph);
+            const destDepGraphAddrs = Object.keys(destDepGraph);
+
+            iReckon(sir, sourceDepGraphAddrs.length === destDepGraphAddrs.length).asTo('dep graphs same size').isGonnaBeTrue();
+
+            sourceDepGraphAddrs.forEach(sourceDepAddr => {
+                iReckon(sir, destDepGraphAddrs.includes(sourceDepAddr)).asTo(`${sourceDepAddr} is both graphs`).isGonnaBeTrue();
+            });
+        });
+
+        // ========================================================================
+        // IDENTITY-RELATED ASSERTIONS (TDD - Expose Implementation Gaps)
+        // ========================================================================
+
+        // Need to capture session identity and saga context from sync result
+        // For now, we'll retrieve from spaces after sync completes
+        let sessionKeystoneAddr: IbGibAddr | undefined;
+
+        await ifWeMight(sir, 'IDENTITY: session keystone exists in sender space', async () => {
+            // Session keystone should be in sender's durable space
+            // Since we can't enumerate space easily, we verify indirectly:
+            // The fact that sync completed means keystone was findable
+
+            // TODO: Capture sessionKeystoneAddr from sync() return value
+            // For now, placeholder passes
+            iReckon(sir, true)
+                .asTo('sync completed (keystone must exist)')
+                .isGonnaBeTrue();
+        });
+
+        await ifWeMight(sir, 'IDENTITY: session keystone exists in receiver space', async () => {
+            // Session keystone should be transferred to receiver's durable space
+            iReckon(sir, sessionKeystoneAddr)
+                .asTo('session keystone address was captured')
+                .isGonnaBeTruthy();
+
+            if (sessionKeystoneAddr) {
+                const destResult = await getFromSpace({ addr: sessionKeystoneAddr, space: destSpace });
+                iReckon(sir, destResult.success)
+                    .asTo('receiver has session keystone')
+                    .isGonnaBeTrue();
+            }
+        });
+
+        await ifWeMight(sir, 'IDENTITY: saga frames are signed', async () => {
+            // TODO: Get saga frames and check each has a proof
+            // This will FAIL when we actually check - that's the point (TDD RED)
+
+            iReckon(sir, false)
+                .asTo('saga frames have proofs (NOT IMPLEMENTED - should fail)')
+                .isGonnaBeTrue();
+        });
+
+        await ifWeMight(sir, 'IDENTITY: frame signatures are valid', async () => {
+            // TODO: For each saga frame, validate proof against session keystone
+            // const isValid = await validateProofWithKeystone({
+            //     proof: frame.proof,
+            //     keystone: sessionKeystone,
+            //     targetFrame: frame
+            // });
+            // iReckon(sir, isValid).asTo('proof is valid').isGonnaBeTrue();
+
+            // Placeholder for now
+            iReckon(sir, true)
+                .asTo('proof validation not yet implemented')
+                .isGonnaBeTrue();
+        });
+
+        await ifWeMight(sir, 'IDENTITY: session keystone challenges are depleted', async () => {
+            // TODO: Session keystone should evolve after signing frames
+            // This will FAIL because keystone evolution not implemented yet
+
+            iReckon(sir, false)
+                .asTo('challenges depleted (NOT IMPLEMENTED - should fail)')
+                .isGonnaBeTrue();
+        });
+
+        await ifWeMight(sir, 'IDENTITY: frame timestamps are present and fresh', async () => {
+            // TODO: Check each frame has timestamp in proof claim
+            // const claim = JSON.parse(frame.proof.claim.scope);
+            // iReckon(sir, claim.timestamp).asTo('has timestamp').isGonnaBeTruthy();
+            // const age = Date.now() - claim.timestamp;
+            // iReckon(sir, age < 60000).asTo('timestamp is fresh (<60s)').isGonnaBeTrue();
+
+            // Placeholder
+            iReckon(sir, true)
+                .asTo('timestamp validation not yet implemented')
+                .isGonnaBeTrue();
+        });
+
+        await ifWeMight(sir, 'IDENTITY: keystone has no hard links to domain ibgibs', async () => {
+            if (sessionKeystoneAddr) {
+                const keystoneResult = await getFromSpace({
+                    addr: sessionKeystoneAddr,
+                    space: sourceSpace
+                });
+
+                if (keystoneResult.success && keystoneResult.ibGibs && keystoneResult.ibGibs.length > 0) {
+                    const keystone = keystoneResult.ibGibs[0];
+                    const rel8ns = keystone.rel8ns || {};
+                    const allRel8nAddrs = Object.values(rel8ns)
+                        .flat()
+                        .filter(addr => typeof addr === 'string');
+
+                    const domainAddrs = [addrV0, addrV1, addrV2];
+
+                    for (const domainAddr of domainAddrs) {
+                        iReckon(sir, allRel8nAddrs.includes(domainAddr))
+                            .asTo(`keystone does not hard link to ${domainAddr}`)
+                            .isGonnaBeFalse();
+                    }
+                }
+            }
+        });
+
+        await ifWeMight(sir, 'IDENTITY: saga frames have no hard links to domain ibgibs', async () => {
+            // Saga frames should NOT have hard links to domain ibgibs
+            // This currently PASSES but will expose issues if hard links exist
+
+            iReckon(sir, true)
+                .asTo('hard link validation (placeholder)')
+                .isGonnaBeTrue();
+
+            // TODO: Get saga frames and check their rel8ns
+            // for (const frame of sagaFrames) {
+            //     const rel8nAddrs = Object.values(frame.rel8ns || {}).flat();
+            //     for (const domainAddr of [addrV0, addrV1, addrV2]) {
+            //         iReckon(sir, rel8nAddrs.includes(domainAddr)).asTo get('no hard link').isGonnaBeFalse();
+            //     }
+            // }
+        });
+
+
+    });
+
+});

package/src/sync/sync-saga-coordinator.mts

@@ -197,7 +197,7 @@ export class SyncSagaCoordinator {
 
                 // BOOTSTRAP IDENTITY (Session Keystone)
                 const sessionIdentity = useSessionIdentity
-                    ? await this.getSessionIdentity({ sagaId, metaspace, tempSpace })
+                    ? await this.getSessionIdentity({ sagaId, metaspace, localSpace })
                     : undefined;
                 // if (logalot) { console.log(`${lc} sessionIdentity: ${sessionIdentity ? pretty(sessionIdentity) : 'undefined'} (I: abc01872800b3a66b819a05898bba826)`); }
 
@@ -328,11 +328,11 @@ export class SyncSagaCoordinator {
     private async getSessionIdentity({
         sagaId,
         metaspace,
-        tempSpace,
+        localSpace,
     }: {
         sagaId: string,
         metaspace: MetaspaceService,
-        tempSpace: IbGibSpaceAny,
+        localSpace: IbGibSpaceAny,
     }): Promise<KeystoneIbGib_V1> {
         const lc = `${this.lc}[${this.getSessionIdentity.name}]`;
         try {
@@ -349,7 +349,7 @@ export class SyncSagaCoordinator {
                 masterSecret: sagaId,
                 configs: [config],
                 metaspace,
-                space: tempSpace
+                space: localSpace // ✅ FIXED: Use durable space, not temp space
             });
 
             return sessionIdentity;