@ibgib/core-gib 0.1.19 → 0.1.21

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

@@ -0,0 +1,330 @@
+/**
+ * @module sync-conflict.respec
+ *
+ * Verifies Conflict Resolution strategies in SyncSagaCoordinator.
+ * Reproduces divergence scenarios and asserts resolution behavior.
+ */
+
+import {
+    respecfully, lastOfAll, ifWe, iReckon,
+    ifWeMight
+} from '@ibgib/helper-gib/dist/respec-gib/respec-gib.mjs';
+const maam = `[${import.meta.url}]`, sir = maam;
+import { delay, extractErrorMsg, pretty } from '@ibgib/helper-gib/dist/helpers/utils-helper.mjs';
+import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
+
+import { SyncSagaCoordinator } from './sync-saga-coordinator.mjs';
+import { getFromSpace } 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 { createTimelineRootHelper, getTestKeystoneServiceHelper } from '../agent-helpers.mjs';
+import { mut8Timeline } from '../timeline/timeline-api.mjs';
+import { SyncPeerInnerspace_V1 } from './sync-peer/sync-peer-innerspace-v1.mjs';
+import { DEFAULT_INNER_SPACE_DATA_V1 } from '../witness/space/inner-space/inner-space-types.mjs';
+import { getTjpAddr, toDto } from '../common/other/ibgib-helper.mjs';
+import { SyncConflictStrategy, SyncSagaInfo } from './sync-types.mjs';
+import { IbGibData_V1, IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
+import { fnObs } from '../common/pubsub/observer/observer-helper.mjs';
+import { getDependencyGraph } from '../common/other/graph-helper.mjs';
+import { ErrorIbGib_V1 } from '../common/error/error-types.mjs';
+
+interface TestData extends IbGibData_V1 {
+    text?: string;
+    fieldA?: string;
+    fieldB?: string;
+}
+
+const logalot = true;
+const lc = `[sync-conflict.respec]`;
+
+await respecfully(sir, `Sync Conflict Resolution`, async () => {
+
+    let metaspace: Metaspace_Innerspace;
+    let sourceSpace: InnerSpace_V1;
+    let destSpace: InnerSpace_V1;
+
+    await respecfully(sir, `Scenario: Simple Divergence (Field A vs Field B)`, async () => {
+        // 1. Setup Spaces
+        metaspace = new Metaspace_Innerspace(undefined);
+        await metaspace.initialize({
+            getFnAlert: () => async ({ title, msg }) => { console.log(`[Alert] ${title}: ${msg}`); },
+            getFnPrompt: () => async ({ title, msg }) => { console.log(`[Prompt] ${title}: ${msg}`); return ''; },
+            getFnPromptPassword: () => async (title, msg) => { console.log(`[PromptPwd] ${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 Common History (V0 -> V1)
+        console.log(`${lc} Creating Common History...`);
+        const testRoot = await createTimelineRootHelper<TestData>({
+            ib: 'timeline_root',
+            data: { type: 'testRoot', text: 'v0' },
+            space: sourceSpace,
+        });
+        // Create V1 (Common)
+        const v1_Common = await mut8Timeline<TestData>({
+            timeline: testRoot,
+            mut8Opts: { dataToAddOrPatch: { text: 'v1_common' } },
+            metaspace,
+            space: sourceSpace,
+        });
+        const tjpAddr =
+            getTjpAddr({ ibGib: testRoot, defaultIfNone: 'incomingAddr' }) ??
+            getIbGibAddr({ ibGib: testRoot });
+        console.log(`${lc} [TEST DEBUG] tjpAddr: ${tjpAddr}`)
+        // Sync testRoot to dest immediately so they start synced
+        // must get the entire dependency graph for testRoot
+        const depGraph_testRootAndV1Common = await getDependencyGraph({
+            ibGibAddrs: [tjpAddr],
+            space: sourceSpace,
+            live: true,
+        }) ?? {};
+        console.log(`${lc} depGraph_testRootAndV1Common: ${pretty(depGraph_testRootAndV1Common)}`)
+        if (Object.keys(depGraph_testRootAndV1Common).length === 0) {
+            throw new Error(`(UNEXPECTED) depGraph_testRootAndV1Common empty? (E: 39b4d855ffa65476084b4123786da826)`);
+        }
+        // put the entire graph into the destspace, but...
+        await metaspace.put({ ibGibs: Object.values(depGraph_testRootAndV1Common), space: destSpace });
+        // ...only register the main ibgibs
+        await metaspace.registerNewIbGib({ ibGib: testRoot, space: destSpace });
+        await metaspace.registerNewIbGib({ ibGib: v1_Common, space: destSpace });
+
+        const resGetDest = await getFromSpace({ space: destSpace, addr: getIbGibAddr({ ibGib: v1_Common }) });
+        if (!resGetDest.success || !resGetDest.ibGibs || resGetDest.ibGibs.length === 0) {
+            throw new Error(`Failed to retrieve v1_Dest from destSpace. (E: a1b2c3d4e5f6g7h8i9j0)`);
+        }
+        const v1_Dest = resGetDest.ibGibs[0];
+
+
+        // 3. Create Divergence (V2a vs V2b)
+        console.log(`${lc} Creating Divergence...`);
+
+        // Source: V1 -> V2a (Edit Field A)
+        const v2a = await mut8Timeline<TestData>({
+            timeline: v1_Common,
+            mut8Opts: { dataToAddOrPatch: { fieldA: 'source_edit' } },
+            metaspace,
+            space: sourceSpace,
+        });
+
+        // Dest: V1 -> V2b (Edit Field B)
+        const v2b = await mut8Timeline<TestData>({
+            timeline: v1_Dest,
+            mut8Opts: { dataToAddOrPatch: { fieldB: 'dest_edit' } },
+            metaspace,
+            space: destSpace,
+        });
+
+        // Verify Divergence
+        console.log(`${lc} Divergence created.`);
+
+
+        // 4. Run Sync (Optimistic)
+        console.log(`${lc} Setting up Coordinators...`);
+        const mockKeystone = await getTestKeystoneServiceHelper();
+        const senderCoordinator = new SyncSagaCoordinator(mockKeystone);
+        const receiverCoordinator = new SyncSagaCoordinator(mockKeystone);
+
+
+        // Create sender's tempSpace for transactional payload transfer
+        const senderTempSpaceName = `tmp_sender_test_${Date.now()}`;
+        const senderTempSpace = await metaspace.createNewLocalSpace({
+            opts: {
+                allowCancel: false,
+                spaceName: senderTempSpaceName,
+                getFnPrompt: metaspace.getFnPrompt!,
+            }
+        });
+        if (!senderTempSpace) { throw new Error(`(UNEXPECTED) senderTempSpace falsy? (E: ef4388c87e98f0211852eefa22414f26)`); }
+        await senderTempSpace.initialized;
+
+        const peer = new SyncPeerInnerspace_V1({
+            senderSpace: sourceSpace,
+            senderTempSpace,  // Pass sender's tempSpace for payload transfer
+            receiverSpace: destSpace,
+            receiverCoordinator,
+            receiverMetaspace: metaspace,
+        });
+        await peer.initialized;
+
+        // Verify Receiver has correct KV (Pre-Sync Check)
+        // This ensures the conflict precondition exists.
+        await ifWeMight(sir, 'verify receiver KV pre-sync', async () => {
+            try {
+                const destKV = await receiverCoordinator.getKnowledgeVector({
+                    space: destSpace,
+                    metaspace,
+                    domainIbGibs: [v1_Dest]
+                });
+                const v1TjpAddr = getTjpAddr({ ibGib: v1_Dest, defaultIfNone: 'incomingAddr' }) ?? getIbGibAddr({ ibGib: v1_Dest });
+                console.log(`[TEST DEBUG] v1_Dest: ${JSON.stringify(v1_Dest)}`);
+                console.log(`[TEST DEBUG] v1TjpAddr: ${v1TjpAddr}`);
+                console.log(`[TEST DEBUG] destKV: ${JSON.stringify(destKV)}`);
+                console.log(`[TEST DEBUG] v1_Dest.rel8ns.tjp: ${v1_Dest.rel8ns?.tjp?.join(', ')}`);
+
+                // Actually v1 has tjp rel8n.
+                const destTip = destKV[v1TjpAddr];
+                iReckon(sir, !!destTip).asTo(`Dest KV has timeline tip for ${v1TjpAddr}`).isGonnaBeTruthy();
+                if (!destTip) {
+                    throw new Error(`Test Setup Fail: Dest Space does not have index for timeline ${v1TjpAddr}. Seeding failed. (E: c194a80b4e4877b77826c37a1753b826)`);
+                }
+
+            } catch (error) {
+                console.error(`${lc} ${extractErrorMsg(error)}`);
+                iReckon(sir, true).asTo('getKnowledgeVector errored out').isGonnaBeFalse();
+            }
+        });
+
+        console.log(`${lc} Running Sync (ConflictStrategy: optimistic)...`);
+
+        let resSync: SyncSagaInfo | undefined;
+        try {
+            resSync = await senderCoordinator.sync({
+                peer,
+                source: sourceSpace,
+                dest: destSpace,
+                metaspace,
+                domainIbGibs: [v2a],
+                conflictStrategy: SyncConflictStrategy.optimistic,
+                // identity: undefined as any, // Not needed? If removed, it uses session identity.
+                // identitySecret: undefined as any,
+                // explicit useSessionIdentity: true is default
+            });
+
+            const sublc = `${lc}[updates$]`;
+            /**
+             * I have added this so you can see how to subscribe to an ibgib
+             * observable using {@link fnObs}.
+             */
+            const subscription = await resSync.updates$.subscribe(fnObs({
+                next: async (ctxIbGib) => {
+                    console.log(`${sublc} next fired. ${pretty(ctxIbGib)}`);
+                },
+                error: async (e: ErrorIbGib_V1) => {
+                    if (e.data) {
+                        console.error(`${sublc} error fired. error: ${JSON.stringify(e.data)} (E: 01cc08ba05ad99682831174fd7c31a26)`);
+                    } else {
+                        console.dir(e);
+                        console.error(`${sublc} error fired. error: ${extractErrorMsg(e)} (E: 73d3d61464e8e4ce4cd6efd8b9675826)`);
+                    }
+                },
+                complete: async () => {
+                    console.log(`${sublc} complete fired`);
+                },
+            }));
+
+            console.log(`${lc} awaiting resSync.done`)
+            await resSync.done;
+
+            console.log(`${lc} Sync Complete.`);
+        } catch (e) {
+            console.error(`${lc} Sync Failed with Error:`, e);
+            iReckon(sir, false).asTo(`Sync failed with error: ${e}`).isGonnaBeTruthy();
+            return; // Exit test early
+        }
+
+        // 5. Verification
+        // Expectation: Both Spaces should now have a NEW tip (V3) that merges V2a and V2b.
+
+        const resSourceTip = await getFromSpace({ space: sourceSpace, addr: getIbGibAddr({ ibGib: v2a }) });
+
+        await ifWeMight(sir, `verify merge happened`, 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.
+
+            try {
+                // Get the KV for the Source Space
+                const sourceKV = await senderCoordinator.getKnowledgeVector({
+                    space: sourceSpace,
+                    metaspace,
+                    domainIbGibs: [testRoot] // We want to know the tip of this timeline
+                });
+                const tjpAddr =
+                    getTjpAddr({ ibGib: testRoot, defaultIfNone: 'incomingAddr' }) ??
+                    getIbGibAddr({ ibGib: testRoot });
+
+                if (logalot) { console.log(`${lc} getKnowledgeVector returned. sourceKV: ${pretty(sourceKV)} (I: e8780cda37c8b2a46eeb85786874e926)`); }
+
+                const sourceTipAddr = sourceKV[tjpAddr];
+                if (!sourceTipAddr) {
+                    throw new Error(`Source Space missing timeline tip for ${tjpAddr} (E: ec95980b9c980c5c5870812e15e43826)`);
+                }
+                console.log(`${lc} [TEST DEBUG] sourceTipAddr: ${sourceTipAddr}`);
+                console.log(`${lc} [TEST DEBUG] v2a: ${getIbGibAddr({ ibGib: v2a })}`);
+                console.log(`${lc} [TEST DEBUG] v2b: ${getIbGibAddr({ ibGib: v2b })}`);
+
+
+                iReckon(sir, sourceTipAddr).asTo(`Source Tip (${sourceTipAddr}) should NOT be v2a`).not.isGonnaBe(getIbGibAddr({ ibGib: v2a }));
+                iReckon(sir, sourceTipAddr).asTo(`Source Tip (${sourceTipAddr}) should NOT be v2b`).not.isGonnaBe(getIbGibAddr({ ibGib: v2b }));
+
+                // Fetch the new tip
+                const resTip = await getFromSpace({ space: sourceSpace, addr: sourceTipAddr });
+                const newTip = resTip.ibGibs![0] as IbGib_V1<TestData>;
+                console.log(`${lc} [TEST DEBUG] newTip: ${JSON.stringify(newTip)}`);
+
+
+                // Check Data: Should have BOTH edits
+                iReckon(sir, newTip.data!.fieldA).asTo('New Tip Data Field A').isGonnaBe('source_edit');
+                iReckon(sir, newTip.data!.fieldB).asTo('New Tip Data Field B').isGonnaBe('dest_edit');
+
+                // Check Graft Structure
+                // Look for 'graftinfo' rel8n
+                const graftInfoRel = newTip.rel8ns?.graftinfo;
+                iReckon(sir, graftInfoRel).asTo('New Tip should have graftinfo rel8n').isGonnaBeTruthy();
+                if (graftInfoRel) {
+                    iReckon(sir, graftInfoRel!.length).asTo('Only 1 graftinfo').isGonnaBe(1);
+
+                    // Fetch Graft Info Stone
+                    const resGraft = await getFromSpace({ space: sourceSpace, addr: graftInfoRel![0] });
+                    const graftInfo = resGraft.ibGibs![0];
+                    console.log(`${lc} [TEST DEBUG] graftInfo: ${JSON.stringify(graftInfo)}`);
+
+                    // Check Graft Relations (graftbase, graftorphan)
+                    const baseRel = graftInfo.rel8ns?.graftbase;
+                    const orphanRel = graftInfo.rel8ns?.graftorphan;
+
+                    iReckon(sir, baseRel).asTo('Graft Base exists').isGonnaBeTruthy();
+                    iReckon(sir, orphanRel).asTo('Graft Orphan exists').isGonnaBeTruthy();
+
+
+                    // Verify Base/Orphan identity (one should be v2a, one v2b)
+                    const addrV2a = getIbGibAddr({ ibGib: v2a });
+                    const addrV2b = getIbGibAddr({ ibGib: v2b });
+
+                    const bases = baseRel || [];
+                    const orphans = orphanRel || [];
+
+                    const isV2aInvolved = bases.includes(addrV2a) || orphans.includes(addrV2a);
+                    const isV2bInvolved = bases.includes(addrV2b) || orphans.includes(addrV2b);
+
+                    iReckon(sir, isV2aInvolved).asTo('V2a is involved in graft').isGonnaBeTrue();
+                    iReckon(sir, isV2bInvolved).asTo('V2b is involved in graft').isGonnaBeTrue();
+                }
+            } catch (error) {
+                console.error(`${lc} ${extractErrorMsg(error)}`);
+                iReckon(sir, true).asTo('getKnowledgeVector errored out').isGonnaBeFalse();
+            }
+
+        });
+    });
+
+});

package/src/sync/sync-constants.mts

@@ -13,15 +13,13 @@ export const SYNC_STAGE_ACK = "ack";
 export const SYNC_STAGE_REQUEST = "request";
 export const SYNC_STAGE_DELTA = "delta";
 export const SYNC_STAGE_COMMIT = "commit";
-export const SYNC_STAGE_CONFLICT = "conflict";
 
 export type SyncStage =
     | typeof SYNC_STAGE_INIT
     | typeof SYNC_STAGE_ACK
     | typeof SYNC_STAGE_REQUEST
     | typeof SYNC_STAGE_DELTA
-    | typeof SYNC_STAGE_COMMIT
-    | typeof SYNC_STAGE_CONFLICT;
+    | typeof SYNC_STAGE_COMMIT;
 
 export const SyncStage = {
     init: SYNC_STAGE_INIT,
@@ -29,5 +27,4 @@ export const SyncStage = {
     request: SYNC_STAGE_REQUEST,
     delta: SYNC_STAGE_DELTA,
     commit: SYNC_STAGE_COMMIT,
-    conflict: SYNC_STAGE_CONFLICT,
 } as const;

package/src/sync/sync-innerspace-constants.respec.mts

@@ -25,7 +25,7 @@ const lc = `[sync-innerspace-constants.respec]`;
 
 await respecfully(sir, `Sync Constants (No TJP)`, async () => {
 
-    await ifWeMight(sir, `Verify Constants Sync`, async () => {
+    await ifWe(sir, `Verify Constants Sync`, async () => {
         // 1. Setup Spaces
         const metaspace = new Metaspace_Innerspace(undefined);
         await metaspace.initialize({

package/src/sync/sync-innerspace-deep-updates.respec.mts

@@ -118,7 +118,6 @@ await respecfully(sir, `Sync InnerSpaces (Deep Updates)`, async () => {
             localSpace: sourceSpace,
             metaspace: metaspace,
             domainIbGibs: [commentV2], // Sync the TIP
-            useSessionIdentity: false,
         });
 
         await resSync.done;

package/src/sync/sync-innerspace.respec.mts

@@ -33,7 +33,7 @@ await respecfully(sir, `Sync InnerSpaces`, async () => {
     let sourceSpace: InnerSpace_V1;
     let destSpace: InnerSpace_V1;
 
-    await ifWe(sir, `Basic Push Sync (Source -> Dest)`, async () => {
+    await respecfully(sir, `Basic Push Sync (Source -> Dest)`, async () => {
         // 1. Setup Spaces
         metaspace = new Metaspace_Innerspace(undefined);
         await metaspace.initialize({

package/src/sync/sync-peer/sync-peer-innerspace-v1.mts

@@ -7,20 +7,22 @@ import { IbGib_V1 } from '@ibgib/ts-gib/dist/V1/types.mjs';
 import { getIbGibAddr } from '@ibgib/ts-gib/dist/helper.mjs';
 
 import { GLOBAL_LOG_A_LOT } from '../../core-constants.mjs';
-import { SYNC_ATOM } from '../sync-constants.mjs';
+import { SYNC_ATOM, SYNC_MSG_REL8N_NAME } from '../sync-constants.mjs';
 import { IbGibSpaceAny } from '../../witness/space/space-base-v1.mjs';
-import { SyncSagaContextIbGib_V1 } from '../sync-saga-context/sync-saga-context-types.mjs';
-import { SyncPeer_V1 } from './sync-peer-v1.mjs';
 import { SyncSagaCoordinator } from '../sync-saga-coordinator.mjs';
-import { createSyncSagaContext } from '../sync-saga-context/sync-saga-context-helpers.mjs';
-import { getFromSpace, putInSpace } from '../../witness/space/space-helper.mjs';
 import { MetaspaceService } from '../../witness/space/metaspace/metaspace-types.mjs';
+import { SyncPeer_V1 } from './sync-peer-v1.mjs';
+import { getFromSpace, putInSpace } from '../../witness/space/space-helper.mjs';
+import { SyncSagaContextIbGib_V1 } from '../sync-saga-context/sync-saga-context-types.mjs';
+import { createSyncSagaContext } from '../sync-saga-context/sync-saga-context-helpers.mjs';
 
 export interface SyncPeerInnerspaceOptions {
-    senderSpace: IbGibSpaceAny;
-    receiverSpace: IbGibSpaceAny;
+    senderSpace: IbGibSpaceAny;          // Durable space for audit trail
+    senderTempSpace?: IbGibSpaceAny;     // Transactional space - will use if provided
+    receiverSpace: IbGibSpaceAny;        // Durable space for receiver audit trail
     receiverCoordinator: SyncSagaCoordinator;
     receiverMetaspace: MetaspaceService; // Need this for receiver execution
+    receiverTempSpace?: IbGibSpaceAny;   // Optional: will be created if not provided
 }
 
 const logalot = GLOBAL_LOG_A_LOT || true;
@@ -41,6 +43,26 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1 {
         super(opts.receiverSpace.data!); // Use receiver space data as initial phantom data? Or empty.
     }
 
+    private async ensureReceiverTempSpace(): Promise<IbGibSpaceAny> {
+        if (!this.opts.receiverTempSpace) {
+            const { receiverMetaspace } = this.opts;
+            const uuid = crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36);
+            const tempSpaceName = `tmp_sync_recv_${uuid.substring(0, 8)}`;
+            this.opts.receiverTempSpace = await receiverMetaspace.createNewLocalSpace({
+                opts: {
+                    allowCancel: false,
+                    spaceName: tempSpaceName,
+                    getFnPrompt: receiverMetaspace.getFnPrompt!,
+                    logalot
+                }
+            });
+            if (this.opts.receiverTempSpace) {
+                await this.opts.receiverTempSpace.initialized;
+            }
+        }
+        return this.opts.receiverTempSpace!; // Non-null assertion since we just created it
+    }
+
     protected async getLocalIbGib(addr: string): Promise<IbGib_V1 | undefined> {
         const res = await getFromSpace({ space: this.opts.senderSpace, addr });
         return res.ibGibs?.[0];
@@ -69,6 +91,27 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1 {
             const sagaFrame = resFrame.ibGibs?.[0] as any;
             if (!sagaFrame) { throw new Error(`${lc} sagaFrame not found in receiver space: ${sagaFrameAddr} (E: 2c0190bd04ea408c909618193850029b)`); }
 
+            // Ensure receiverTempSpace exists
+            const receiverTempSpace = await this.ensureReceiverTempSpace();
+
+            // Store saga frame in tempSpace for easy queries during transaction
+            // (Control ibgibs like saga frames and msg stones go in BOTH spaces:
+            //  destSpace for audit trail, tempSpace for easy queries)
+            await putInSpace({ space: receiverTempSpace, ibGib: sagaFrame });
+            await receiverMetaspace.registerNewIbGib({ ibGib: sagaFrame });
+
+            // Also store the message stone (if present) in tempSpace
+            const msgStoneAddrs = sagaFrame.rel8ns?.[SYNC_MSG_REL8N_NAME];
+            if (msgStoneAddrs && msgStoneAddrs.length > 0) {
+                const resMsgStone = await getFromSpace({ space: receiverSpace, addrs: msgStoneAddrs });
+                if (resMsgStone.ibGibs) {
+                    for (const msgStone of resMsgStone.ibGibs) {
+                        await putInSpace({ space: receiverTempSpace, ibGib: msgStone });
+                        await receiverMetaspace.registerNewIbGib({ ibGib: msgStone });
+                    }
+                }
+            }
+
             // 2. Execute Receiver Logic
             // The Peer "Network" triggers the Receiver Coordinator.
             if (logalot) { console.log(`${lc} Invoking Receiver Coordinator...`); }
@@ -78,7 +121,8 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1 {
             const result = await receiverCoordinator.handleSagaFrame({
                 sagaIbGib: sagaFrame,
                 srcGraph: {},
-                space: receiverSpace,
+                destSpace: receiverSpace,       // Query existing data
+                tempSpace: receiverTempSpace,   // Transaction space
                 metaspace: receiverMetaspace,
             });
 
@@ -91,10 +135,31 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1 {
 
             if (logalot) { console.log(`${lc} responseFrame addr: ${getIbGibAddr({ ibGib: responseFrame })}`); }
 
-            // 3. Persist Response Data to Receiver Space (Output Buffer)
-            // The Receiver created new data (Frame, Payload). It must be saved in Receiver Space
-            // so the "Network" can PULL it back to Sender.
-            const ibGibsToPersist = [responseFrame, ...(payloadIbGibs || [])];
+            // 3. Persist Response Control IbGibs (Frame + Msg Stones) to BOTH Spaces
+            // Control ibgibs (saga frames, msg stones, identity) go in BOTH spaces:
+            // - receiverSpace (destSpace): Audit trail
+            // - receiverTempSpace: Already there from creation in tempSpace
+
+            // Ensure response frame is in receiverSpace for audit trail
+            await putInSpace({ space: receiverSpace, ibGib: responseFrame });
+            await receiverMetaspace.registerNewIbGib({ ibGib: responseFrame });
+
+            // Ensure response msg stone is in receiverSpace for audit trail
+            const responseMsgStoneAddrs = responseFrame.rel8ns?.[SYNC_MSG_REL8N_NAME];
+            if (responseMsgStoneAddrs && responseMsgStoneAddrs.length > 0) {
+                const resResponseMsgStone = await getFromSpace({ space: receiverTempSpace, addrs: responseMsgStoneAddrs });
+                if (resResponseMsgStone.ibGibs) {
+                    for (const msgStone of resResponseMsgStone.ibGibs) {
+                        await putInSpace({ space: receiverSpace, ibGib: msgStone });
+                        await receiverMetaspace.registerNewIbGib({ ibGib: msgStone });
+                    }
+                }
+            }
+
+            // 4. Persist Domain Payload IbGibs
+            // Domain ibgibs stay in tempSpace ONLY until commit
+            // (they're already in the appropriate space from coordinator's work)
+            const ibGibsToPersist = [...(payloadIbGibs || [])];
 
             // Note: payloadIbGibs might have deep dependencies. 
             // Since they were generated/fetched by the Receiver Coordinator, 
@@ -107,6 +172,14 @@ export class SyncPeerInnerspace_V1 extends SyncPeer_V1 {
 
             await putInSpace({ space: receiverSpace, ibGibs: ibGibsToPersist });
 
+            // CRITICAL: Also put payloadIbGibs into sender's tempSpace
+            // Sender needs these for merge logic in handleDeltaFrame (tempSpace queries)
+            // Do NOT put in sender's durable space - these are transactional!
+            if (this.opts.senderTempSpace && ibGibsToPersist.length > 0) {
+                console.log(`${lc} [CONFLICT DEBUG] Transferring ${ibGibsToPersist.length} payload ibgibs to sender's tempSpace`);
+                await putInSpace({ space: this.opts.senderTempSpace, ibGibs: ibGibsToPersist });
+            }
+
             // 4. Create Response Context
             const responsePayloadAddrs = payloadIbGibs?.map(p => getIbGibAddr({ ibGib: p }));
             const responseCtx = await createSyncSagaContext({