@ibgib/core-gib 0.1.21 → 0.1.23

package/dist/sync/sync-saga-coordinator.mjs

@@ -1,24 +1,25 @@
 import { extractErrorMsg, getUUID, // so our timestamp in ticks as a string are uniform
-pretty } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
+pretty, delay, } 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 { Factory_V1 } from "@ibgib/ts-gib/dist/V1/factory.mjs";
-import { GLOBAL_LOG_A_LOT } from "../core-constants.mjs";
 import { putInSpace, getLatestAddrs, getFromSpace } from "../witness/space/space-helper.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 } from "../timeline/timeline-api.mjs";
-import { SyncMode, } from "./sync-types.mjs";
-import { getSyncIb, isPastFrame } from "./sync-helpers.mjs";
-import { getSyncSagaDependencyGraph } from "./sync-helpers.mjs";
-import { getDependencyGraph } from "../common/other/graph-helper.mjs";
+import { SyncConflictStrategy, SyncMode, } from "./sync-types.mjs";
+import { getSyncIb, getTempSpaceName, isPastFrame } from "./sync-helpers.mjs";
+import { getDependencyGraph, toFlatGraph } from "../common/other/graph-helper.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 { SyncSagaContextCmd } from "./sync-saga-context/sync-saga-context-types.mjs";
+import { splitPerTjpAndOrDna, getTimelinesGroupedByTjp, isIbGib } from "../common/other/ibgib-helper.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 { mergeDivergentTimelines } from "./strategies/conflict-optimistic.mjs";
 import { getSyncSagaMessageFromFrame } from "./sync-saga-message/sync-saga-message-helpers.mjs";
-const logalot = GLOBAL_LOG_A_LOT || true;
+import { fnObs } from "../common/pubsub/observer/observer-helper.mjs";
+// const logalot = GLOBAL_LOG_A_LOT || true;
+const logalot = false;
+const logalotControlDomain = true;
+const lcControlDomain = '[ControlDomain]';
 /**
  * Orchestrates the synchronization process between two spaces (Source and Destination).
  *
@@ -51,14 +52,13 @@ export class SyncSagaCoordinator {
      * @param opts.domainIbGibs - The root ibgibs defining the scope of the sync.
      * @param opts.useSessionIdentity - (Optional) Whether to create an ephemeral session identity. Default: true.
      */
-    async sync({ peer, localSpace: _localSpace, source: _source, metaspace, domainIbGibs, conflictStrategy = 'abort', useSessionIdentity = true, }) {
+    async sync({ peer, domainIbGibs, conflictStrategy = SyncConflictStrategy.abort, useSessionIdentity = true, metaspace, localSpace, }) {
         const lc = `${this.lc}[${this.sync.name}]`;
         if (logalot) {
             console.log(`${lc} starting...`);
         }
-        const localSpace = (_source || _localSpace);
         if (!localSpace) {
-            throw new Error(`${lc} source (or localSpace) required (E: 8a9b0c1d)`);
+            throw new Error(`${lc} source (or localSpace) required (E: 25df3761f7686a1099a552f83c95d326)`);
         }
         // 1. SETUP SAGA METADATA
         const sagaId = await getUUID();
@@ -74,10 +74,6 @@ export class SyncSagaCoordinator {
             resolveDone = resolve;
             rejectDone = reject;
         });
-        async function getTempSpaceName() {
-            const uuid = await getUUID();
-            return `tmp_sync_space_${uuid.substring(0, 8)}`;
-        }
         // WORKING CONTEXT (Transactional)
         const tempSpaceName = await getTempSpaceName();
         const tempSpace = await metaspace.createNewLocalSpace({
@@ -105,33 +101,24 @@ export class SyncSagaCoordinator {
                     : undefined;
                 // 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({
+                const { sagaFrame: initFrame, initialDomainGraph } = await this.createInitFrame({
                     sagaId,
                     sessionIdentity,
-                    localSpace,
                     domainIbGibs,
-                    tempSpace,
-                    metaspace,
-                    conflictStrategy
-                });
-                // 4. EXECUTE SAGA LOOP (FSM)
-                const syncedIbGibs = await this.executeSagaLoop({
-                    initialFrame: initFrame,
-                    srcGraph,
-                    peer,
-                    sessionIdentity,
-                    updates$,
-                    localSpace,
-                    tempSpace,
-                    metaspace
+                    conflictStrategy,
+                    metaspace, localSpace, tempSpace,
                 });
-                // 5. MERGE RESULT (Optimistic Commit)
-                if (syncedIbGibs && syncedIbGibs.length > 0) {
-                    if (logalot) {
-                        console.log(`${lc} Merging ${syncedIbGibs.length} synced ibGibs to localSpace...`);
-                    }
-                    await putInSpace({ space: localSpace, ibGibs: syncedIbGibs });
-                }
+                // 4. KICK OFF THE PING-PONG SAGA LOOP (FSM)
+                // commented to compile
+                // await this.executeSagaLoop({
+                //     initialFrame: initFrame,
+                //     peer,
+                //     sessionIdentity,
+                //     updates$,
+                //     localSpace,
+                //     tempSpace,
+                //     metaspace
+                // });
                 resolveDone();
                 if (!updates$.complete) {
                     throw new Error(`(UNEXPECTED) updates$.complete falsy? (E: d24cd82184aec130c89a320819b39126)`);
@@ -194,87 +181,110 @@ export class SyncSagaCoordinator {
      * **Execution Context**: **Sender (Local)**.
      *
      * This method manages the "Ping Pong" request-response cycle on the Sender.
-     * It sends frames via the Peer Witness and processes the responses using `handleSagaFrame`.
+     * It sends frames via the Peer Witness and processes the responses using `handleSagaResponseContext`.
      *
      * **Data Transport Note**:
      * Actual ibGib data (payloads) are transported via `SyncSagaContext.rel8ns.payload`.
-     * When `handleSagaFrame` returns a `nextPayloadIbGibs` (data to send), this loop injects it into
+     * When `handleSagaResponseContext` returns a `nextPayloadIbGibs` (data to send), this loop injects it into
      * the NEXT request context.
      * When the Peer responds with data (in the response context), it is resolved and put into `tempSpace`.
      */
-    async executeSagaLoop({ initialFrame, srcGraph, peer, sessionIdentity, updates$, localSpace, tempSpace, metaspace }) {
+    async executeSagaLoop({ initialFrame, initialDomainGraph, peer, sessionIdentity, updates$, localSpace, tempSpace, metaspace }) {
         const lc = `${this.lc}[${this.executeSagaLoop.name}]`;
         // The current frame we just generated (e.g., Init or Delta Request)
         let currentFrame = initialFrame;
         // The payload we need to attach to the message (data we are sending)
-        let nextPayloadIbGibs = [];
-        // Accumulator for all data we've successfully pulled from the remote
-        const allReceivedIbGibs = [];
+        let nextDomainIbGibs = [];
+        // First, inject local/tempSpace into peer so it can pull as
+        // needed...code smell?
+        peer.senderSpace = localSpace;
+        peer.senderTempSpace = tempSpace;
         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 = [];
+            // We must do this BEFORE creating the Context so we can list them
+            // all in payloadAddrsDomain and payloadAddrsControl.
+            const nextDomainIbGibsAndDeps = [];
             // 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 });
+            // TODO: THIS IS EXTREMELY INEFFICIENT. adjust this algorithm to
+            // only do the dependencies that the other end doesn't need (diff
+            // between tip and LCA). This can be done using the information in
+            // the ack's conflicts array.
+            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) {
+                    nextDomainIbGibsAndDeps.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}`);
-            }
-            // B. Frames (Shallow Sync Deps)
-            if (currentFrame) {
-                const deps = await getSyncSagaDependencyGraph({ ibGib: currentFrame, space: tempSpace });
-                if (deps)
-                    allDeps.push(...deps);
+                console.log(`${lc} payloadIbGibsDomain count: ${nextDomainIbGibsAndDeps.length} (I: 2beda8ca7dc5ac0f48ed9e25e704b826)`);
             }
             // 2. Create Context (Envelope)
-            // Use the FULL dependency list as the payload manifest
-            const payloadAddrs = allDeps.map(p => getIbGibAddr({ ibGib: p }));
+            // set up subscription for response's payload ibgibs (if any)
+            const domainPayloadsMap = new Map();
+            const sublc = `${lc}[peer.payloadIbGibsDomainReceived$]`;
+            const subscription = await peer.payloadIbGibsDomainReceived$.subscribe(fnObs({
+                next: async (ibgib) => {
+                    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) => {
+                    if (isIbGib(e)) {
+                        console.error(`${sublc} error fired. error: ${JSON.stringify(e.data)} (E: 01cc08ba05ad99682831174fd7c31a26)`);
+                    }
+                    else {
+                        console.dir(e);
+                        console.error(`${sublc} error fired. error: ${extractErrorMsg(e)} (E: 73d3d61464e8e4ce4cd6efd8b9675826)`);
+                    }
+                },
+                complete: async () => {
+                    if (logalot) {
+                        console.log(`${sublc} complete fired. (I: a47218aa9e4433fdb97c068880a45826)`);
+                    }
+                    await subscription.unsubscribe();
+                },
+            }));
+            // Create the Request Context...
             const requestCtx = await createSyncSagaContext({
-                cmd: SyncSagaContextCmd.process,
                 sagaFrame: currentFrame,
                 sessionKeystones: sessionIdentity ? [sessionIdentity] : undefined,
-                payloadAddrs: payloadAddrs.length > 0 ? payloadAddrs : undefined,
+                /**
+                 * init frame: empty
+                 *
+                 */
+                payloadIbGibsDomain: nextDomainIbGibsAndDeps,
+                localSpace,
             });
-            // Add Context Deps
-            if (requestCtx) {
-                const deps = await getSyncSagaDependencyGraph({ ibGib: requestCtx, space: tempSpace });
-                if (deps)
-                    allDeps.push(...deps);
-            }
-            // 3. Identity (if exists)
-            // Identity might be deep? Keystone? Usually self-contained or shallow references.
-            if (sessionIdentity) {
-                allDeps.push(sessionIdentity);
-            }
-            if (allDeps.length > 0) {
-                await putInSpace({
-                    space: localSpace,
-                    ibGibs: allDeps
-                });
-            }
-            // B. Transmit
+            // Log what we're sending
+            if (logalotControlDomain) {
+                const domainAddrs = nextDomainIbGibsAndDeps.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}   DOMAIN Payloads (${domainAddrs.length}): ${domainAddrs.join(', ') || '(none)'}`);
+            }
+            // update our saga listeners...
             // if (logalot) { console.log(`${lc} transmitting... requestCtx: ${pretty(requestCtx)} (I: 8cf20817c66899abdb1e76df50356826)`); }
-            updates$.next(requestCtx);
+            updates$.next(requestCtx); // spins off 
+            // ...And send the context
             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.`);
@@ -282,59 +292,79 @@ export class SyncSagaCoordinator {
                         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)`);
-            }
-            updates$.next(responseCtx);
-            // 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)`);
-            }
-            // 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 });
-            }
-            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
-            // 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 });
-            }
-            // 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,
-                srcGraph,
-                destSpace: localSpace, // Query existing data from localSpace (Source)
-                tempSpace: tempSpace, // Transaction space for saga frames
-                identity: sessionIdentity,
-                metaspace
+            // ---------------------------------------------------------------------
+            // 2d. HANDLE RESPONSE
+            // ---------------------------------------------------------------------
+            // at this point, we have received the response context ibgib, but
+            // if there were payloads expected to be transferred, they may not
+            // be done yet.
+            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] || [];
+            // Poll for them if needed
+            if (responsePayloadAddrsDomain.length > 0) {
+                responseCtx.payloadIbGibsDomain = await this.pollForDomainPayloads({
+                    expectedAddrs: responsePayloadAddrsDomain,
+                    pollIntervalMs: 20, // relatively arbitrary right now
+                    domainPayloadsMap,
+                    tempSpace,
+                });
+            }
+            // at this point, we have received the context AND **all** of the
+            // domain payloads (if applicable), so we are ready to do the next 
+            // iteration in the saga loop
+            // Log what we received back
+            if (!responseCtx.sagaFrame) {
+                throw new Error(`(UNEXPECTED) responseCtx.sagaFrame falsy? the Peer should have set this when it got the response back from the remote. (E: e650adadf9a2063ec6764a1e31d3d826)`);
+            }
+            if (logalotControlDomain) {
+                const responseControlAddrs = responseCtx.data?.['@payloadAddrsControl'] || [];
+                console.log(`${lc}${lcControlDomain} SENDER RECEIVED <- peer.witness (I: c4d5e6f7a8b9c0d1)`);
+                console.log(`${lc}${lcControlDomain}   Response Context: ${getIbGibAddr({ ibGib: responseCtx })}`);
+                console.log(`${lc}${lcControlDomain}   Response Saga Frame: ${getIbGibAddr({ ibGib: responseCtx.sagaFrame })}`);
+                console.log(`${lc}${lcControlDomain}   CONTROL Payloads (${responseControlAddrs.length}): ${responseControlAddrs.join(', ') || '(none)'}`);
+                console.log(`${lc}${lcControlDomain}   DOMAIN Payloads (${responsePayloadAddrsDomain.length}): ${responsePayloadAddrsDomain.join(', ') || '(none)'}`);
+            }
+            // Handle Response Frame
+            // interface HandleSagaFrameResult {
+            //     frame: SyncIbGib_V1;
+            //     payloadIbGibsDomain?: IbGib_V1[];
+            //     conflictInfos?: SyncSagaConflictInfo;
+            // }
+            const handleResult = await this.handleSagaContext({
+                sagaContext: responseCtx,
+                mySpace: localSpace,
+                myTempSpace: tempSpace,
+                metaspace,
             });
-            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);
+            if (!handleResult) {
+                if (logalot) {
+                    console.log(`${lc} Handler returned null (Saga End).`);
+                }
+                break;
+            }
+            currentFrame = handleResult.frame;
+            // Collect next DOMAIN payloads for the NEXT request
+            nextDomainIbGibs = [...(handleResult.payloadIbGibsDomain || [])];
+            // Log handler output for next iteration
+            if (logalotControlDomain) {
+                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}   DOMAIN for next (${handlerDomainAddrs.length}): ${handlerDomainAddrs.join(', ') || '(none)'}`);
             }
         }
-        return allReceivedIbGibs;
     }
     /**
      * Helper to get Knowledge Vector for specific domain ibGibs or TJPs.
@@ -346,7 +376,7 @@ export class SyncSagaCoordinator {
             if (logalot) {
                 console.log(`${lc} starting... (I: e184f8a7818666febfbbd2d841ed3826)`);
             }
-            console.dir(space);
+            // console.dir(space);
             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)`);
@@ -361,23 +391,21 @@ export class SyncSagaCoordinator {
             }
             else if (domainIbGibs && domainIbGibs.length > 0) {
                 // Extract TJPs from domain Ibgibs
-                if (logalot) {
-                    console.log(`${lc} domainIbGibs (${domainIbGibs.length}) provided.  (I: a378995a0658af1f086ac1f297486c26)`);
-                }
+                // if (false) { console.log(`${lc} domainIbGibs (${domainIbGibs.length}) provided.  (I: a378995a0658af1f086ac1f297486c26)`); }
                 const { mapWithTjp_YesDna, mapWithTjp_NoDna } = splitPerTjpAndOrDna({ ibGibs: domainIbGibs });
-                if (logalot) {
+                if (false) {
                     console.log(`${lc}[TEST DEBUG] mapWithTjp_YesDna: ${JSON.stringify(mapWithTjp_YesDna)} (I: 287e22897148298e185712c8d50cfb26)`);
                 }
-                if (logalot) {
+                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 (logalot) {
+                if (false) {
                     console.log(`${lc}[TEST DEBUG] timelineMap: ${JSON.stringify(timelineMap)} (I: 2cc04898e5f85179fb1ac7f827abc426)`);
                 }
                 tjps = Object.keys(timelineMap);
-                if (logalot) {
+                if (false) {
                     console.log(`${lc}[TEST DEBUG] tjps: ${tjps} (I: 3dd548667cbd967c68e57c88dc570826)`);
                 }
             }
@@ -390,16 +418,14 @@ export class SyncSagaCoordinator {
             if (tjps.length === 0) {
                 return {};
             }
-            if (logalot) {
+            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 (logalot) {
-                console.log(`${lc}[TEST DEBUG] res.data.latestAddrsMap: ${JSON.stringify(res.data.latestAddrsMap)} (I: a8e128bdf80898ac2e6d8021a5bff726)`);
-            }
+            // if (false) { console.log(`${lc}[TEST DEBUG] res.data.latestAddrsMap: ${JSON.stringify(res.data.latestAddrsMap)} (I: a8e128bdf80898ac2e6d8021a5bff726)`); }
             return res.data.latestAddrsMap;
         }
         catch (error) {
@@ -412,24 +438,27 @@ export class SyncSagaCoordinator {
             }
         }
     }
-    async analyzeTimelines({ domainIbGibs, space, }) {
-        const lc = `${this.lc}[${this.analyzeTimelines.name}]`;
-        const srcGraph = await getDependencyGraph({
+    async analyzeDomainIbGibs({ domainIbGibs, space, }) {
+        const lc = `${this.lc}[${this.analyzeDomainIbGibs.name}]`;
+        if (domainIbGibs.length === 0) {
+            throw new Error(`invalid domainIbGibs. expected at least one, but array is empty. (E: 820a719bcac5a16878a2af697113b826)`);
+        }
+        const fullGraph = await getDependencyGraph({
             ibGibs: domainIbGibs,
             live: true,
             space,
         });
-        const srcGraphIsValid = srcGraph && Object.keys(srcGraph).length > 0;
+        const graphIsValid = fullGraph && Object.keys(fullGraph).length > 0;
         if (logalot) {
-            console.log(`${lc} graph generated. nodes: ${srcGraphIsValid ? Object.keys(srcGraph).length : 0}`);
+            console.log(`${lc} graph generated. nodes: ${graphIsValid ? Object.keys(fullGraph).length : 0}`);
         }
-        const srcIbGibs = srcGraphIsValid ? Object.values(srcGraph) : [];
+        const srcIbGibs = graphIsValid ? Object.values(fullGraph) : [];
         const { mapWithTjp_YesDna: srcMapWithTjp_YesDna, mapWithTjp_NoDna: srcMapWithTjp_NoDna, mapWithoutTjps: src_MapWithoutTjps } = splitPerTjpAndOrDna({ ibGibs: srcIbGibs });
-        const srcStones = Object.values(src_MapWithoutTjps);
-        const srcLiving = [...Object.values(srcMapWithTjp_YesDna), ...Object.values(srcMapWithTjp_NoDna)];
-        const srcTimelinesMap = getTimelinesGroupedByTjp({ ibGibs: srcLiving });
-        const srcSortedTjps = this.sortTimelinesTopologically(srcTimelinesMap);
-        return { srcStones, srcTimelinesMap, srcSortedTjps, srcGraph };
+        const stones = Object.values(src_MapWithoutTjps);
+        const withTimelines = [...Object.values(srcMapWithTjp_YesDna), ...Object.values(srcMapWithTjp_NoDna)];
+        const timelinesMap = getTimelinesGroupedByTjp({ ibGibs: withTimelines });
+        const topologicallySortedTjpAddrs = this.sortTimelinesTopologically(timelinesMap);
+        return { stones, timelinesMap, topologicallySortedTjpAddrs, fullGraph };
     }
     /**
      * Creates the Initial Saga Frame (Init Stage).
@@ -440,57 +469,54 @@ export class SyncSagaCoordinator {
      * Generates the first frame containing the Knowledge Vector of the Local Space.
      * This is sent to the Receiver to begin Gap Analysis.
      */
-    async createInitFrame({ sagaId, sessionIdentity, localSpace, domainIbGibs, tempSpace, metaspace, conflictStrategy, }) {
+    async createInitFrame({ sagaId, sessionIdentity, domainIbGibs, conflictStrategy, metaspace, localSpace, tempSpace, }) {
         const lc = `${this.lc}[${this.createInitFrame.name}]`;
         try {
             if (logalot) {
                 console.log(`${lc} starting... (I: 551af8b411ae9be712ce3358d43ee726)`);
             }
             // Analyze Timelines & Stones
-            const analysis = await this.analyzeTimelines({ domainIbGibs, space: localSpace });
-            // this is a lot, so uncomment this only if you want even more logging specific to this analysis
+            const analysis = await this.analyzeDomainIbGibs({ domainIbGibs, space: localSpace });
             // if (logalot) { console.log(`${lc} analysis: ${pretty(analysis)}(I: cd00e2be5eccc8976879c888ff2dfb26)`); } 
-            const { srcTimelinesMap, srcGraph, srcStones, } = analysis;
+            const { timelinesMap: srcTimelinesMap, fullGraph, stones: srcStones, } = analysis;
+            // we need to store the fullGraph in our tempSpace for later...
+            await putInSpace({ ibGibs: Object.values(fullGraph), space: tempSpace });
+            // populate our knowledge vector with tjp -> latest addr/tip in timeline
+            const knowledgeVector = {};
+            Object.keys(srcTimelinesMap).forEach(tjp => {
+                const timeline = srcTimelinesMap[tjp];
+                const tip = timeline.at(-1);
+                knowledgeVector[tjp] = getIbGibAddr({ ibGib: tip });
+            });
             const initData = {
                 sagaId,
                 stage: SyncStage.init,
-                knowledgeVector: {},
+                knowledgeVector,
                 identity: sessionIdentity, // KeystoneIbGib is already public data
                 mode: SyncMode.sync,
                 stones: srcStones.map(s => getIbGibAddr({ ibGib: s })),
             };
-            // Populate Knowledge Vector
-            Object.keys(srcTimelinesMap).forEach(tjp => {
-                const timeline = srcTimelinesMap[tjp];
-                const tip = timeline.at(-1);
-                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}`);
             }
+            // create the stone and save/register it
             const initStone = await this.createSyncMsgStone({
                 data: initData,
-                space: tempSpace,
-                metaspace
+                localSpace,
+                metaspace,
             });
             // if (logalot) { console.log(`${lc} initStone: ${pretty(initStone)} (I: 06e532f8a408549069474e96bed44826)`); }
+            // create the initial sync ibgib frame, save/register it
             const sagaFrame = await this.evolveSyncSagaIbGib({
                 msgStones: [initStone],
-                identity: sessionIdentity,
-                space: tempSpace,
-                metaspace,
                 conflictStrategy,
-            });
-            // IMMEDIATELY persist to both spaces for audit trail
-            await this.ensureSagaFrameInBothSpaces({
-                frame: sagaFrame,
-                destSpace: localSpace, // localSpace is the Sender's destSpace
-                tempSpace,
-                metaspace
+                sessionIdentity: sessionIdentity,
+                metaspace,
+                localSpace,
             });
             // if (logalot) { console.log(`${lc} sagaFrame (init): ${pretty(sagaFrame)} (I: b3d6a8be69248f18713cc3073cb08626)`); }
-            return { sagaFrame, srcGraph };
+            return { sagaFrame, initialDomainGraph: fullGraph };
         }
         catch (error) {
             console.error(`${lc} ${extractErrorMsg(error)}`);
@@ -503,24 +529,90 @@ export class SyncSagaCoordinator {
         }
     }
     /**
-     * Reacts to an incoming saga frame and dispatches to appropriate handler.
+     * Helper to poll for streaming domain payloads and put them in the
+     * local {@link tempSpace}.
      *
-     * @remarks
-     * **Execution Context**: **Universal (Both Sender and Receiver)**.
+     * @returns when all {@link expectedAddrs} are done being transmitted.
+     */
+    async pollForDomainPayloads({ expectedAddrs, pollIntervalMs, domainPayloadsMap, tempSpace, }) {
+        const lc = `${this.lc}[${this.pollForDomainPayloads.name}]`;
+        try {
+            if (logalot) {
+                console.log(`${lc} starting... (I: 26dce86bfca572939885798802d6e926)`);
+            }
+            let resultDomainPayloads = [];
+            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 = [];
+                const found = [];
+                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 });
+                    found.forEach(x => resultDomainPayloads.push(x));
+                }
+                pending = stillPending;
+                if (pending.length > 0) {
+                    await delay(pollIntervalMs);
+                }
+            }
+            if (expectedAddrs.length !== resultDomainPayloads.length) {
+                throw new Error(`(UNEXPECTED) expectedAddrs.length !== resultDomainPayloads.length? at this point, we expect all of the payload ibgibs to have been received. (E: 03749a7478c4b8b28bfc86951887a826)`);
+            }
+            return resultDomainPayloads;
+        }
+        catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        }
+        finally {
+            if (logalot) {
+                console.log(`${lc} complete.`);
+            }
+        }
+    }
+    /**
+     * This is the heart of the "ping pong" transaction, where we send a context
+     * and receive a context. IOW, this drives the FSM of the sync saga ibgib as
+     * a whole.
+     *
+     * This is called in two places:
+     *
+     * ## 1. Sender
+     *
+     * On the sender, this is called within the {@link executeSagaLoop} which
+     * initiates and drives the sync.
+     *
+     * ## 2. 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.
+     * On the receiver, this is called directly by the receiving endpoint. That
+     * endpoint's job is basically to get these things collocated and prepared
+     * to make this call.
      *
-     * *   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`.
+     * This is a one-off on the receiver.
      */
-    async handleSagaFrame({ sagaIbGib, srcGraph, destSpace, tempSpace, identity, identitySecret, metaspace, }) {
-        const lc = `${this.lc}[${this.handleSagaFrame.name}]`;
+    async handleSagaContext({ sagaContext, mySpace, myTempSpace, identity, identitySecret, metaspace, }) {
+        const lc = `${this.lc}[${this.handleSagaContext.name}]`;
         try {
             if (logalot) {
                 console.log(`${lc} starting... (I: 5deec8a1f7a6d263c88cd458ad990826)`);
             }
+            const sagaIbGib = sagaContext.sagaFrame;
             if (!sagaIbGib.data) {
                 throw new Error(`(UNEXPECTED) sagaIbGib.data falsy? (E: 71b938adf1d87c2527bfd4f86dfd0826)`);
             }
@@ -528,19 +620,31 @@ export class SyncSagaCoordinator {
                 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: tempSpace });
+            const { stage, messageData } = await this.getStageAndPayloadFromFrame({ sagaFrame: sagaIbGib, space: myTempSpace });
             if (logalot) {
                 console.log(`${lc} handling frame stage: ${stage}`);
             }
+            /**
+             * don't like this name, need to refactor
+             */
+            const srcGraph = toFlatGraph({ ibGibs: sagaContext.payloadIbGibsDomain }) ?? {};
             switch (stage) {
                 case SyncStage.init:
-                    return await this.handleInitFrame({ sagaIbGib, messageData, metaspace, destSpace, tempSpace, identity, identitySecret });
+                    return await this.handleInitFrame({
+                        sagaIbGib,
+                        messageData: messageData,
+                        metaspace,
+                        mySpace: mySpace,
+                        myTempSpace: myTempSpace,
+                        identity,
+                        identitySecret
+                    });
                 case SyncStage.ack:
-                    return await this.handleAckFrame({ sagaIbGib, srcGraph, metaspace, destSpace, tempSpace, identity });
+                    return await this.handleAckFrame({ sagaIbGib, srcGraph, metaspace, destSpace: mySpace, tempSpace: myTempSpace, identity });
                 case SyncStage.delta:
-                    return await this.handleDeltaFrame({ sagaIbGib, srcGraph, metaspace, destSpace, tempSpace, identity, });
+                    return await this.handleDeltaFrame({ sagaIbGib, srcGraph, metaspace, destSpace: mySpace, tempSpace: myTempSpace, identity, });
                 case SyncStage.commit:
-                    return await this.handleCommitFrame({ sagaIbGib, metaspace, destSpace, tempSpace, identity, });
+                    return await this.handleCommitFrame({ sagaIbGib, metaspace, destSpace: mySpace, tempSpace: myTempSpace, identity, });
                 default:
                     throw new Error(`${lc} (UNEXPECTED) Unknown sync stage: ${stage} (E: 9c2b4c8a6d34469f8263544710183355)`);
             }
@@ -568,277 +672,278 @@ export class SyncSagaCoordinator {
      * 3.  Identifies what Receiver needs (`deltaReqAddrs`).
      * 4.  Returns an `Ack` frame containing these lists.
      */
-    async handleInitFrame({ sagaIbGib, messageData, destSpace, tempSpace, metaspace, identity, identitySecret, }) {
+    async handleInitFrame({ sagaIbGib, messageData, mySpace, myTempSpace, metaspace, identity,
+    // identitySecret,
+     }) {
         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
-        const initData = messageData; // Using renamed variable for clarity
-        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 (!initData || !initData.knowledgeVector) {
-            throw new Error(`${lc} Invalid init frame: missing knowledgeVector (E: ed02c869e028d2d06841b9c7f80f2826)`);
-        }
-        // Determine Strategy from Saga Data (since V1 stores it in root)
-        const conflictStrategy = sagaIbGib.data.conflictStrategy || 'abort';
-        // 2. Gap Analysis
-        const conflicts = [];
-        const deltaReqAddrs = [];
-        const pushOfferAddrs = [];
-        // Stones Analysis (Constants / Non-TJPs)
-        const stones = initData.stones || [];
-        if (stones.length > 0) {
+        try {
             if (logalot) {
-                console.log(`${lc} processing stones: ${stones.length}`);
+                console.log(`${lc} starting... (I: 9d88dcad0408c029e898a4bcf3b08426)`);
             }
-            // Check if we have these stones
-            const resStones = await getFromSpace({ space: destSpace, addrs: stones });
-            const addrsNotFound = resStones.rawResultIbGib?.data?.addrsNotFound;
-            if (addrsNotFound && addrsNotFound.length > 0) {
+            console.log(`${lc} [TEST DEBUG] Received destSpace: ${mySpace.data?.name || mySpace.ib} (uuid: ${mySpace.data?.uuid || '[no uuid]'})`);
+            if (logalot) {
+                console.log(`${lc} starting...`);
+            }
+            // Extract Init Data
+            const initData = messageData; // Using renamed variable for clarity
+            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 (!initData || !initData.knowledgeVector) {
+                throw new Error(`${lc} Invalid init frame: missing knowledgeVector (E: ed02c869e028d2d06841b9c7f80f2826)`);
+            }
+            // Determine Strategy from Saga Data (since V1 stores it in root)
+            const conflictStrategy = sagaIbGib.data.conflictStrategy || SyncConflictStrategy.abort;
+            // 2. Gap Analysis
+            const conflicts = [];
+            const deltaReqAddrs = [];
+            const pushOfferAddrs = [];
+            // First do the consant stones (Non-TJPs)
+            const stones = initData.stones || [];
+            if (stones.length > 0) {
                 if (logalot) {
-                    console.log(`${lc} stones missing (requesting): ${addrsNotFound.length}`);
+                    console.log(`${lc} processing stones: ${stones.length}`);
+                }
+                // Check if we have these stones
+                const resStones = await getFromSpace({ space: mySpace, addrs: stones });
+                const rawResultIbGib = resStones.rawResultIbGib;
+                if (!rawResultIbGib.data) {
+                    throw new Error(`(UNEXPECTED) rawResultIbGib.data falsy? (E: f3c40b492adc02c3f480b998fc7a5926)`);
                 }
-                addrsNotFound.forEach(addr => {
-                    if (!deltaReqAddrs.includes(addr)) {
-                        deltaReqAddrs.push(addr);
+                const addrsNotFound = rawResultIbGib.data.addrsNotFound;
+                if (addrsNotFound && addrsNotFound.length > 0) {
+                    if (logalot) {
+                        console.log(`${lc} stones missing (requesting): ${addrsNotFound.length}`);
                     }
-                });
-            }
-        }
-        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
-        let localKV = {};
-        if (remoteTjps.length > 0) {
-            // Batch get latest addrs for the TJPs
-            const resGetLatestAddrs = await getLatestAddrs({
-                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)`);
+                    addrsNotFound.forEach(addr => {
+                        if (!deltaReqAddrs.includes(addr)) {
+                            deltaReqAddrs.push(addr);
+                        }
+                    });
+                }
             }
-            localKV = resGetLatestAddrs.data.latestAddrsMap;
-            console.log(`${lc} [TEST DEBUG] localKV: ${JSON.stringify(localKV)}`);
+            /**
+             * "remote" local to receiver's context is the sender
+             */
+            const remoteKV = initData.knowledgeVector;
             if (logalot) {
-                console.log(`${lc} localKV: ${pretty(localKV)} (I: 980975642cbccd8018cf0cd808d30826)`);
-            }
-        }
-        // 2. Gap Analysis
-        for (const tjp of remoteTjps) {
-            const remoteAddr = remoteKV[tjp];
-            const localAddr = localKV[tjp];
-            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: destSpace,
-            });
-            if (isRemoteInPast) {
-                console.log(`${lc} [TEST DEBUG] TJP ${tjp}: Remote is in past - offering push`);
-                pushOfferAddrs.push(localAddr);
+                console.log(`${lc} remoteKV: ${pretty(remoteKV)} (I: 9f957862356dfeae183c200854e86e26)`);
             }
-            else {
-                // Remote is not in our past. 
-                // Either Remote is ahead (Fast-Backward) OR Diverged.
-                // Check if Local is in Remote's PAST (Remote is Ahead -> Delta Request)
-                const isLocalInPast = await isPastFrame({
-                    olderAddr: localAddr,
-                    newerAddr: remoteAddr,
-                    space: destSpace,
+            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
+            let localKV = {};
+            if (remoteTjps.length > 0) {
+                // Batch get latest addrs for the TJPs
+                const resGetLatestAddrs = await getLatestAddrs({
+                    space: mySpace, // executing on receiver, so this is receiver's space
+                    tjpAddrs: remoteTjps,
                 });
-                if (isLocalInPast) {
-                    // Fast-Forward: We update to remote's tip.
-                    console.log(`${lc} [TEST DEBUG] TJP ${tjp}: Local is in past - requesting delta`);
+                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)`);
+                }
+            }
+            // 2. Gap Analysis
+            for (const tjp of remoteTjps) {
+                const remoteAddr = remoteKV[tjp];
+                const localAddr = localKV[tjp];
+                if (!localAddr) {
+                    // We (Receiver) don't have this timeline at all. 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: mySpace,
+                });
+                if (isRemoteInPast) {
+                    console.log(`${lc} [TEST DEBUG] TJP ${tjp}: Remote is in past - offering push`);
+                    pushOfferAddrs.push(localAddr);
                 }
                 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.
-                        // But for Unified Ack, we just mark it terminal in the list?
-                        // Or do we actually throw/abort the saga?
-                        // Current logic (below) aborts the saga if ANY conflict is terminal/abort.
-                        conflicts.push({
-                            tjpAddr: tjp,
-                            localAddr: localAddr,
-                            remoteAddr,
-                            timelineAddrs: [], // Not needed for abort
-                            reason: 'divergence',
-                            terminal: true
-                        });
-                    }
-                    else if (conflictStrategy === 'optimistic') {
-                        // Optimistic: We want to resolving this.
-                        // We need to send our history to the Sender so they can Merge.
-                        // Fetch Full History for Local Timeline
-                        // Note: We might optimize this to only send "recent" history if we had a KV?
-                        // But for now, get full past.
-                        // Optimization: localKV might not have full history.
-                        // We need to inspect the 'past' of the local tip.
-                        // We need the ACTUAL object to get the past.
-                        // We have 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)`);
-                        }
-                        const timelineAddrs = [localAddr, ...(localTip.rel8ns?.past || [])];
-                        conflicts.push({
-                            tjpAddr: tjp,
-                            localAddr: localAddr,
-                            remoteAddr,
-                            timelineAddrs,
-                            reason: 'divergence',
-                            terminal: false
-                        });
+                    // Remote is not in our past. 
+                    // Either Remote is ahead (Fast-Backward) OR Diverged.
+                    // Check if Local is in Remote's PAST (Remote is Ahead -> Delta Request)
+                    const isLocalInPast = await isPastFrame({
+                        olderAddr: localAddr,
+                        newerAddr: remoteAddr,
+                        space: mySpace,
+                    });
+                    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 {
-                        throw new Error(`${lc} Unsupported conflict strategy: ${conflictStrategy} (E: 2a9b3c4d5e6f7g8h9i0j)`);
+                        // 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.
+                            // But for Unified Ack, we just mark it terminal in the list?
+                            // Or do we actually throw/abort the saga?
+                            // Current logic (below) aborts the saga if ANY conflict is terminal/abort.
+                            conflicts.push({
+                                tjpAddr: tjp,
+                                localAddr: localAddr,
+                                remoteAddr,
+                                timelineAddrs: [], // Not needed for abort
+                                reason: 'divergence',
+                                terminal: true
+                            });
+                        }
+                        else if (conflictStrategy === 'optimistic') {
+                            // Optimistic: We want to resolving this.
+                            // We need to send our history to the Sender so they can Merge.
+                            // Fetch Full History for Local Timeline
+                            // Note: We might optimize this to only send "recent" history if we had a KV?
+                            // But for now, get full past.
+                            // Optimization: localKV might not have full history.
+                            // We need to inspect the 'past' of the local tip.
+                            // We need the ACTUAL object to get the past.
+                            // We have localAddr.
+                            const resLocalTip = await getFromSpace({ space: mySpace, addr: localAddr });
+                            if (!resLocalTip.success || resLocalTip.ibGibs?.length !== 1) {
+                                throw new Error(`couldn't get local tip (${localAddr}) from space (${mySpace.ib}) (E: ff06ff849fa8e8dba32ce09807411226)`);
+                            }
+                            const localTip = resLocalTip.ibGibs[0];
+                            if (!localTip) {
+                                throw new Error(`${lc} Failed to load local tip for conflict resolution. (E: 8f9b2c3d4e5f6g7h)`);
+                            }
+                            const timelineAddrs = [...(localTip.rel8ns?.past ?? []), localAddr];
+                            conflicts.push({
+                                tjpAddr: tjp,
+                                localAddr,
+                                remoteAddr,
+                                timelineAddrs,
+                                reason: 'divergence',
+                                terminal: false
+                            });
+                        }
+                        else {
+                            throw new Error(`${lc} Unsupported conflict strategy: ${conflictStrategy} (E: 2a9b3c4d5e6f7g8h9i0j)`);
+                        }
                     }
                 }
             }
-        }
-        // Check if we should ABORT (if any conflict is terminal)
-        const hasTerminalConflicts = conflicts.some(c => c.terminal);
-        if (hasTerminalConflicts) {
-            // Abort Strategy: Kill the saga.
-            if (logalot) {
-                console.warn(`${lc} ABORTING Sync Saga due to terminal conflicts: ${JSON.stringify(conflicts)}`);
-            }
-            // We reuse the ConflictData structure for terminal aborts?
-            // Or do we send an Ack with terminal conflicts?
-            // Original design had explicit Conflict Frame for Abort.
-            // Let's stick to that for purely terminal cases to be safe/explicit?
-            // Or Unified: Just send Ack with terminal=true conflicts. Sender sees them and aborts.
-            // Decision: Unified Ack for everything is cleaner protocol.
-            // But wait, the original code below creates a Conflict Stone.
-            // Let's preserve the explicit 'Conflict' frame for total aborts if that's easier,
-            // OR fully switch to Ack.
-            // Protocol states: Init -> Ack. If Ack contains terminal errors, Sender can Commit(Fail).
-            // Let's use Ack with conflicts.
-        }
-        // 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: 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);
-            }
-        }
-        // 3. Build Knowledge Vector (Full History for known timelines)
-        // [NEW] Smart Diff
-        // We iterate over all relevant addresses (deltas we are requesting OR push offers we might have newer versions of).
-        // Since we are "reacting" to Init, we primarily want to tell the Sender what we DO have for the things they talked about.
-        const knowledgeVector = {};
-        const relevantAddrs = new Set([...pushOfferAddrs, ...deltaReqAddrs]);
-        // [Smart Diff] Populate knowledge from timelines identified by Sender
-        for (const tjp of remoteTjps) {
-            const localAddr = localKV[tjp];
-            if (localAddr) {
-                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 
-                    if (!knowledgeVector[realTjp]) {
-                        const past = ibGib.rel8ns?.past || [];
-                        knowledgeVector[realTjp] = [getIbGibAddr({ ibGib }), ...past];
+            // Check if we should ABORT (if any conflict is terminal)
+            const hasTerminalConflicts = conflicts.some(c => c.terminal);
+            if (hasTerminalConflicts) {
+                // Abort Strategy: Kill the saga.
+                if (logalot) {
+                    console.warn(`${lc} ABORTING Sync Saga due to terminal conflicts: ${JSON.stringify(conflicts)}`);
+                }
+                throw new Error(`the saga has terminal conflicts. conflicts: ${JSON.stringify(conflicts)} (E: f2edbe93cc07a63b38bfc013d2213b26)`);
+            }
+            // 3. Build Knowledge Vector (Full History for known timelines)
+            // [NEW] Smart Diff
+            // We iterate over all relevant addresses (deltas we are requesting OR push offers we might have newer versions of).
+            // Since we are "reacting" to Init, we primarily want to tell the Sender what we DO have for the things they talked about.
+            /**
+             * we will put this in {@link SyncSagaMessageAckData_V1.knowledgeVector}
+             */
+            const knowledgeVector = {};
+            // [Smart Diff] Populate knowledge from timelines identified by Sender
+            for (const tjp of remoteTjps) {
+                const localAddr = localKV[tjp];
+                if (localAddr) {
+                    const res = await getFromSpace({ addr: localAddr, space: mySpace });
+                    if (res.success && res.ibGibs?.[0]) {
+                        const ibGib = res.ibGibs[0];
+                        const realTjp = ibGib.rel8ns?.tjp?.[0] || getIbGibAddr({ ibGib }); // Should match `tjp` if normalized 
+                        if (!knowledgeVector[realTjp]) {
+                            const past = ibGib.rel8ns?.past || [];
+                            knowledgeVector[realTjp] = [getIbGibAddr({ ibGib }), ...past];
+                        }
                     }
                 }
             }
-        }
-        // [Smart Diff] Also check individual requested addresses (Fall back for constants/unknown TJPs)
-        for (const addr of relevantAddrs) {
-            // Only process if not already covered by TJP logic above
-            // 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: destSpace });
-            if (res.success && res.ibGibs?.[0]) {
-                const ibGib = res.ibGibs[0];
-                const tjpAddr = ibGib.rel8ns?.tjp?.[0] || getIbGibAddr({ ibGib });
-                if (!knowledgeVector[tjpAddr]) {
-                    const past = ibGib.rel8ns?.past || [];
-                    knowledgeVector[tjpAddr] = [getIbGibAddr({ ibGib }), ...past];
-                }
+            // Also populate from `knowledgeVector` in Init if we want bidirectional? 
+            // No, `Init` doesn't have `knowledgeVector` in `SyncSagaMessageInitData` yet (it has `SyncInitData` generic props).
+            // Let's assume standard flow:
+            // 1. Sender says "I have X"
+            // 2. Receiver says "I don't have X. But if I did have Y (ancestor), I'd tell you." 
+            // Problem: Receiver doesn't know X is related to Y without X.
+            // SOLUTION:
+            // The *Sender* must include TJP mappings or we rely on `knowledgeVector` in `Init`?
+            // `SyncSagaMessageInitData_V1` extends `SyncInitData`.
+            // `SyncInitData` has `knowledgeVector`.
+            // If Sender populates `knowledgeVector` in `Init`, Receiver can use keys (TJPs) to look up its own state!
+            // Let's implement Sender populating `Init.knowledgeVector`.
+            // But `SyncSagaCoordinator.startSaga` creates Init.
+            // 3. Create Ack Frame
+            const sagaId = sagaIbGib.data.uuid;
+            // Create Payload Stone
+            const ackData = {
+                sagaId,
+                stage: SyncStage.ack,
+                deltaReqAddrs,
+                pushOfferAddrs,
+                knowledgeVector,
+            };
+            if (conflicts?.length > 0) {
+                ackData.conflicts = conflicts;
             }
-            else {
-                // We don't have `addr`.
+            const ackStone = await this.createSyncMsgStone({
+                data: ackData,
+                localSpace: myTempSpace,
+                metaspace,
+            });
+            if (logalot) {
+                console.log(`${lc} ackStone created: ${pretty(ackStone)} (I: 313708132dd53ff946befb7833657826)`);
             }
+            // Evolve Saga
+            const ackFrame = await this.evolveSyncSagaIbGib({
+                prevSagaIbGib: sagaIbGib,
+                msgStones: [ackStone],
+                sessionIdentity: identity,
+                localSpace: mySpace,
+                metaspace,
+            });
+            // if (logalot) { console.log(`${lc} ackFrame created: ${pretty(ackFrame)} (I: be24480592eec478086bb3da49286826)`); }
+            /**
+             * we want to push ibgibs to the remote/sender if we have push
+             * offers. an ack frame's payloads, if any, are those push offers
+             */
+            // let payloadIbGibsDomain: IbGib_V1[] | undefined = await getPushOffers
+            if (pushOfferAddrs.length > 0) {
+            }
+            return {
+                frame: ackFrame,
+                // conflictInfos,
+                // payloadIbGibsDomain,
+            };
         }
-        // Also populate from `knowledgeVector` in Init if we want bidirectional? 
-        // No, `Init` doesn't have `knowledgeVector` in `SyncSagaMessageInitData` yet (it has `SyncInitData` generic props).
-        // Let's assume standard flow:
-        // 1. Sender says "I have X"
-        // 2. Receiver says "I don't have X. But if I did have Y (ancestor), I'd tell you." 
-        // Problem: Receiver doesn't know X is related to Y without X.
-        // SOLUTION:
-        // The *Sender* must include TJP mappings or we rely on `knowledgeVector` in `Init`?
-        // `SyncSagaMessageInitData_V1` extends `SyncInitData`.
-        // `SyncInitData` has `knowledgeVector`.
-        // If Sender populates `knowledgeVector` in `Init`, Receiver can use keys (TJPs) to look up its own state!
-        // Let's implement Sender populating `Init.knowledgeVector`.
-        // But `SyncSagaCoordinator.startSaga` creates Init.
-        // 3. Create Ack Frame
-        const sagaId = sagaIbGib.data.uuid;
-        // Create Payload Stone
-        const ackData = {
-            sagaId,
-            stage: SyncStage.ack,
-            deltaReqAddrs,
-            pushOfferAddrs,
-            knowledgeVector,
-            conflicts: conflicts.length > 0 ? conflicts : undefined, // Include conflicts if any detected
-        };
-        const ackStone = await this.createSyncMsgStone({
-            data: ackData,
-            space: tempSpace,
-            metaspace,
-        });
-        if (logalot) {
-            console.log(`${lc} ackStone created: ${pretty(ackStone)} (I: 313708132dd53ff946befb7833657826)`);
+        catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        }
+        finally {
+            if (logalot) {
+                console.log(`${lc} complete.`);
+            }
         }
-        // Evolve Saga
-        const ackFrame = await this.evolveSyncSagaIbGib({
-            prevSagaIbGib: sagaIbGib,
-            msgStones: [ackStone],
-            identity,
-            space: tempSpace,
-            metaspace,
-        });
-        // 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 };
     }
     /**
      * Handles the `Ack` frame.
@@ -858,7 +963,7 @@ export class SyncSagaCoordinator {
             if (logalot) {
                 console.log(`${lc} starting... (I: 605b6860e898267a5b50c6d85704be26)`);
             }
-            const { messageData, } = await this.getStageAndPayloadFromFrame({ ibGib: sagaIbGib, space: tempSpace });
+            const { messageData, } = await this.getStageAndPayloadFromFrame({ sagaFrame: sagaIbGib, space: tempSpace });
             const ackData = messageData;
             if (!ackData) {
                 throw new Error(`${lc} ackData falsy (E: 3b8415edc876084c88a25b98e2d55826)`);
@@ -938,50 +1043,7 @@ export class SyncSagaCoordinator {
                         // 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?
+                            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
@@ -1138,22 +1200,26 @@ export class SyncSagaCoordinator {
             }
             const deltaStone = await this.createSyncMsgStone({
                 data: deltaData,
-                space: tempSpace,
+                localSpace: tempSpace,
                 metaspace,
             });
             const deltaFrame = await this.evolveSyncSagaIbGib({
                 prevSagaIbGib: sagaIbGib,
                 msgStones: [deltaStone],
-                identity,
-                space: tempSpace,
+                sessionIdentity: identity,
+                localSpace: 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)}`);
             }
-            return { frame: deltaFrame, payloadIbGibs };
+            // Build control payloads: frame + its dependencies (msg stone, identity)
+            const payloadIbGibsControl = [deltaFrame, deltaStone];
+            if (identity) {
+                payloadIbGibsControl.push(identity);
+            }
+            // return { frame: deltaFrame, payloadIbGibsControl, payloadIbGibsDomain: payloadIbGibs };
+            return { frame: deltaFrame, payloadIbGibsDomain: payloadIbGibs };
         }
         catch (error) {
             console.error(`${lc} ${extractErrorMsg(error)}`);
@@ -1180,7 +1246,7 @@ export class SyncSagaCoordinator {
         if (logalot) {
             console.log(`${lc} starting...`);
         }
-        const { messageData } = await this.getStageAndPayloadFromFrame({ ibGib: sagaIbGib, space: tempSpace });
+        const { messageData } = await this.getStageAndPayloadFromFrame({ sagaFrame: sagaIbGib, space: tempSpace });
         const deltaData = messageData;
         if (!deltaData) {
             throw new Error(`${lc} deltaData falsy (E: 7c28c8d8f08a4421b8344e6727271421)`);
@@ -1366,19 +1432,23 @@ export class SyncSagaCoordinator {
             responseDeltaData.proposeCommit = true;
             const deltaStone = await this.createSyncMsgStone({
                 data: responseDeltaData,
-                space: tempSpace,
+                localSpace: tempSpace,
                 metaspace
             });
             const deltaFrame = await this.evolveSyncSagaIbGib({
                 prevSagaIbGib: sagaIbGib,
                 msgStones: [deltaStone],
-                identity,
-                space: tempSpace,
+                sessionIdentity: identity,
+                localSpace: tempSpace,
                 metaspace
             });
-            // IMMEDIATELY persist to both spaces for audit trail
-            await this.ensureSagaFrameInBothSpaces({ frame: deltaFrame, destSpace, tempSpace, metaspace });
-            return { frame: deltaFrame, payloadIbGibs: outgoingPayload, receivedPayloadIbGibs };
+            // Build control payloads: frame + its dependencies (msg stone, identity)
+            const payloadIbGibsControl = [deltaFrame, deltaStone];
+            if (identity) {
+                payloadIbGibsControl.push(identity);
+            }
+            // return { frame: deltaFrame, payloadIbGibsControl, payloadIbGibsDomain: outgoingPayload };
+            return { frame: deltaFrame, payloadIbGibsDomain: outgoingPayload };
         }
         else {
             // We have nothing to send.
@@ -1391,19 +1461,23 @@ export class SyncSagaCoordinator {
                 };
                 const commitStone = await this.createSyncMsgStone({
                     data: commitData,
-                    space: tempSpace,
+                    localSpace: tempSpace,
                     metaspace
                 });
                 const commitFrame = await this.evolveSyncSagaIbGib({
                     prevSagaIbGib: sagaIbGib,
                     msgStones: [commitStone],
-                    identity,
-                    space: tempSpace,
+                    sessionIdentity: identity,
+                    localSpace: tempSpace,
                     metaspace
                 });
-                // IMMEDIATELY persist to both spaces for audit trail
-                await this.ensureSagaFrameInBothSpaces({ frame: commitFrame, destSpace, tempSpace, metaspace });
-                return { frame: commitFrame, receivedPayloadIbGibs };
+                // Build control payloads for commit
+                const commitCtrlPayloads = [commitFrame, commitStone];
+                if (identity) {
+                    commitCtrlPayloads.push(identity);
+                }
+                // return { frame: commitFrame, payloadIbGibsControl: commitCtrlPayloads };
+                return { frame: commitFrame, };
             }
             else {
                 // peer did NOT propose commit (maybe they just sent data/requests and didn't ready flag).
@@ -1417,18 +1491,16 @@ export class SyncSagaCoordinator {
                 };
                 const deltaStone = await this.createSyncMsgStone({
                     data: responseDeltaData,
-                    space: tempSpace,
+                    localSpace: tempSpace,
                     metaspace
                 });
                 const deltaFrame = await this.evolveSyncSagaIbGib({
                     prevSagaIbGib: sagaIbGib,
                     msgStones: [deltaStone],
-                    identity,
-                    space: tempSpace,
+                    sessionIdentity: identity,
+                    localSpace: 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) {
@@ -1443,21 +1515,31 @@ export class SyncSagaCoordinator {
                     };
                     const commitStone = await this.createSyncMsgStone({
                         data: commitData,
-                        space: tempSpace,
+                        localSpace: tempSpace,
                         metaspace
                     });
                     const commitFrame = await this.evolveSyncSagaIbGib({
                         prevSagaIbGib: deltaFrame, // Build on top of the Delta we just created/persisted
                         msgStones: [commitStone],
-                        identity,
-                        space: tempSpace,
+                        sessionIdentity: identity,
+                        localSpace: tempSpace,
                         metaspace
                     });
-                    // IMMEDIATELY persist to both spaces for audit trail
-                    await this.ensureSagaFrameInBothSpaces({ frame: commitFrame, destSpace, tempSpace, metaspace });
-                    return { frame: commitFrame, receivedPayloadIbGibs };
+                    // Build control payloads for commit
+                    const commitCtrlPayloads2 = [commitFrame, commitStone];
+                    if (identity) {
+                        commitCtrlPayloads2.push(identity);
+                    }
+                    // return { frame: commitFrame, payloadIbGibsControl: commitCtrlPayloads2 };
+                    return { frame: commitFrame, };
+                }
+                // Build control payloads for delta propose
+                const deltaCtrlPayloads = [deltaFrame, deltaStone];
+                if (identity) {
+                    deltaCtrlPayloads.push(identity);
                 }
-                return { frame: deltaFrame, receivedPayloadIbGibs };
+                // return { frame: deltaFrame, payloadIbGibsControl: deltaCtrlPayloads };
+                return { frame: deltaFrame, };
             }
         }
     }
@@ -1480,7 +1562,7 @@ export class SyncSagaCoordinator {
         return null;
     }
     // #endregion Handlers
-    async createSyncMsgStone({ data, space, metaspace, }) {
+    async createSyncMsgStone({ data, localSpace, metaspace, }) {
         const lc = `${this.lc}[${this.createSyncMsgStone.name}]`;
         try {
             if (logalot) {
@@ -1496,7 +1578,7 @@ export class SyncSagaCoordinator {
             if (logalot) {
                 console.log(`${lc} Created stone: ${getIbGibAddr({ ibGib: stone })}`);
             }
-            await putInSpace({ space, ibGib: stone });
+            await metaspace.put({ ibGib: stone, space: localSpace });
             await metaspace.registerNewIbGib({ ibGib: stone });
             return stone;
         }
@@ -1510,41 +1592,10 @@ 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.
-     */
-    async ensureSagaFrameInBothSpaces({ frame, destSpace, tempSpace, metaspace, }) {
-        // 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.
      */
-    async evolveSyncSagaIbGib({ prevSagaIbGib, msgStones, identity, space, metaspace, conflictStrategy, }) {
+    async evolveSyncSagaIbGib({ prevSagaIbGib, conflictStrategy, msgStones, sessionIdentity, localSpace, metaspace, }) {
         const lc = `${this.lc}[${this.evolveSyncSagaIbGib.name}]`;
         try {
             // Validation
@@ -1567,7 +1618,7 @@ export class SyncSagaCoordinator {
                     throw new Error(`${lc} Mismatched stage in stones. Expected ${stage}, got ${d.stage} (E: d12c6571b0882f762921b60880c3f826)`);
                 }
             }
-            const identityAddr = identity ? getIbGibAddr({ ibGib: identity }) : undefined;
+            const identityAddr = sessionIdentity ? getIbGibAddr({ ibGib: sessionIdentity }) : undefined;
             if (prevSagaIbGib) {
                 /**
                  * rel8ns always include the new msg stone(s)
@@ -1579,8 +1630,8 @@ export class SyncSagaCoordinator {
                     }
                 ];
                 // if we're authenticating/signing, we'll have identity
-                if (identity) {
-                    rel8nInfos.push({ rel8nName: 'identity', ibGibs: [identity], });
+                if (sessionIdentity) {
+                    rel8nInfos.push({ rel8nName: 'identity', ibGibs: [sessionIdentity], });
                 }
                 // remove the existing sync msg stones' addrs 
                 if (!prevSagaIbGib.rel8ns) {
@@ -1601,7 +1652,7 @@ export class SyncSagaCoordinator {
                     rel8nInfos,
                     rel8nRemovalInfos,
                     metaspace,
-                    space,
+                    space: localSpace,
                     noDna: true, // Explicitly no DNA for sync frames
                 });
                 const newFrame = resAppend;
@@ -1609,31 +1660,36 @@ export class SyncSagaCoordinator {
             }
             else {
                 // Create New Timeline (Root Frame)
+                // data
                 const data = {
                     uuid: sagaId,
-                    // stage, // Removed from V1
-                    payload: undefined, // Data in stone
                     n: 0,
                     isTjp: true,
                     conflictStrategy,
                 };
+                // ib
                 const ib = await getSyncIb({ data });
+                // rel8ns
                 const stoneAddrs = msgStones.map(s => getIbGibAddr({ ibGib: s }));
-                const rel8ns = {
-                    [SYNC_MSG_REL8N_NAME]: stoneAddrs,
-                };
+                const rel8ns = { [SYNC_MSG_REL8N_NAME]: stoneAddrs, };
                 if (identityAddr) {
                     rel8ns.identity = [identityAddr];
                 }
                 const resNew = await createTimeline({
-                    space,
+                    space: localSpace,
                     metaspace,
                     ib,
                     data,
                     rel8ns,
                     parentIb: SYNC_ATOM, // "sync"
+                    /**
+                     * this will squash the result into a single frame
+                     */
                     noDna: true,
                 });
+                if (!!resNew.intermediateIbGibs) {
+                    throw new Error(`(UNEXPECTED) resNew.intermediateIbGibs? we were assuming we were creating a single frame. (E: 456818147235d991ccb4d10d0bbe4826)`);
+                }
                 return resNew.newIbGib;
             }
         }
@@ -1642,16 +1698,16 @@ export class SyncSagaCoordinator {
             throw error;
         }
     }
-    async getStageAndPayloadFromFrame({ ibGib, space }) {
+    async getStageAndPayloadFromFrame({ sagaFrame, space }) {
         const lc = `${this.lc}[${this.getStageAndPayloadFromFrame.name}]`;
         try {
             if (logalot) {
                 console.log(`${lc} starting... (I: fddc287bd4d55253dc50e519fd352226)`);
             }
-            if (!ibGib.rel8ns) {
-                throw new Error(`(UNEXPECTED) ibGib.rel8ns falsy? (E: 725bc8eb5dfe5c7058907ad8e3063826)`);
+            if (!sagaFrame.rel8ns) {
+                throw new Error(`(UNEXPECTED) sagaFrame.rel8ns falsy? (E: 725bc8eb5dfe5c7058907ad8e3063826)`);
             }
-            const stoneAddrs = ibGib.rel8ns?.[SYNC_MSG_REL8N_NAME];
+            const stoneAddrs = sagaFrame.rel8ns?.[SYNC_MSG_REL8N_NAME];
             if (stoneAddrs && stoneAddrs.length > 0) {
                 const stoneAddr = stoneAddrs[0];
                 const res = await getFromSpace({ addr: stoneAddr, space });
@@ -1670,7 +1726,7 @@ export class SyncSagaCoordinator {
                 }
             }
             else {
-                throw new Error(`(UNEXPECTED) no stone addrs rel8d to sync saga ibgib frame? ibGib addr: ${getIbGibAddr(ibGib)} (E: 43eae8579e289d016741b5526052f226)`);
+                throw new Error(`(UNEXPECTED) no stone addrs rel8d to sync saga ibgib frame? sagaFrame addr: ${getIbGibAddr(sagaFrame)} (E: 43eae8579e289d016741b5526052f226)`);
             }
         }
         catch (error) {