@osmosis-ai/sync 0.1.0

package/dist/config.d.ts

@@ -0,0 +1,10 @@
+export interface SyncConfig {
+    /** URL of the Osmosis mesh server */
+    meshUrl: string;
+    /** Auto-sync interval in ms (default: 5 min) */
+    syncIntervalMs: number;
+    /** Enable periodic sync */
+    autoSync: boolean;
+}
+export declare const DEFAULT_SYNC_CONFIG: SyncConfig;
+export declare function resolveSyncConfig(partial?: Partial<SyncConfig>): SyncConfig;

package/dist/config.js

@@ -0,0 +1,9 @@
+export const DEFAULT_SYNC_CONFIG = {
+    meshUrl: 'https://mesh.osmosis.dev',
+    syncIntervalMs: 5 * 60 * 1000,
+    autoSync: false,
+};
+export function resolveSyncConfig(partial) {
+    return { ...DEFAULT_SYNC_CONFIG, ...partial };
+}
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AASA,MAAM,CAAC,MAAM,mBAAmB,GAAe;IAC7C,OAAO,EAAE,0BAA0B;IACnC,cAAc,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI;IAC7B,QAAQ,EAAE,KAAK;CAChB,CAAC;AAEF,MAAM,UAAU,iBAAiB,CAAC,OAA6B;IAC7D,OAAO,EAAE,GAAG,mBAAmB,EAAE,GAAG,OAAO,EAAE,CAAC;AAChD,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { contributeTo, pushAtoms } from './push.js';
+export { learnFrom, pullAtoms } from './pull.js';
+export { syncWithMesh, syncWithPeer } from './sync.js';
+export { createSyncServer } from './server.js';
+export { startAutoSync } from './scheduler.js';
+export type { AutoSyncHandle } from './scheduler.js';
+export { resolveSyncConfig, DEFAULT_SYNC_CONFIG } from './config.js';
+export type { SyncConfig } from './config.js';
+export type { SyncResult } from './types.js';
+export { getAllPeers } from './meta.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export { contributeTo, pushAtoms } from './push.js';
+export { learnFrom, pullAtoms } from './pull.js';
+export { syncWithMesh, syncWithPeer } from './sync.js';
+export { createSyncServer } from './server.js';
+export { startAutoSync } from './scheduler.js';
+export { resolveSyncConfig, DEFAULT_SYNC_CONFIG } from './config.js';
+export { getAllPeers } from './meta.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAE/C,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGrE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC"}

package/dist/meta.d.ts

@@ -0,0 +1,10 @@
+import type { AtomStore } from '@osmosis-ai/core';
+export declare function getLastPushAt(store: AtomStore, peerUrl: string): string | null;
+export declare function getLastPullAt(store: AtomStore, peerUrl: string): string | null;
+export declare function setLastPushAt(store: AtomStore, peerUrl: string, ts: string): void;
+export declare function setLastPullAt(store: AtomStore, peerUrl: string, ts: string): void;
+export declare function getAllPeers(store: AtomStore): Array<{
+    peer_url: string;
+    last_push_at: string | null;
+    last_pull_at: string | null;
+}>;

package/dist/meta.js

@@ -0,0 +1,45 @@
+const SYNC_META_SCHEMA = `
+CREATE TABLE IF NOT EXISTS sync_meta (
+  peer_url TEXT PRIMARY KEY,
+  last_push_at TEXT,
+  last_pull_at TEXT
+);
+`;
+function ensureTable(store) {
+    const db = store.db;
+    db.exec(SYNC_META_SCHEMA);
+}
+export function getLastPushAt(store, peerUrl) {
+    ensureTable(store);
+    const db = store.db;
+    const row = db.prepare('SELECT last_push_at FROM sync_meta WHERE peer_url = ?').get(peerUrl);
+    return row?.last_push_at ?? null;
+}
+export function getLastPullAt(store, peerUrl) {
+    ensureTable(store);
+    const db = store.db;
+    const row = db.prepare('SELECT last_pull_at FROM sync_meta WHERE peer_url = ?').get(peerUrl);
+    return row?.last_pull_at ?? null;
+}
+export function setLastPushAt(store, peerUrl, ts) {
+    ensureTable(store);
+    const db = store.db;
+    db.prepare(`
+    INSERT INTO sync_meta (peer_url, last_push_at) VALUES (?, ?)
+    ON CONFLICT(peer_url) DO UPDATE SET last_push_at = excluded.last_push_at
+  `).run(peerUrl, ts);
+}
+export function setLastPullAt(store, peerUrl, ts) {
+    ensureTable(store);
+    const db = store.db;
+    db.prepare(`
+    INSERT INTO sync_meta (peer_url, last_pull_at) VALUES (?, ?)
+    ON CONFLICT(peer_url) DO UPDATE SET last_pull_at = excluded.last_pull_at
+  `).run(peerUrl, ts);
+}
+export function getAllPeers(store) {
+    ensureTable(store);
+    const db = store.db;
+    return db.prepare('SELECT * FROM sync_meta').all();
+}
+//# sourceMappingURL=meta.js.map

package/dist/meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.js","sourceRoot":"","sources":["../src/meta.ts"],"names":[],"mappings":"AAEA,MAAM,gBAAgB,GAAG;;;;;;CAMxB,CAAC;AAEF,SAAS,WAAW,CAAC,KAAgB;IACnC,MAAM,EAAE,GAAI,KAAa,CAAC,EAAE,CAAC;IAC7B,EAAE,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;AAC5B,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,KAAgB,EAAE,OAAe;IAC7D,WAAW,CAAC,KAAK,CAAC,CAAC;IACnB,MAAM,EAAE,GAAI,KAAa,CAAC,EAAE,CAAC;IAC7B,MAAM,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,uDAAuD,CAAC,CAAC,GAAG,CAAC,OAAO,CAAQ,CAAC;IACpG,OAAO,GAAG,EAAE,YAAY,IAAI,IAAI,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,KAAgB,EAAE,OAAe;IAC7D,WAAW,CAAC,KAAK,CAAC,CAAC;IACnB,MAAM,EAAE,GAAI,KAAa,CAAC,EAAE,CAAC;IAC7B,MAAM,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,uDAAuD,CAAC,CAAC,GAAG,CAAC,OAAO,CAAQ,CAAC;IACpG,OAAO,GAAG,EAAE,YAAY,IAAI,IAAI,CAAC;AACnC,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,KAAgB,EAAE,OAAe,EAAE,EAAU;IACzE,WAAW,CAAC,KAAK,CAAC,CAAC;IACnB,MAAM,EAAE,GAAI,KAAa,CAAC,EAAE,CAAC;IAC7B,EAAE,CAAC,OAAO,CAAC;;;GAGV,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;AACtB,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,KAAgB,EAAE,OAAe,EAAE,EAAU;IACzE,WAAW,CAAC,KAAK,CAAC,CAAC;IACnB,MAAM,EAAE,GAAI,KAAa,CAAC,EAAE,CAAC;IAC7B,EAAE,CAAC,OAAO,CAAC;;;GAGV,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;AACtB,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,KAAgB;IAC1C,WAAW,CAAC,KAAK,CAAC,CAAC;IACnB,MAAM,EAAE,GAAI,KAAa,CAAC,EAAE,CAAC;IAC7B,OAAO,EAAE,CAAC,OAAO,CAAC,yBAAyB,CAAC,CAAC,GAAG,EAAW,CAAC;AAC9D,CAAC"}

package/dist/pull.d.ts

@@ -0,0 +1,7 @@
+import type { AtomStore } from '@osmosis-ai/core';
+import type { SyncResult } from './types.js';
+/**
+ * Learn from the mesh server — pull new/updated atoms.
+ */
+export declare function learnFrom(localStore: AtomStore, meshUrl: string): Promise<SyncResult>;
+export declare const pullAtoms: typeof learnFrom;

package/dist/pull.js

@@ -0,0 +1,56 @@
+import { getLastPullAt, setLastPullAt } from './meta.js';
+/**
+ * Learn from the mesh server — pull new/updated atoms.
+ */
+export async function learnFrom(localStore, meshUrl) {
+    const errors = [];
+    const since = getLastPullAt(localStore, meshUrl);
+    const now = new Date().toISOString();
+    let remoteAtoms = [];
+    try {
+        const url = since
+            ? `${meshUrl}/mesh/atoms?since=${encodeURIComponent(since)}`
+            : `${meshUrl}/mesh/atoms`;
+        const res = await fetch(url);
+        if (!res.ok) {
+            const errBody = await res.text();
+            return { pushed: 0, pulled: 0, deduped: 0, errors: [`Learn failed: ${res.status} ${errBody}`], timestamp: now };
+        }
+        remoteAtoms = await res.json();
+    }
+    catch (err) {
+        return { pushed: 0, pulled: 0, deduped: 0, errors: [`Learn error: ${err.message}`], timestamp: now };
+    }
+    let pulled = 0;
+    let deduped = 0;
+    for (const atom of remoteAtoms) {
+        try {
+            const { id, created_at, updated_at, ...data } = atom;
+            let result;
+            if (data.type === 'tool') {
+                result = localStore.createToolAtom(data);
+            }
+            else if (data.type === 'negative') {
+                result = localStore.createNegativeAtom(data);
+            }
+            else {
+                result = localStore.createAtom(data);
+            }
+            const ec = result.evidence_count;
+            if (ec && ec > 1) {
+                deduped++;
+            }
+            else {
+                pulled++;
+            }
+        }
+        catch (err) {
+            errors.push(`Learn insert error: ${err.message}`);
+        }
+    }
+    setLastPullAt(localStore, meshUrl, now);
+    return { pushed: 0, pulled, deduped, errors, timestamp: now };
+}
+// Keep backward compat alias
+export const pullAtoms = learnFrom;
+//# sourceMappingURL=pull.js.map

package/dist/pull.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull.js","sourceRoot":"","sources":["../src/pull.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAEzD;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,UAAqB,EAAE,OAAe;IACpE,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,MAAM,KAAK,GAAG,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IACjD,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAErC,IAAI,WAAW,GAAoB,EAAE,CAAC;IACtC,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,KAAK;YACf,CAAC,CAAC,GAAG,OAAO,qBAAqB,kBAAkB,CAAC,KAAK,CAAC,EAAE;YAC5D,CAAC,CAAC,GAAG,OAAO,aAAa,CAAC;QAC5B,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;QAC7B,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;YACZ,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC;YACjC,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,iBAAiB,GAAG,CAAC,MAAM,IAAI,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;QAClH,CAAC;QACD,WAAW,GAAG,MAAM,GAAG,CAAC,IAAI,EAAqB,CAAC;IACpD,CAAC;IAAC,OAAO,GAAQ,EAAE,CAAC;QAClB,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,gBAAgB,GAAG,CAAC,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;IACvG,CAAC;IAED,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;QAC/B,IAAI,CAAC;YACH,MAAM,EAAE,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,IAAI,EAAE,GAAG,IAAW,CAAC;YAC5D,IAAI,MAAqB,CAAC;YAC1B,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;gBACzB,MAAM,GAAG,UAAU,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;YAC3C,CAAC;iBAAM,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;gBACpC,MAAM,GAAG,UAAU,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;YAC/C,CAAC;iBAAM,CAAC;gBACN,MAAM,GAAG,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;YACvC,CAAC;YAED,MAAM,EAAE,GAAI,MAAc,CAAC,cAAc,CAAC;YAC1C,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;gBACjB,OAAO,EAAE,CAAC;YACZ,CAAC;iBAAM,CAAC;gBACN,MAAM,EAAE,CAAC;YACX,CAAC;QACH,CAAC;QAAC,OAAO,GAAQ,EAAE,CAAC;YAClB,MAAM,CAAC,IAAI,CAAC,uBAAuB,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IAED,aAAa,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IACxC,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;AAChE,CAAC;AAED,6BAA6B;AAC7B,MAAM,CAAC,MAAM,SAAS,GAAG,SAAS,CAAC"}

package/dist/push.d.ts

@@ -0,0 +1,7 @@
+import type { AtomStore } from '@osmosis-ai/core';
+import type { SyncResult } from './types.js';
+/**
+ * Contribute local atoms to the mesh server.
+ */
+export declare function contributeTo(localStore: AtomStore, meshUrl: string): Promise<SyncResult>;
+export declare const pushAtoms: typeof contributeTo;

package/dist/push.js

@@ -0,0 +1,52 @@
+import { getLastPushAt, setLastPushAt } from './meta.js';
+/**
+ * Contribute local atoms to the mesh server.
+ */
+export async function contributeTo(localStore, meshUrl) {
+    const errors = [];
+    const since = getLastPushAt(localStore, meshUrl);
+    const now = new Date().toISOString();
+    const allAtoms = localStore.getAll();
+    const toSync = since
+        ? allAtoms.filter(a => a.updated_at > since)
+        : allAtoms;
+    if (toSync.length === 0) {
+        setLastPushAt(localStore, meshUrl, now);
+        return { pushed: 0, pulled: 0, deduped: 0, errors: [], timestamp: now };
+    }
+    let pushed = 0;
+    let deduped = 0;
+    try {
+        const payload = toSync.map(stripAutoFields);
+        const res = await fetch(`${meshUrl}/mesh/contribute`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        if (res.ok) {
+            const body = await res.json();
+            for (const r of body.results) {
+                if (r.status === 'deduped')
+                    deduped++;
+                else
+                    pushed++;
+            }
+        }
+        else {
+            const errBody = await res.text();
+            errors.push(`Contribute failed: ${res.status} ${errBody}`);
+        }
+    }
+    catch (err) {
+        errors.push(`Contribute error: ${err.message}`);
+    }
+    setLastPushAt(localStore, meshUrl, now);
+    return { pushed, pulled: 0, deduped, errors, timestamp: now };
+}
+function stripAutoFields(atom) {
+    const { id, created_at, updated_at, ...rest } = atom;
+    return rest;
+}
+// Keep backward compat alias
+export const pushAtoms = contributeTo;
+//# sourceMappingURL=push.js.map

package/dist/push.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.js","sourceRoot":"","sources":["../src/push.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAEzD;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,UAAqB,EAAE,OAAe;IACvE,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,MAAM,KAAK,GAAG,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IACjD,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAErC,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC;IACrC,MAAM,MAAM,GAAG,KAAK;QAClB,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,GAAG,KAAK,CAAC;QAC5C,CAAC,CAAC,QAAQ,CAAC;IAEb,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxB,aAAa,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;QACxC,OAAO,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;IAC1E,CAAC;IAED,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAC5C,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,GAAG,OAAO,kBAAkB,EAAE;YACpD,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;SAC9B,CAAC,CAAC;QAEH,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC;YACX,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,IAAI,EAA0E,CAAC;YACtG,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBAC7B,IAAI,CAAC,CAAC,MAAM,KAAK,SAAS;oBAAE,OAAO,EAAE,CAAC;;oBACjC,MAAM,EAAE,CAAC;YAChB,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC;YACjC,MAAM,CAAC,IAAI,CAAC,sBAAsB,GAAG,CAAC,MAAM,IAAI,OAAO,EAAE,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;IAAC,OAAO,GAAQ,EAAE,CAAC;QAClB,MAAM,CAAC,IAAI,CAAC,qBAAqB,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;IAClD,CAAC;IAED,aAAa,CAAC,UAAU,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IACxC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;AAChE,CAAC;AAED,SAAS,eAAe,CAAC,IAAmB;IAC1C,MAAM,EAAE,EAAE,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,IAAI,EAAE,GAAG,IAAW,CAAC;IAC5D,OAAO,IAAI,CAAC;AACd,CAAC;AAED,6BAA6B;AAC7B,MAAM,CAAC,MAAM,SAAS,GAAG,YAAY,CAAC"}

package/dist/scheduler.d.ts

@@ -0,0 +1,6 @@
+import type { AtomStore } from '@osmosis-ai/core';
+import type { SyncConfig } from './config.js';
+export interface AutoSyncHandle {
+    stop(): void;
+}
+export declare function startAutoSync(store: AtomStore, config: SyncConfig): AutoSyncHandle;

package/dist/scheduler.js

@@ -0,0 +1,20 @@
+import { syncWithMesh } from './sync.js';
+export function startAutoSync(store, config) {
+    if (!config.autoSync || !config.meshUrl) {
+        return { stop() { } };
+    }
+    const timer = setInterval(async () => {
+        try {
+            await syncWithMesh(store, config.meshUrl);
+        }
+        catch {
+            // Silent failure — sync will retry next interval
+        }
+    }, config.syncIntervalMs);
+    return {
+        stop() {
+            clearInterval(timer);
+        },
+    };
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../src/scheduler.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAMzC,MAAM,UAAU,aAAa,CAAC,KAAgB,EAAE,MAAkB;IAChE,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;QACxC,OAAO,EAAE,IAAI,KAAI,CAAC,EAAE,CAAC;IACvB,CAAC;IAED,MAAM,KAAK,GAAG,WAAW,CAAC,KAAK,IAAI,EAAE;QACnC,IAAI,CAAC;YACH,MAAM,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;QAC5C,CAAC;QAAC,MAAM,CAAC;YACP,iDAAiD;QACnD,CAAC;IACH,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC,CAAC;IAE1B,OAAO;QACL,IAAI;YACF,aAAa,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/server.d.ts

@@ -0,0 +1,8 @@
+import { type Server } from 'node:http';
+import { AtomStore } from '@osmosis-ai/core';
+import type { SyncConfig } from './config.js';
+/**
+ * Create a local API server for querying the local atom store.
+ * This is the "osmosis serve" server — local queries only, no peer sync routes.
+ */
+export declare function createSyncServer(store: AtomStore, port: number, _config: SyncConfig): Server;

package/dist/server.js

@@ -0,0 +1,88 @@
+import { createServer as createHttpServer } from 'node:http';
+/**
+ * Create a local API server for querying the local atom store.
+ * This is the "osmosis serve" server — local queries only, no peer sync routes.
+ */
+export function createSyncServer(store, port, _config) {
+    const server = createHttpServer(async (req, res) => {
+        const url = new URL(req.url ?? '/', `http://localhost:${port}`);
+        const path = url.pathname;
+        const method = req.method ?? 'GET';
+        const json = (status, data) => {
+            res.writeHead(status, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(data));
+        };
+        try {
+            const readBody = () => new Promise((resolve, reject) => {
+                const chunks = [];
+                req.on('data', (c) => chunks.push(c));
+                req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+                req.on('error', reject);
+            });
+            // POST /atoms
+            if (method === 'POST' && path === '/atoms') {
+                const body = JSON.parse(await readBody());
+                let atom;
+                if (body.type === 'tool') {
+                    atom = store.createToolAtom(body);
+                }
+                else if (body.type === 'negative') {
+                    atom = store.createNegativeAtom(body);
+                }
+                else {
+                    atom = store.createAtom(body);
+                }
+                return json(201, atom);
+            }
+            // GET /atoms/search?q=...
+            if (method === 'GET' && path === '/atoms/search') {
+                const q = url.searchParams.get('q') ?? '';
+                return json(200, store.search(q));
+            }
+            // GET /atoms/:id
+            const idMatch = path.match(/^\/atoms\/([^/]+)$/);
+            if (method === 'GET' && idMatch) {
+                const atom = store.getById(idMatch[1]);
+                if (!atom)
+                    return json(404, { error: 'Not found' });
+                return json(200, atom);
+            }
+            // GET /atoms?type=&tool_name=&since=
+            if (method === 'GET' && path === '/atoms') {
+                const type = url.searchParams.get('type');
+                const toolName = url.searchParams.get('tool_name');
+                const since = url.searchParams.get('since');
+                let atoms;
+                if (toolName) {
+                    atoms = store.queryByToolName(toolName);
+                }
+                else if (type) {
+                    atoms = store.queryByType(type);
+                }
+                else {
+                    atoms = store.getAll();
+                }
+                if (since) {
+                    atoms = atoms.filter(a => a.updated_at > since);
+                }
+                return json(200, atoms);
+            }
+            // GET /sync/status — kept for backward compat
+            if (method === 'GET' && path === '/sync/status') {
+                const allAtoms = store.getAll();
+                return json(200, {
+                    atomCount: allAtoms.length,
+                    meshUrl: _config.meshUrl,
+                });
+            }
+            json(404, { error: 'Not found' });
+        }
+        catch (err) {
+            const status = err.name === 'ZodError' ? 400 : 500;
+            json(status, { error: err.message ?? 'Internal error' });
+        }
+    });
+    server.listen(port);
+    return server;
+}
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/dist/sync.d.ts

@@ -0,0 +1,7 @@
+import type { AtomStore } from '@osmosis-ai/core';
+import type { SyncResult } from './types.js';
+/**
+ * Full sync with mesh: contribute local atoms, then learn from mesh.
+ */
+export declare function syncWithMesh(localStore: AtomStore, meshUrl: string): Promise<SyncResult>;
+export declare const syncWithPeer: typeof syncWithMesh;

package/dist/sync.js

@@ -0,0 +1,19 @@
+import { contributeTo } from './push.js';
+import { learnFrom } from './pull.js';
+/**
+ * Full sync with mesh: contribute local atoms, then learn from mesh.
+ */
+export async function syncWithMesh(localStore, meshUrl) {
+    const pushResult = await contributeTo(localStore, meshUrl);
+    const pullResult = await learnFrom(localStore, meshUrl);
+    return {
+        pushed: pushResult.pushed + pushResult.deduped,
+        pulled: pullResult.pulled,
+        deduped: pushResult.deduped + pullResult.deduped,
+        errors: [...pushResult.errors, ...pullResult.errors],
+        timestamp: pullResult.timestamp,
+    };
+}
+// Keep backward compat alias
+export const syncWithPeer = syncWithMesh;
+//# sourceMappingURL=sync.js.map

package/dist/sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.js","sourceRoot":"","sources":["../src/sync.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEtC;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CAAC,UAAqB,EAAE,OAAe;IACvE,MAAM,UAAU,GAAG,MAAM,YAAY,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAC3D,MAAM,UAAU,GAAG,MAAM,SAAS,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAExD,OAAO;QACL,MAAM,EAAE,UAAU,CAAC,MAAM,GAAG,UAAU,CAAC,OAAO;QAC9C,MAAM,EAAE,UAAU,CAAC,MAAM;QACzB,OAAO,EAAE,UAAU,CAAC,OAAO,GAAG,UAAU,CAAC,OAAO;QAChD,MAAM,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,GAAG,UAAU,CAAC,MAAM,CAAC;QACpD,SAAS,EAAE,UAAU,CAAC,SAAS;KAChC,CAAC;AACJ,CAAC;AAED,6BAA6B;AAC7B,MAAM,CAAC,MAAM,YAAY,GAAG,YAAY,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+export interface SyncResult {
+    pushed: number;
+    pulled: number;
+    deduped: number;
+    errors: string[];
+    timestamp: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@osmosis-ai/sync",
+  "version": "0.1.0",
+  "description": "Sync engine for Osmosis — HTTP-based instance-to-instance sync",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@osmosis-ai/core": "*",
+    "@osmosis-ai/mesh-server": "*"
+  },
+  "devDependencies": {
+    "better-sqlite3": "^11.7.0",
+    "@types/better-sqlite3": "^7.6.12",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "license": "MIT"
+}

package/src/__tests__/mesh-sync.test.ts

@@ -0,0 +1,183 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { AtomStore } from '@osmosis-ai/core';
+import type { Server } from 'node:http';
+import { startMeshServer, type MeshServerHandle } from '@osmosis-ai/mesh-server';
+import { contributeTo } from '../push.js';
+import { learnFrom } from '../pull.js';
+import { syncWithMesh } from '../sync.js';
+
+let nextPort = 19500;
+function getPort() { return nextPort++; }
+
+function makeToolAtom(toolName: string, observation: string) {
+  return {
+    type: 'tool' as const,
+    observation,
+    context: `testing ${toolName}`,
+    confidence: 0.8,
+    fitness_score: 0.7,
+    trust_tier: 'local' as const,
+    source_agent_hash: 'test-agent-' + toolName,
+    decay_rate: 0.99,
+    tool_name: toolName,
+    params_hash: 'abc123',
+    outcome: 'success' as const,
+    error_signature: null,
+    latency_ms: 100,
+    reliability_score: 0.9,
+  };
+}
+
+describe('mesh sync: two clients + one mesh', () => {
+  let clientA: AtomStore;
+  let clientB: AtomStore;
+  let mesh: MeshServerHandle;
+  let meshUrl: string;
+
+  function setup() {
+    const port = getPort();
+    clientA = new AtomStore(':memory:');
+    clientB = new AtomStore(':memory:');
+    mesh = startMeshServer({ port, dbPath: ':memory:' });
+    meshUrl = `http://localhost:${port}`;
+  }
+
+  afterEach(() => {
+    try { mesh?.stop(); } catch {}
+    try { clientA?.close(); } catch {}
+    try { clientB?.close(); } catch {}
+  });
+
+  it('client A contributes atoms to mesh', async () => {
+    setup();
+    clientA.createToolAtom(makeToolAtom('browser.click', 'browser.click fails on hidden elements'));
+
+    const result = await contributeTo(clientA, meshUrl);
+    expect(result.errors).toEqual([]);
+    expect(result.pushed).toBe(1);
+
+    // Mesh should have the atom
+    const meshAtoms = mesh.store.getAll();
+    expect(meshAtoms.length).toBe(1);
+    expect(meshAtoms[0]!.observation).toBe('browser.click fails on hidden elements');
+    // Mesh atoms are quarantined
+    expect(meshAtoms[0]!.trust_tier).toBe('quarantine');
+  });
+
+  it('client B learns from mesh', async () => {
+    setup();
+    // Seed the mesh directly
+    mesh.store.createToolAtom(makeToolAtom('fetch', 'fetch times out on large payloads'));
+
+    const result = await learnFrom(clientB, meshUrl);
+    expect(result.errors).toEqual([]);
+    expect(result.pulled).toBe(1);
+
+    const bAtoms = clientB.getAll();
+    expect(bAtoms.length).toBe(1);
+    expect(bAtoms[0]!.observation).toBe('fetch times out on large payloads');
+  });
+
+  it('full flow: A captures → mesh → B learns → B captures → mesh → A learns', async () => {
+    setup();
+
+    // Client A captures tool calls
+    clientA.createToolAtom(makeToolAtom('screenshot', 'screenshot fails on lazy-loaded pages'));
+    clientA.createToolAtom(makeToolAtom('exec', 'exec needs pty for interactive commands'));
+
+    // A contributes to mesh
+    await contributeTo(clientA, meshUrl);
+    expect(mesh.store.getAll().length).toBe(2);
+
+    // B learns from mesh
+    await learnFrom(clientB, meshUrl);
+    expect(clientB.getAll().length).toBe(2);
+
+    // B captures different tool calls
+    clientB.createToolAtom(makeToolAtom('file.write', 'file.write creates parent dirs automatically'));
+
+    // B contributes to mesh
+    await contributeTo(clientB, meshUrl);
+    expect(mesh.store.getAll().length).toBe(3);
+
+    // A learns from mesh
+    await learnFrom(clientA, meshUrl);
+
+    // Both should have all 3 atoms
+    expect(clientA.getAll().length).toBe(3);
+    expect(clientB.getAll().length).toBe(3);
+    expect(mesh.store.getAll().length).toBe(3);
+  });
+
+  it('syncWithMesh does contribute + learn in one call', async () => {
+    setup();
+    clientA.createToolAtom(makeToolAtom('browser.type', 'browser.type needs focus first'));
+
+    const result = await syncWithMesh(clientA, meshUrl);
+    expect(result.errors).toEqual([]);
+    expect(result.pushed).toBeGreaterThanOrEqual(1);
+
+    // Mesh has the atom
+    expect(mesh.store.getAll().length).toBe(1);
+  });
+
+  it('dedup: same observation does not create duplicates on mesh', async () => {
+    setup();
+
+    // Both clients have same observation
+    clientA.createToolAtom(makeToolAtom('browser.click', 'browser.click fails on hidden elements'));
+    clientB.createToolAtom(makeToolAtom('browser.click', 'browser.click fails on hidden elements'));
+
+    // Both contribute
+    await contributeTo(clientA, meshUrl);
+    await contributeTo(clientB, meshUrl);
+
+    // Mesh should have 1 atom (deduped)
+    expect(mesh.store.getAll().length).toBe(1);
+  });
+
+  it('mesh stats endpoint works', async () => {
+    setup();
+    clientA.createToolAtom(makeToolAtom('tool1', 'observation one'));
+    clientA.createToolAtom(makeToolAtom('tool2', 'observation two completely different'));
+    await contributeTo(clientA, meshUrl);
+
+    const res = await fetch(`${meshUrl}/mesh/stats`);
+    const stats = await res.json() as any;
+    expect(stats.totalAtoms).toBe(2);
+    expect(stats.contributors).toBeGreaterThanOrEqual(1);
+  });
+
+  it('mesh query endpoint works', async () => {
+    setup();
+    mesh.store.createToolAtom(makeToolAtom('browser.click', 'browser.click fails on hidden elements'));
+    mesh.store.createToolAtom(makeToolAtom('fetch', 'fetch times out on large payloads'));
+
+    const res = await fetch(`${meshUrl}/mesh/query?q=browser`);
+    const atoms = await res.json() as any[];
+    expect(atoms.length).toBe(1);
+    expect(atoms[0].tool_name).toBe('browser.click');
+  });
+
+  it('incremental sync with since parameter', async () => {
+    setup();
+
+    // First sync: A has one atom
+    clientA.createToolAtom(makeToolAtom('old-tool', 'old observation'));
+    await syncWithMesh(clientA, meshUrl);
+
+    // B syncs — gets 1 atom
+    await syncWithMesh(clientB, meshUrl);
+    expect(clientB.getAll().length).toBe(1);
+
+    // A adds another atom
+    await new Promise(r => setTimeout(r, 50));
+    clientA.createToolAtom(makeToolAtom('new-tool', 'completely new and different observation'));
+    await contributeTo(clientA, meshUrl);
+
+    // B syncs again — should get only the new one (incremental)
+    const result = await learnFrom(clientB, meshUrl);
+    expect(result.pulled).toBe(1);
+    expect(clientB.getAll().length).toBe(2);
+  });
+});

package/src/__tests__/two-instance.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { AtomStore } from '@osmosis-ai/core';
+import { startMeshServer, type MeshServerHandle } from '@osmosis-ai/mesh-server';
+import { createSyncServer } from '../server.js';
+import { syncWithMesh } from '../sync.js';
+import { contributeTo } from '../push.js';
+import { learnFrom } from '../pull.js';
+import { resolveSyncConfig } from '../config.js';
+import type { Server } from 'node:http';
+
+let nextPort = 19432;
+function getPort() { return nextPort++; }
+
+function makeToolAtom(toolName: string, observation: string) {
+  return {
+    type: 'tool' as const,
+    observation,
+    context: `testing ${toolName}`,
+    confidence: 0.8,
+    fitness_score: 0.7,
+    trust_tier: 'quarantine' as const,
+    source_agent_hash: 'test-agent-' + toolName,
+    decay_rate: 0.99,
+    tool_name: toolName,
+    params_hash: 'abc123',
+    outcome: 'success' as const,
+    error_signature: null,
+    latency_ms: 100,
+    reliability_score: 0.9,
+  };
+}
+
+describe('two-instance sync via mesh', () => {
+  let storeA: AtomStore;
+  let storeB: AtomStore;
+  let serverA: Server;
+  let mesh: MeshServerHandle;
+  let meshUrl: string;
+  let portA: number;
+
+  function setup() {
+    portA = getPort();
+    const meshPort = getPort();
+    storeA = new AtomStore(':memory:');
+    storeB = new AtomStore(':memory:');
+    meshUrl = `http://localhost:${meshPort}`;
+    const config = resolveSyncConfig({ meshUrl, autoSync: false });
+    serverA = createSyncServer(storeA, portA, config);
+    mesh = startMeshServer({ port: meshPort, dbPath: ':memory:' });
+  }
+
+  afterEach(() => {
+    try { serverA?.close(); } catch {}
+    try { mesh?.stop(); } catch {}
+    try { storeA?.close(); } catch {}
+    try { storeB?.close(); } catch {}
+  });
+
+  it('should push atoms from A to mesh', async () => {
+    setup();
+    storeA.createToolAtom(makeToolAtom('browser.click', 'browser.click fails on hidden elements'));
+
+    const result = await contributeTo(storeA, meshUrl);
+    expect(result.errors).toEqual([]);
+    expect(result.pushed + result.deduped).toBeGreaterThanOrEqual(1);
+
+    const meshAtoms = mesh.store.getAll();
+    expect(meshAtoms.length).toBe(1);
+    expect(meshAtoms[0]!.observation).toBe('browser.click fails on hidden elements');
+  });
+
+  it('should pull atoms from mesh to B', async () => {
+    setup();
+    mesh.store.createToolAtom(makeToolAtom('fetch', 'fetch times out on large payloads'));
+
+    const result = await learnFrom(storeB, meshUrl);
+    expect(result.errors).toEqual([]);
+    expect(result.pulled).toBe(1);
+
+    const bAtoms = storeB.getAll();
+    expect(bAtoms.length).toBe(1);
+    expect(bAtoms[0]!.observation).toBe('fetch times out on large payloads');
+  });
+
+  it('should full sync: A captures, sync to mesh, B syncs from mesh, B captures, sync to mesh, A syncs', async () => {
+    setup();
+
+    // Instance A captures some tool calls
+    storeA.createToolAtom(makeToolAtom('screenshot', 'screenshot fails on lazy-loaded pages'));
+    storeA.createToolAtom(makeToolAtom('exec', 'exec needs pty for interactive commands'));
+
+    // Sync A → mesh
+    await syncWithMesh(storeA, meshUrl);
+    expect(mesh.store.getAll().length).toBe(2);
+
+    // Sync mesh → B
+    await syncWithMesh(storeB, meshUrl);
+    expect(storeB.getAll().length).toBe(2);
+
+    // Instance B captures different tool calls
+    storeB.createToolAtom(makeToolAtom('file.write', 'file.write creates parent dirs automatically'));
+
+    // Sync B → mesh → A
+    await syncWithMesh(storeB, meshUrl);
+    await syncWithMesh(storeA, meshUrl);
+
+    // Both should have everything
+    const aAtoms = storeA.getAll();
+    const bAtoms = storeB.getAll();
+    expect(aAtoms.length).toBe(3);
+    expect(bAtoms.length).toBe(3);
+  });
+
+  it('should dedup: same observation does not create duplicates', async () => {
+    setup();
+
+    // Both instances have the same observation
+    storeA.createToolAtom(makeToolAtom('browser.click', 'browser.click fails on hidden elements'));
+    storeB.createToolAtom(makeToolAtom('browser.click', 'browser.click fails on hidden elements'));
+
+    // Both sync to mesh
+    await syncWithMesh(storeA, meshUrl);
+    await syncWithMesh(storeB, meshUrl);
+
+    // Mesh should have just 1 atom (deduped)
+    expect(mesh.store.getAll().length).toBe(1);
+    // Both should still have 1 atom
+    expect(storeA.getAll().length).toBe(1);
+    expect(storeB.getAll().length).toBe(1);
+  });
+
+  it('should filter atoms with ?since= parameter on local server', async () => {
+    setup();
+
+    // Create atom at known time
+    storeA.createToolAtom(makeToolAtom('old-tool', 'this is an old observation'));
+
+    const sinceTime = new Date().toISOString();
+
+    // Small delay to ensure timestamp difference
+    await new Promise(r => setTimeout(r, 50));
+
+    storeA.createToolAtom(makeToolAtom('new-tool', 'this is a totally new and different observation'));
+
+    // Fetch with since filter from local server
+    const res = await fetch(`http://localhost:${portA}/atoms?since=${encodeURIComponent(sinceTime)}`);
+    const atoms = await res.json() as any[];
+    expect(atoms.length).toBe(1);
+    expect(atoms[0].tool_name).toBe('new-tool');
+  });
+
+  it('should report sync status', async () => {
+    setup();
+    storeA.createToolAtom(makeToolAtom('test', 'test observation for status'));
+
+    const res = await fetch(`http://localhost:${portA}/sync/status`);
+    const status = await res.json() as any;
+    expect(status.atomCount).toBe(1);
+  });
+});

package/src/config.ts

@@ -0,0 +1,18 @@
+export interface SyncConfig {
+  /** URL of the Osmosis mesh server */
+  meshUrl: string;
+  /** Auto-sync interval in ms (default: 5 min) */
+  syncIntervalMs: number;
+  /** Enable periodic sync */
+  autoSync: boolean;
+}
+
+export const DEFAULT_SYNC_CONFIG: SyncConfig = {
+  meshUrl: 'https://mesh.osmosis.dev',
+  syncIntervalMs: 5 * 60 * 1000,
+  autoSync: false,
+};
+
+export function resolveSyncConfig(partial?: Partial<SyncConfig>): SyncConfig {
+  return { ...DEFAULT_SYNC_CONFIG, ...partial };
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export { contributeTo, pushAtoms } from './push.js';
+export { learnFrom, pullAtoms } from './pull.js';
+export { syncWithMesh, syncWithPeer } from './sync.js';
+export { createSyncServer } from './server.js';
+export { startAutoSync } from './scheduler.js';
+export type { AutoSyncHandle } from './scheduler.js';
+export { resolveSyncConfig, DEFAULT_SYNC_CONFIG } from './config.js';
+export type { SyncConfig } from './config.js';
+export type { SyncResult } from './types.js';
+export { getAllPeers } from './meta.js';

package/src/meta.ts

@@ -0,0 +1,52 @@
+import type { AtomStore } from '@osmosis-ai/core';
+
+const SYNC_META_SCHEMA = `
+CREATE TABLE IF NOT EXISTS sync_meta (
+  peer_url TEXT PRIMARY KEY,
+  last_push_at TEXT,
+  last_pull_at TEXT
+);
+`;
+
+function ensureTable(store: AtomStore): void {
+  const db = (store as any).db;
+  db.exec(SYNC_META_SCHEMA);
+}
+
+export function getLastPushAt(store: AtomStore, peerUrl: string): string | null {
+  ensureTable(store);
+  const db = (store as any).db;
+  const row = db.prepare('SELECT last_push_at FROM sync_meta WHERE peer_url = ?').get(peerUrl) as any;
+  return row?.last_push_at ?? null;
+}
+
+export function getLastPullAt(store: AtomStore, peerUrl: string): string | null {
+  ensureTable(store);
+  const db = (store as any).db;
+  const row = db.prepare('SELECT last_pull_at FROM sync_meta WHERE peer_url = ?').get(peerUrl) as any;
+  return row?.last_pull_at ?? null;
+}
+
+export function setLastPushAt(store: AtomStore, peerUrl: string, ts: string): void {
+  ensureTable(store);
+  const db = (store as any).db;
+  db.prepare(`
+    INSERT INTO sync_meta (peer_url, last_push_at) VALUES (?, ?)
+    ON CONFLICT(peer_url) DO UPDATE SET last_push_at = excluded.last_push_at
+  `).run(peerUrl, ts);
+}
+
+export function setLastPullAt(store: AtomStore, peerUrl: string, ts: string): void {
+  ensureTable(store);
+  const db = (store as any).db;
+  db.prepare(`
+    INSERT INTO sync_meta (peer_url, last_pull_at) VALUES (?, ?)
+    ON CONFLICT(peer_url) DO UPDATE SET last_pull_at = excluded.last_pull_at
+  `).run(peerUrl, ts);
+}
+
+export function getAllPeers(store: AtomStore): Array<{ peer_url: string; last_push_at: string | null; last_pull_at: string | null }> {
+  ensureTable(store);
+  const db = (store as any).db;
+  return db.prepare('SELECT * FROM sync_meta').all() as any[];
+}

package/src/pull.ts

@@ -0,0 +1,59 @@
+import type { AtomStore, KnowledgeAtom } from '@osmosis-ai/core';
+import type { SyncResult } from './types.js';
+import { getLastPullAt, setLastPullAt } from './meta.js';
+
+/**
+ * Learn from the mesh server — pull new/updated atoms.
+ */
+export async function learnFrom(localStore: AtomStore, meshUrl: string): Promise<SyncResult> {
+  const errors: string[] = [];
+  const since = getLastPullAt(localStore, meshUrl);
+  const now = new Date().toISOString();
+
+  let remoteAtoms: KnowledgeAtom[] = [];
+  try {
+    const url = since
+      ? `${meshUrl}/mesh/atoms?since=${encodeURIComponent(since)}`
+      : `${meshUrl}/mesh/atoms`;
+    const res = await fetch(url);
+    if (!res.ok) {
+      const errBody = await res.text();
+      return { pushed: 0, pulled: 0, deduped: 0, errors: [`Learn failed: ${res.status} ${errBody}`], timestamp: now };
+    }
+    remoteAtoms = await res.json() as KnowledgeAtom[];
+  } catch (err: any) {
+    return { pushed: 0, pulled: 0, deduped: 0, errors: [`Learn error: ${err.message}`], timestamp: now };
+  }
+
+  let pulled = 0;
+  let deduped = 0;
+
+  for (const atom of remoteAtoms) {
+    try {
+      const { id, created_at, updated_at, ...data } = atom as any;
+      let result: KnowledgeAtom;
+      if (data.type === 'tool') {
+        result = localStore.createToolAtom(data);
+      } else if (data.type === 'negative') {
+        result = localStore.createNegativeAtom(data);
+      } else {
+        result = localStore.createAtom(data);
+      }
+
+      const ec = (result as any).evidence_count;
+      if (ec && ec > 1) {
+        deduped++;
+      } else {
+        pulled++;
+      }
+    } catch (err: any) {
+      errors.push(`Learn insert error: ${err.message}`);
+    }
+  }
+
+  setLastPullAt(localStore, meshUrl, now);
+  return { pushed: 0, pulled, deduped, errors, timestamp: now };
+}
+
+// Keep backward compat alias
+export const pullAtoms = learnFrom;

package/src/push.ts

@@ -0,0 +1,58 @@
+import type { AtomStore, KnowledgeAtom } from '@osmosis-ai/core';
+import type { SyncResult } from './types.js';
+import { getLastPushAt, setLastPushAt } from './meta.js';
+
+/**
+ * Contribute local atoms to the mesh server.
+ */
+export async function contributeTo(localStore: AtomStore, meshUrl: string): Promise<SyncResult> {
+  const errors: string[] = [];
+  const since = getLastPushAt(localStore, meshUrl);
+  const now = new Date().toISOString();
+
+  const allAtoms = localStore.getAll();
+  const toSync = since
+    ? allAtoms.filter(a => a.updated_at > since)
+    : allAtoms;
+
+  if (toSync.length === 0) {
+    setLastPushAt(localStore, meshUrl, now);
+    return { pushed: 0, pulled: 0, deduped: 0, errors: [], timestamp: now };
+  }
+
+  let pushed = 0;
+  let deduped = 0;
+
+  try {
+    const payload = toSync.map(stripAutoFields);
+    const res = await fetch(`${meshUrl}/mesh/contribute`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+
+    if (res.ok) {
+      const body = await res.json() as { accepted: number; results: Array<{ id: string; status: string }> };
+      for (const r of body.results) {
+        if (r.status === 'deduped') deduped++;
+        else pushed++;
+      }
+    } else {
+      const errBody = await res.text();
+      errors.push(`Contribute failed: ${res.status} ${errBody}`);
+    }
+  } catch (err: any) {
+    errors.push(`Contribute error: ${err.message}`);
+  }
+
+  setLastPushAt(localStore, meshUrl, now);
+  return { pushed, pulled: 0, deduped, errors, timestamp: now };
+}
+
+function stripAutoFields(atom: KnowledgeAtom): Record<string, unknown> {
+  const { id, created_at, updated_at, ...rest } = atom as any;
+  return rest;
+}
+
+// Keep backward compat alias
+export const pushAtoms = contributeTo;

package/src/scheduler.ts

@@ -0,0 +1,27 @@
+import type { AtomStore } from '@osmosis-ai/core';
+import type { SyncConfig } from './config.js';
+import { syncWithMesh } from './sync.js';
+
+export interface AutoSyncHandle {
+  stop(): void;
+}
+
+export function startAutoSync(store: AtomStore, config: SyncConfig): AutoSyncHandle {
+  if (!config.autoSync || !config.meshUrl) {
+    return { stop() {} };
+  }
+
+  const timer = setInterval(async () => {
+    try {
+      await syncWithMesh(store, config.meshUrl);
+    } catch {
+      // Silent failure — sync will retry next interval
+    }
+  }, config.syncIntervalMs);
+
+  return {
+    stop() {
+      clearInterval(timer);
+    },
+  };
+}

package/src/server.ts

@@ -0,0 +1,100 @@
+import { createServer as createHttpServer, type Server } from 'node:http';
+import { AtomStore } from '@osmosis-ai/core';
+import type { SyncConfig } from './config.js';
+
+/**
+ * Create a local API server for querying the local atom store.
+ * This is the "osmosis serve" server — local queries only, no peer sync routes.
+ */
+export function createSyncServer(
+  store: AtomStore,
+  port: number,
+  _config: SyncConfig,
+): Server {
+  const server = createHttpServer(async (req, res) => {
+    const url = new URL(req.url ?? '/', `http://localhost:${port}`);
+    const path = url.pathname;
+    const method = req.method ?? 'GET';
+
+    const json = (status: number, data: unknown) => {
+      res.writeHead(status, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(data));
+    };
+
+    try {
+      const readBody = (): Promise<string> => new Promise((resolve, reject) => {
+        const chunks: Buffer[] = [];
+        req.on('data', (c: Buffer) => chunks.push(c));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+        req.on('error', reject);
+      });
+
+      // POST /atoms
+      if (method === 'POST' && path === '/atoms') {
+        const body = JSON.parse(await readBody());
+        let atom;
+        if (body.type === 'tool') {
+          atom = store.createToolAtom(body);
+        } else if (body.type === 'negative') {
+          atom = store.createNegativeAtom(body);
+        } else {
+          atom = store.createAtom(body);
+        }
+        return json(201, atom);
+      }
+
+      // GET /atoms/search?q=...
+      if (method === 'GET' && path === '/atoms/search') {
+        const q = url.searchParams.get('q') ?? '';
+        return json(200, store.search(q));
+      }
+
+      // GET /atoms/:id
+      const idMatch = path.match(/^\/atoms\/([^/]+)$/);
+      if (method === 'GET' && idMatch) {
+        const atom = store.getById(idMatch[1]!);
+        if (!atom) return json(404, { error: 'Not found' });
+        return json(200, atom);
+      }
+
+      // GET /atoms?type=&tool_name=&since=
+      if (method === 'GET' && path === '/atoms') {
+        const type = url.searchParams.get('type');
+        const toolName = url.searchParams.get('tool_name');
+        const since = url.searchParams.get('since');
+
+        let atoms;
+        if (toolName) {
+          atoms = store.queryByToolName(toolName);
+        } else if (type) {
+          atoms = store.queryByType(type as any);
+        } else {
+          atoms = store.getAll();
+        }
+
+        if (since) {
+          atoms = atoms.filter(a => a.updated_at > since);
+        }
+
+        return json(200, atoms);
+      }
+
+      // GET /sync/status — kept for backward compat
+      if (method === 'GET' && path === '/sync/status') {
+        const allAtoms = store.getAll();
+        return json(200, {
+          atomCount: allAtoms.length,
+          meshUrl: _config.meshUrl,
+        });
+      }
+
+      json(404, { error: 'Not found' });
+    } catch (err: any) {
+      const status = err.name === 'ZodError' ? 400 : 500;
+      json(status, { error: err.message ?? 'Internal error' });
+    }
+  });
+
+  server.listen(port);
+  return server;
+}

package/src/sync.ts

@@ -0,0 +1,23 @@
+import type { AtomStore } from '@osmosis-ai/core';
+import type { SyncResult } from './types.js';
+import { contributeTo } from './push.js';
+import { learnFrom } from './pull.js';
+
+/**
+ * Full sync with mesh: contribute local atoms, then learn from mesh.
+ */
+export async function syncWithMesh(localStore: AtomStore, meshUrl: string): Promise<SyncResult> {
+  const pushResult = await contributeTo(localStore, meshUrl);
+  const pullResult = await learnFrom(localStore, meshUrl);
+
+  return {
+    pushed: pushResult.pushed + pushResult.deduped,
+    pulled: pullResult.pulled,
+    deduped: pushResult.deduped + pullResult.deduped,
+    errors: [...pushResult.errors, ...pullResult.errors],
+    timestamp: pullResult.timestamp,
+  };
+}
+
+// Keep backward compat alias
+export const syncWithPeer = syncWithMesh;

package/src/types.ts

@@ -0,0 +1,7 @@
+export interface SyncResult {
+  pushed: number;
+  pulled: number;
+  deduped: number;
+  errors: string[];
+  timestamp: string;
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "composite": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"],
+  "references": [
+    { "path": "../core" },
+    { "path": "../mesh-server" }
+  ]
+}