@ibgib/core-gib 0.1.19 → 0.1.20

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

@@ -23,6 +23,7 @@ import { appendToTimeline, createTimeline, Rel8nInfo, Rel8nRemovalInfo } from ".
 import {
     SyncData_V1, SyncIbGib_V1, SyncInitData, SyncConflictStrategy,
     SyncMode,
+    SyncOptions,
 } from "./sync-types.mjs";
 import { getSyncIb, isPastFrame } from "./sync-helpers.mjs";
 import { getSyncSagaDependencyGraph } from "./sync-helpers.mjs";
@@ -41,6 +42,9 @@ import { createSyncSagaContext } from "./sync-saga-context/sync-saga-context-hel
 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";
+
 
 const logalot = GLOBAL_LOG_A_LOT || true;
 
@@ -81,20 +85,19 @@ export class SyncSagaCoordinator {
      */
     async sync({
         peer,
-        localSpace,
+        localSpace: _localSpace,
+        source: _source,
         metaspace,
         domainIbGibs,
-        useSessionIdentity,
-    }: {
-        peer: SyncPeerWitness,
-        localSpace: IbGibSpaceAny,
-        metaspace: MetaspaceService,
-        domainIbGibs: IbGib_V1[],
-        useSessionIdentity: boolean,
-    }): Promise<SyncSagaInfo> {
+        conflictStrategy = 'abort',
+        useSessionIdentity = true,
+    }: 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)`); }
+
         // 1. SETUP SAGA METADATA
         const sagaId = await getUUID();
 
@@ -150,6 +153,7 @@ export class SyncSagaCoordinator {
                     domainIbGibs,
                     tempSpace,
                     metaspace,
+                    conflictStrategy
                 });
 
                 // 4. EXECUTE SAGA LOOP (FSM)
@@ -337,6 +341,17 @@ export class SyncSagaCoordinator {
 
             // C. Handle Response
             if (!responseCtx) {
+                // Check if we just sent a Commit frame. If so, peer's silence is success/expected.
+                if (currentFrame) {
+                    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;
+                    }
+                }
+
                 throw new Error(`responseCtx falsy. Peer returned no response context (E: c099d8073b48d85e881f917835158f26)`);
                 // console.warn(`${lc} Peer returned no response context. Ending loop.`);
                 // currentFrame = null;
@@ -397,6 +412,49 @@ export class SyncSagaCoordinator {
         return allReceivedIbGibs;
     }
 
+    /**
+     * Helper to get Knowledge Vector for specific domain ibGibs or TJPs.
+     * Useful for testing and external validation.
+     */
+    public async getKnowledgeVector({
+        space,
+        metaspace,
+        domainIbGibs,
+        tjpAddrs,
+    }: {
+        space: IbGibSpaceAny,
+        metaspace: MetaspaceService,
+        domainIbGibs?: IbGib_V1[],
+        tjpAddrs?: string[],
+    }): Promise<{ [tjp: string]: string | null }> {
+        const lc = `${this.lc}[${this.getKnowledgeVector.name}]`;
+        if (logalot) { console.log(`${lc} starting...`); }
+
+        let tjps: string[] = [];
+        if (tjpAddrs) {
+            tjps = tjpAddrs;
+        } else if (domainIbGibs && domainIbGibs.length > 0) {
+            // Extract TJPs from domain Ibgibs
+            const { mapWithTjp_YesDna, mapWithTjp_NoDna } = splitPerTjpAndOrDna({ ibGibs: domainIbGibs });
+            const allWithTjp = [...Object.values(mapWithTjp_YesDna), ...Object.values(mapWithTjp_NoDna)];
+            const timelineMap = getTimelinesGroupedByTjp({ ibGibs: allWithTjp });
+            tjps = Object.keys(timelineMap);
+        } else {
+            // No info provided. Return empty? Or throw?
+            // User test context implied "everything", but implementation requires scope.
+            console.warn(`${lc} No domainIbGibs or tjpAddrs provided. Returning empty KV.`);
+            return {};
+        }
+
+        if (tjps.length === 0) { return {}; }
+
+        const res = await getLatestAddrs({ space, tjpAddrs: tjps });
+        if (!res.data || !res.data.latestAddrsMap) {
+            throw new Error(`${lc} Failed to get latest addrs. (E: 7a8b9c0d)`);
+        }
+        return res.data.latestAddrsMap;
+    }
+
     protected async analyzeTimelines({
         domainIbGibs,
         space,
@@ -450,14 +508,16 @@ export class SyncSagaCoordinator {
         localSpace,
         domainIbGibs,
         tempSpace,
-        metaspace
+        metaspace,
+        conflictStrategy,
     }: {
         sagaId: string,
         sessionIdentity?: KeystoneIbGib_V1,
         localSpace: IbGibSpaceAny,
         domainIbGibs: IbGib_V1[],
         tempSpace: IbGibSpaceAny,
-        metaspace: MetaspaceService
+        metaspace: MetaspaceService,
+        conflictStrategy: SyncConflictStrategy,
     }): Promise<{ sagaFrame: SyncIbGib_V1, srcGraph: { [addr: string]: IbGib_V1 } }> {
         const lc = `${this.lc}[${this.createInitFrame.name}]`;
         try {
@@ -496,7 +556,8 @@ export class SyncSagaCoordinator {
                 msgStones: [initStone],
                 identity: sessionIdentity,
                 space: tempSpace,
-                metaspace
+                metaspace,
+                conflictStrategy,
             });
             if (logalot) { console.log(`${lc} sagaFrame (init): ${pretty(sagaFrame)} (I: b3d6a8be69248f18713cc3073cb08626)`); }
 
@@ -552,19 +613,19 @@ export class SyncSagaCoordinator {
 
             switch (stage) {
                 case SyncStage.init:
-                    return await this.handleInitFrame({ sagaIbGib, messageData, space, metaspace, identity, identitySecret });
+                    return await this.handleInitFrame({ sagaIbGib, messageData, metaspace, space, identity, identitySecret });
 
                 case SyncStage.ack:
-                    return await this.handleAckFrame({ sagaIbGib, srcGraph, space, metaspace, identity });
+                    return await this.handleAckFrame({ sagaIbGib, srcGraph, metaspace, space, identity });
 
                 case SyncStage.delta:
-                    return await this.handleDeltaFrame({ sagaIbGib, srcGraph, space, identity, metaspace });
+                    return await this.handleDeltaFrame({ sagaIbGib, srcGraph, metaspace, space, identity, });
 
                 case SyncStage.commit:
-                    return await this.handleCommitFrame({ sagaIbGib, space });
+                    return await this.handleCommitFrame({ sagaIbGib, metaspace, space, identity, });
 
                 case SyncStage.conflict:
-                    return await this.handleConflictFrame({ sagaIbGib, space });
+                    return await this.handleConflictFrame({ sagaIbGib, metaspace, space, });
 
                 default:
                     throw new Error(`${lc} (UNEXPECTED) Unknown sync stage: ${stage} (E: 9c2b4c8a6d34469f8263544710183355)`);
@@ -611,14 +672,19 @@ export class SyncSagaCoordinator {
 
         // 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)`);
         }
 
+        // Determine Strategy from Saga Data (since V1 stores it in root)
+        const conflictStrategy = sagaIbGib.data!.conflictStrategy || 'abort';
+
         // 2. Gap Analysis
-        const conflicts: { tjp: string, localAddr?: string, remoteAddr: string, reason: string }[] = [];
-        const conflictStrategy: SyncConflictStrategy = initData.conflictStrategy || 'abort'; // Default to abort if not specified, or we should parameterize this
+        const conflicts: { tjpAddr: string, localAddr: string, remoteAddr: string, timelineAddrs: string[], reason: string, terminal: boolean }[] = [];
 
         const deltaReqAddrs: string[] = [];
         const pushOfferAddrs: string[] = [];
@@ -703,21 +769,47 @@ export class SyncSagaCoordinator {
                     deltaReqAddrs.push(remoteAddr);
                 } else {
                     // DIVERGENCE: Both have changes the other doesn't know about.
-                    conflicts.push({ tjp, localAddr, remoteAddr, reason: 'divergence' });
-
-                    // Conflict Strategy Handling
-                    // TODO: Implement "manual" strategy (requires user intervention/pause)
-                    // TODO: Implement "local_wins" strategy
-                    // TODO: Implement "server_wins" strategy
 
                     if (conflictStrategy === 'abort') {
-                        // We will abort immediately after this loop check if any conflicts exist
+                        // 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 Try to resolve by syncing timeline-by-timeline.
-                        // We request the remote data (deltaReq) and will attempt to merge later?
-                        // OR we treat it as a delta request for now, hoping the merge logic handles it?
-                        // For now, we request the remote tip.
-                        deltaReqAddrs.push(remoteAddr);
+                        // 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, 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
+                        });
+
                     } else {
                         throw new Error(`${lc} Unsupported conflict strategy: ${conflictStrategy} (E: 2a9b3c4d5e6f7g8h9i0j)`);
                     }
@@ -725,34 +817,26 @@ export class SyncSagaCoordinator {
             }
         }
 
-        if (conflicts.length > 0 && conflictStrategy === 'abort') {
+        // 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 conflicts: ${JSON.stringify(conflicts)}`); }
+            if (logalot) { console.warn(`${lc} ABORTING Sync Saga due to terminal conflicts: ${JSON.stringify(conflicts)}`); }
 
-            const sagaId = sagaIbGib.data!.uuid;
-            const conflictData: SyncSagaMessageConflictData_V1 = {
-                sagaId,
-                stage: SyncStage.conflict,
-                conflictStrategy,
-                isTerminal: true,
-                conflicts,
-            };
+            // We reuse the ConflictData structure for terminal aborts?
+            // Or do we send an Ack with terminal conflicts?
+            // Original design had explicit Conflict Frame for Abort.
+            // Let's stick to that for purely terminal cases to be safe/explicit?
+            // Or Unified: Just send Ack with terminal=true conflicts. Sender sees them and aborts.
 
-            const conflictStone = await this.createSyncMsgStone({
-                data: conflictData,
-                space,
-                metaspace,
-            });
+            // 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).
 
-            const conflictFrame = await this.evolveSyncSagaIbGib({
-                prevSagaIbGib: sagaIbGib,
-                msgStones: [conflictStone],
-                identity,
-                space,
-                metaspace,
-            });
-
-            return { frame: conflictFrame };
+            // Let's use Ack with conflicts.
         }
 
         // 2. Add Push Offers (Missing in Local)
@@ -817,27 +901,7 @@ export class SyncSagaCoordinator {
         // Problem: Receiver doesn't know X is related to Y without X.
 
         // SOLUTION:
-        // The *Sender* must include TJP/Past info in `Init`? Or `pushOfferAddrs` should be richer?
-        // OR: Receiver does a check.
-        // Wait, if Sender sends V2, it's just an address.
-        // If Receiver doesn't have it, it's opaque.
-
-        // REVISIT "Constant / No TJP" logic:
-        // IF we are testing "Sender Newer", meaning Sender has V2, Receiver has V1.
-        // Sender calls `sync([V2])`. Init Frame contains `stones: [V2_Address]`.
-        // Receiver checks V2_Address. Not found.
-        // Receiver requests V2.
-        // Receiver sends Ack(DeltaReq: [V2], Knowledge: {}).
-        // Sender receives Ack. Sender sends V2 *AND* its deps (V1, Root).
-        // Receiver has V1. Sender sends V1 anyway.
-        // This is "Naive Deep Sync".
-
-        // TO ACHIEVE "Smart Diff":
-        // Receiver needs to know "Oh, V2 is a timeline tip of TJP_A".
-        // If Sender doesn't send TJP info, Receiver is blind.
-
-        // Proposed Fix (Short Term):
-        // `SyncInitData` should include TJP mappings or we rely on `knowledgeVector` in `Init`?
+        // 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!
@@ -914,6 +978,148 @@ export class SyncSagaCoordinator {
         if (ackData.stage !== SyncStage.ack) {
             throw new Error(`${lc} Invalid ack frame: ackData.stage !== SyncStage.ack (E: 2e8b0a94b5954a66a6a1a7a0b3f5b7a1)`);
         }
+        if (logalot) { console.log(`${lc} ackData: ${pretty(ackData)} (I: 7f8e9d0a1b2c3d4e5f6g7h8i9j0k)`); }
+
+        // 1. Check for Conflicts
+        const conflicts = ackData.conflicts || [];
+        const terminalConflicts = conflicts.filter(c => c.terminal);
+        if (terminalConflicts.length > 0) {
+            console.warn(`${lc} Received terminal conflicts from Ack: ${JSON.stringify(terminalConflicts)}`);
+            // Terminal failure. Sender should probably Commit(Fail) or just Abort.
+            // For now, throw to trigger abort.
+            throw new Error(`${lc} Peer reported terminal conflicts. (E: a1b2c3d4e5f6g7h8i9j0k)`);
+        }
+
+        const optimisticConflicts = conflicts.filter(c => !c.terminal);
+        const mergeDeltaReqs: string[] = []; // Additional requests for merging
+
+        if (optimisticConflicts.length > 0) {
+            if (logalot) { console.log(`${lc} Processing optimistic conflicts: ${optimisticConflicts.length}`); }
+            // We need to resolve these.
+            // Strategy:
+            // 1. Analyze Divergence (Sender vs Receiver)
+            // 2. Identify missing data needed for merge (Receiver's unique frames)
+            // 3. Request that data (as Delta Reqs)
+            // 4. (Later in Delta Phase) Perform Merge.
+
+            // BUT: The Delta Phase is usually generic "Send me these Addrs".
+            // If we just add to `deltaReqAddrs` (which are requests for Sender to send to Receiver?),
+            // wait. `ackData.deltaReqAddrs` are what RECEIVER wants from SENDER.
+
+            // We (Sender) are processing the Ack.
+            // We need to request data FROM Receiver.
+            // But the protocol 'Ack' step typically leads to 'Delta' (Sender sending data).
+
+            // If Sender needs data from Receiver, it usually happens in 'Pull' mode or a separate request?
+            // Or can we send a 'Delta Request' frame?
+            // Standard Saga: Init(Push) -> Ack(Pull Reqs) -> Delta(Push Data).
+
+            // If Sender needs data, we might need a "Reverse Delta" or "Pull" phase?
+            // Or we just proceed to Delta (sending what Receiver wants), 
+            // AND we piggyback our own requests?
+            // OR: We treat the Conflict Resolution as a sub-saga or side-effect?
+
+            // SIMPLIFICATION for V1:
+            // If we need data to merge, we must get it.
+            // We are the Coordinator (Active). We can fetch from Peer immediately?
+            // `peer.pull(addr)`?
+            // Yes! The Coordinator has the `peer`.
+
+            // Let's analyze and pull immediately.
+
+            for (const conflict of optimisticConflicts) {
+                const { timelineAddrs, localAddr: receiverTip, remoteAddr: senderTip } = conflict;
+
+                // Sender History
+                // We need our own history for this timeline.
+                // We know the 'senderTip' (remoteAddr in Ack).
+                // Sender should verify it has this tip.
+
+                // Compute Diffs
+                // We need to find `receiverOnly` addrs.
+                // Receiver sent us `timelineAddrs` (Full History).
+                const receiverHistorySet = new Set(timelineAddrs);
+
+                // We need our execution context's history for this senderTip.
+                // We can fetch valid 'past' from space.
+                const resSenderTip = await getFromSpace({ space, addr: senderTip });
+                const senderTipIbGib = resSenderTip.ibGibs?.[0];
+                if (!senderTipIbGib) { throw new Error(`${lc} Sender missing its own tip? ${senderTip} (E: 9c8d7e6f5g4h3i2j1k0l)`); }
+
+                // Basic Diff: Find what Receiver has that we don't.
+                // Actually, we need to traverse OUR past to find commonality.
+                const senderHistory = [senderTip, ...(senderTipIbGib.rel8ns?.past || [])];
+
+                const receiverOnlyAddrs = timelineAddrs.filter(addr => !senderHistory.includes(addr));
+
+                if (receiverOnlyAddrs.length > 0) {
+                    if (logalot) { console.log(`${lc} Pulling divergent history from Receiver: ${receiverOnlyAddrs.length} frames`); }
+                    // PULL these frames from Peer into Local Space
+                    // (Validation: We trust peer for now / verification happens on put)
+                    for (const addr of receiverOnlyAddrs) {
+                        // This 'pull' is a sync-peer method?
+                        // The Coordinator 'peer' passed in 'sync()' might be needed here?
+                        // Wait, `handleAckFrame` doesn't have reference to `peer`?
+                        // It only has `space`, `metaspace`.
+                        // The `peer` is held by the `executeSagaLoop`.
+
+                        // PROBLEM: `handleAckFrame` is pure logic on the Space/Data?
+                        // No, it's a method on Coordinator. 
+                        // But `executeSagaLoop` calls it.
+                        // We might need to return "Requirements" to the loop?
+
+                        // Checking return type: `{ frame: SyncIbGib_V1, payloadIbGibs?: ... }`
+                        // It returns the NEXT frame (Delta).
+
+                        // If we need to fetch data, we are blocked.
+                        // We can't easily "Pull" here without the Peer reference.
+
+                        // OPTION A: Pass `peer` to `handleAckFrame`.
+                        // OPTION B: Return a strict list of "MissingDeps" and let Loop handle it.
+
+                        // Let's assume we can resolve this by adding `peer` to signature or using `metaspace` if it's a peer-witness?
+                        // No, Peer is ephemeral connection.
+
+                        // Let's add `peer` to `handleAckFrame` signature?
+                        // It breaks the pattern of just handling frame + space.
+
+                        // ALTERNATIVE: Use the `Delta` frame to request data?
+                        // `SyncSagaMessageDeltaData` has `requests?: string[]`.
+                        // Sender sends Delta Frame.
+                        // Does Receiver handle Delta Requests?
+                        // `handleDeltaFrame` (Receiver) -> checks `requests`.
+                        // YES.
+
+                        // So Sender puts `receiverOnlyAddrs` into `deltaFrame.requests`.
+                        // Receiver sees them, fetches them, and includes them in the Response (Commit?).
+                        // Wait, Init->Ack->Delta->Commit.
+                        // If Receiver sends data in Commit, that's "too late" for Sender to Merge in THIS saga round?
+                        // Unless Commit is not the end?
+
+                        // Or we do a "Delta 2" loop?
+
+                        // "Iterative Resolution Loop" from plan.
+                        // If we request data in Delta, Receiver sends it in Commit (or Delta-Response).
+                        // Sender gets Commit. Sees data. Merges.
+                        // Then Sender needs to Send the MERGE result.
+                        // Needs another Push/Delta.
+
+                        // REFINED FLOW:
+                        // 1. Sender sends Delta Frame with `requests: [receiverOnlyAddrs]`.
+                        // 2. Receiver responds (Commit? or Ack 2?) with Payload (Divergent Frames).
+                        // 3. Sender handles response -> Merges.
+                        // 4. Sender sends Commit (containing Merge Frame).
+
+                        // Issue: Current state machine is Init->Ack->Delta->Commit.
+                        // We need to keep Saga open.
+                        // If Sender sends Delta with requests, does it transition to Commit?
+                    }
+                    mergeDeltaReqs.push(...receiverOnlyAddrs);
+                }
+            }
+        }
+
+        // 2. Prepare Delta Payload (What Receiver Requesting + Our Conflict Logic)
 
         const deltaReqAddrs = ackData.deltaReqAddrs || [];
         const pushOfferAddrs = ackData.pushOfferAddrs || [];
@@ -1003,10 +1209,10 @@ export class SyncSagaCoordinator {
         // 3. Create Delta Frame
         const sagaId = ackData.sagaId;
         const deltaData: SyncSagaMessageDeltaData_V1 = {
-            sagaId,
+            sagaId: sagaIbGib.data!.uuid,
             stage: SyncStage.delta,
             payloadAddrs: payloadIbGibs.map(p => getIbGibAddr({ ibGib: p })),
-            requests: pullReqAddrs.length > 0 ? pullReqAddrs : undefined,
+            requests: [...(pullReqAddrs || []), ...(mergeDeltaReqs || [])].length > 0 ? [...(pullReqAddrs || []), ...(mergeDeltaReqs || [])] : undefined,
         };
 
         const deltaStone = await this.createSyncMsgStone({
@@ -1061,25 +1267,37 @@ export class SyncSagaCoordinator {
         if (deltaData.stage !== SyncStage.delta) {
             throw new Error(`${lc} Invalid delta frame: deltaData.stage !== SyncStage.delta (E: 0c28c8d8f08a4421b8344e6727271421)`);
         }
+        if (logalot) { console.log(`${lc} deltaData: ${pretty(deltaData)} (I: 8d7e6f5g4h3i2j1k0l9m)`); }
 
         const payloadAddrs = deltaData.payloadAddrs || [];
-        const requests = deltaData.requests || [];
+        const peerRequests = deltaData.requests || [];
+        const peerProposesCommit = deltaData.proposeCommit || false;
 
-        // 1. Process Received Payload
+        // 1. Process Received Payload (Ingest)
         const receivedPayloadIbGibs: IbGib_V1[] = [];
         if (payloadAddrs.length > 0) {
+            // We use `payloadAddrs` as the manifest. 
+            // The ACTUAL collection of ibGibs should be available via `getFromSpace` 
+            // assuming the "Transport" layer put them there implicitly?
+            // OR, if we are local-only, we just get them.
+            // The `handleDeltaFrame` contract assumes data is reachable in `space`.
+
             const res = await getFromSpace({
                 addrs: payloadAddrs,
                 space,
             });
             if (res.ibGibs) {
                 receivedPayloadIbGibs.push(...res.ibGibs);
+                // Also put them? `getFromSpace` retrieves. If they are in space, they are persisted.
+                // If this is a Temp Space, they are safe.
+            } else {
+                console.warn(`${lc} Failed to retrieve payloads listed in delta: ${payloadAddrs.join(', ')}`);
             }
         }
 
-        // 2. Fulfill Requests (Outgoing Payload)
+        // 2. Fulfill Peer Requests (Outgoing Payload)
         const outgoingPayload: IbGib_V1[] = [];
-        for (const addr of requests) {
+        for (const addr of peerRequests) {
             let ibGib = srcGraph[addr];
             if (!ibGib) {
                 const res = await getFromSpace({ addr, space });
@@ -1089,19 +1307,116 @@ export class SyncSagaCoordinator {
             }
             if (ibGib) {
                 outgoingPayload.push(ibGib);
+            } else {
+                console.warn(`${lc} Requested addr not found during delta fulfillment: ${addr}`);
+            }
+        }
+
+        // 3. Execute Merges (If applicable)
+        // Check if we have pending conflicts that we CAN resolve now that we have data.
+        // We look at the Saga History (Ack Frame) to find conflicts.
+        // Optimization: Do this only if we received payloads.
+        const mergeResultIbGibs: IbGib_V1[] = [];
+
+        if (receivedPayloadIbGibs.length > 0) {
+            // Find the Ack frame in history to get conflicts
+            // Optimization: Batch fetch history from `sagaIbGib.rel8ns.past`
+            // V1 timelines carry full history in `past`.
+            const pastAddrs = sagaIbGib.rel8ns?.past || [];
+            let ackData: SyncSagaMessageAckData_V1 | undefined;
+
+            if (pastAddrs.length > 0) {
+                // Batch fetch all past frames
+                const resPast = await getFromSpace({ addrs: pastAddrs, space });
+                if (resPast.success && resPast.ibGibs) {
+                    // Iterate backwards (most recent first) to find the latest Ack
+                    for (let i = resPast.ibGibs.length - 1; i >= 0; i--) {
+                        const pastFrame = resPast.ibGibs[i];
+                        const messageStone = await getSyncSagaMessageFromFrame({
+                            frameIbGib: pastFrame,
+                            space
+                        });
+                        if (messageStone?.data?.stage === SyncStage.ack) {
+                            ackData = messageStone.data as SyncSagaMessageAckData_V1;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if (ackData && ackData.conflicts) {
+                const optimisticConflicts = ackData.conflicts.filter(c => !c.terminal);
+                for (const conflict of optimisticConflicts) {
+                    const { timelineAddrs, localAddr: receiverTip, remoteAddr: senderTip } = conflict;
+                    // We are Sender (usually) here if we are merging.
+                    // Check if we have the history needed (timelineAddrs).
+                    // Specifically, we needed the `receiverOnly` parts.
+
+                    // We blindly attempt merge if we have both tips accessible?
+                    // We need `receiverTip` (localAddr in Ack) and `senderTip` (remoteAddr).
+
+                    // Check if we have receiverTip in space
+                    const resRecTip = await getFromSpace({ addr: receiverTip, space });
+                    if (resRecTip.success && resRecTip.ibGibs?.[0]) {
+                        // We have the tip!
+                        // Do we have the full history? 
+                        // `mergeDivergentTimelines` in `conflict-optimistic` will attempt to fetch history.
+                        // If we just ingested the missing pieces, `getFromSpace` inside `merge` should succeed.
+
+                        // Perform Merge!
+                        try {
+                            const mergeResult = await mergeDivergentTimelines({
+                                tipA: (await getFromSpace({ addr: senderTip, space })).ibGibs![0], // Our tip
+                                tipB: resRecTip.ibGibs[0], // Their tip
+                                space,
+                                metaspace,
+                            });
+                            if (mergeResult) {
+                                if (logalot) { console.log(`${lc} Merge success! New Tip: ${getIbGibAddr({ ibGib: mergeResult })}`); }
+                                mergeResultIbGibs.push(mergeResult);
+                                outgoingPayload.push(mergeResult); // Send result to peer
+                            }
+                        } catch (e) {
+                            console.error(`${lc} Merge failed: ${e}`);
+                            // If merge fails, we might Abort or just continue?
+                        }
+                    }
+                }
             }
         }
 
-        // 3. Determine Next Stage
-        if (requests.length > 0) {
-            // They requested more data -> Send Delta
-            const sagaId = deltaData.sagaId;
+        // 4. Determine Next Action
+        // We have `outgoingPayload` (Requests + Merge Results).
+        // Does Peer have outstanding requests? No, we fulfilled `peerRequests`.
+        // Do WE have outstanding requests?
+        // We might if `mergeResult` requires further sync? Usually no, result is complete.
+
+        const myRequests: string[] = []; // If we had more needs (e.g. partial payload), we'd add here.
+
+        const hasOutgoing = outgoingPayload.length > 0;
+        const hasMyRequests = myRequests.length > 0;
+
+        if (hasOutgoing || hasMyRequests) {
+            // We have business to attend to -> Send Delta
             const responseDeltaData: SyncSagaMessageDeltaData_V1 = {
-                sagaId,
+                sagaId: deltaData.sagaId,
                 stage: SyncStage.delta,
                 payloadAddrs: outgoingPayload.map(p => getIbGibAddr({ ibGib: p })),
+                requests: hasMyRequests ? myRequests : undefined,
+                proposeCommit: !hasMyRequests // If we are sending data but have no requests, we VALIDATE PROPOSAL?
+                // Wait. If we send data, we are NOT committing yet. 
+                // We are sending data. The OTHER side must ingest it.
+                // So proposeCommit = true? 
+                // "Here is the data. I'm done. If you are good, let's commit."
+                // Yes.
             };
 
+            // BUT if `peerProposesCommit` was true, and we are sending data, we are effectively rejecting/delaying it.
+            // We just send the Delta. Peer receives it, ingests, sees ProposeCommit=True (from us), and then Commits.
+
+            // So yes, proposeCommit = true.
+            responseDeltaData.proposeCommit = true;
+
             const deltaStone = await this.createSyncMsgStone({
                 data: responseDeltaData,
                 space,
@@ -1119,49 +1434,126 @@ export class SyncSagaCoordinator {
             return { frame: deltaFrame, payloadIbGibs: outgoingPayload, receivedPayloadIbGibs };
 
         } else {
-            // No requests -> Commit
-            const sagaId = deltaData.sagaId;
-            const commitData: SyncSagaMessageCommitData_V1 = {
-                sagaId,
-                stage: SyncStage.commit,
-                success: true,
-            };
+            // We have nothing to send.
+
+            if (peerProposesCommit) {
+                // Peer is done. We are done. -> Commit.
+                const commitData: SyncSagaMessageCommitData_V1 = {
+                    sagaId: deltaData.sagaId,
+                    stage: SyncStage.commit,
+                    success: true,
+                };
 
-            const commitStone = await this.createSyncMsgStone({
-                data: commitData,
-                space,
-                metaspace
-            });
+                const commitStone = await this.createSyncMsgStone({
+                    data: commitData,
+                    space,
+                    metaspace
+                });
 
-            const commitFrame = await this.evolveSyncSagaIbGib({
-                prevSagaIbGib: sagaIbGib,
-                msgStones: [commitStone],
-                identity,
-                space,
-                metaspace
-            });
+                const commitFrame = await this.evolveSyncSagaIbGib({
+                    prevSagaIbGib: sagaIbGib,
+                    msgStones: [commitStone],
+                    identity,
+                    space,
+                    metaspace
+                });
+
+                return { frame: commitFrame, receivedPayloadIbGibs };
+
+            } else {
+                // peer did NOT propose commit (maybe they just sent data/requests and didn't ready flag).
+                // But we are empty.
+                // So WE propose commit.
+                const responseDeltaData: SyncSagaMessageDeltaData_V1 = {
+                    sagaId: deltaData.sagaId,
+                    stage: SyncStage.delta,
+                    proposeCommit: true,
+                    payloadAddrs: [], // Always include empty array if sending delta
+                };
 
-            return { frame: commitFrame, receivedPayloadIbGibs };
+                const deltaStone = await this.createSyncMsgStone({
+                    data: responseDeltaData,
+                    space,
+                    metaspace
+                });
+
+                const deltaFrame = await this.evolveSyncSagaIbGib({
+                    prevSagaIbGib: sagaIbGib,
+                    msgStones: [deltaStone],
+                    identity,
+                    space,
+                    metaspace
+                });
+
+                // Check if PEER proposed commit
+                if (deltaData.proposeCommit) {
+                    if (logalot) { console.log(`${lc} Peer proposed commit. Accepting & Committing.`); }
+                    // Peer wants to commit and has no more requests.
+                    // We should Commit.
+
+                    const commitData: SyncSagaMessageCommitData_V1 = {
+                        sagaId: deltaData.sagaId,
+                        stage: SyncStage.commit,
+                        success: true,
+                    };
+
+                    const commitStone = await this.createSyncMsgStone({
+                        data: commitData,
+                        space,
+                        metaspace
+                    });
+
+                    const commitFrame = await this.evolveSyncSagaIbGib({
+                        prevSagaIbGib: deltaFrame, // Build on top of the Delta we just created/persisted
+                        msgStones: [commitStone],
+                        identity,
+                        space,
+                        metaspace
+                    });
+
+                    return { frame: commitFrame, receivedPayloadIbGibs };
+                }
+
+                return { frame: deltaFrame, receivedPayloadIbGibs };
+            }
         }
     }
 
+
     protected async handleCommitFrame({
         sagaIbGib,
         space,
+        metaspace,
     }: {
         sagaIbGib: SyncIbGib_V1,
         space: IbGibSpaceAny,
+        metaspace: MetaspaceService,
+        identity?: KeystoneIbGib_V1,
     }): Promise<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[] } | null> {
         const lc = `${this.lc}[${this.handleCommitFrame.name}]`;
-        if (logalot) { console.log(`${lc} Commit received. Saga complete.`); }
+        if (logalot) { console.log(`${lc} Commit received.`); }
+
+        // Sender Logic (Finalizing):
+        // If we are here, we received a Commit frame from the Peer.
+        // This implies the Peer has successfully committed.
+        // We should now:
+        // 1. Validate (implicitly done by receiving valid frame)
+        // 2. Perform our own cleanup (Temp -> Dest, if applicable)
+        // 3. Return null to signal saga completion.
+
+        // Note: Currently we don't have explicit cleanup logic implemented here yet (TODO).
+
+        if (logalot) { console.log(`${lc} Peer committed. Finalizing saga locally. Saga Complete.`); }
         return null;
     }
 
     protected async handleConflictFrame({
         sagaIbGib,
+        metaspace,
         space,
     }: {
         sagaIbGib: SyncIbGib_V1,
+        metaspace: MetaspaceService,
         space: IbGibSpaceAny,
     }): Promise<{ frame: SyncIbGib_V1, payloadIbGibs?: IbGib_V1[] } | null> {
         const lc = `${this.lc}[${this.handleConflictFrame.name}]`;
@@ -1189,16 +1581,27 @@ export class SyncSagaCoordinator {
         space: IbGibSpaceAny,
         metaspace: MetaspaceService,
     }): Promise<IbGib_V1<TStoneData>> {
-        const ib = await getSyncSagaMessageIb({ data });
-        const stone = await Factory_V1.stone({
-            ib,
-            parentPrimitiveIb: SYNC_SAGA_MSG_ATOM,
-            data,
-            uuid: true, // we want the stone to have its own uniqueness
-        });
-        await putInSpace({ space, ibGib: stone });
-        await metaspace.registerNewIbGib({ ibGib: stone });
-        return stone as IbGib_V1<TStoneData>;
+        const lc = `${this.lc}[${this.createSyncMsgStone.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} starting... (I: 5f7f98e8ff980364f7191fcee4531e26)`); }
+
+            const ib = await getSyncSagaMessageIb({ data });
+            const stone = await Factory_V1.stone({
+                ib,
+                parentPrimitiveIb: SYNC_SAGA_MSG_ATOM,
+                data,
+                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.registerNewIbGib({ ibGib: stone });
+            return stone as IbGib_V1<TStoneData>;
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        } finally {
+            if (logalot) { console.log(`${lc} complete.`); }
+        }
     }
 
 
@@ -1211,12 +1614,14 @@ export class SyncSagaCoordinator {
         identity,
         space,
         metaspace,
+        conflictStrategy,
     }: {
         prevSagaIbGib?: SyncIbGib_V1,
         msgStones: IbGib_V1[],
         identity?: KeystoneIbGib_V1,
         space: IbGibSpaceAny,
         metaspace: MetaspaceService,
+        conflictStrategy?: SyncConflictStrategy,
     }): Promise<SyncIbGib_V1> {
         const lc = `${this.lc}[${this.evolveSyncSagaIbGib.name}]`;
         try {
@@ -1293,6 +1698,7 @@ export class SyncSagaCoordinator {
                     payload: undefined, // Data in stone
                     n: 0,
                     isTjp: true,
+                    conflictStrategy,
                 };
                 const ib = await getSyncIb({ data });