@ibgib/core-gib 0.1.22 → 0.1.23

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

@@ -6,12 +6,12 @@ import {
     pretty,
     clone,
     unique,
+    delay,
 } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
 import { getIbGibAddr } from "@ibgib/ts-gib/dist/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";
+import { IbGib_V1, } from "@ibgib/ts-gib/dist/V1/types.mjs";
+import { IbGibAddr } from "@ibgib/ts-gib/dist/types.mjs";
 
 import { GLOBAL_LOG_A_LOT } from "../core-constants.mjs";
 import { IbGibSpaceAny } from "../witness/space/space-base-v1.mjs";
@@ -20,35 +20,35 @@ 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, SYNC_SAGA_PAYLOAD_ADDRS_DOMAIN } from "./sync-constants.mjs";
-import { appendToTimeline, createTimeline, Rel8nInfo, Rel8nRemovalInfo } from "../timeline/timeline-api.mjs";
+import { appendToTimeline, createTimeline, getHistory, Rel8nInfo, Rel8nRemovalInfo } from "../timeline/timeline-api.mjs";
 import {
-    SyncData_V1, SyncIbGib_V1, SyncInitData, SyncConflictStrategy,
-    SyncMode,
-    SyncOptions,
+    SyncData_V1, SyncIbGib_V1, SyncConflictStrategy, SyncMode, SyncOptions,
+    SyncRel8ns_V1, DomainIbGibAnalysisInfo, HandleSagaFrameResult,
 } from "./sync-types.mjs";
-import { getSyncIb, isPastFrame } from "./sync-helpers.mjs";
-import { getSyncSagaDependencyGraph as getSyncSagaDependencyGraphForThisFrameOnly } from "./sync-helpers.mjs";
-import { getDependencyGraph } from "../common/other/graph-helper.mjs";
+import { getSyncIb, getTempSpaceName, isPastFrame } from "./sync-helpers.mjs";
+import { getDependencyGraph, toFlatGraph } from "../common/other/graph-helper.mjs";
 import {
     SyncSagaMessageData_V1, SyncSagaMessageInitData_V1,
     SyncSagaMessageAckData_V1, SyncSagaMessageDeltaData_V1,
-    SyncSagaMessageCommitData_V1
+    SyncSagaMessageCommitData_V1, SyncSagaConflictInfo,
 } 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 { splitPerTjpAndOrDna, getTimelinesGroupedByTjp, isIbGib } from "../common/other/ibgib-helper.mjs";
 import { SyncPeerWitness } from "./sync-peer/sync-peer-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 { 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";
+import {
+    IbGibSpaceResultData, IbGibSpaceResultIbGib, IbGibSpaceResultRel8ns
+} from "../witness/space/space-types.mjs";
+import { FlatIbGibGraph } from "../common/other/graph-types.mjs";
 
 
 // const logalot = GLOBAL_LOG_A_LOT || true;
@@ -56,16 +56,6 @@ 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).
  * 
@@ -103,18 +93,16 @@ export class SyncSagaCoordinator {
      */
     async sync({
         peer,
-        localSpace: _localSpace,
-        source: _source,
-        metaspace,
         domainIbGibs,
-        conflictStrategy = 'abort',
+        conflictStrategy = SyncConflictStrategy.abort,
         useSessionIdentity = true,
+        metaspace,
+        localSpace,
     }: SyncOptions): Promise<SyncSagaInfo> {
         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)`); }
+        if (!localSpace) { throw new Error(`${lc} source (or localSpace) required (E: 25df3761f7686a1099a552f83c95d326)`); }
 
         // 1. SETUP SAGA METADATA
         const sagaId = await getUUID();
@@ -130,11 +118,6 @@ export class SyncSagaCoordinator {
             rejectDone = reject;
         });
 
-        async function getTempSpaceName(): Promise<string> {
-            const uuid = await getUUID();
-            return `tmp_sync_space_${uuid.substring(0, 8)}`;
-        }
-
         // WORKING CONTEXT (Transactional)
         const tempSpaceName = await getTempSpaceName();
         const tempSpace = await metaspace.createNewLocalSpace({
@@ -164,40 +147,25 @@ export class SyncSagaCoordinator {
                 // 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)
-                // 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,
-                    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)`); }
@@ -263,17 +231,17 @@ 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`.
      */
     protected async executeSagaLoop({
         initialFrame,
-        srcGraph,
+        initialDomainGraph,
         peer,
         sessionIdentity,
         updates$,
@@ -282,131 +250,103 @@ export class SyncSagaCoordinator {
         metaspace
     }: {
         initialFrame: SyncIbGib_V1,
-        srcGraph: { [addr: string]: IbGib_V1 },
+        initialDomainGraph: FlatIbGibGraph,
         peer: SyncPeerWitness,
         sessionIdentity?: KeystoneIbGib_V1,
         updates$: SubjectWitness<SyncSagaContextIbGib_V1>,
+        metaspace: MetaspaceService
         localSpace: IbGibSpaceAny,
         tempSpace: IbGibSpaceAny,
-        metaspace: MetaspaceService
-    }): Promise<IbGib_V1[]> {
+    }): Promise<void> {
         const lc = `${this.lc}[${this.executeSagaLoop.name}]`;
 
         // 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 nextDomainIbGibs: IbGib_V1[] = [];
-        // Accumulator for all data we've successfully pulled from the remote
-        const allReceivedIbGibs: IbGib_V1[] = [];
+
+        // 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)
-            // 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[] = [];
+            const nextDomainIbGibsAndDeps: IbGib_V1[] = [];
 
             // A. Payload (Standard Deep Deps)
+            // 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 (nextDomainIbGibGraph) {
-                    payloadIbGibsDomain.push(...Object.values(nextDomainIbGibGraph));
+                    nextDomainIbGibsAndDeps.push(...Object.values(nextDomainIbGibGraph));
                 } else {
                     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} payloadIbGibsDomain count: ${payloadIbGibsDomain.length} (I: 2beda8ca7dc5ac0f48ed9e25e704b826)`); }
-
-            // B. Frames (Shallow Sync Deps)
-            if (currentFrame) {
-                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)`);
-                }
-            }
+            if (logalot) { console.log(`${lc} payloadIbGibsDomain count: ${nextDomainIbGibsAndDeps.length} (I: 2beda8ca7dc5ac0f48ed9e25e704b826)`); }
 
             // 2. Create Context (Envelope)
+            // set up subscription for response's payload ibgibs (if any)
             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 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();
+                },
+            }));
+
+            // Create the Request Context...
             const requestCtx = await createSyncSagaContext({
                 sagaFrame: currentFrame,
                 sessionKeystones: sessionIdentity ? [sessionIdentity] : undefined,
-                payloadIbGibsDomain,
+
+                /**
+                 * init frame: empty
+                 * 
+                 */
+                payloadIbGibsDomain: nextDomainIbGibsAndDeps,
+                localSpace,
             });
 
             // Log what we're sending
             if (logalotControlDomain) {
-                const controlAddrs = payloadIbGibsControl.map(p => getIbGibAddr({ ibGib: p }));
-                const domainAddrs = payloadIbGibsDomain.map(p => getIbGibAddr({ ibGib: p }));
+                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}   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) {
-                payloadIbGibsControl.push(sessionIdentity);
-            }
-
-            // 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
+            // update our saga listeners...
             // if (logalot) { console.log(`${lc} transmitting... requestCtx: ${pretty(requestCtx)} (I: 8cf20817c66899abdb1e76df50356826)`); }
-            updates$.next(requestCtx); // spins off (don't remove this comment!)
+            updates$.next(requestCtx); // spins off 
 
+            // ...And send the context
             const responseCtx = await peer.witness(requestCtx);
 
             // C. Handle Response
@@ -429,55 +369,51 @@ export class SyncSagaCoordinator {
             // ---------------------------------------------------------------------
             // 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] as string[] || [];
 
-            // 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.
-
             // Poll for them if needed
             if (responsePayloadAddrsDomain.length > 0) {
-                await this.pollForDomainPayloads({
+                responseCtx.payloadIbGibsDomain = await this.pollForDomainPayloads({
                     expectedAddrs: responsePayloadAddrsDomain,
+                    pollIntervalMs: 20, // relatively arbitrary right now
                     domainPayloadsMap,
                     tempSpace,
                 });
             }
 
-            // Extract Response Frame
-            const responseFrameAddr = responseCtx.rel8ns?.sagaFrame?.[0];
-            if (!responseFrameAddr) { throw new Error(`${lc} Peer response missing sagaFrame (E: 83a0)`); }
+            // 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'] 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}   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)'}`);
             }
 
-            // 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,
+            // interface HandleSagaFrameResult {
+            //     frame: SyncIbGib_V1;
+            //     payloadIbGibsDomain?: IbGib_V1[];
+            //     conflictInfos?: SyncSagaConflictInfo;
+            // }
+            const handleResult = await this.handleSagaContext({
+                sagaContext: responseCtx,
+                mySpace: localSpace,
+                myTempSpace: tempSpace,
                 metaspace,
-                domainPayloadsMap,
-                expectedDomainAddrs: responsePayloadAddrsDomain,
             });
 
             if (!handleResult) {
@@ -488,23 +424,16 @@ export class SyncSagaCoordinator {
             currentFrame = handleResult.frame;
 
             // 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;
     }
 
     /**
@@ -584,42 +513,41 @@ export class SyncSagaCoordinator {
         }
     }
 
-    protected async analyzeTimelines({
+    protected async analyzeDomainIbGibs({
         domainIbGibs,
         space,
     }: {
         domainIbGibs: IbGib_V1[],
         space: IbGibSpaceAny,
-    }): Promise<{
-        srcStones: IbGib_V1[],
-        srcTimelinesMap: { [tjp: string]: IbGib_V1[] },
-        srcSortedTjps: string[],
-        srcGraph: { [addr: string]: IbGib_V1 },
-    }> {
-        const lc = `${this.lc}[${this.analyzeTimelines.name}]`;
-        const srcGraph = await getDependencyGraph({
+    }): Promise<DomainIbGibAnalysisInfo> {
+        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;
-        if (logalot) { console.log(`${lc} graph generated. nodes: ${srcGraphIsValid ? Object.keys(srcGraph).length : 0}`); }
+        const graphIsValid = fullGraph && Object.keys(fullGraph).length > 0;
+        if (logalot) { 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 stones = Object.values(src_MapWithoutTjps);
+        const withTimelines = [...Object.values(srcMapWithTjp_YesDna), ...Object.values(srcMapWithTjp_NoDna)];
 
-        const srcTimelinesMap = getTimelinesGroupedByTjp({ ibGibs: srcLiving });
-        const srcSortedTjps = this.sortTimelinesTopologically(srcTimelinesMap);
+        const timelinesMap = getTimelinesGroupedByTjp({ ibGibs: withTimelines });
+        const topologicallySortedTjpAddrs = this.sortTimelinesTopologically(timelinesMap);
 
-        return { srcStones, srcTimelinesMap, srcSortedTjps, srcGraph };
+        return { stones, timelinesMap, topologicallySortedTjpAddrs, fullGraph };
     }
 
     /**
@@ -634,78 +562,72 @@ export class SyncSagaCoordinator {
     protected async createInitFrame({
         sagaId,
         sessionIdentity,
-        localSpace,
         domainIbGibs,
-        tempSpace,
-        metaspace,
         conflictStrategy,
+        metaspace,
+        localSpace,
+        tempSpace,
     }: {
         sagaId: string,
         sessionIdentity?: KeystoneIbGib_V1,
-        localSpace: IbGibSpaceAny,
         domainIbGibs: IbGib_V1[],
-        tempSpace: IbGibSpaceAny,
-        metaspace: MetaspaceService,
         conflictStrategy: SyncConflictStrategy,
-    }): Promise<{ sagaFrame: SyncIbGib_V1, srcGraph: { [addr: string]: IbGib_V1 } }> {
+        metaspace: MetaspaceService,
+        localSpace: IbGibSpaceAny,
+        tempSpace: IbGibSpaceAny,
+    }): Promise<{ sagaFrame: SyncIbGib_V1, initialDomainGraph: { [addr: string]: IbGib_V1 } }> {
         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: { [tjp: string]: IbGibAddr } = {};
+            Object.keys(srcTimelinesMap).forEach(tjp => {
+                const timeline = srcTimelinesMap[tjp];
+                const tip = timeline.at(-1)!;
+                knowledgeVector[tjp] = getIbGibAddr({ ibGib: tip });
+            });
             const initData: SyncSagaMessageInitData_V1 = {
                 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)}`);
             throw error;
@@ -717,20 +639,26 @@ export class SyncSagaCoordinator {
     /**
      * Helper to poll for streaming domain payloads and put them in the
      * local {@link tempSpace}.
+     * 
+     * @returns when all {@link expectedAddrs} are done being transmitted.
      */
     protected async pollForDomainPayloads({
         expectedAddrs,
+        pollIntervalMs,
         domainPayloadsMap,
         tempSpace,
     }: {
         expectedAddrs: string[],
+        pollIntervalMs: number,
         domainPayloadsMap: Map<string, IbGib_V1>,
         tempSpace: IbGibSpaceAny,
-    }): Promise<void> {
+    }): Promise<IbGib_V1[]> {
         const lc = `${this.lc}[${this.pollForDomainPayloads.name}]`;
         try {
             if (logalot) { console.log(`${lc} starting... (I: 26dce86bfca572939885798802d6e926)`); }
 
+            let resultDomainPayloads: IbGib_V1[] = [];
+
             let pending = [...expectedAddrs];
             const start = Date.now();
             /**
@@ -757,14 +685,19 @@ export class SyncSagaCoordinator {
 
                 if (found.length > 0) {
                     await putInSpace({ space: tempSpace, ibGibs: found });
+                    found.forEach(x => resultDomainPayloads.push(x));
                 }
 
                 pending = stillPending;
 
-                if (pending.length > 0) {
-                    await new Promise(resolve => setTimeout(resolve, 50));
-                }
+                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;
@@ -773,49 +706,85 @@ export class SyncSagaCoordinator {
         }
     }
 
-    async handleSagaFrame({
-        sagaIbGib,
-        srcGraph,
-        destSpace,
-        tempSpace,
+    /**
+     * 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
+     * 
+     * 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.
+     * 
+     * This is a one-off on the receiver.
+     */
+    public async handleSagaContext({
+        sagaContext,
+        mySpace,
+        myTempSpace,
         identity,
         identitySecret,
         metaspace,
     }: {
-        sagaIbGib: SyncIbGib_V1,
-        srcGraph: { [addr: string]: IbGib_V1 },
-        destSpace: IbGibSpaceAny,
-        tempSpace: IbGibSpaceAny,
+        sagaContext: SyncSagaContextIbGib_V1,
+        /**
+         * Local space relative to the execution context's POV
+         */
+        mySpace: IbGibSpaceAny,
+        /**
+         * Local temp space relative to the execution context's POV
+         */
+        myTempSpace: IbGibSpaceAny,
         identity?: KeystoneIbGib_V1,
         identitySecret?: string,
         metaspace: MetaspaceService,
-        domainPayloadsMap?: Map<string, IbGib_V1>,
-        expectedDomainAddrs?: string[],
     }): Promise<HandleSagaFrameResult | null> {
-        const lc = `${this.lc}[${this.handleSagaFrame.name}]`;
+        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)`); }
             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: 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 as SyncSagaMessageInitData_V1,
+                        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)`);
@@ -845,309 +814,297 @@ export class SyncSagaCoordinator {
     protected async handleInitFrame({
         sagaIbGib,
         messageData,
-        destSpace,
-        tempSpace,
+        mySpace,
+        myTempSpace,
         metaspace,
         identity,
-        identitySecret,
+        // identitySecret,
     }: {
         sagaIbGib: SyncIbGib_V1,
-        messageData: any,
-        destSpace: IbGibSpaceAny,
-        tempSpace: IbGibSpaceAny,
+        messageData: SyncSagaMessageInitData_V1,
+        /**
+         * Local space relative to the execution context's POV
+         */
+        mySpace: IbGibSpaceAny,
+        /**
+         * Local temp space relative to the execution context's POV.
+         * 
+         * NOTE: Since this always executes on the receiver's end, this should
+         * be the receiver's temp space.
+         */
+        myTempSpace: IbGibSpaceAny,
         metaspace: MetaspaceService,
         identity?: KeystoneIbGib_V1,
         identitySecret?: string,
     }): 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...`); }
+        try {
+            if (logalot) { console.log(`${lc} starting... (I: 9d88dcad0408c029e898a4bcf3b08426)`); }
 
-        // Extract Init Data
-        const initData = messageData as SyncSagaMessageInitData_V1; // 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)`);
-        }
+            console.log(`${lc} [TEST DEBUG] Received destSpace: ${mySpace.data?.name || mySpace.ib} (uuid: ${mySpace.data?.uuid || '[no uuid]'})`);
+            if (logalot) { console.log(`${lc} starting...`); }
 
-        // Determine Strategy from Saga Data (since V1 stores it in root)
-        const conflictStrategy = sagaIbGib.data!.conflictStrategy || 'abort';
-
-        // 2. Gap Analysis
-        const conflicts: { tjpAddr: string, localAddr: string, remoteAddr: string, timelineAddrs: string[], reason: string, terminal: boolean }[] = [];
-
-        const deltaReqAddrs: string[] = [];
-        const pushOfferAddrs: string[] = [];
-
-        // Stones Analysis (Constants / Non-TJPs)
-        const stones = initData.stones || [];
-        if (stones.length > 0) {
-            if (logalot) { console.log(`${lc} processing stones: ${stones.length}`); }
-            // 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) {
-                if (logalot) { console.log(`${lc} stones missing (requesting): ${addrsNotFound.length}`); }
-                addrsNotFound.forEach(addr => {
-                    if (!deltaReqAddrs.includes(addr)) {
-                        deltaReqAddrs.push(addr);
-                    }
-                });
+            // Extract Init Data
+            const initData = messageData as SyncSagaMessageInitData_V1; // 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)`);
             }
-        }
-
-        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: { [tjp: string]: string | null } = {};
-        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)`); }
-            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. Request it.
-                console.log(`${lc} [TEST DEBUG] Missing local timeline for TJP: ${tjp}. Requesting remoteAddr: ${remoteAddr}`);
-                deltaReqAddrs.push(remoteAddr);
-                continue;
+            // Determine Strategy from Saga Data (since V1 stores it in root)
+            const conflictStrategy = sagaIbGib.data!.conflictStrategy || SyncConflictStrategy.abort;
+
+            // 2. Gap Analysis
+            const conflicts: SyncSagaConflictInfo[] = [];
+            const deltaReqAddrs: string[] = [];
+            const pushOfferAddrs: string[] = [];
+
+            // First do the consant stones (Non-TJPs)
+            const stones = initData.stones || [];
+            if (stones.length > 0) {
+                if (logalot) { 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 as IbGibSpaceResultIbGib<IbGib_V1, IbGibSpaceResultData, IbGibSpaceResultRel8ns>;
+                if (!rawResultIbGib.data) { throw new Error(`(UNEXPECTED) rawResultIbGib.data falsy? (E: f3c40b492adc02c3f480b998fc7a5926)`); }
+                const addrsNotFound = rawResultIbGib.data.addrsNotFound;
+                if (addrsNotFound && addrsNotFound.length > 0) {
+                    if (logalot) { console.log(`${lc} stones missing (requesting): ${addrsNotFound.length}`); }
+                    addrsNotFound.forEach(addr => {
+                        if (!deltaReqAddrs.includes(addr)) { deltaReqAddrs.push(addr); }
+                    });
+                }
             }
 
-            if (localAddr === remoteAddr) {
-                // Synced
-                console.log(`${lc} [TEST DEBUG] TJP ${tjp}: Synced (localAddr === remoteAddr)`);
-                continue;
+            /**
+             * "remote" local to receiver's context is the sender
+             */
+            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: { [tjp: string]: string | null } = {};
+            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 (!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)`); }
             }
-            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);
-            } else {
-                // Remote is not in our past. 
-                // Either Remote is ahead (Fast-Backward) OR Diverged.
+            // 2. Gap Analysis
+            for (const tjp of remoteTjps) {
+                const remoteAddr = remoteKV[tjp];
+                const localAddr = localKV[tjp];
 
-                // Check if Local is in Remote's PAST (Remote is Ahead -> Delta Request)
-                const isLocalInPast = await isPastFrame({
-                    olderAddr: localAddr,
-                    newerAddr: remoteAddr,
-                    space: destSpace,
+                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 (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);
+                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)}`); }
+            // Check if we should ABORT (if any conflict is terminal)
+            const hasTerminalConflicts = conflicts.some(c => c.terminal);
 
-            // 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.
+            if (hasTerminalConflicts) {
+                // Abort Strategy: Kill the saga.
+                if (logalot) { console.warn(`${lc} ABORTING Sync Saga due to terminal conflicts: ${JSON.stringify(conflicts)}`); }
 
-            // 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);
+                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.
-
-        const knowledgeVector: { [groupKey: string]: string[] } = {};
-        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];
+            // 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: { [groupKey: string]: string[] } = {};
+
+            // [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];
-                }
-            } else {
-                // We don't have `addr`.
-            }
-        }
+            // 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: SyncSagaMessageAckData_V1 = {
+                sagaId,
+                stage: SyncStage.ack,
+                deltaReqAddrs,
+                pushOfferAddrs,
+                knowledgeVector,
+            };
+            if (conflicts?.length > 0) { ackData.conflicts = conflicts; }
 
-        // 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: SyncSagaMessageAckData_V1 = {
-            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,
+                localSpace: myTempSpace,
+                metaspace,
+            });
+            if (logalot) { console.log(`${lc} ackStone created: ${pretty(ackStone)} (I: 313708132dd53ff946befb7833657826)`); }
 
-        const ackStone = await this.createSyncMsgStone({
-            data: ackData,
-            space: tempSpace,
-            metaspace,
-        });
-        if (logalot) { console.log(`${lc} ackStone created: ${pretty(ackStone)} (I: 313708132dd53ff946befb7833657826)`); }
-
-        // Evolve Saga
-        const ackFrame = await this.evolveSyncSagaIbGib({
-            prevSagaIbGib: sagaIbGib,
-            msgStones: [ackStone],
-            identity,
-            space: tempSpace,
-            metaspace,
-        });
+            // Evolve Saga
+            const ackFrame = await this.evolveSyncSagaIbGib({
+                prevSagaIbGib: sagaIbGib,
+                msgStones: [ackStone],
+                sessionIdentity: identity,
+                localSpace: mySpace,
+                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)`); }
 
-        // 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) {
+            }
 
-        // Build control payloads: frame + its dependencies (msg stone, identity)
-        const payloadIbGibsControl: IbGib_V1[] = [ackFrame, ackStone];
-        if (identity) { payloadIbGibsControl.push(identity); }
+            return {
+                frame: ackFrame,
+                // conflictInfos,
+                // payloadIbGibsDomain,
+            };
 
-        return { frame: ackFrame, payloadIbGibsControl };
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
     }
 
     /**
@@ -1181,7 +1138,7 @@ export class SyncSagaCoordinator {
         try {
             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 as SyncSagaMessageAckData_V1;
 
             if (!ackData) {
@@ -1444,28 +1401,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)}`); }
 
             // 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 };
+            // return { frame: deltaFrame, payloadIbGibsControl, payloadIbGibsDomain: payloadIbGibs };
+            return { frame: deltaFrame, payloadIbGibsDomain: payloadIbGibs };
         } catch (error) {
             console.error(`${lc} ${extractErrorMsg(error)}`);
             throw error;
@@ -1502,7 +1457,7 @@ export class SyncSagaCoordinator {
         const lc = `${this.lc}[${this.handleDeltaFrame.name}]`;
         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 as SyncSagaMessageDeltaData_V1;
 
         if (!deltaData) {
@@ -1708,26 +1663,24 @@ 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 });
-
             // 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 };
+            // return { frame: deltaFrame, payloadIbGibsControl, payloadIbGibsDomain: outgoingPayload };
+            return { frame: deltaFrame, payloadIbGibsDomain: outgoingPayload };
 
         } else {
             // We have nothing to send.
@@ -1742,26 +1695,24 @@ 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 });
-
                 // Build control payloads for commit
                 const commitCtrlPayloads: IbGib_V1[] = [commitFrame, commitStone];
                 if (identity) { commitCtrlPayloads.push(identity); }
 
-                return { frame: commitFrame, payloadIbGibsControl: commitCtrlPayloads };
+                // 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).
@@ -1776,21 +1727,18 @@ 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) { console.log(`${lc} Peer proposed commit. Accepting & Committing.`); }
@@ -1805,33 +1753,32 @@ 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 });
-
                     // Build control payloads for commit
                     const commitCtrlPayloads2: IbGib_V1[] = [commitFrame, commitStone];
                     if (identity) { commitCtrlPayloads2.push(identity); }
 
-                    return { frame: commitFrame, payloadIbGibsControl: commitCtrlPayloads2 };
+                    // return { frame: commitFrame, payloadIbGibsControl: commitCtrlPayloads2 };
+                    return { frame: commitFrame, };
                 }
 
                 // Build control payloads for delta propose
                 const deltaCtrlPayloads: IbGib_V1[] = [deltaFrame, deltaStone];
                 if (identity) { deltaCtrlPayloads.push(identity); }
 
-                return { frame: deltaFrame, payloadIbGibsControl: deltaCtrlPayloads };
+                // return { frame: deltaFrame, payloadIbGibsControl: deltaCtrlPayloads };
+                return { frame: deltaFrame, };
             }
         }
     }
@@ -1871,11 +1818,11 @@ export class SyncSagaCoordinator {
 
     protected async createSyncMsgStone<TStoneData extends SyncSagaMessageData_V1>({
         data,
-        space,
+        localSpace,
         metaspace,
     }: {
         data: TStoneData,
-        space: IbGibSpaceAny,
+        localSpace: IbGibSpaceAny,
         metaspace: MetaspaceService,
     }): Promise<IbGib_V1<TStoneData>> {
         const lc = `${this.lc}[${this.createSyncMsgStone.name}]`;
@@ -1890,7 +1837,7 @@ export class SyncSagaCoordinator {
                 uuid: true, // we want the stone to have its own uniqueness
             });
             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 as IbGib_V1<TStoneData>;
         } catch (error) {
@@ -1902,67 +1849,23 @@ 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.
      */
     protected async evolveSyncSagaIbGib({
         prevSagaIbGib,
+        conflictStrategy,
         msgStones,
-        identity,
-        space,
+        sessionIdentity,
+        localSpace,
         metaspace,
-        conflictStrategy,
     }: {
         prevSagaIbGib?: SyncIbGib_V1,
+        conflictStrategy?: SyncConflictStrategy,
         msgStones: IbGib_V1[],
-        identity?: KeystoneIbGib_V1,
-        space: IbGibSpaceAny,
+        localSpace: IbGibSpaceAny,
         metaspace: MetaspaceService,
-        conflictStrategy?: SyncConflictStrategy,
+        sessionIdentity?: KeystoneIbGib_V1,
     }): Promise<SyncIbGib_V1> {
         const lc = `${this.lc}[${this.evolveSyncSagaIbGib.name}]`;
         try {
@@ -1988,10 +1891,9 @@ export class SyncSagaCoordinator {
                 }
             }
 
-            const identityAddr = identity ? getIbGibAddr({ ibGib: identity }) : undefined;
+            const identityAddr = sessionIdentity ? getIbGibAddr({ ibGib: sessionIdentity }) : undefined;
 
             if (prevSagaIbGib) {
-
                 /**
                  * rel8ns always include the new msg stone(s)
                  */
@@ -2003,8 +1905,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 
@@ -2025,7 +1927,7 @@ export class SyncSagaCoordinator {
                     rel8nInfos,
                     rel8nRemovalInfos,
                     metaspace,
-                    space,
+                    space: localSpace,
                     noDna: true, // Explicitly no DNA for sync frames
                 });
 
@@ -2033,33 +1935,33 @@ export class SyncSagaCoordinator {
                 return newFrame;
             } else {
                 // Create New Timeline (Root Frame)
+                // data
                 const data: SyncData_V1 = {
                     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: IbGibRel8ns_V1 = {
-                    [SYNC_MSG_REL8N_NAME]: stoneAddrs,
-                };
-                if (identityAddr) {
-                    rel8ns.identity = [identityAddr];
-                }
+                const rel8ns: SyncRel8ns_V1 = { [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 as SyncIbGib_V1;
             }
@@ -2070,14 +1972,20 @@ export class SyncSagaCoordinator {
         }
     }
 
-    protected async getStageAndPayloadFromFrame({ ibGib, space }: { ibGib: IbGib_V1, space: IbGibSpaceAny }): Promise<{ stage: SyncStage, messageData: any }> {
+    protected async getStageAndPayloadFromFrame({
+        sagaFrame,
+        space
+    }: {
+        sagaFrame: IbGib_V1,
+        space: IbGibSpaceAny
+    }): Promise<{ stage: SyncStage, messageData: unknown }> {
         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 });
@@ -2090,7 +1998,7 @@ export class SyncSagaCoordinator {
                     throw new Error(`couldn't get stoneAddr (${stoneAddr}) from space (${space.ib}) (E: f3c826e756f8a5c358beb88aa4a65e26)`);
                 }
             } 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) {
             console.error(`${lc} ${extractErrorMsg(error)}`);