@ibgib/core-gib 0.1.20 → 0.1.22

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

@@ -4,10 +4,11 @@ import {
     getTimestamp, // so our timestamp strings are uniform
     getTimestampInTicks, // so our timestamp in ticks as a string are uniform
     pretty,
-    clone
+    clone,
+    unique,
 } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
 import { getIbGibAddr } from "@ibgib/ts-gib/dist/helper.mjs";
-import { splitPerTjpAndOrDna, getTimelinesGroupedByTjp } from "../common/other/ibgib-helper.mjs";
+import { splitPerTjpAndOrDna, getTimelinesGroupedByTjp, isIbGib } from "../common/other/ibgib-helper.mjs";
 import { Factory_V1 } from "@ibgib/ts-gib/dist/V1/factory.mjs";
 import { IbGib_V1, IbGibRel8ns_V1 } from "@ibgib/ts-gib/dist/V1/types.mjs";
 import { isPrimitive } from "@ibgib/ts-gib/dist/V1/transforms/transform-helper.mjs";
@@ -18,7 +19,7 @@ import { putInSpace, getLatestAddrs, getFromSpace } from "../witness/space/space
 import { KeystoneIbGib_V1 } from "../keystone/keystone-types.mjs";
 import { KeystoneService_V1 } from "../keystone/keystone-service-v1.mjs";
 import { MetaspaceService } from "../witness/space/metaspace/metaspace-types.mjs";
-import { SyncStage, SYNC_ATOM, SYNC_MSG_REL8N_NAME } from "./sync-constants.mjs";
+import { SyncStage, SYNC_ATOM, SYNC_MSG_REL8N_NAME, SYNC_SAGA_PAYLOAD_ADDRS_DOMAIN } from "./sync-constants.mjs";
 import { appendToTimeline, createTimeline, Rel8nInfo, Rel8nRemovalInfo } from "../timeline/timeline-api.mjs";
 import {
     SyncData_V1, SyncIbGib_V1, SyncInitData, SyncConflictStrategy,
@@ -26,27 +27,44 @@ import {
     SyncOptions,
 } from "./sync-types.mjs";
 import { getSyncIb, isPastFrame } from "./sync-helpers.mjs";
-import { getSyncSagaDependencyGraph } from "./sync-helpers.mjs";
+import { getSyncSagaDependencyGraph as getSyncSagaDependencyGraphForThisFrameOnly } from "./sync-helpers.mjs";
 import { getDependencyGraph } from "../common/other/graph-helper.mjs";
 import {
     SyncSagaMessageData_V1, SyncSagaMessageInitData_V1,
     SyncSagaMessageAckData_V1, SyncSagaMessageDeltaData_V1,
-    SyncSagaMessageCommitData_V1, SyncSagaMessageConflictData_V1
+    SyncSagaMessageCommitData_V1
 } from "./sync-saga-message/sync-saga-message-types.mjs";
 import { getSyncSagaMessageIb } from "./sync-saga-message/sync-saga-message-helpers.mjs";
 import { SYNC_SAGA_MSG_ATOM } from "./sync-saga-message/sync-saga-message-constants.mjs";
 import { SyncSagaInfo } from "./sync-types.mjs";
 import { SyncPeerWitness } from "./sync-peer/sync-peer-types.mjs";
-import { SyncSagaContextIbGib_V1, SyncSagaContextCmd } from "./sync-saga-context/sync-saga-context-types.mjs";
+import { SyncSagaContextIbGib_V1, } from "./sync-saga-context/sync-saga-context-types.mjs";
 import { createSyncSagaContext } from "./sync-saga-context/sync-saga-context-helpers.mjs";
-import { newupSubject } from "../common/pubsub/subject/subject-helper.mjs";
+import { newupSubject, } from "../common/pubsub/subject/subject-helper.mjs";
 import { SubjectWitness } from "../common/pubsub/subject/subject-types.mjs";
 
 import { mergeDivergentTimelines } from "./strategies/conflict-optimistic.mjs";
 import { getSyncSagaMessageFromFrame } from "./sync-saga-message/sync-saga-message-helpers.mjs";
+import { fnObs } from "../common/pubsub/observer/observer-helper.mjs";
+import { SubscriptionWitness } from "../common/pubsub/subscription/subscription-types.mjs";
+import { ErrorIbGib_V1 } from "../common/error/error-types.mjs";
+import { SyncPeerInnerspace_V1 } from "./sync-peer/sync-peer-innerspace/sync-peer-innerspace-v1.mjs";
 
 
-const logalot = GLOBAL_LOG_A_LOT || true;
+// const logalot = GLOBAL_LOG_A_LOT || true;
+const logalot = false;
+const logalotControlDomain = true;
+const lcControlDomain = '[ControlDomain]';
+
+/**
+ * Result of handling a saga frame.
+ * Separates control and domain payloads.
+ */
+export interface HandleSagaFrameResult {
+    frame: SyncIbGib_V1;
+    payloadIbGibsControl?: IbGib_V1[];
+    payloadIbGibsDomain?: IbGib_V1[];
+}
 
 /**
  * Orchestrates the synchronization process between two spaces (Source and Destination).
@@ -143,7 +161,7 @@ export class SyncSagaCoordinator {
                 const sessionIdentity = useSessionIdentity
                     ? await this.getSessionIdentity({ sagaId, metaspace, tempSpace })
                     : undefined;
-                if (logalot) { console.log(`${lc} sessionIdentity: ${sessionIdentity ? pretty(sessionIdentity) : 'undefined'} (I: abc01872800b3a66b819a05898bba826)`); }
+                // if (logalot) { console.log(`${lc} sessionIdentity: ${sessionIdentity ? pretty(sessionIdentity) : 'undefined'} (I: abc01872800b3a66b819a05898bba826)`); }
 
                 // 3. CREATE INITIAL FRAME (Stage.init)
                 const { sagaFrame: initFrame, srcGraph } = await this.createInitFrame({
@@ -157,6 +175,13 @@ export class SyncSagaCoordinator {
                 });
 
                 // 4. EXECUTE SAGA LOOP (FSM)
+                // Inject tempSpace into peer so it can pull control payloads to the right place
+                // if ('opts' in peer && peer.opts) {
+                if (!peer.data) { throw new Error(`(UNEXPECTED) peer.data falsy? (E: 8546a884c82ffb1999e95d9867da2826)`); }
+                if (peer.data.classname === SyncPeerInnerspace_V1.name) {
+                    // (peer as SyncPeerInnerspace_V1).senderTempSpace = tempSpace;
+                }
+
                 const syncedIbGibs = await this.executeSagaLoop({
                     initialFrame: initFrame,
                     srcGraph,
@@ -260,7 +285,6 @@ export class SyncSagaCoordinator {
         srcGraph: { [addr: string]: IbGib_V1 },
         peer: SyncPeerWitness,
         sessionIdentity?: KeystoneIbGib_V1,
-        // updates$: Subject_V1<SyncSagaContextIbGib_V1>,
         updates$: SubjectWitness<SyncSagaContextIbGib_V1>,
         localSpace: IbGibSpaceAny,
         tempSpace: IbGibSpaceAny,
@@ -271,142 +295,213 @@ export class SyncSagaCoordinator {
         // The current frame we just generated (e.g., Init or Delta Request)
         let currentFrame: SyncIbGib_V1 | null = initialFrame;
         // The payload we need to attach to the message (data we are sending)
-        let nextPayloadIbGibs: IbGib_V1[] = [];
+        let nextDomainIbGibs: IbGib_V1[] = [];
         // Accumulator for all data we've successfully pulled from the remote
         const allReceivedIbGibs: IbGib_V1[] = [];
 
         while (currentFrame) {
             // A. Create Context (Request)
             // 1. Calculate Full Dependency Graph (including Ancestors/DNA)
-            // We must do this BEFORE creating the Context so we can list them all in payloadAddrs.
-            const allDeps: IbGib_V1[] = [];
+            // TODO: adjust this algorithm to only do the dependencies that the other end doesn't need (diff between tip and LCA)
+            // We must do this BEFORE creating the Context so we can list them
+            // all in payloadAddrsDomain and payloadAddrsControl.
+            // const depsDomainIbGibs: IbGib_V1[] = [];
+            // const depsControlIbGibs: IbGib_V1[] = [];
+            const payloadIbGibsControl: IbGib_V1[] = [];
+            const payloadIbGibsDomain: IbGib_V1[] = [];
 
             // A. Payload (Standard Deep Deps)
-            for (const item of nextPayloadIbGibs) {
-                let graph = await getDependencyGraph({ ibGib: item, space: localSpace });
-                if (!graph) {
-                    graph = await getDependencyGraph({ ibGib: item, space: tempSpace });
+            for (const nextDomainIbGib of nextDomainIbGibs) {
+                let nextDomainIbGibGraph = await getDependencyGraph({ ibGib: nextDomainIbGib, space: localSpace });
+                if (!nextDomainIbGibGraph) {
+                    nextDomainIbGibGraph = await getDependencyGraph({ ibGib: nextDomainIbGib, space: tempSpace });
                 }
 
-                if (graph) {
-                    allDeps.push(...Object.values(graph));
+                if (nextDomainIbGibGraph) {
+                    payloadIbGibsDomain.push(...Object.values(nextDomainIbGibGraph));
                 } else {
-                    allDeps.push(item);
+                    throw new Error(`(UNEXPECTED) we couldn't get the graph for a known domain ibgib? nextDomainIbGib addr: ${getIbGibAddr({ ibGib: nextDomainIbGib })} (E: 01b3e4db8768b5b77db72e486f4f7826)`);
                 }
             }
-            if (logalot) {
-                // console.log(`${lc} allDeps count: ${allDeps.length}`);
-            }
+            if (logalot) { console.log(`${lc} payloadIbGibsDomain count: ${payloadIbGibsDomain.length} (I: 2beda8ca7dc5ac0f48ed9e25e704b826)`); }
 
             // B. Frames (Shallow Sync Deps)
             if (currentFrame) {
-                const deps = await getSyncSagaDependencyGraph({ ibGib: currentFrame, space: tempSpace });
-                if (deps) allDeps.push(...deps);
+                const depsCurrentFrame = await getSyncSagaDependencyGraphForThisFrameOnly({ ibGib: currentFrame, space: tempSpace });
+                if (depsCurrentFrame.length > 0) {
+                    depsCurrentFrame.forEach(x => payloadIbGibsControl.push(x));
+                } else {
+                    throw new Error(`(UNEXPECTED) couldn't get deps for currentFrame? currentFrame: ${JSON.stringify(currentFrame)} (E: 06344d07adc80d80b809211171444d26)`);
+                }
             }
 
             // 2. Create Context (Envelope)
-            // Use the FULL dependency list as the payload manifest
-            const payloadAddrs = allDeps.map(p => getIbGibAddr({ ibGib: p }));
+            const domainPayloadsMap = new Map<string, IbGib_V1>();
+            const sublc = `${lc}[peer.payloadIbGibsDomainReceived$]`;
+            let subscription: SubscriptionWitness;
+            if (peer && peer.payloadIbGibsDomainReceived$) {
+                // Subscribe to stream
+                subscription = await peer.payloadIbGibsDomainReceived$.subscribe(fnObs({
+                    next: async (ibgib: IbGib_V1) => {
+                        if (logalot) { console.log(`${sublc} next fired. (I: 2b4bdf502a38a90ba33d9711e7cb7826)`); }
+                        const addr = getIbGibAddr({ ibGib: ibgib });
+                        if (logalotControlDomain) { console.log(`${lc}${lcControlDomain} DOMAIN STREAM RECEIVED <- observable: ${addr} (I: d69ee80fcaece272483ec33b2d289826)`); }
+                        domainPayloadsMap.set(addr, ibgib);
+                    },
+                    error: async (e: string | Error | ErrorIbGib_V1) => {
+                        if (isIbGib(e)) {
+                            console.error(`${sublc} error fired. error: ${JSON.stringify((e as IbGib_V1).data)} (E: 01cc08ba05ad99682831174fd7c31a26)`);
+                        } else {
+                            console.dir(e);
+                            console.error(`${sublc} error fired. error: ${extractErrorMsg(e)} (E: 73d3d61464e8e4ce4cd6efd8b9675826)`);
+                        }
+                    },
+                    complete: async () => {
+                        if (logalot) { console.log(`${sublc} complete fired. (I: a47218aa9e4433fdb97c068880a45826)`); }
+                        await subscription.unsubscribe();
+                    },
+                }));
+            }
 
+            // 2b. Request Context
             const requestCtx = await createSyncSagaContext({
-                cmd: SyncSagaContextCmd.process,
                 sagaFrame: currentFrame,
                 sessionKeystones: sessionIdentity ? [sessionIdentity] : undefined,
-                payloadAddrs: payloadAddrs.length > 0 ? payloadAddrs : undefined,
+                payloadIbGibsDomain,
             });
 
-            // Add Context Deps
-            if (requestCtx) {
-                const deps = await getSyncSagaDependencyGraph({ ibGib: requestCtx, space: tempSpace });
-                if (deps) allDeps.push(...deps);
+            // Log what we're sending
+            if (logalotControlDomain) {
+                const controlAddrs = payloadIbGibsControl.map(p => getIbGibAddr({ ibGib: p }));
+                const domainAddrs = payloadIbGibsDomain.map(p => getIbGibAddr({ ibGib: p }));
+                console.log(`${lc}${lcControlDomain} SENDER TRANSMIT -> peer.witness (I: b3c4d5e6f7a8b9c0)`);
+                console.log(`${lc}${lcControlDomain}   Context: ${getIbGibAddr({ ibGib: requestCtx })}`);
+                console.log(`${lc}${lcControlDomain}   Frame: ${getIbGibAddr({ ibGib: currentFrame })}`);
+                console.log(`${lc}${lcControlDomain}   CONTROL Payloads (${controlAddrs.length}): ${controlAddrs.join(', ') || '(none)'}`);
+                console.log(`${lc}${lcControlDomain}   DOMAIN Payloads (${domainAddrs.length}): ${domainAddrs.join(', ') || '(none)'}`);
             }
 
+            // Add Context Deps
+            // do we need to add requestCtx to the payload ibgibs?
+            // if (requestCtx) {
+            //     const deps = await getSyncSagaDependencyGraphForThisFrameOnly({ ibGib: requestCtx, space: tempSpace });
+            //     if (deps) { deps.forEach(x => payloadIbGibsControl.push(x)); }
+            // }
+
             // 3. Identity (if exists)
             // Identity might be deep? Keystone? Usually self-contained or shallow references.
             if (sessionIdentity) {
-                allDeps.push(sessionIdentity);
+                payloadIbGibsControl.push(sessionIdentity);
             }
 
-            if (allDeps.length > 0) {
-                await putInSpace({
-                    space: localSpace,
-                    ibGibs: allDeps
-                });
+            // we only put the **CONTROL** payload ibgibs in localSpace. we
+            // don't put any domain ibgibs into this durable space until the
+            // final commit phase.
+            // The requestCtx envelope itself also goes to localSpace so transfer can find it.
+            await putInSpace({ space: localSpace, ibGib: requestCtx });
+            if (payloadIbGibsControl.length > 0) {
+                await putInSpace({ space: localSpace, ibGibs: payloadIbGibsControl });
             }
 
             // B. Transmit
-            if (logalot) { console.log(`${lc} transmitting... requestCtx: ${pretty(requestCtx)} (I: 8cf20817c66899abdb1e76df50356826)`); }
-            updates$.next(requestCtx);
+            // if (logalot) { console.log(`${lc} transmitting... requestCtx: ${pretty(requestCtx)} (I: 8cf20817c66899abdb1e76df50356826)`); }
+            updates$.next(requestCtx); // spins off (don't remove this comment!)
+
             const responseCtx = await peer.witness(requestCtx);
 
             // C. Handle Response
             if (!responseCtx) {
-                // Check if we just sent a Commit frame. If so, peer's silence is success/expected.
                 if (currentFrame) {
+                    // Check for Commit (Peer silence expected)
                     const msg = await getSyncSagaMessageFromFrame({ frameIbGib: currentFrame, space: localSpace });
-                    if (logalot) { console.log(`${lc} Checking currentFrame stage: ${msg?.data?.stage} (Expected: ${SyncStage.commit})`); }
                     if (msg?.data?.stage === SyncStage.commit) {
                         if (logalot) { console.log(`${lc} Sender sent Commit. Peer returned no response. Saga Complete.`); }
                         currentFrame = null;
                         break;
+                    } else {
+                        throw new Error(`(UNEXPECTED) responseCtx falsy and currentFrame truthy, but we're not in the commit stage? This may be expected ultimately, but atow I am not seeing this as being expected. (E: cc34498962bd370deeff351fac939f26)`);
                     }
+                } else {
+                    throw new Error(`(UNEXPECTED) no response and currentFrame falsy? (E: 8d1085ea2f28cfc3f9c922649864a826)`);
                 }
-
-                throw new Error(`responseCtx falsy. Peer returned no response context (E: c099d8073b48d85e881f917835158f26)`);
-                // console.warn(`${lc} Peer returned no response context. Ending loop.`);
-                // currentFrame = null;
-                // break;
             }
 
-            if (logalot) {
-                console.log(`${lc} received responseCtx: ${pretty(responseCtx)} (I: 8f35c8b7a9e886aa9743d38bee907826)`);
-            }
+            // ---------------------------------------------------------------------
+            // 2d. HANDLE RESPONSE
+            // ---------------------------------------------------------------------
+            if (!responseCtx.data) { throw new Error(`(UNEXPECTED) responseCtx.data falsy? (E: a969992bae53ab18a827ec58aec15826)`); }
+            updates$.next(responseCtx); // spins off -- don't remove this comment!
+
+            // Extract expected domain addresses from response context
+            const responsePayloadAddrsDomain = responseCtx.data[SYNC_SAGA_PAYLOAD_ADDRS_DOMAIN] as string[] || [];
 
-            updates$.next(responseCtx);
+            // TODO: check if we are validating the responseCtx in sync peer. I'm thinking that we must, because we can't start the domain ibgibs until we know the response's control ibgibs are valid.
 
-            // D. Extract Remote Frame & React
-            const remoteFrameAddr = responseCtx.rel8ns?.sagaFrame?.[0];
-            if (!remoteFrameAddr) {
-                // If the remote didn't send a saga frame, we can't continue the protocol.
-                throw new Error(`${lc} Peer response has no sagaFrame. Ending loop. (E: 0224e84a83e1c7ee288aaed6bdc40826)`);
+            // Poll for them if needed
+            if (responsePayloadAddrsDomain.length > 0) {
+                await this.pollForDomainPayloads({
+                    expectedAddrs: responsePayloadAddrsDomain,
+                    domainPayloadsMap,
+                    tempSpace,
+                });
             }
 
-            // We look in localSpace first (where Peer delivers), then tempSpace.
-            let resRemoteFrame = await getFromSpace({ addr: remoteFrameAddr, space: localSpace });
-            if (!resRemoteFrame.success || !resRemoteFrame.ibGibs?.length) {
-                // Fallback to tempSpace just in case
-                resRemoteFrame = await getFromSpace({ addr: remoteFrameAddr, space: tempSpace });
+            // Extract Response Frame
+            const responseFrameAddr = responseCtx.rel8ns?.sagaFrame?.[0];
+            if (!responseFrameAddr) { throw new Error(`${lc} Peer response missing sagaFrame (E: 83a0)`); }
+
+            // Log what we received back
+            if (logalotControlDomain) {
+                const responseControlAddrs = responseCtx.data?.['@payloadAddrsControl'] as string[] || [];
+                console.log(`${lc}${lcControlDomain} SENDER RECEIVED <- peer.witness (I: c4d5e6f7a8b9c0d1)`);
+                console.log(`${lc}${lcControlDomain}   Response Context: ${getIbGibAddr({ ibGib: responseCtx })}`);
+                console.log(`${lc}${lcControlDomain}   Response Frame: ${responseFrameAddr}`);
+                console.log(`${lc}${lcControlDomain}   CONTROL Payloads (${responseControlAddrs.length}): ${responseControlAddrs.join(', ') || '(none)'}`);
+                console.log(`${lc}${lcControlDomain}   DOMAIN Payloads (${responsePayloadAddrsDomain.length}): ${responsePayloadAddrsDomain.join(', ') || '(none)'}`);
             }
-            const remoteFrame = resRemoteFrame.ibGibs?.[0];
 
-            if (!remoteFrame) { throw new Error(`Could not resolve remote frame: ${remoteFrameAddr}`); }
-            // if (logalot) { console.log(`${lc} remoteFrame: ${pretty(remoteFrame)}`); } // leave this in for later use if needed
+            // Get response frame from localSpace (SyncPeer puts it there)
+            let resResponseFrame = await getFromSpace({ space: localSpace, addr: responseFrameAddr });
+            if (!resResponseFrame.success || !resResponseFrame.ibGibs?.length) {
+                // Fallback to tempSpace
+                resResponseFrame = await getFromSpace({ space: tempSpace, addr: responseFrameAddr });
+            }
+            const responseFrame = resResponseFrame.ibGibs?.[0] as any;
+            if (!responseFrame) throw new Error(`${lc} Response frame not found (E: 7c2a)`);
+
+            // Handle Response Frame
+            const handleResult = await this.handleSagaFrame({
+                sagaIbGib: responseFrame,
+                srcGraph: {},
+                destSpace: localSpace,
+                tempSpace,
+                metaspace,
+                domainPayloadsMap,
+                expectedDomainAddrs: responsePayloadAddrsDomain,
+            });
 
-            // Ensure remote frame and its dependencies are in tempSpace
-            // The Peer delivered them to localSpace, but handleSagaFrame works in tempSpace.
-            const remoteDeps = await getSyncSagaDependencyGraph({ ibGib: remoteFrame, space: localSpace });
-            if (remoteDeps && remoteDeps.length > 0) {
-                await putInSpace({ space: tempSpace, ibGibs: remoteDeps });
+            if (!handleResult) {
+                if (logalot) { console.log(`${lc} Handler returned null (Saga End).`); }
+                break;
             }
 
-            // React (Reducer)
-            // This processes the FRAME we just got from the peer.
-            // i.e., We Sent Init -> Got Ack. This calls handleAckFrame.
-            // i.e., We Sent Delta -> Got Delta. This calls handleDeltaFrame.
-            const result = await this.handleSagaFrame({
-                sagaIbGib: remoteFrame as SyncIbGib_V1,
-                srcGraph,
-                space: localSpace, // Must be localSpace (Source) to find domain data
-                identity: sessionIdentity,
-                metaspace
-            });
+            currentFrame = handleResult.frame;
 
-            currentFrame = result?.frame || null;
-            nextPayloadIbGibs = result?.payloadIbGibs || []; // Payload to send in NEXT Ping
-            if (result?.receivedPayloadIbGibs) {
-                // Keep track of what we received for final merge
-                allReceivedIbGibs.push(...result.receivedPayloadIbGibs);
+            // Collect next DOMAIN payloads for the NEXT request
+            // Control payloads are handled separately by ensureSagaFrameInBothSpaces
+            nextDomainIbGibs = [...(handleResult.payloadIbGibsDomain || [])];
+
+            // Log handler output for next iteration
+            if (logalotControlDomain) {
+                const handlerControlAddrs = (handleResult.payloadIbGibsControl || []).map(p => getIbGibAddr({ ibGib: p }));
+                const handlerDomainAddrs = nextDomainIbGibs.map(p => getIbGibAddr({ ibGib: p }));
+                console.log(`${lc}${lcControlDomain} HANDLER RESULT -> next iteration (I: d5e6f7a8b9c0d1e2)`);
+                console.log(`${lc}${lcControlDomain}   Next Frame: ${getIbGibAddr({ ibGib: currentFrame })}`);
+                console.log(`${lc}${lcControlDomain}   CONTROL for next (${handlerControlAddrs.length}): ${handlerControlAddrs.join(', ') || '(none)'} (saved via ensureSagaFrameInBothSpaces)`);
+                console.log(`${lc}${lcControlDomain}   DOMAIN for next (${handlerDomainAddrs.length}): ${handlerDomainAddrs.join(', ') || '(none)'}`);
             }
+
+            // Note: currentFrame is automatically added to dependencies at start of next loop via B. Frames logic.
         }
 
         return allReceivedIbGibs;
@@ -428,31 +523,65 @@ export class SyncSagaCoordinator {
         tjpAddrs?: string[],
     }): Promise<{ [tjp: string]: string | null }> {
         const lc = `${this.lc}[${this.getKnowledgeVector.name}]`;
-        if (logalot) { console.log(`${lc} starting...`); }
+        try {
+            if (logalot) { console.log(`${lc} starting... (I: e184f8a7818666febfbbd2d841ed3826)`); }
+            // console.dir(space);
 
-        let tjps: string[] = [];
-        if (tjpAddrs) {
-            tjps = tjpAddrs;
-        } else if (domainIbGibs && domainIbGibs.length > 0) {
-            // Extract TJPs from domain Ibgibs
-            const { mapWithTjp_YesDna, mapWithTjp_NoDna } = splitPerTjpAndOrDna({ ibGibs: domainIbGibs });
-            const allWithTjp = [...Object.values(mapWithTjp_YesDna), ...Object.values(mapWithTjp_NoDna)];
-            const timelineMap = getTimelinesGroupedByTjp({ ibGibs: allWithTjp });
-            tjps = Object.keys(timelineMap);
-        } else {
-            // No info provided. Return empty? Or throw?
-            // User test context implied "everything", but implementation requires scope.
-            console.warn(`${lc} No domainIbGibs or tjpAddrs provided. Returning empty KV.`);
-            return {};
-        }
+            if (!(domainIbGibs && domainIbGibs.length > 0) &&
+                !(tjpAddrs && tjpAddrs.length > 0)
+            ) {
+                throw new Error(`(UNEXPECTED) domainIbGibs and tjpAddrs falsy/empty? we need one or the other (E: f674285111c8648398cd79d8c08ec826)`);
+            }
+
+            if ((domainIbGibs && domainIbGibs.length > 0) &&
+                (tjpAddrs && tjpAddrs.length > 0)
+            ) {
+                throw new Error(`(UNEXPECTED) both domainIbGibs and tjpAddrs truthy? only pass in one or the other. (E: f674285111c8648398cd79d8c08ec826)`);
+            }
 
-        if (tjps.length === 0) { return {}; }
+            let tjps: string[] = [];
+            if (tjpAddrs) {
+                tjps = tjpAddrs;
+            } else if (domainIbGibs && domainIbGibs.length > 0) {
+                // Extract TJPs from domain Ibgibs
+                // if (false) { console.log(`${lc} domainIbGibs (${domainIbGibs.length}) provided.  (I: a378995a0658af1f086ac1f297486c26)`); }
 
-        const res = await getLatestAddrs({ space, tjpAddrs: tjps });
-        if (!res.data || !res.data.latestAddrsMap) {
-            throw new Error(`${lc} Failed to get latest addrs. (E: 7a8b9c0d)`);
+                const { mapWithTjp_YesDna, mapWithTjp_NoDna } =
+                    splitPerTjpAndOrDna({ ibGibs: domainIbGibs });
+                if (false) { console.log(`${lc}[TEST DEBUG] mapWithTjp_YesDna: ${JSON.stringify(mapWithTjp_YesDna)} (I: 287e22897148298e185712c8d50cfb26)`); }
+                if (false) { console.log(`${lc}[TEST DEBUG] mapWithTjp_NoDna: ${JSON.stringify(mapWithTjp_NoDna)} (I: 1bdc62656294aed0f9df334647dc7326)`); }
+
+                const allWithTjp = [...Object.values(mapWithTjp_YesDna), ...Object.values(mapWithTjp_NoDna)];
+                const timelineMap = getTimelinesGroupedByTjp({ ibGibs: allWithTjp });
+                if (false) { console.log(`${lc}[TEST DEBUG] timelineMap: ${JSON.stringify(timelineMap)} (I: 2cc04898e5f85179fb1ac7f827abc426)`); }
+
+                tjps = Object.keys(timelineMap);
+                if (false) { console.log(`${lc}[TEST DEBUG] tjps: ${tjps} (I: 3dd548667cbd967c68e57c88dc570826)`); }
+            } else {
+                // No info provided. Return empty? Or throw?
+                // User test context implied "everything", but implementation requires scope.
+                console.warn(`${lc} No domainIbGibs or tjpAddrs provided. Returning empty KV.`);
+                return {};
+            }
+
+            if (tjps.length === 0) { return {}; }
+
+            if (false) { console.log(`${lc} getting latest addrs for tjps: ${tjps} (I: d4e7080b8ba8187c583b82fd91ac0626)`); }
+
+            const res = await getLatestAddrs({ space, tjpAddrs: tjps });
+            if (!res.data || !res.data.latestAddrsMap) {
+                throw new Error(`${lc} Failed to get latest addrs. (E: 7a8b9c0d)`);
+            }
+
+            // if (false) { console.log(`${lc}[TEST DEBUG] res.data.latestAddrsMap: ${JSON.stringify(res.data.latestAddrsMap)} (I: a8e128bdf80898ac2e6d8021a5bff726)`); }
+
+            return res.data.latestAddrsMap;
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
         }
-        return res.data.latestAddrsMap;
     }
 
     protected async analyzeTimelines({
@@ -545,12 +674,17 @@ export class SyncSagaCoordinator {
                 initData.knowledgeVector[tjp] = getIbGibAddr({ ibGib: tip });
             });
 
+            if (logalot) {
+                console.log(`${lc} SyncStage.init: ${SyncStage.init}, SyncStage.commit: ${SyncStage.commit}`);
+                console.log(`${lc} initData.stage: ${initData.stage}`);
+            }
+
             const initStone = await this.createSyncMsgStone({
                 data: initData,
                 space: tempSpace,
                 metaspace
             });
-            if (logalot) { console.log(`${lc} initStone: ${pretty(initStone)} (I: 06e532f8a408549069474e96bed44826)`); }
+            // if (logalot) { console.log(`${lc} initStone: ${pretty(initStone)} (I: 06e532f8a408549069474e96bed44826)`); }
 
             const sagaFrame = await this.evolveSyncSagaIbGib({
                 msgStones: [initStone],
@@ -559,7 +693,16 @@ export class SyncSagaCoordinator {
                 metaspace,
                 conflictStrategy,
             });
-            if (logalot) { console.log(`${lc} sagaFrame (init): ${pretty(sagaFrame)} (I: b3d6a8be69248f18713cc3073cb08626)`); }
+
+            // IMMEDIATELY persist to both spaces for audit trail
+            await this.ensureSagaFrameInBothSpaces({
+                frame: sagaFrame,
+                destSpace: localSpace,  // localSpace is the Sender's destSpace
+                tempSpace,
+                metaspace
+            });
+
+            // if (logalot) { console.log(`${lc} sagaFrame (init): ${pretty(sagaFrame)} (I: b3d6a8be69248f18713cc3073cb08626)`); }
 
             return { sagaFrame, srcGraph };
 
@@ -572,33 +715,83 @@ export class SyncSagaCoordinator {
     }
 
     /**
-     * Reacts to an incoming saga frame and dispatches to appropriate handler.
-     * 
-     * @remarks
-     * **Execution Context**: **Universal (Both Sender and Receiver)**.
-     * 
-     * This method acts as the "Reducer" for the Sync FSM. It determines the current stage
-     * based on the incoming frame and delegates to the appropriate handler.
-     * 
-     * *   If running on **Receiver**: Handles `Init` (via `handleInitFrame`).
-     * *   If running on **Sender**: Handles `Ack` (via `handleAckFrame`).
-     * *   If running on **Either**: Handles `Delta` (via `handleDeltaFrame`) or `Commit`.
+     * Helper to poll for streaming domain payloads and put them in the
+     * local {@link tempSpace}.
      */
+    protected async pollForDomainPayloads({
+        expectedAddrs,
+        domainPayloadsMap,
+        tempSpace,
+    }: {
+        expectedAddrs: string[],
+        domainPayloadsMap: Map<string, IbGib_V1>,
+        tempSpace: IbGibSpaceAny,
+    }): Promise<void> {
+        const lc = `${this.lc}[${this.pollForDomainPayloads.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} starting... (I: 26dce86bfca572939885798802d6e926)`); }
+
+            let pending = [...expectedAddrs];
+            const start = Date.now();
+            /**
+             * This needs 
+             */
+            const timeoutMs = 5 * 60 * 1000; // 5 minutes...arbitrary at this point. This needs to be pulled out and improved eesh.
+
+            while (pending.length > 0) {
+                if (Date.now() - start > timeoutMs) {
+                    throw new Error(`Timeout waiting for payloads: ${pending.join(', ')} (E: 46e1683c9578095261aaf798bd5e1826)`);
+                }
+
+                const stillPending: string[] = [];
+                const found: IbGib_V1[] = [];
+
+                for (const addr of pending) {
+                    if (domainPayloadsMap.has(addr)) {
+                        found.push(domainPayloadsMap.get(addr)!);
+                        domainPayloadsMap.delete(addr);
+                    } else {
+                        stillPending.push(addr);
+                    }
+                }
+
+                if (found.length > 0) {
+                    await putInSpace({ space: tempSpace, ibGibs: found });
+                }
+
+                pending = stillPending;
+
+                if (pending.length > 0) {
+                    await new Promise(resolve => setTimeout(resolve, 50));
+                }
+            }
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
+    }
+
     async handleSagaFrame({
         sagaIbGib,
         srcGraph,
-        space,
+        destSpace,
+        tempSpace,
         identity,
         identitySecret,
         metaspace,
     }: {
         sagaIbGib: SyncIbGib_V1,
         srcGraph: { [addr: string]: IbGib_V1 },
-        space: IbGibSpaceAny,
+        destSpace: IbGibSpaceAny,
+        tempSpace: IbGibSpaceAny,
         identity?: KeystoneIbGib_V1,
         identitySecret?: string,
         metaspace: MetaspaceService,
-    }): Promise<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[], receivedPayloadIbGibs?: IbGib_V1[] } | null> {
+        domainPayloadsMap?: Map<string, IbGib_V1>,
+        expectedDomainAddrs?: string[],
+    }): Promise<HandleSagaFrameResult | null> {
         const lc = `${this.lc}[${this.handleSagaFrame.name}]`;
         try {
             if (logalot) { console.log(`${lc} starting... (I: 5deec8a1f7a6d263c88cd458ad990826)`); }
@@ -607,25 +800,22 @@ export class SyncSagaCoordinator {
             if (logalot) { console.log(`${lc} sagaIbGib: ${pretty(sagaIbGib)} (I: 1b99d87d262e9d18d8a607a80b1a0126)`); }
 
             // Get Stage from Stone (or Frame for Init fallback)
-            const { stage, messageData } = await this.getStageAndPayloadFromFrame({ ibGib: sagaIbGib, space });
+            const { stage, messageData } = await this.getStageAndPayloadFromFrame({ ibGib: sagaIbGib, space: tempSpace });
 
             if (logalot) { console.log(`${lc} handling frame stage: ${stage}`); }
 
             switch (stage) {
                 case SyncStage.init:
-                    return await this.handleInitFrame({ sagaIbGib, messageData, metaspace, space, identity, identitySecret });
+                    return await this.handleInitFrame({ sagaIbGib, messageData, metaspace, destSpace, tempSpace, identity, identitySecret });
 
                 case SyncStage.ack:
-                    return await this.handleAckFrame({ sagaIbGib, srcGraph, metaspace, space, identity });
+                    return await this.handleAckFrame({ sagaIbGib, srcGraph, metaspace, destSpace, tempSpace, identity });
 
                 case SyncStage.delta:
-                    return await this.handleDeltaFrame({ sagaIbGib, srcGraph, metaspace, space, identity, });
+                    return await this.handleDeltaFrame({ sagaIbGib, srcGraph, metaspace, destSpace, tempSpace, identity, });
 
                 case SyncStage.commit:
-                    return await this.handleCommitFrame({ sagaIbGib, metaspace, space, identity, });
-
-                case SyncStage.conflict:
-                    return await this.handleConflictFrame({ sagaIbGib, metaspace, space, });
+                    return await this.handleCommitFrame({ sagaIbGib, metaspace, destSpace, tempSpace, identity, });
 
                 default:
                     throw new Error(`${lc} (UNEXPECTED) Unknown sync stage: ${stage} (E: 9c2b4c8a6d34469f8263544710183355)`);
@@ -655,19 +845,22 @@ export class SyncSagaCoordinator {
     protected async handleInitFrame({
         sagaIbGib,
         messageData,
-        space,
+        destSpace,
+        tempSpace,
         metaspace,
         identity,
         identitySecret,
     }: {
         sagaIbGib: SyncIbGib_V1,
         messageData: any,
-        space: IbGibSpaceAny,
+        destSpace: IbGibSpaceAny,
+        tempSpace: IbGibSpaceAny,
         metaspace: MetaspaceService,
         identity?: KeystoneIbGib_V1,
         identitySecret?: string,
-    }): Promise<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[] } | null> {
+    }): Promise<HandleSagaFrameResult | null> {
         const lc = `${this.lc}[${this.handleInitFrame.name}]`;
+        console.log(`${lc} [TEST DEBUG] Received destSpace: ${destSpace.data?.name || destSpace.ib} (uuid: ${destSpace.data?.uuid || '[no uuid]'})`);
         if (logalot) { console.log(`${lc} starting...`); }
 
         // Extract Init Data
@@ -675,7 +868,7 @@ export class SyncSagaCoordinator {
         if (initData.stage !== SyncStage.init) {
             throw new Error(`${lc} Invalid init frame: initData.stage !== SyncStage.init (E: 8a2b3c4d5e6f7g8h)`);
         }
-        if (logalot) { console.log(`${lc} initData: ${pretty(initData)} (I: 46b0f8441b96ad7a388f1ce3239dd826)`); }
+        // if (logalot) { console.log(`${lc} initData: ${pretty(initData)} (I: 46b0f8441b96ad7a388f1ce3239dd826)`); }
         if (!initData || !initData.knowledgeVector) {
             throw new Error(`${lc} Invalid init frame: missing knowledgeVector (E: ed02c869e028d2d06841b9c7f80f2826)`);
         }
@@ -694,7 +887,7 @@ export class SyncSagaCoordinator {
         if (stones.length > 0) {
             if (logalot) { console.log(`${lc} processing stones: ${stones.length}`); }
             // Check if we have these stones
-            const resStones = await getFromSpace({ space, addrs: stones });
+            const resStones = await getFromSpace({ space: destSpace, addrs: stones });
             const addrsNotFound = resStones.rawResultIbGib?.data?.addrsNotFound;
             if (addrsNotFound && addrsNotFound.length > 0) {
                 if (logalot) { console.log(`${lc} stones missing (requesting): ${addrsNotFound.length}`); }
@@ -709,6 +902,7 @@ export class SyncSagaCoordinator {
         const remoteKV = initData.knowledgeVector;
         if (logalot) { console.log(`${lc} remoteKV: ${pretty(remoteKV)} (I: 9f957862356dfeae183c200854e86e26)`); }
         const remoteTjps = Object.keys(remoteKV);
+        console.log(`${lc} [TEST DEBUG] remoteTjps: ${JSON.stringify(remoteTjps)}`);
         if (logalot) { console.log(`${lc} remoteTjps: ${pretty(remoteTjps)} (I: 86ea4c53db0dc184c8b253386c402126)`); }
 
         // 1. Get Local Latest Addrs for all TJPs
@@ -716,12 +910,13 @@ export class SyncSagaCoordinator {
         if (remoteTjps.length > 0) {
             // Batch get latest addrs for the TJPs
             const resGetLatestAddrs = await getLatestAddrs({
-                space,
+                space: destSpace,
                 tjpAddrs: remoteTjps,
             });
             if (!resGetLatestAddrs.data) { throw new Error(`(UNEXPECTED) resGetLatestAddrs.data falsy? (E: b180d813c088042b38e1e02e06a16926)`); }
             if (!resGetLatestAddrs.data.latestAddrsMap) { throw new Error(`(UNEXPECTED) resGetLatestAddrs.data.latestAddrsMap falsy? (E: 16bc386dd51d0ff53a49620b1e641826)`); }
             localKV = resGetLatestAddrs.data.latestAddrsMap;
+            console.log(`${lc} [TEST DEBUG] localKV: ${JSON.stringify(localKV)}`);
             if (logalot) { console.log(`${lc} localKV: ${pretty(localKV)} (I: 980975642cbccd8018cf0cd808d30826)`); }
         }
 
@@ -734,24 +929,28 @@ export class SyncSagaCoordinator {
 
             if (!localAddr) {
                 // We (Receiver) don't have this timeline. Request it.
+                console.log(`${lc} [TEST DEBUG] Missing local timeline for TJP: ${tjp}. Requesting remoteAddr: ${remoteAddr}`);
                 deltaReqAddrs.push(remoteAddr);
                 continue;
             }
 
             if (localAddr === remoteAddr) {
                 // Synced
+                console.log(`${lc} [TEST DEBUG] TJP ${tjp}: Synced (localAddr === remoteAddr)`);
                 continue;
             }
+            console.log(`${lc} [TEST DEBUG] TJP ${tjp}: localAddr=${localAddr}, remoteAddr=${remoteAddr} - checking for divergence...`);
 
             // Check if Remote is in Local's PAST (Local is Ahead -> Push Offer)
             // (Sender has older version, Receiver has newer) -> Receiver Offers Push
             const isRemoteInPast = await isPastFrame({
                 olderAddr: remoteAddr,
                 newerAddr: localAddr,
-                space,
+                space: destSpace,
             });
 
             if (isRemoteInPast) {
+                console.log(`${lc} [TEST DEBUG] TJP ${tjp}: Remote is in past - offering push`);
                 pushOfferAddrs.push(localAddr);
             } else {
                 // Remote is not in our past. 
@@ -761,14 +960,16 @@ export class SyncSagaCoordinator {
                 const isLocalInPast = await isPastFrame({
                     olderAddr: localAddr,
                     newerAddr: remoteAddr,
-                    space,
+                    space: destSpace,
                 });
 
                 if (isLocalInPast) {
                     // Fast-Forward: We update to remote's tip.
+                    console.log(`${lc} [TEST DEBUG] TJP ${tjp}: Local is in past - requesting delta`);
                     deltaReqAddrs.push(remoteAddr);
                 } else {
                     // DIVERGENCE: Both have changes the other doesn't know about.
+                    console.log(`${lc} [TEST DEBUG] TJP ${tjp}: DIVERGENCE DETECTED! conflictStrategy=${conflictStrategy}`);
 
                     if (conflictStrategy === 'abort') {
                         // Abort Strategy: We will treat this as terminal.
@@ -795,7 +996,7 @@ export class SyncSagaCoordinator {
 
                         // We need the ACTUAL object to get the past.
                         // We have localAddr.
-                        const resLocalTip = await getFromSpace({ space, addr: localAddr! });
+                        const resLocalTip = await getFromSpace({ space: destSpace, addr: localAddr! });
                         const localTip = resLocalTip.ibGibs?.[0];
                         if (!localTip) { throw new Error(`${lc} Failed to load local tip for conflict resolution. (E: 8f9b2c3d4e5f6g7h)`); }
 
@@ -842,7 +1043,7 @@ export class SyncSagaCoordinator {
         // 2. Add Push Offers (Missing in Local)
         // Check if we have them. If not, ask for them.
         for (const addr of pushOfferAddrs) {
-            const hasIt = await getFromSpace({ addr, space });
+            const hasIt = await getFromSpace({ addr, space: destSpace });
             if (!hasIt.success || !hasIt.ibGibs || hasIt.ibGibs.length === 0) {
                 // If we don't have it, we put it in `deltaReqAddrs` of the Ack.
                 deltaReqAddrs.push(addr);
@@ -861,7 +1062,7 @@ export class SyncSagaCoordinator {
         for (const tjp of remoteTjps) {
             const localAddr = localKV[tjp];
             if (localAddr) {
-                const res = await getFromSpace({ addr: localAddr, space });
+                const res = await getFromSpace({ addr: localAddr, space: destSpace });
                 if (res.success && res.ibGibs?.[0]) {
                     const ibGib = res.ibGibs[0];
                     const realTjp = ibGib.rel8ns?.tjp?.[0] || getIbGibAddr({ ibGib }); // Should match `tjp` if normalized 
@@ -879,7 +1080,7 @@ export class SyncSagaCoordinator {
             // We can't really know if it's covered easily without resolving. 
             // But if we don't have it (requesting), we won't find it here anyway.
             // If we DO have it (push offer), we might find it.
-            const res = await getFromSpace({ addr, space });
+            const res = await getFromSpace({ addr, space: destSpace });
             if (res.success && res.ibGibs?.[0]) {
                 const ibGib = res.ibGibs[0];
                 const tjpAddr = ibGib.rel8ns?.tjp?.[0] || getIbGibAddr({ ibGib });
@@ -918,11 +1119,12 @@ export class SyncSagaCoordinator {
             deltaReqAddrs,
             pushOfferAddrs,
             knowledgeVector,
+            conflicts: conflicts.length > 0 ? conflicts : undefined, // Include conflicts if any detected
         };
 
         const ackStone = await this.createSyncMsgStone({
             data: ackData,
-            space,
+            space: tempSpace,
             metaspace,
         });
         if (logalot) { console.log(`${lc} ackStone created: ${pretty(ackStone)} (I: 313708132dd53ff946befb7833657826)`); }
@@ -932,13 +1134,20 @@ export class SyncSagaCoordinator {
             prevSagaIbGib: sagaIbGib,
             msgStones: [ackStone],
             identity,
-            space,
+            space: tempSpace,
             metaspace,
         });
 
-        if (logalot) { console.log(`${lc} ackFrame created: ${pretty(ackFrame)} (I: be24480592eec478086bb3da49286826)`); }
+        // IMMEDIATELY persist to both spaces for audit trail (before any errors can occur)
+        await this.ensureSagaFrameInBothSpaces({ frame: ackFrame, destSpace, tempSpace, metaspace });
+
+        // if (logalot) { console.log(`${lc} ackFrame created: ${pretty(ackFrame)} (I: be24480592eec478086bb3da49286826)`); }
 
-        return { frame: ackFrame };
+        // Build control payloads: frame + its dependencies (msg stone, identity)
+        const payloadIbGibsControl: IbGib_V1[] = [ackFrame, ackStone];
+        if (identity) { payloadIbGibsControl.push(identity); }
+
+        return { frame: ackFrame, payloadIbGibsControl };
     }
 
     /**
@@ -956,280 +1165,313 @@ export class SyncSagaCoordinator {
     protected async handleAckFrame({
         sagaIbGib,
         srcGraph,
-        space,
+        destSpace,
+        tempSpace,
         metaspace,
         identity,
     }: {
         sagaIbGib: SyncIbGib_V1,
         srcGraph: { [addr: string]: IbGib_V1 },
-        space: IbGibSpaceAny,
+        destSpace: IbGibSpaceAny,
+        tempSpace: IbGibSpaceAny,
         metaspace: MetaspaceService,
         identity?: KeystoneIbGib_V1,
-    }): Promise<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[] } | null> {
+    }): Promise<HandleSagaFrameResult | null> {
         const lc = `${this.lc}[${this.handleAckFrame.name}]`;
-        if (logalot) { console.log(`${lc} starting...`); }
+        try {
+            if (logalot) { console.log(`${lc} starting... (I: 605b6860e898267a5b50c6d85704be26)`); }
 
-        const { messageData, } = await this.getStageAndPayloadFromFrame({ ibGib: sagaIbGib, space });
-        const ackData = messageData as SyncSagaMessageAckData_V1;
+            const { messageData, } = await this.getStageAndPayloadFromFrame({ ibGib: sagaIbGib, space: tempSpace });
+            const ackData = messageData as SyncSagaMessageAckData_V1;
 
-        if (!ackData) {
-            throw new Error(`${lc} ackData falsy (E: 3b8415edc876084c88a25b98e2d55826)`);
-        }
-        if (ackData.stage !== SyncStage.ack) {
-            throw new Error(`${lc} Invalid ack frame: ackData.stage !== SyncStage.ack (E: 2e8b0a94b5954a66a6a1a7a0b3f5b7a1)`);
-        }
-        if (logalot) { console.log(`${lc} ackData: ${pretty(ackData)} (I: 7f8e9d0a1b2c3d4e5f6g7h8i9j0k)`); }
-
-        // 1. Check for Conflicts
-        const conflicts = ackData.conflicts || [];
-        const terminalConflicts = conflicts.filter(c => c.terminal);
-        if (terminalConflicts.length > 0) {
-            console.warn(`${lc} Received terminal conflicts from Ack: ${JSON.stringify(terminalConflicts)}`);
-            // Terminal failure. Sender should probably Commit(Fail) or just Abort.
-            // For now, throw to trigger abort.
-            throw new Error(`${lc} Peer reported terminal conflicts. (E: a1b2c3d4e5f6g7h8i9j0k)`);
-        }
+            if (!ackData) {
+                throw new Error(`${lc} ackData falsy (E: 3b8415edc876084c88a25b98e2d55826)`);
+            }
+            if (ackData.stage !== SyncStage.ack) {
+                throw new Error(`${lc} Invalid ack frame: ackData.stage !== SyncStage.ack (E: 2e8b0a94b5954a66a6a1a7a0b3f5b7a1)`);
+            }
+            if (logalot) { console.log(`${lc} ackData: ${pretty(ackData)} (I: 7f8e9d0a1b2c3d4e5f6g7h8i9j0k)`); }
 
-        const optimisticConflicts = conflicts.filter(c => !c.terminal);
-        const mergeDeltaReqs: string[] = []; // Additional requests for merging
-
-        if (optimisticConflicts.length > 0) {
-            if (logalot) { console.log(`${lc} Processing optimistic conflicts: ${optimisticConflicts.length}`); }
-            // We need to resolve these.
-            // Strategy:
-            // 1. Analyze Divergence (Sender vs Receiver)
-            // 2. Identify missing data needed for merge (Receiver's unique frames)
-            // 3. Request that data (as Delta Reqs)
-            // 4. (Later in Delta Phase) Perform Merge.
-
-            // BUT: The Delta Phase is usually generic "Send me these Addrs".
-            // If we just add to `deltaReqAddrs` (which are requests for Sender to send to Receiver?),
-            // wait. `ackData.deltaReqAddrs` are what RECEIVER wants from SENDER.
-
-            // We (Sender) are processing the Ack.
-            // We need to request data FROM Receiver.
-            // But the protocol 'Ack' step typically leads to 'Delta' (Sender sending data).
-
-            // If Sender needs data from Receiver, it usually happens in 'Pull' mode or a separate request?
-            // Or can we send a 'Delta Request' frame?
-            // Standard Saga: Init(Push) -> Ack(Pull Reqs) -> Delta(Push Data).
-
-            // If Sender needs data, we might need a "Reverse Delta" or "Pull" phase?
-            // Or we just proceed to Delta (sending what Receiver wants), 
-            // AND we piggyback our own requests?
-            // OR: We treat the Conflict Resolution as a sub-saga or side-effect?
-
-            // SIMPLIFICATION for V1:
-            // If we need data to merge, we must get it.
-            // We are the Coordinator (Active). We can fetch from Peer immediately?
-            // `peer.pull(addr)`?
-            // Yes! The Coordinator has the `peer`.
-
-            // Let's analyze and pull immediately.
-
-            for (const conflict of optimisticConflicts) {
-                const { timelineAddrs, localAddr: receiverTip, remoteAddr: senderTip } = conflict;
-
-                // Sender History
-                // We need our own history for this timeline.
-                // We know the 'senderTip' (remoteAddr in Ack).
-                // Sender should verify it has this tip.
-
-                // Compute Diffs
-                // We need to find `receiverOnly` addrs.
-                // Receiver sent us `timelineAddrs` (Full History).
-                const receiverHistorySet = new Set(timelineAddrs);
-
-                // We need our execution context's history for this senderTip.
-                // We can fetch valid 'past' from space.
-                const resSenderTip = await getFromSpace({ space, addr: senderTip });
-                const senderTipIbGib = resSenderTip.ibGibs?.[0];
-                if (!senderTipIbGib) { throw new Error(`${lc} Sender missing its own tip? ${senderTip} (E: 9c8d7e6f5g4h3i2j1k0l)`); }
-
-                // Basic Diff: Find what Receiver has that we don't.
-                // Actually, we need to traverse OUR past to find commonality.
-                const senderHistory = [senderTip, ...(senderTipIbGib.rel8ns?.past || [])];
-
-                const receiverOnlyAddrs = timelineAddrs.filter(addr => !senderHistory.includes(addr));
-
-                if (receiverOnlyAddrs.length > 0) {
-                    if (logalot) { console.log(`${lc} Pulling divergent history from Receiver: ${receiverOnlyAddrs.length} frames`); }
-                    // PULL these frames from Peer into Local Space
-                    // (Validation: We trust peer for now / verification happens on put)
-                    for (const addr of receiverOnlyAddrs) {
-                        // This 'pull' is a sync-peer method?
-                        // The Coordinator 'peer' passed in 'sync()' might be needed here?
-                        // Wait, `handleAckFrame` doesn't have reference to `peer`?
-                        // It only has `space`, `metaspace`.
-                        // The `peer` is held by the `executeSagaLoop`.
-
-                        // PROBLEM: `handleAckFrame` is pure logic on the Space/Data?
-                        // No, it's a method on Coordinator. 
-                        // But `executeSagaLoop` calls it.
-                        // We might need to return "Requirements" to the loop?
-
-                        // Checking return type: `{ frame: SyncIbGib_V1, payloadIbGibs?: ... }`
-                        // It returns the NEXT frame (Delta).
-
-                        // If we need to fetch data, we are blocked.
-                        // We can't easily "Pull" here without the Peer reference.
-
-                        // OPTION A: Pass `peer` to `handleAckFrame`.
-                        // OPTION B: Return a strict list of "MissingDeps" and let Loop handle it.
-
-                        // Let's assume we can resolve this by adding `peer` to signature or using `metaspace` if it's a peer-witness?
-                        // No, Peer is ephemeral connection.
-
-                        // Let's add `peer` to `handleAckFrame` signature?
-                        // It breaks the pattern of just handling frame + space.
-
-                        // ALTERNATIVE: Use the `Delta` frame to request data?
-                        // `SyncSagaMessageDeltaData` has `requests?: string[]`.
-                        // Sender sends Delta Frame.
-                        // Does Receiver handle Delta Requests?
-                        // `handleDeltaFrame` (Receiver) -> checks `requests`.
-                        // YES.
-
-                        // So Sender puts `receiverOnlyAddrs` into `deltaFrame.requests`.
-                        // Receiver sees them, fetches them, and includes them in the Response (Commit?).
-                        // Wait, Init->Ack->Delta->Commit.
-                        // If Receiver sends data in Commit, that's "too late" for Sender to Merge in THIS saga round?
-                        // Unless Commit is not the end?
-
-                        // Or we do a "Delta 2" loop?
-
-                        // "Iterative Resolution Loop" from plan.
-                        // If we request data in Delta, Receiver sends it in Commit (or Delta-Response).
-                        // Sender gets Commit. Sees data. Merges.
-                        // Then Sender needs to Send the MERGE result.
-                        // Needs another Push/Delta.
-
-                        // REFINED FLOW:
-                        // 1. Sender sends Delta Frame with `requests: [receiverOnlyAddrs]`.
-                        // 2. Receiver responds (Commit? or Ack 2?) with Payload (Divergent Frames).
-                        // 3. Sender handles response -> Merges.
-                        // 4. Sender sends Commit (containing Merge Frame).
-
-                        // Issue: Current state machine is Init->Ack->Delta->Commit.
-                        // We need to keep Saga open.
-                        // If Sender sends Delta with requests, does it transition to Commit?
-                    }
-                    mergeDeltaReqs.push(...receiverOnlyAddrs);
-                }
+            // 1. Check for Conflicts
+            const conflicts = ackData.conflicts || [];
+            console.log(`${lc} [CONFLICT DEBUG] Received conflicts from Ack: ${conflicts.length}`);
+            if (conflicts.length > 0) {
+                console.log(`${lc} [CONFLICT DEBUG] Conflicts detail: ${JSON.stringify(conflicts, null, 2)}`);
             }
-        }
 
-        // 2. Prepare Delta Payload (What Receiver Requesting + Our Conflict Logic)
+            const terminalConflicts = conflicts.filter(c => c.terminal);
+            if (terminalConflicts.length > 0) {
+                console.warn(`${lc} Received terminal conflicts from Ack: ${JSON.stringify(terminalConflicts)}`);
+                // Terminal failure. Sender should probably Commit(Fail) or just Abort.
+                // For now, throw to trigger abort.
+                throw new Error(`${lc} Peer reported terminal conflicts. (E: a1b2c3d4e5f6g7h8i9j0k)`);
+            }
 
-        const deltaReqAddrs = ackData.deltaReqAddrs || [];
-        const pushOfferAddrs = ackData.pushOfferAddrs || [];
+            const optimisticConflicts = conflicts.filter(c => !c.terminal);
+            const mergeDeltaReqs: string[] = []; // Additional requests for merging
 
-        // 1. Process Push Offers (Pull Requests) (Naive: Accept all if missing)
-        const pullReqAddrs: string[] = [];
-        for (const addr of pushOfferAddrs) {
-            const existing = srcGraph[addr] || (await getFromSpace({ addr, space })).ibGibs?.[0];
-            if (!existing) {
-                pullReqAddrs.push(addr);
-            }
-        }
+            if (optimisticConflicts.length > 0) {
+                console.log(`${lc} [CONFLICT DEBUG] Processing ${optimisticConflicts.length} optimistic conflicts`);
+                // We need to resolve these.
+                // Strategy:
+                // 1. Analyze Divergence (Sender vs Receiver)
+                // 2. Identify missing data needed for merge (Receiver's unique frames)
+                // 3. Request that data (as Delta Reqs)
+                // 4. (Later in Delta Phase) Perform Merge.
 
-        // 2. Process Delta Requests (Push Payload)
-        // [NEW] Smart Diff: Use knowledgeVector to skip dependencies
-        const skipAddrs = new Set<string>();
-        if (ackData.knowledgeVector) {
-            Object.values(ackData.knowledgeVector).forEach(addrs => {
-                addrs.forEach(a => skipAddrs.add(a));
-            });
-        }
+                // BUT: The Delta Phase is usually generic "Send me these Addrs".
+                // If we just add to `deltaReqAddrs` (which are requests for Sender to send to Receiver?),
+                // wait. `ackData.deltaReqAddrs` are what RECEIVER wants from SENDER.
 
-        const payloadIbGibs: IbGib_V1[] = [];
-        // Gather all tips to sync first
-        const tipsToSync: IbGib_V1[] = [];
-        for (const addr of deltaReqAddrs) {
-            let ibGib = srcGraph[addr];
-            if (!ibGib) {
-                const res = await getFromSpace({ addr, space });
-                if (res.ibGibs && res.ibGibs.length > 0) {
-                    ibGib = res.ibGibs[0];
+                // We (Sender) are processing the Ack.
+                // We need to request data FROM Receiver.
+                // But the protocol 'Ack' step typically leads to 'Delta' (Sender sending data).
+
+                // If Sender needs data from Receiver, it usually happens in 'Pull' mode or a separate request?
+                // Or can we send a 'Delta Request' frame?
+                // Standard Saga: Init(Push) -> Ack(Pull Reqs) -> Delta(Push Data).
+
+                // If Sender needs data, we might need a "Reverse Delta" or "Pull" phase?
+                // Or we just proceed to Delta (sending what Receiver wants), 
+                // AND we piggyback our own requests?
+                // OR: We treat the Conflict Resolution as a sub-saga or side-effect?
+
+                // SIMPLIFICATION for V1:
+                // If we need data to merge, we must get it.
+                // We are the Coordinator (Active). We can fetch from Peer immediately?
+                // `peer.pull(addr)`?
+                // Yes! The Coordinator has the `peer`.
+
+                // Let's analyze and pull immediately.
+
+                for (const conflict of optimisticConflicts) {
+                    const { timelineAddrs, localAddr: receiverTip, remoteAddr: senderTip } = conflict;
+
+                    // Sender History
+                    // We need our own history for this timeline.
+                    // We know the 'senderTip' (remoteAddr in Ack).
+                    // Sender should verify it has this tip.
+
+                    // Compute Diffs
+                    // We need to find `receiverOnly` addrs.
+                    // Receiver sent us `timelineAddrs` (Full History).
+                    const receiverHistorySet = new Set(timelineAddrs);
+
+                    // We need our execution context's history for this senderTip.
+                    // We can fetch valid 'past' from space.
+                    const resSenderTip = await getFromSpace({ space: destSpace, addr: senderTip });
+                    const senderTipIbGib = resSenderTip.ibGibs?.[0];
+                    if (!senderTipIbGib) { throw new Error(`${lc} Sender missing its own tip? ${senderTip} (E: 9c8d7e6f5g4h3i2j1k0l)`); }
+
+                    // Basic Diff: Find what Receiver has that we don't.
+                    // Actually, we need to traverse OUR past to find commonality.
+                    const senderHistory = [senderTip, ...(senderTipIbGib.rel8ns?.past || [])];
+
+                    const receiverOnlyAddrs = timelineAddrs.filter(addr => !senderHistory.includes(addr));
+
+                    if (receiverOnlyAddrs.length > 0) {
+                        console.log(`${lc} [CONFLICT DEBUG] Found ${receiverOnlyAddrs.length} receiver-only frames - need to pull for merge`);
+                        console.log(`${lc} [CONFLICT DEBUG] Receiver-only addrs:`, receiverOnlyAddrs);
+                        // PULL these frames from Peer into Local Space
+                        // (Validation: We trust peer for now / verification happens on put)
+                        for (const addr of receiverOnlyAddrs) {
+                            console.error(`${lc} [CONFLICT DEBUG] NOT IMPLEMENTED (E: e6bf1a9d2758c469bb2f97514062d826)`);
+                        }
+
+                        // Compute DELTA dependencies for each receiver-only frame
+                        // Find LCA to determine what dependencies we already have
+                        const lcaAddr = timelineAddrs.find(addr => senderHistory.includes(addr));
+                        console.log(`${lc} [CONFLICT DEBUG] LCA: ${lcaAddr || 'NONE'}`);
+
+                        const skipAddrsSet = new Set<string>();
+                        if (lcaAddr) {
+                            try {
+                                const lcaRes = await getFromSpace({ addr: lcaAddr, space: destSpace });
+                                const lcaIbGib = lcaRes.ibGibs?.[0];
+                                if (lcaIbGib) {
+                                    const lcaDeps = await getDependencyGraph({ ibGib: lcaIbGib, space: destSpace });
+                                    if (lcaDeps) Object.keys(lcaDeps).forEach(a => skipAddrsSet.add(a));
+                                    console.log(`${lc} [CONFLICT DEBUG] LCA deps to skip: ${skipAddrsSet.size}`);
+                                }
+                            } catch (e) {
+                                console.warn(`${lc} Error getting LCA deps: ${extractErrorMsg(e)}`);
+                            }
+                        }
+
+
+                        // For each receiver-only frame, get its DELTA dependency graph (minus LCA deps)
+                        for (const addr of receiverOnlyAddrs) {
+                            // Add the frame itself first
+                            if (!mergeDeltaReqs.includes(addr)) {
+                                mergeDeltaReqs.push(addr);
+                            }
+
+                            // Get the frame's delta dependencies (skip LCA's deps)
+                            try {
+                                const frameRes = await getFromSpace({ addr, space: destSpace });
+                                const frameIbGib = frameRes.ibGibs?.[0];
+
+                                if (frameIbGib) {
+                                    // Get dependency graph, skipping all LCA dependencies
+                                    const frameDeltaDeps = await getDependencyGraph({
+                                        ibGib: frameIbGib,
+                                        space: destSpace,
+                                        skipAddrs: Array.from(skipAddrsSet), // Skip entire LCA dep graph
+                                    });
+
+                                    if (frameDeltaDeps) {
+                                        // Add all delta dependencies (Object.keys gives us the addresses)
+                                        Object.keys(frameDeltaDeps).forEach(depAddr => {
+                                            if (!mergeDeltaReqs.includes(depAddr) && !skipAddrsSet.has(depAddr)) {
+                                                mergeDeltaReqs.push(depAddr);
+                                            }
+                                        });
+                                    }
+                                }
+                            } catch (depError) {
+                                console.warn(`${lc} [CONFLICT DEBUG] Error getting delta deps for ${addr}: ${extractErrorMsg(depError)}`);
+                            }
+                        }
+
+                        console.log(`${lc} [CONFLICT DEBUG] Total merge requests (frames + delta deps): ${mergeDeltaReqs.length}`);
+                    } else {
+                        console.log(`${lc} [CONFLICT DEBUG] No receiver-only frames found for this conflict`);
+                    }
                 }
-            }
-            if (ibGib) {
-                tipsToSync.push(ibGib);
+
+                console.log(`${lc} [CONFLICT DEBUG] Finished processing ${optimisticConflicts.length} conflicts. mergeDeltaReqs: ${mergeDeltaReqs.length}`);
             } else {
-                throw new Error(`${lc} Requested addr not found: ${addr} (E: d41d59cff4a887f6414c3e92eabd8e26)`);
+                console.log(`${lc} [CONFLICT DEBUG] No optimistic conflicts to process`);
             }
-        }
 
-        // Calculate Dependency Graph for ALL tips, effectively utilizing common history
-        // Pass skipAddrs to `getDependencyGraph` or gather manually.
-        // `getDependencyGraph` takes a single ibGib.
-        // We can optimize by doing it for each tip and unioning the result? 
-        // Or `graph-helper` could support `ibGibs: []`. It currently takes `ibGib`.
-        // We will loop.
-
-        const allDepsSet = new Set<string>();
-
-        for (const tip of tipsToSync) {
-            // Always include the tip itself
-            const tipAddr = getIbGibAddr({ ibGib: tip });
-            // Only process if not skipped (though deltaReq implies they barely just asked for it)
-            // But detailed deps might be skipped.
-
-            // Get Graph with Skips
-            // Logic: "Give me everything related to Tip, EXCEPT X, Y, Z"
-            const deps = await getDependencyGraph({
-                ibGib: tip,
-                space,
-                skipAddrs: Array.from(skipAddrs)
-            });
+            // 2. Prepare Delta Payload (What Receiver Requesting + Our Conflict Logic)
 
-            // [FIX] Ensure Tip is included if not in deps (e.g. constant with no rel8ns)
-            let tipIncluded = false;
+            const deltaReqAddrs = ackData.deltaReqAddrs || [];
+            const pushOfferAddrs = ackData.pushOfferAddrs || [];
 
-            if (deps) {
-                Object.values(deps).forEach(d => {
-                    const dAddr = getIbGibAddr({ ibGib: d });
-                    if (!allDepsSet.has(dAddr)) {
-                        allDepsSet.add(dAddr);
-                        payloadIbGibs.push(d);
-                    }
-                    if (dAddr === tipAddr) { tipIncluded = true; }
+            // 1. Process Push Offers (Pull Requests) (Naive: Accept all if missing)
+            const pullReqAddrs: string[] = [];
+            for (const addr of pushOfferAddrs) {
+                const existing = srcGraph[addr] || (await getFromSpace({ addr, space: destSpace })).ibGibs?.[0];
+                if (!existing) {
+                    pullReqAddrs.push(addr);
+                }
+            }
+
+            // 2. Process Delta Requests (Push Payload)
+            // [NEW] Smart Diff: Use knowledgeVector to skip dependencies
+            const skipAddrs = new Set<string>();
+            if (ackData.knowledgeVector) {
+                Object.values(ackData.knowledgeVector).forEach(addrs => {
+                    addrs.forEach(a => skipAddrs.add(a));
                 });
             }
 
-            if (!tipIncluded && !skipAddrs.has(tipAddr)) {
-                if (logalot) { console.log(`${lc} Tip not in deps, adding explicitly: ${tipAddr}`); }
-                if (!allDepsSet.has(tipAddr)) {
-                    allDepsSet.add(tipAddr);
-                    payloadIbGibs.push(tip);
+            const payloadIbGibs: IbGib_V1[] = [];
+            // Gather all tips to sync first
+            const tipsToSync: IbGib_V1[] = [];
+            for (const addr of deltaReqAddrs) {
+                let ibGib = srcGraph[addr];
+                if (!ibGib) {
+                    const res = await getFromSpace({ addr, space: destSpace });
+                    if (res.ibGibs && res.ibGibs.length > 0) {
+                        ibGib = res.ibGibs[0];
+                    }
+                }
+                if (ibGib) {
+                    tipsToSync.push(ibGib);
+                } else {
+                    throw new Error(`${lc} Requested addr not found: ${addr} (E: d41d59cff4a887f6414c3e92eabd8e26)`);
                 }
             }
-        }
 
-        // 3. Create Delta Frame
-        const sagaId = ackData.sagaId;
-        const deltaData: SyncSagaMessageDeltaData_V1 = {
-            sagaId: sagaIbGib.data!.uuid,
-            stage: SyncStage.delta,
-            payloadAddrs: payloadIbGibs.map(p => getIbGibAddr({ ibGib: p })),
-            requests: [...(pullReqAddrs || []), ...(mergeDeltaReqs || [])].length > 0 ? [...(pullReqAddrs || []), ...(mergeDeltaReqs || [])] : undefined,
-        };
+            // Calculate Dependency Graph for ALL tips, effectively utilizing common history
+            // Pass skipAddrs to `getDependencyGraph` or gather manually.
+            // `getDependencyGraph` takes a single ibGib.
+            // We can optimize by doing it for each tip and unioning the result? 
+            // Or `graph-helper` could support `ibGibs: []`. It currently takes `ibGib`.
+            // We will loop.
+
+            const allDepsSet = new Set<string>();
+
+            for (const tip of tipsToSync) {
+                // Always include the tip itself
+                const tipAddr = getIbGibAddr({ ibGib: tip });
+                // Only process if not skipped (though deltaReq implies they barely just asked for it)
+                // But detailed deps might be skipped.
+
+                // Get Graph with Skips
+                // Logic: "Give me everything related to Tip, EXCEPT X, Y, Z"
+                const deps = await getDependencyGraph({
+                    ibGib: tip,
+                    space: destSpace,
+                    skipAddrs: Array.from(skipAddrs)
+                });
 
-        const deltaStone = await this.createSyncMsgStone({
-            data: deltaData,
-            space,
-            metaspace,
-        });
+                // [FIX] Ensure Tip is included if not in deps (e.g. constant with no rel8ns)
+                let tipIncluded = false;
 
-        const deltaFrame = await this.evolveSyncSagaIbGib({
-            prevSagaIbGib: sagaIbGib,
-            msgStones: [deltaStone],
-            identity,
-            space,
-            metaspace,
-        });
+                if (deps) {
+                    Object.values(deps).forEach(d => {
+                        const dAddr = getIbGibAddr({ ibGib: d });
+                        if (!allDepsSet.has(dAddr)) {
+                            allDepsSet.add(dAddr);
+                            payloadIbGibs.push(d);
+                        }
+                        if (dAddr === tipAddr) { tipIncluded = true; }
+                    });
+                }
+
+                if (!tipIncluded && !skipAddrs.has(tipAddr)) {
+                    if (logalot) { console.log(`${lc} Tip not in deps, adding explicitly: ${tipAddr}`); }
+                    if (!allDepsSet.has(tipAddr)) {
+                        allDepsSet.add(tipAddr);
+                        payloadIbGibs.push(tip);
+                    }
+                }
+            }
+
+            // 3. Create Delta Frame
+            const sagaId = ackData.sagaId;
+            const deltaData: SyncSagaMessageDeltaData_V1 = {
+                sagaId: sagaIbGib.data!.uuid,
+                stage: SyncStage.delta,
+                payloadAddrs: payloadIbGibs.map(p => getIbGibAddr({ ibGib: p })),
+                requests: [...(pullReqAddrs || []), ...(mergeDeltaReqs || [])].length > 0 ? [...(pullReqAddrs || []), ...(mergeDeltaReqs || [])] : undefined,
+            };
+
+            if (logalot) { console.log(`${lc} Creating Delta Stone. Data stage: ${deltaData.stage}`); }
+
+            const deltaStone = await this.createSyncMsgStone({
+                data: deltaData,
+                space: tempSpace,
+                metaspace,
+            });
 
-        return { frame: deltaFrame, payloadIbGibs };
+            const deltaFrame = await this.evolveSyncSagaIbGib({
+                prevSagaIbGib: sagaIbGib,
+                msgStones: [deltaStone],
+                identity,
+                space: tempSpace,
+                metaspace,
+            });
+
+            // IMMEDIATELY persist to both spaces for audit trail
+            await this.ensureSagaFrameInBothSpaces({ frame: deltaFrame, destSpace, tempSpace, metaspace });
+
+            if (logalot) { console.log(`${lc} Delta Frame created. Rel8ns: ${JSON.stringify(deltaFrame.rel8ns)}`); }
+
+            // Build control payloads: frame + its dependencies (msg stone, identity)
+            const payloadIbGibsControl: IbGib_V1[] = [deltaFrame, deltaStone];
+            if (identity) { payloadIbGibsControl.push(identity); }
+
+            return { frame: deltaFrame, payloadIbGibsControl, payloadIbGibsDomain: payloadIbGibs };
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
     }
 
     /**
@@ -1245,20 +1487,22 @@ export class SyncSagaCoordinator {
     protected async handleDeltaFrame({
         sagaIbGib,
         srcGraph,
-        space,
+        destSpace,
+        tempSpace,
         metaspace,
         identity,
     }: {
         sagaIbGib: SyncIbGib_V1,
         srcGraph: { [addr: string]: IbGib_V1 },
-        space: IbGibSpaceAny,
+        destSpace: IbGibSpaceAny,
+        tempSpace: IbGibSpaceAny,
         metaspace: MetaspaceService,
         identity?: KeystoneIbGib_V1,
-    }): Promise<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[], receivedPayloadIbGibs?: IbGib_V1[] } | null> {
+    }): Promise<HandleSagaFrameResult | null> {
         const lc = `${this.lc}[${this.handleDeltaFrame.name}]`;
         if (logalot) { console.log(`${lc} starting...`); }
 
-        const { messageData } = await this.getStageAndPayloadFromFrame({ ibGib: sagaIbGib, space });
+        const { messageData } = await this.getStageAndPayloadFromFrame({ ibGib: sagaIbGib, space: tempSpace });
         const deltaData = messageData as SyncSagaMessageDeltaData_V1;
 
         if (!deltaData) {
@@ -1269,6 +1513,8 @@ export class SyncSagaCoordinator {
         }
         if (logalot) { console.log(`${lc} deltaData: ${pretty(deltaData)} (I: 8d7e6f5g4h3i2j1k0l9m)`); }
 
+        console.log(`${lc} [CONFLICT DEBUG] deltaData.payloadAddrs count: ${deltaData.payloadAddrs?.length || 0}`);
+
         const payloadAddrs = deltaData.payloadAddrs || [];
         const peerRequests = deltaData.requests || [];
         const peerProposesCommit = deltaData.proposeCommit || false;
@@ -1284,7 +1530,7 @@ export class SyncSagaCoordinator {
 
             const res = await getFromSpace({
                 addrs: payloadAddrs,
-                space,
+                space: tempSpace, // Incoming data is in tempSpace
             });
             if (res.ibGibs) {
                 receivedPayloadIbGibs.push(...res.ibGibs);
@@ -1295,49 +1541,89 @@ export class SyncSagaCoordinator {
             }
         }
 
-        // 2. Fulfill Peer Requests (Outgoing Payload)
+        // 2. Fulfill Peer Requests (Outgoing Payload with Delta Dependencies)
         const outgoingPayload: IbGib_V1[] = [];
+        const outgoingAddrsSet = new Set<string>(); // Track what we've added
+
+        console.log(`${lc} [CONFLICT DEBUG] Fulfilling ${peerRequests.length} peer requests`);
+
         for (const addr of peerRequests) {
+            // Get the requested ibGib
             let ibGib = srcGraph[addr];
             if (!ibGib) {
-                const res = await getFromSpace({ addr, space });
+                const res = await getFromSpace({ addr, space: destSpace }); // Query from destSpace  
                 if (res.ibGibs && res.ibGibs.length > 0) {
                     ibGib = res.ibGibs[0];
                 }
             }
+
             if (ibGib) {
-                outgoingPayload.push(ibGib);
+                // Add the requested ibGib itself
+                const ibGibAddr = getIbGibAddr({ ibGib });
+                if (!outgoingAddrsSet.has(ibGibAddr)) {
+                    outgoingPayload.push(ibGib);
+                    outgoingAddrsSet.add(ibGibAddr);
+                }
+
+                // Expand to include full dependency graph for this ibGib
+                // (Receiver needs all deps to properly process/merge)
+                try {
+                    const deps = await getDependencyGraph({
+                        ibGib,
+                        space: destSpace,
+                    });
+
+                    if (deps) {
+                        Object.values(deps).forEach(depIbGib => {
+                            const depAddr = getIbGibAddr({ ibGib: depIbGib });
+                            if (!outgoingAddrsSet.has(depAddr)) {
+                                outgoingPayload.push(depIbGib);
+                                outgoingAddrsSet.add(depAddr);
+                            }
+                        });
+                    }
+                } catch (depError) {
+                    console.warn(`${lc} [CONFLICT DEBUG] Error expanding deps for ${addr}: ${extractErrorMsg(depError)}`);
+                }
             } else {
                 console.warn(`${lc} Requested addr not found during delta fulfillment: ${addr}`);
             }
         }
 
+        console.log(`${lc} [CONFLICT DEBUG] Outgoing payload size (with deps): ${outgoingPayload.length}`);
+
+
         // 3. Execute Merges (If applicable)
         // Check if we have pending conflicts that we CAN resolve now that we have data.
         // We look at the Saga History (Ack Frame) to find conflicts.
         // Optimization: Do this only if we received payloads.
         const mergeResultIbGibs: IbGib_V1[] = [];
 
+        console.log(`${lc} [CONFLICT DEBUG] Checking for merge. receivedPayloadIbGibs.length: ${receivedPayloadIbGibs.length}`);
+
         if (receivedPayloadIbGibs.length > 0) {
+            console.log(`${lc} [TEST DEBUG] Received Payloads (${receivedPayloadIbGibs.length}). Checking for conflicts/merges...`);
             // Find the Ack frame in history to get conflicts
             // Optimization: Batch fetch history from `sagaIbGib.rel8ns.past`
             // V1 timelines carry full history in `past`.
             const pastAddrs = sagaIbGib.rel8ns?.past || [];
+            console.log(`${lc} [TEST DEBUG] pastAddrs count: ${pastAddrs.length}`);
             let ackData: SyncSagaMessageAckData_V1 | undefined;
 
             if (pastAddrs.length > 0) {
                 // Batch fetch all past frames
-                const resPast = await getFromSpace({ addrs: pastAddrs, space });
+                const resPast = await getFromSpace({ addrs: pastAddrs, space: tempSpace });
                 if (resPast.success && resPast.ibGibs) {
                     // Iterate backwards (most recent first) to find the latest Ack
                     for (let i = resPast.ibGibs.length - 1; i >= 0; i--) {
                         const pastFrame = resPast.ibGibs[i];
                         const messageStone = await getSyncSagaMessageFromFrame({
                             frameIbGib: pastFrame,
-                            space
+                            space: tempSpace
                         });
                         if (messageStone?.data?.stage === SyncStage.ack) {
                             ackData = messageStone.data as SyncSagaMessageAckData_V1;
+                            console.log(`${lc} [TEST DEBUG] Found Ack Frame. Conflicts: ${ackData.conflicts?.length || 0}`);
                             break;
                         }
                     }
@@ -1356,7 +1642,9 @@ export class SyncSagaCoordinator {
                     // We need `receiverTip` (localAddr in Ack) and `senderTip` (remoteAddr).
 
                     // Check if we have receiverTip in space
-                    const resRecTip = await getFromSpace({ addr: receiverTip, space });
+                    console.log(`${lc} [CONFLICT DEBUG] Attempting merge for conflict. ReceiverTip: ${receiverTip}, SenderTip: ${senderTip}`);
+                    const resRecTip = await getFromSpace({ addr: receiverTip, space: tempSpace }); // Check tempSpace for incoming data
+                    console.log(`${lc} [CONFLICT DEBUG] ReceiverTip found in tempSpace: ${!!resRecTip.ibGibs?.[0]}`);
                     if (resRecTip.success && resRecTip.ibGibs?.[0]) {
                         // We have the tip!
                         // Do we have the full history? 
@@ -1366,12 +1654,13 @@ export class SyncSagaCoordinator {
                         // Perform Merge!
                         try {
                             const mergeResult = await mergeDivergentTimelines({
-                                tipA: (await getFromSpace({ addr: senderTip, space })).ibGibs![0], // Our tip
-                                tipB: resRecTip.ibGibs[0], // Their tip
-                                space,
+                                tipA: (await getFromSpace({ addr: senderTip, space: destSpace })).ibGibs![0], // Our tip from destSpace
+                                tipB: resRecTip.ibGibs[0], // Their tip (from tempSpace)
+                                space: tempSpace, // Merge uses tempSpace
                                 metaspace,
                             });
                             if (mergeResult) {
+                                console.log(`${lc} [TEST DEBUG] Merge success! New Tip: ${getIbGibAddr({ ibGib: mergeResult })}`);
                                 if (logalot) { console.log(`${lc} Merge success! New Tip: ${getIbGibAddr({ ibGib: mergeResult })}`); }
                                 mergeResultIbGibs.push(mergeResult);
                                 outgoingPayload.push(mergeResult); // Send result to peer
@@ -1419,7 +1708,7 @@ export class SyncSagaCoordinator {
 
             const deltaStone = await this.createSyncMsgStone({
                 data: responseDeltaData,
-                space,
+                space: tempSpace,
                 metaspace
             });
 
@@ -1427,11 +1716,18 @@ export class SyncSagaCoordinator {
                 prevSagaIbGib: sagaIbGib,
                 msgStones: [deltaStone],
                 identity,
-                space,
+                space: tempSpace,
                 metaspace
             });
 
-            return { frame: deltaFrame, payloadIbGibs: outgoingPayload, receivedPayloadIbGibs };
+            // IMMEDIATELY persist to both spaces for audit trail
+            await this.ensureSagaFrameInBothSpaces({ frame: deltaFrame, destSpace, tempSpace, metaspace });
+
+            // Build control payloads: frame + its dependencies (msg stone, identity)
+            const payloadIbGibsControl: IbGib_V1[] = [deltaFrame, deltaStone];
+            if (identity) { payloadIbGibsControl.push(identity); }
+
+            return { frame: deltaFrame, payloadIbGibsControl, payloadIbGibsDomain: outgoingPayload };
 
         } else {
             // We have nothing to send.
@@ -1446,7 +1742,7 @@ export class SyncSagaCoordinator {
 
                 const commitStone = await this.createSyncMsgStone({
                     data: commitData,
-                    space,
+                    space: tempSpace,
                     metaspace
                 });
 
@@ -1454,11 +1750,18 @@ export class SyncSagaCoordinator {
                     prevSagaIbGib: sagaIbGib,
                     msgStones: [commitStone],
                     identity,
-                    space,
+                    space: tempSpace,
                     metaspace
                 });
 
-                return { frame: commitFrame, receivedPayloadIbGibs };
+                // IMMEDIATELY persist to both spaces for audit trail
+                await this.ensureSagaFrameInBothSpaces({ frame: commitFrame, destSpace, tempSpace, metaspace });
+
+                // Build control payloads for commit
+                const commitCtrlPayloads: IbGib_V1[] = [commitFrame, commitStone];
+                if (identity) { commitCtrlPayloads.push(identity); }
+
+                return { frame: commitFrame, payloadIbGibsControl: commitCtrlPayloads };
 
             } else {
                 // peer did NOT propose commit (maybe they just sent data/requests and didn't ready flag).
@@ -1473,7 +1776,7 @@ export class SyncSagaCoordinator {
 
                 const deltaStone = await this.createSyncMsgStone({
                     data: responseDeltaData,
-                    space,
+                    space: tempSpace,
                     metaspace
                 });
 
@@ -1481,10 +1784,13 @@ export class SyncSagaCoordinator {
                     prevSagaIbGib: sagaIbGib,
                     msgStones: [deltaStone],
                     identity,
-                    space,
+                    space: tempSpace,
                     metaspace
                 });
 
+                // IMMEDIATELY persist to both spaces for audit trail
+                await this.ensureSagaFrameInBothSpaces({ frame: deltaFrame, destSpace, tempSpace, metaspace });
+
                 // Check if PEER proposed commit
                 if (deltaData.proposeCommit) {
                     if (logalot) { console.log(`${lc} Peer proposed commit. Accepting & Committing.`); }
@@ -1499,7 +1805,7 @@ export class SyncSagaCoordinator {
 
                     const commitStone = await this.createSyncMsgStone({
                         data: commitData,
-                        space,
+                        space: tempSpace,
                         metaspace
                     });
 
@@ -1507,14 +1813,25 @@ export class SyncSagaCoordinator {
                         prevSagaIbGib: deltaFrame, // Build on top of the Delta we just created/persisted
                         msgStones: [commitStone],
                         identity,
-                        space,
+                        space: tempSpace,
                         metaspace
                     });
 
-                    return { frame: commitFrame, receivedPayloadIbGibs };
+                    // IMMEDIATELY persist to both spaces for audit trail
+                    await this.ensureSagaFrameInBothSpaces({ frame: commitFrame, destSpace, tempSpace, metaspace });
+
+                    // Build control payloads for commit
+                    const commitCtrlPayloads2: IbGib_V1[] = [commitFrame, commitStone];
+                    if (identity) { commitCtrlPayloads2.push(identity); }
+
+                    return { frame: commitFrame, payloadIbGibsControl: commitCtrlPayloads2 };
                 }
 
-                return { frame: deltaFrame, receivedPayloadIbGibs };
+                // Build control payloads for delta propose
+                const deltaCtrlPayloads: IbGib_V1[] = [deltaFrame, deltaStone];
+                if (identity) { deltaCtrlPayloads.push(identity); }
+
+                return { frame: deltaFrame, payloadIbGibsControl: deltaCtrlPayloads };
             }
         }
     }
@@ -1522,14 +1839,17 @@ export class SyncSagaCoordinator {
 
     protected async handleCommitFrame({
         sagaIbGib,
-        space,
+        destSpace,
+        tempSpace,
         metaspace,
+        identity,
     }: {
         sagaIbGib: SyncIbGib_V1,
-        space: IbGibSpaceAny,
+        destSpace: IbGibSpaceAny,
+        tempSpace: IbGibSpaceAny,
         metaspace: MetaspaceService,
         identity?: KeystoneIbGib_V1,
-    }): Promise<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[] } | null> {
+    }): Promise<HandleSagaFrameResult | null> {
         const lc = `${this.lc}[${this.handleCommitFrame.name}]`;
         if (logalot) { console.log(`${lc} Commit received.`); }
 
@@ -1547,29 +1867,6 @@ export class SyncSagaCoordinator {
         return null;
     }
 
-    protected async handleConflictFrame({
-        sagaIbGib,
-        metaspace,
-        space,
-    }: {
-        sagaIbGib: SyncIbGib_V1,
-        metaspace: MetaspaceService,
-        space: IbGibSpaceAny,
-    }): Promise<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[] } | null> {
-        const lc = `${this.lc}[${this.handleConflictFrame.name}]`;
-        const { messageData } = await this.getStageAndPayloadFromFrame({ ibGib: sagaIbGib, space });
-        const conflictData = messageData as SyncSagaMessageConflictData_V1;
-
-        if (logalot) { console.log(`${lc} Conflict received. Strategy: ${conflictData?.conflictStrategy}. Terminal: ${conflictData?.isTerminal}`); }
-
-        if (conflictData?.isTerminal) {
-            throw new Error(`${lc} Saga aborted due to conflicts: ${JSON.stringify(conflictData.conflicts)} (E: b08d1f2a3c4e5d6f7a8b9c0d1e2f3a4b)`);
-        }
-
-        // Non-terminal logic (stub for future)
-        return null;
-    }
-
     // #endregion Handlers
 
     protected async createSyncMsgStone<TStoneData extends SyncSagaMessageData_V1>({
@@ -1605,6 +1902,50 @@ export class SyncSagaCoordinator {
     }
 
 
+    /**
+     * Ensures saga frame and its msg stone(s) are in BOTH spaces for audit trail.
+     * Control ibgibs (saga frames, msg stones, identity) must be in both destSpace and tempSpace.
+     */
+    protected async ensureSagaFrameInBothSpaces({
+        frame,
+        destSpace,
+        tempSpace,
+        metaspace,
+    }: {
+        frame: SyncIbGib_V1,
+        destSpace: IbGibSpaceAny,
+        tempSpace: IbGibSpaceAny,
+        metaspace: MetaspaceService,
+    }): Promise<void> {
+        // Frame itself (already in tempSpace from creation, need in destSpace for audit)
+        await putInSpace({ space: destSpace, ibGib: frame });
+        await metaspace.registerNewIbGib({ ibGib: frame });
+
+        // Msg stone(s) (already in tempSpace, need in destSpace for audit)
+        const msgStoneAddrs = frame.rel8ns?.[SYNC_MSG_REL8N_NAME];
+        if (msgStoneAddrs && msgStoneAddrs.length > 0) {
+            const resMsgStones = await getFromSpace({ space: tempSpace, addrs: msgStoneAddrs });
+            if (resMsgStones.ibGibs) {
+                for (const msgStone of resMsgStones.ibGibs) {
+                    await putInSpace({ space: destSpace, ibGib: msgStone });
+                    await metaspace.registerNewIbGib({ ibGib: msgStone });
+                }
+            }
+        }
+
+        // Identity (if present, already in tempSpace, need in destSpace)
+        const identityAddrs = frame.rel8ns?.identity;
+        if (identityAddrs && identityAddrs.length > 0) {
+            const resIdentity = await getFromSpace({ space: tempSpace, addrs: identityAddrs });
+            if (resIdentity.ibGibs) {
+                for (const identity of resIdentity.ibGibs) {
+                    await putInSpace({ space: destSpace, ibGib: identity });
+                    await metaspace.registerNewIbGib({ ibGib: identity });
+                }
+            }
+        }
+    }
+
     /**
      * Evolves the saga timeline with a new frame.
      */