Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

fix: retry incomplete peer task merges immediately (#10677)

Adam Eivy9225593584c8
diff --git a/server/services/sharing/cosTasksSync.test.js b/server/services/sharing/cosTasksSync.test.js
index 7c4b384474..8e19983085 100644
--- a/server/services/sharing/cosTasksSync.test.js
+++ b/server/services/sharing/cosTasksSync.test.js
@@ -36,11 +36,15 @@ vi.mock('../../lib/peerHttpClient.js', async (importOriginal) => ({
// cosTaskStore is dynamic-imported by both the sender (getUserTasks/getCosTasks)
// and the receiver (mergePeerTasks). Spy it so the wire build + merge are
// observable AND can't read/write the real task files.
-vi.mock('../cosTaskStore.js', () => ({
- getUserTasks: vi.fn().mockResolvedValue({ tasks: [] }),
- getCosTasks: vi.fn().mockResolvedValue({ tasks: [] }),
- mergePeerTasks: vi.fn().mockResolvedValue({ changed: false }),
-}));
+const taskStoreAvailability = vi.hoisted(() => ({ available: true }));
+vi.mock('../cosTaskStore.js', () => {
+ const merge = vi.fn().mockResolvedValue({ changed: false });
+ return {
+ getUserTasks: vi.fn().mockResolvedValue({ tasks: [] }),
+ getCosTasks: vi.fn().mockResolvedValue({ tasks: [] }),
+ get mergePeerTasks() { return taskStoreAvailability.available ? merge : undefined; },
+ };
+});
import {
buildCosTasksPayload,
@@ -70,6 +74,7 @@ function task(id, status = 'pending', overrides = {}) {
}
beforeEach(() => {
+ taskStoreAvailability.available = true;
vi.mocked(peerFetch).mockReset();
vi.mocked(getPeers).mockResolvedValue([PEER]);
vi.mocked(getUserTasks).mockReset().mockResolvedValue({ tasks: [] });
@@ -184,6 +189,46 @@ describe('syncCosTasksFromPeer', () => {
expect(internalCall[1].map((t) => t.id)).toEqual(['sys-b']);
});
+ it.each(['user', 'internal'])('retries the identical payload immediately after the %s file merge fails', async (failedType) => {
+ const peer = { ...PEER, instanceId: `retry-${failedType}` };
+ const tasks = [
+ { id: 'user-retry', status: 'in_progress', priority: 'MEDIUM', description: 'Example user task', metadata: { claimedBy: peer.instanceId, claimId: 'user-claim' }, taskType: 'user' },
+ { id: 'internal-retry', status: 'in_progress', priority: 'MEDIUM', description: 'Example internal task', metadata: { claimedBy: peer.instanceId, claimId: 'internal-claim' }, taskType: 'internal' },
+ ];
+ const stored = { user: [], internal: [] };
+ let failing = true;
+ vi.mocked(peerFetch).mockResolvedValue(payloadRes({ schemaVersion: PORTOS_SCHEMA_VERSIONS.cosTasks, listHash: sha(peer.instanceId), tasks }));
+ vi.mocked(mergePeerTasks).mockImplementation(async (type, incoming) => {
+ if (failing && type === failedType) throw new Error('Synthetic task-file write failure');
+ const changed = JSON.stringify(stored[type]) !== JSON.stringify(incoming);
+ stored[type] = structuredClone(incoming);
+ return { changed };
+ });
+
+ expect(await syncCosTasksFromPeer(peer)).toEqual({ merged: 1 });
+ expect(stored[failedType]).toEqual([]);
+ const successfulType = failedType === 'user' ? 'internal' : 'user';
+ expect(stored[successfulType]).toEqual(tasks.filter(t => t.taskType === successfulType));
+
+ failing = false;
+ expect(await syncCosTasksFromPeer(peer)).toEqual({ merged: 1 });
+ expect(stored.user).toEqual([tasks[0]]);
+ expect(stored.internal).toEqual([tasks[1]]);
+ expect(await syncCosTasksFromPeer(peer)).toEqual({ merged: 0, skipped: 'unchanged' });
+ expect(mergePeerTasks).toHaveBeenCalledTimes(4);
+ });
+
+ it('retries the same payload when the task-store merge is unavailable', async () => {
+ const peer = { ...PEER, instanceId: 'retry-unavailable-store' };
+ vi.mocked(peerFetch).mockResolvedValue(payloadRes({ schemaVersion: 1, listHash: sha('unavailable-store'), tasks: [] }));
+ taskStoreAvailability.available = false;
+ expect(await syncCosTasksFromPeer(peer)).toEqual({ merged: 0 });
+ taskStoreAvailability.available = true;
+ expect(await syncCosTasksFromPeer(peer)).toEqual({ merged: 0 });
+ expect(mergePeerTasks).toHaveBeenCalledTimes(2);
+ expect(await syncCosTasksFromPeer(peer)).toEqual({ merged: 0, skipped: 'unchanged' });
+ });
+
it('short-circuits an unchanged backlog on the second identical sweep', async () => {
vi.mocked(peerFetch).mockResolvedValue(payloadRes({ schemaVersion: 1, listHash: sha('stable'), tasks: [] }));
await syncCosTasksFromPeer(PEER); // first sweep records the hash
diff --git a/server/services/sharing/peerCosSync.js b/server/services/sharing/peerCosSync.js
index a89d05955b..bc0f3d753f 100644
--- a/server/services/sharing/peerCosSync.js
+++ b/server/services/sharing/peerCosSync.js
@@ -447,11 +447,11 @@ const cosTasksSweepInFlight = new Set(); // peerInstanceId
* Apply a peer's task payload into the LOCAL task files via a claim-aware merge.
* Splits the entries by taskType and hands each file's tasks to
* cosTaskStore.mergePeerTasks (which runs the pure merge under the state lock).
- * Returns the number of files actually changed.
+ * Returns changed-file count separately from successful application completion.
*/
async function mergeCosTasksFromPayload(tasks) {
const mod = await import('../cosTaskStore.js').catch(() => null);
- if (!mod?.mergePeerTasks) return 0;
+ if (!mod?.mergePeerTasks) return { changed: 0, complete: false };
const user = [];
const internal = [];
for (const t of Array.isArray(tasks) ? tasks : []) {
@@ -471,7 +471,7 @@ async function mergeCosTasksFromPayload(tasks) {
logFailureWithStack('⚠️ peerSync: cos-tasks internal merge failed', err); return null;
});
if (internalRes?.changed) changed++;
- return changed;
+ return { changed, complete: userRes !== null && internalRes !== null };
}
/**
@@ -529,8 +529,11 @@ export async function syncCosTasksFromPeer(peer) {
}
cosTasksUnchangedSkips.set(peer.instanceId, 0); // forced re-merge — fall through
}
- const changed = await mergeCosTasksFromPayload(payload.tasks);
- lastCosTasksListHash.set(peer.instanceId, payload.listHash);
+ const { changed, complete } = await mergeCosTasksFromPayload(payload.tasks);
+ // A partial merge remains retryable on the very next sweep. Successful
+ // files are retained and safely re-applied by the idempotent store merge.
+ if (complete) lastCosTasksListHash.set(peer.instanceId, payload.listHash);
+ else lastCosTasksListHash.delete(peer.instanceId);
if (changed > 0) {
console.log(`📥 peerSync: cos-tasks sweep from ${peer.name || peer.instanceId} — merged ${changed} task file(s)`);
}