@ibgib/core-gib 0.1.21 → 0.1.23

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

@@ -4,13 +4,14 @@ import {
     getTimestamp, // so our timestamp strings are uniform
     getTimestampInTicks, // so our timestamp in ticks as a string are uniform
     pretty,
-    clone
+    clone,
+    unique,
+    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 { 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";
@@ -18,35 +19,42 @@ import { putInSpace, getLatestAddrs, getFromSpace } from "../witness/space/space
 import { KeystoneIbGib_V1 } from "../keystone/keystone-types.mjs";
 import { KeystoneService_V1 } from "../keystone/keystone-service-v1.mjs";
 import { MetaspaceService } from "../witness/space/metaspace/metaspace-types.mjs";
-import { SyncStage, SYNC_ATOM, SYNC_MSG_REL8N_NAME } from "./sync-constants.mjs";
-import { appendToTimeline, createTimeline, Rel8nInfo, Rel8nRemovalInfo } from "../timeline/timeline-api.mjs";
+import { SyncStage, SYNC_ATOM, SYNC_MSG_REL8N_NAME, SYNC_SAGA_PAYLOAD_ADDRS_DOMAIN } from "./sync-constants.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 } 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, SyncSagaContextCmd } from "./sync-saga-context/sync-saga-context-types.mjs";
+import { SyncSagaContextIbGib_V1, } from "./sync-saga-context/sync-saga-context-types.mjs";
 import { createSyncSagaContext } from "./sync-saga-context/sync-saga-context-helpers.mjs";
-import { newupSubject } from "../common/pubsub/subject/subject-helper.mjs";
+import { newupSubject, } from "../common/pubsub/subject/subject-helper.mjs";
 import { SubjectWitness } from "../common/pubsub/subject/subject-types.mjs";
-
 import { mergeDivergentTimelines } from "./strategies/conflict-optimistic.mjs";
 import { getSyncSagaMessageFromFrame } from "./sync-saga-message/sync-saga-message-helpers.mjs";
+import { fnObs } from "../common/pubsub/observer/observer-helper.mjs";
+import { ErrorIbGib_V1 } from "../common/error/error-types.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;
+// 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).
@@ -85,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();
@@ -112,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({
@@ -146,33 +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)
-                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)`); }
@@ -238,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$,
@@ -257,161 +250,190 @@ export class SyncSagaCoordinator {
         metaspace
     }: {
         initialFrame: SyncIbGib_V1,
-        srcGraph: { [addr: string]: IbGib_V1 },
+        initialDomainGraph: FlatIbGibGraph,
         peer: SyncPeerWitness,
         sessionIdentity?: KeystoneIbGib_V1,
-        // updates$: Subject_V1<SyncSagaContextIbGib_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 nextPayloadIbGibs: IbGib_V1[] = [];
-        // Accumulator for all data we've successfully pulled from the remote
-        const allReceivedIbGibs: IbGib_V1[] = [];
+        let nextDomainIbGibs: 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)
-            // We must do this BEFORE creating the Context so we can list them all in payloadAddrs.
-            const allDeps: IbGib_V1[] = [];
+            // We must do this BEFORE creating the Context so we can list them
+            // all in payloadAddrsDomain and payloadAddrsControl.
+            const nextDomainIbGibsAndDeps: IbGib_V1[] = [];
 
             // A. Payload (Standard Deep Deps)
-            for (const item of nextPayloadIbGibs) {
-                let graph = await getDependencyGraph({ ibGib: item, space: localSpace });
-                if (!graph) {
-                    graph = await getDependencyGraph({ ibGib: item, space: tempSpace });
+            // 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);
-            }
+            if (logalot) { 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<string, IbGib_V1>();
+            const sublc = `${lc}[peer.payloadIbGibsDomainReceived$]`;
+            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({
-                cmd: SyncSagaContextCmd.process,
                 sagaFrame: currentFrame,
                 sessionKeystones: sessionIdentity ? [sessionIdentity] : undefined,
-                payloadAddrs: payloadAddrs.length > 0 ? payloadAddrs : undefined,
-            });
 
-            // 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);
-            }
+                /**
+                 * init frame: empty
+                 * 
+                 */
+                payloadIbGibsDomain: nextDomainIbGibsAndDeps,
+                localSpace,
+            });
 
-            if (allDeps.length > 0) {
-                await putInSpace({
-                    space: localSpace,
-                    ibGibs: allDeps
-                });
+            // 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)'}`);
             }
 
-            // B. Transmit
+            // 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.`); }
                         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)`);
+            // ---------------------------------------------------------------------
+            // 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[] || [];
+
+            // Poll for them if needed
+            if (responsePayloadAddrsDomain.length > 0) {
+                responseCtx.payloadIbGibsDomain = await this.pollForDomainPayloads({
+                    expectedAddrs: responsePayloadAddrsDomain,
+                    pollIntervalMs: 20, // relatively arbitrary right now
+                    domainPayloadsMap,
+                    tempSpace,
+                });
             }
 
-            // We look in localSpace first (where Peer delivers), then tempSpace.
-            let resRemoteFrame = await getFromSpace({ addr: remoteFrameAddr, space: localSpace });
-            if (!resRemoteFrame.success || !resRemoteFrame.ibGibs?.length) {
-                // Fallback to tempSpace just in case
-                resRemoteFrame = await getFromSpace({ addr: remoteFrameAddr, space: tempSpace });
+            // 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 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)'}`);
             }
-            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
+            // 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,
+            });
 
-            // Ensure remote frame and its dependencies are in tempSpace
-            // The Peer delivered them to localSpace, but handleSagaFrame works in tempSpace.
-            const remoteDeps = await getSyncSagaDependencyGraph({ ibGib: remoteFrame, space: localSpace });
-            if (remoteDeps && remoteDeps.length > 0) {
-                await putInSpace({ space: tempSpace, ibGibs: remoteDeps });
+            if (!handleResult) {
+                if (logalot) { console.log(`${lc} Handler returned null (Saga End).`); }
+                break;
             }
 
+            currentFrame = handleResult.frame;
 
-            // React (Reducer)
-            // This processes the FRAME we just got from the peer.
-            // i.e., We Sent Init -> Got Ack. This calls handleAckFrame.
-            // i.e., We Sent Delta -> Got Delta. This calls handleDeltaFrame.
-            const result = await this.handleSagaFrame({
-                sagaIbGib: remoteFrame as SyncIbGib_V1,
-                srcGraph,
-                destSpace: localSpace, // Query existing data from localSpace (Source)
-                tempSpace: tempSpace,   // Transaction space for saga frames
-                identity: sessionIdentity,
-                metaspace
-            });
+            // Collect next DOMAIN payloads for the NEXT request
+            nextDomainIbGibs = [...(handleResult.payloadIbGibsDomain || [])];
 
-            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);
+            // 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;
     }
 
     /**
@@ -432,7 +454,7 @@ export class SyncSagaCoordinator {
         const lc = `${this.lc}[${this.getKnowledgeVector.name}]`;
         try {
             if (logalot) { console.log(`${lc} starting... (I: e184f8a7818666febfbbd2d841ed3826)`); }
-            console.dir(space)
+            // console.dir(space);
 
             if (!(domainIbGibs && domainIbGibs.length > 0) &&
                 !(tjpAddrs && tjpAddrs.length > 0)
@@ -451,19 +473,19 @@ export class SyncSagaCoordinator {
                 tjps = tjpAddrs;
             } 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) { console.log(`${lc}[TEST DEBUG] mapWithTjp_YesDna: ${JSON.stringify(mapWithTjp_YesDna)} (I: 287e22897148298e185712c8d50cfb26)`); }
-                if (logalot) { console.log(`${lc}[TEST DEBUG] mapWithTjp_NoDna: ${JSON.stringify(mapWithTjp_NoDna)} (I: 1bdc62656294aed0f9df334647dc7326)`); }
+                if (false) { console.log(`${lc}[TEST DEBUG] mapWithTjp_YesDna: ${JSON.stringify(mapWithTjp_YesDna)} (I: 287e22897148298e185712c8d50cfb26)`); }
+                if (false) { console.log(`${lc}[TEST DEBUG] mapWithTjp_NoDna: ${JSON.stringify(mapWithTjp_NoDna)} (I: 1bdc62656294aed0f9df334647dc7326)`); }
 
                 const allWithTjp = [...Object.values(mapWithTjp_YesDna), ...Object.values(mapWithTjp_NoDna)];
                 const timelineMap = getTimelinesGroupedByTjp({ ibGibs: allWithTjp });
-                if (logalot) { console.log(`${lc}[TEST DEBUG] timelineMap: ${JSON.stringify(timelineMap)} (I: 2cc04898e5f85179fb1ac7f827abc426)`); }
+                if (false) { console.log(`${lc}[TEST DEBUG] timelineMap: ${JSON.stringify(timelineMap)} (I: 2cc04898e5f85179fb1ac7f827abc426)`); }
 
                 tjps = Object.keys(timelineMap);
-                if (logalot) { console.log(`${lc}[TEST DEBUG] tjps: ${tjps} (I: 3dd548667cbd967c68e57c88dc570826)`); }
+                if (false) { console.log(`${lc}[TEST DEBUG] tjps: ${tjps} (I: 3dd548667cbd967c68e57c88dc570826)`); }
             } else {
                 // No info provided. Return empty? Or throw?
                 // User test context implied "everything", but implementation requires scope.
@@ -473,14 +495,14 @@ export class SyncSagaCoordinator {
 
             if (tjps.length === 0) { return {}; }
 
-            if (logalot) { console.log(`${lc} getting latest addrs for tjps: ${tjps} (I: d4e7080b8ba8187c583b82fd91ac0626)`); }
+            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) {
@@ -491,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 };
     }
 
     /**
@@ -541,78 +562,142 @@ 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;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
+    }
 
+    /**
+     * 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<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();
+            /**
+             * This needs 
+             */
+            const timeoutMs = 5 * 60 * 1000; // 5 minutes...arbitrary at this point. This needs to be pulled out and improved eesh.
+
+            while (pending.length > 0) {
+                if (Date.now() - start > timeoutMs) {
+                    throw new Error(`Timeout waiting for payloads: ${pending.join(', ')} (E: 46e1683c9578095261aaf798bd5e1826)`);
+                }
+
+                const stillPending: string[] = [];
+                const found: IbGib_V1[] = [];
+
+                for (const addr of pending) {
+                    if (domainPayloadsMap.has(addr)) {
+                        found.push(domainPayloadsMap.get(addr)!);
+                        domainPayloadsMap.delete(addr);
+                    } else {
+                        stillPending.push(addr);
+                    }
+                }
+
+                if (found.length > 0) {
+                    await putInSpace({ space: tempSpace, ibGibs: found });
+                    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;
@@ -622,59 +707,84 @@ export class SyncSagaCoordinator {
     }
 
     /**
-     * Reacts to an incoming saga frame and dispatches to appropriate handler.
+     * 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.
      * 
-     * @remarks
-     * **Execution Context**: **Universal (Both Sender and Receiver)**.
+     * 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,
+    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,
-    }): Promise<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[], receivedPayloadIbGibs?: IbGib_V1[] } | null> {
-        const lc = `${this.lc}[${this.handleSagaFrame.name}]`;
+    }): Promise<HandleSagaFrameResult | null> {
+        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)`);
@@ -704,305 +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<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[] } | null> {
+    }): Promise<HandleSagaFrameResult | null> {
         const lc = `${this.lc}[${this.handleInitFrame.name}]`;
-        console.log(`${lc} [TEST DEBUG] Received destSpace: ${destSpace.data?.name || destSpace.ib} (uuid: ${destSpace.data?.uuid || '[no uuid]'})`);
-        if (logalot) { console.log(`${lc} starting...`); }
+        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,
+            });
+
+            // 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
 
-        // IMMEDIATELY persist to both spaces for audit trail (before any errors can occur)
-        await this.ensureSagaFrameInBothSpaces({ frame: ackFrame, destSpace, tempSpace, metaspace });
+            if (pushOfferAddrs.length > 0) {
+            }
 
-        // if (logalot) { console.log(`${lc} ackFrame created: ${pretty(ackFrame)} (I: be24480592eec478086bb3da49286826)`); }
+            return {
+                frame: ackFrame,
+                // conflictInfos,
+                // payloadIbGibsDomain,
+            };
 
-        return { frame: ackFrame };
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
     }
 
     /**
@@ -1031,12 +1133,12 @@ export class SyncSagaCoordinator {
         tempSpace: IbGibSpaceAny,
         metaspace: MetaspaceService,
         identity?: KeystoneIbGib_V1,
-    }): Promise<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[] } | null> {
+    }): Promise<HandleSagaFrameResult | null> {
         const lc = `${this.lc}[${this.handleAckFrame.name}]`;
         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) {
@@ -1130,62 +1232,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
@@ -1354,24 +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)}`); }
 
-            return { frame: deltaFrame, payloadIbGibs };
+            // 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, payloadIbGibsDomain: payloadIbGibs };
         } catch (error) {
             console.error(`${lc} ${extractErrorMsg(error)}`);
             throw error;
@@ -1404,11 +1453,11 @@ export class SyncSagaCoordinator {
         tempSpace: IbGibSpaceAny,
         metaspace: MetaspaceService,
         identity?: KeystoneIbGib_V1,
-    }): Promise<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[], receivedPayloadIbGibs?: IbGib_V1[] } | null> {
+    }): Promise<HandleSagaFrameResult | null> {
         const lc = `${this.lc}[${this.handleDeltaFrame.name}]`;
         if (logalot) { console.log(`${lc} starting...`); }
 
-        const { messageData } = await this.getStageAndPayloadFromFrame({ ibGib: sagaIbGib, space: tempSpace });
+        const { messageData } = await this.getStageAndPayloadFromFrame({ sagaFrame: sagaIbGib, space: tempSpace });
         const deltaData = messageData as SyncSagaMessageDeltaData_V1;
 
         if (!deltaData) {
@@ -1614,22 +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, payloadIbGibs: outgoingPayload, receivedPayloadIbGibs };
+            // return { frame: deltaFrame, payloadIbGibsControl, payloadIbGibsDomain: outgoingPayload };
+            return { frame: deltaFrame, payloadIbGibsDomain: outgoingPayload };
 
         } else {
             // We have nothing to send.
@@ -1644,22 +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, receivedPayloadIbGibs };
+                // 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).
@@ -1674,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.`); }
@@ -1703,25 +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, receivedPayloadIbGibs };
+                    // return { frame: commitFrame, payloadIbGibsControl: commitCtrlPayloads2 };
+                    return { frame: commitFrame, };
                 }
 
-                return { frame: deltaFrame, receivedPayloadIbGibs };
+                // Build control payloads for delta propose
+                const deltaCtrlPayloads: IbGib_V1[] = [deltaFrame, deltaStone];
+                if (identity) { deltaCtrlPayloads.push(identity); }
+
+                // return { frame: deltaFrame, payloadIbGibsControl: deltaCtrlPayloads };
+                return { frame: deltaFrame, };
             }
         }
     }
@@ -1739,7 +1796,7 @@ export class SyncSagaCoordinator {
         tempSpace: IbGibSpaceAny,
         metaspace: MetaspaceService,
         identity?: KeystoneIbGib_V1,
-    }): Promise<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[] } | null> {
+    }): Promise<HandleSagaFrameResult | null> {
         const lc = `${this.lc}[${this.handleCommitFrame.name}]`;
         if (logalot) { console.log(`${lc} Commit received.`); }
 
@@ -1761,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}]`;
@@ -1780,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) {
@@ -1792,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 {
@@ -1878,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)
                  */
@@ -1893,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 
@@ -1915,7 +1927,7 @@ export class SyncSagaCoordinator {
                     rel8nInfos,
                     rel8nRemovalInfos,
                     metaspace,
-                    space,
+                    space: localSpace,
                     noDna: true, // Explicitly no DNA for sync frames
                 });
 
@@ -1923,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;
             }
@@ -1960,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 });
@@ -1980,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)}`);