n2n-nexus 0.4.2 → 0.6.0

package/build/server/nexus.js

@@ -1,54 +1,97 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { NexusClient } from "../client/nexus-client.js";
+import { CLIENT_INFO_META_KEY, ProtocolError, ProtocolErrorCode, Server, } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { NexusClient, NexusToolError, NexusTransportError } from "../client/nexus-client.js";
 import { pkg } from "../config/index.js";
+import { resolveInstanceId } from "./instance-id.js";
 const RETRY_INTERVAL_MS = 3000;
+/** How long the first tools/list waits for the startup daemon fetch before answering with what it has. */
+const INITIAL_LIST_WAIT_MS = 1000;
 const SERVICE_NAME = "n2n-nexus";
+/**
+ * Stateless MCP adapter in front of the daemon.
+ *
+ * Served through the v2 SDK's serveStdio entry, which answers both
+ * protocol eras on one connection: 2026-07-28 clients (per-request `_meta`
+ * envelope, `server/discover`, `subscriptions/listen`) and 2025-era clients
+ * (`initialize` handshake).
+ */
 export class NexusServer {
-    server;
+    server = null;
+    handle = null;
     client;
-    instanceId;
     cachedTools = [];
     retryTimer = null;
+    /** True while a reconnect loop is active (waiting or attempting). */
+    retrying = false;
+    retryIntervalMs;
     connected = false;
-    constructor() {
+    stopped = false;
+    /**
+     * First client name seen on this stdio connection. clientInfo is only a
+     * SHOULD per request under 2026-07-28, so a request without it must not
+     * fall back to a different instance id than its siblings.
+     */
+    clientName;
+    /** The first daemon fetch, started once serving has begun. */
+    initialFetch = null;
+    constructor(options = {}) {
         const endpoint = process.env.NEXUS_ENDPOINT || "http://127.0.0.1:5688";
-        const instanceId = process.env.NEXUS_INSTANCE_ID ||
-            process.argv.find((_, i) => process.argv[i - 1] === "--id") ||
-            `mcp-${Math.random().toString(36).slice(2, 6)}`;
-        this.instanceId = instanceId;
-        this.client = new NexusClient({ endpoint, timeoutMs: 5000 });
-        this.server = new Server({ name: SERVICE_NAME, version: pkg.version }, { capabilities: { tools: { listChanged: true } } });
-        this.setupHandlers();
+        this.retryIntervalMs = options.retryIntervalMs ?? RETRY_INTERVAL_MS;
+        this.client = new NexusClient({ endpoint, timeoutMs: options.requestTimeoutMs ?? 5000 });
     }
-    setupHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: this.cachedTools
-        }));
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    /** Builds the MCP server instance serveStdio pins for the connection. */
+    buildServer() {
+        const server = new Server({ name: SERVICE_NAME, version: pkg.version }, { capabilities: { tools: { listChanged: true } } });
+        server.setRequestHandler("tools/list", async () => {
+            // Give a local daemon a moment so the first list is complete; never block on a hung one.
+            if (!this.connected && this.initialFetch) {
+                await Promise.race([this.initialFetch, new Promise((r) => setTimeout(r, INITIAL_LIST_WAIT_MS))]);
+            }
+            return { tools: this.cachedTools };
+        });
+        server.setRequestHandler("tools/call", async (request, ctx) => {
             if (!this.connected) {
                 return {
                     content: [{ type: "text", text: "Daemon is not ready yet. Please wait a moment and retry." }],
                     isError: true
                 };
             }
+            // Unknown tool is a protocol error (JSON-RPC -32602), not a tool execution error.
+            const unknownTool = () => new ProtocolError(ProtocolErrorCode.InvalidParams, `Unknown tool: ${request.params.name}`);
+            if (!this.cachedTools.some((t) => t.name === request.params.name))
+                throw unknownTool();
+            // 2026-07-28 clients identify themselves per request; 2025-era clients did so in initialize.
+            const envelope = ctx.mcpReq.envelope;
+            this.clientName ??= envelope?.[CLIENT_INFO_META_KEY]?.name
+                ?? server.getClientVersion()?.name;
+            const instanceId = resolveInstanceId(process.env, process.argv, process.cwd(), this.clientName);
             try {
-                const result = await this.client.callTool(request.params.name, request.params.arguments, this.instanceId);
+                const result = await this.client.callTool(request.params.name, request.params.arguments, instanceId);
+                // Every daemon result is a JSON object, so it goes out as structuredContent
+                // (data tools also publish an outputSchema for it; write tools do not). The
+                // JSON text keeps clients that only read content working (the spec's
+                // backwards-compatibility advice).
                 return {
-                    content: [{
-                            type: "text",
-                            text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
-                        }]
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                    structuredContent: result
                 };
             }
             catch (e) {
                 const message = e instanceof Error ? e.message : String(e);
-                // Daemon went away — start retry loop
+                // The daemon dropped the tool since the list was fetched: resync so tools/list stops offering it.
+                if (e instanceof NexusToolError && e.status === 404) {
+                    await this.refreshTools();
+                    throw unknownTool();
+                }
+                if (!(e instanceof NexusTransportError)) {
+                    // The daemon answered; the tool itself failed. Keep the tool list.
+                    return { content: [{ type: "text", text: message }], isError: true };
+                }
+                // Daemon went away — drop the tool list and start the retry loop
                 if (this.connected) {
                     this.connected = false;
                     this.cachedTools = [];
-                    await this.server.sendToolListChanged();
+                    await this.notifyToolsChanged();
                     this.scheduleRetry();
                 }
                 return {
@@ -57,41 +100,107 @@ export class NexusServer {
                 };
             }
         });
+        this.server = server;
+        return server;
+    }
+    /** Delivered unsolicited on 2025-era connections and via subscriptions/listen on 2026-07-28 ones. */
+    async notifyToolsChanged() {
+        await this.server?.sendToolListChanged().catch(() => { });
+    }
+    /** Re-fetch the daemon's tool list; notify the client if it changed. */
+    async refreshTools() {
+        try {
+            const tools = await this.client.fetchTools();
+            const before = JSON.stringify(this.cachedTools);
+            this.cachedTools = tools;
+            if (JSON.stringify(tools) !== before)
+                await this.notifyToolsChanged();
+        }
+        catch {
+            // Transport trouble is handled by the next call; keep the current list.
+        }
     }
     async tryConnect() {
         try {
             const tools = await this.client.fetchTools();
+            // JSON Schema produced by the daemon; the SDK models it as JSON values.
             this.cachedTools = tools;
             this.connected = true;
             console.error(`[n2n-nexus] Connected to daemon. ${tools.length} tools loaded.`);
-            await this.server.sendToolListChanged();
+            await this.notifyToolsChanged();
             return true;
         }
         catch {
             return false;
         }
     }
+    stopRetry() {
+        this.retrying = false;
+        if (this.retryTimer) {
+            clearTimeout(this.retryTimer);
+            this.retryTimer = null;
+        }
+    }
+    /** Stop reconnecting and close the MCP connection. Safe to call more than once. */
+    async shutdown() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        this.stopRetry();
+        await this.handle?.close().catch(() => { });
+    }
+    /**
+     * Reconnect loop. Each attempt is scheduled only after the previous one
+     * finished, so a daemon that hangs (attempt longer than the interval)
+     * never accumulates concurrent requests.
+     */
     scheduleRetry() {
-        if (this.retryTimer)
+        if (this.retrying || this.stopped)
             return;
+        this.retrying = true;
         const endpoint = process.env.NEXUS_ENDPOINT || "http://127.0.0.1:5688";
-        this.retryTimer = setInterval(async () => {
-            console.error(`[n2n-nexus] Waiting for daemon at ${endpoint}...`);
-            const ok = await this.tryConnect();
-            if (ok && this.retryTimer) {
-                clearInterval(this.retryTimer);
-                this.retryTimer = null;
-            }
-        }, RETRY_INTERVAL_MS);
+        const next = () => {
+            this.retryTimer = setTimeout(async () => {
+                console.error(`[n2n-nexus] Waiting for daemon at ${endpoint}...`);
+                const ok = await this.tryConnect();
+                if (!this.retrying)
+                    return; // stopped while the attempt was in flight
+                // A tools/call may have lost the daemon again while this attempt was still
+                // notifying the client; only stop if the connection is still up.
+                if (ok && this.connected)
+                    this.stopRetry();
+                else
+                    next();
+            }, this.retryIntervalMs);
+        };
+        next();
     }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        // Try to connect immediately; if not ready, start retry loop
-        const ok = await this.tryConnect();
-        if (!ok) {
+    /**
+     * Serve MCP. Per the stdio transport spec the server should exit when its
+     * input closes; without that the reconnect timer would keep the adapter
+     * alive after the IDE went away.
+     */
+    async run(options = {}) {
+        const stdio = !options.transport;
+        const input = options.input ?? (stdio ? process.stdin : undefined);
+        const onExit = options.onExit ?? (() => process.exit(0));
+        if (input) {
+            const exit = () => { void this.shutdown().then(onExit); };
+            input.once("end", exit);
+            input.once("close", exit);
+        }
+        // Serve first so discover/initialize are answered even when the daemon hangs;
+        // tools/list briefly waits for this fetch (2026-07-28 clients only hear
+        // list_changed if they subscribe).
+        this.handle = serveStdio(() => this.buildServer(), {
+            transport: options.transport,
+            onerror: (err) => console.error("[n2n-nexus] MCP transport error:", err.message)
+        });
+        this.initialFetch = this.tryConnect();
+        const ok = await this.initialFetch;
+        if (!ok && !this.stopped) {
             const endpoint = process.env.NEXUS_ENDPOINT || "http://127.0.0.1:5688";
-            console.error(`[n2n-nexus] Daemon not available at ${endpoint}. Will retry every ${RETRY_INTERVAL_MS / 1000}s...`);
+            console.error(`[n2n-nexus] Daemon not available at ${endpoint}. Will retry every ${this.retryIntervalMs / 1000}s...`);
             this.scheduleRetry();
         }
     }

package/build/storage/docs.js

@@ -1,6 +1,7 @@
 import { promises as fs } from "node:fs";
 import { NexusPaths } from "./paths.js";
 import { FILE_ENCODING } from "../constants.js";
+import { toDict, writeFileAtomic, writeJsonAtomic } from "./fs-utils.js";
 export class DocStorage {
     static async ensureDirectory() {
         await fs.mkdir(NexusPaths.docsDir(), { recursive: true });
@@ -8,7 +9,7 @@ export class DocStorage {
             await fs.access(NexusPaths.docsIndexFile);
         }
         catch {
-            await fs.writeFile(NexusPaths.docsIndexFile, JSON.stringify({}, null, 2), FILE_ENCODING);
+            await writeJsonAtomic(NexusPaths.docsIndexFile, {});
         }
     }
     static async readIndex() {
@@ -17,26 +18,32 @@ export class DocStorage {
             const raw = await fs.readFile(NexusPaths.docsIndexFile, FILE_ENCODING);
             const parsed = JSON.parse(raw);
             if (parsed && typeof parsed === "object")
-                return parsed;
+                return toDict(Object.entries(parsed));
         }
         catch {
             // fall through
         }
-        return {};
+        return toDict();
     }
     static async writeIndex(index) {
         await this.ensureDirectory();
-        await fs.writeFile(NexusPaths.docsIndexFile, JSON.stringify(index, null, 2), FILE_ENCODING);
+        await writeJsonAtomic(NexusPaths.docsIndexFile, index);
     }
     static async init() {
         await this.ensureDirectory();
+    }
+    /** The master strategy document (global/blueprint.md). */
+    static async getBlueprint() {
         try {
-            await fs.access(NexusPaths.globalBlueprint);
+            return await fs.readFile(NexusPaths.globalBlueprint, FILE_ENCODING);
         }
         catch {
-            await fs.writeFile(NexusPaths.globalBlueprint, "# Global Collaboration Blueprint\n\nShared meeting space.", FILE_ENCODING);
+            return "";
         }
     }
+    static async saveBlueprint(content) {
+        await writeFileAtomic(NexusPaths.globalBlueprint, content);
+    }
     static async listDocs() {
         await this.ensureDirectory();
         return this.readIndex();
@@ -55,7 +62,7 @@ export class DocStorage {
         await this.ensureDirectory();
         const index = await this.readIndex();
         const filePath = NexusPaths.docFile(docId);
-        await fs.writeFile(filePath, content, FILE_ENCODING);
+        await writeFileAtomic(filePath, content);
         index[docId] = {
             title,
             lastUpdated: new Date().toISOString(),

package/build/storage/events.js

@@ -0,0 +1,31 @@
+import { getDatabase } from "./sqlite.js";
+function toEvent(row) {
+    return {
+        id: row.id,
+        timestamp: row.timestamp,
+        actor: row.actor,
+        action: row.action,
+        target: row.target ?? undefined,
+        detail: row.detail ? JSON.parse(row.detail) : undefined
+    };
+}
+/**
+ * Structured audit trail of state changes made through the daemon
+ * (project synced, meeting ended, ...). Kept separate from the chat
+ * streams so assistants can read conversation and activity independently.
+ */
+export class EventStore {
+    static record(actor, action, target, detail) {
+        const timestamp = new Date().toISOString();
+        const result = getDatabase().prepare("INSERT INTO events (timestamp, actor, action, target, detail) VALUES (?, ?, ?, ?, ?)").run(timestamp, actor, action, target ?? null, detail ? JSON.stringify(detail) : null);
+        return { id: Number(result.lastInsertRowid), timestamp, actor, action, target, detail };
+    }
+    /** Newest events first. `action` filters by exact action name or a `prefix.` */
+    static list(limit, action) {
+        const db = getDatabase();
+        const rows = (action
+            ? db.prepare("SELECT * FROM events WHERE action = ? OR action LIKE ? ORDER BY id DESC LIMIT ?").all(action, `${action}.%`, limit)
+            : db.prepare("SELECT * FROM events ORDER BY id DESC LIMIT ?").all(limit));
+        return rows.map(toEvent);
+    }
+}

package/build/storage/fs-utils.js

@@ -0,0 +1,42 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { AsyncMutex } from "../utils/async-mutex.js";
+import { FILE_ENCODING } from "../constants.js";
+/**
+ * Serializes every file-store write inside the daemon. HTTP requests are
+ * handled concurrently, so read-modify-write sequences on registry.json,
+ * manifests and the docs index must be queued behind one lock.
+ */
+export const fileWriteLock = new AsyncMutex();
+/**
+ * Write to a temp file in the same directory, then rename over the target so
+ * readers never observe a partially written file.
+ */
+export async function writeFileAtomic(filePath, data) {
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+    const tmp = path.join(dir, `.${path.basename(filePath)}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.tmp`);
+    try {
+        await fs.writeFile(tmp, data, typeof data === "string" ? FILE_ENCODING : undefined);
+        await fs.rename(tmp, filePath);
+    }
+    catch (e) {
+        await fs.rm(tmp, { force: true }).catch(() => { });
+        throw e;
+    }
+}
+/**
+ * Copy entries into an object without a prototype. Registry and index maps
+ * are keyed by user-supplied ids; on a plain object ids such as
+ * "constructor" or "__proto__" hit Object.prototype on lookup or rewrite the
+ * prototype on assignment.
+ */
+export function toDict(entries = []) {
+    const dict = Object.create(null);
+    for (const [k, v] of entries)
+        dict[k] = v;
+    return dict;
+}
+export function writeJsonAtomic(filePath, value) {
+    return writeFileAtomic(filePath, JSON.stringify(value, null, 2));
+}

package/build/storage/global-messages.js

@@ -0,0 +1,44 @@
+import { getDatabase } from "./sqlite.js";
+function toMessage(row) {
+    return { id: row.id, from: row.sender, text: row.text, category: row.category ?? undefined, timestamp: row.timestamp };
+}
+/**
+ * Global (non-meeting) chat stream, stored in SQLite so appends are cheap,
+ * concurrent-safe and addressable by id for per-instance unread cursors.
+ */
+export class GlobalMessageStore {
+    static addMessage(from, text, category) {
+        const db = getDatabase();
+        const timestamp = new Date().toISOString();
+        const result = db.prepare("INSERT INTO global_messages (sender, text, category, timestamp) VALUES (?, ?, ?, ?)").run(from, text, category ?? null, timestamp);
+        return { id: Number(result.lastInsertRowid), from, text, category, timestamp };
+    }
+    /** Messages this instance has not read yet, oldest first; advances the cursor. */
+    static readUnread(instanceId, count) {
+        const db = getDatabase();
+        const cursor = db.prepare("SELECT last_read_id FROM read_cursors WHERE instance_id = ? AND context_type = 'global' AND context_id = 'global'").get(instanceId);
+        const lastReadId = cursor?.last_read_id ?? 0;
+        const rows = db.prepare("SELECT id, sender, text, category, timestamp FROM global_messages WHERE id > ? ORDER BY id ASC LIMIT ?").all(lastReadId, count);
+        if (rows.length > 0) {
+            db.prepare("INSERT OR REPLACE INTO read_cursors (instance_id, context_type, context_id, last_read_id, updated_at) VALUES (?, 'global', 'global', ?, ?)").run(instanceId, rows[rows.length - 1].id, new Date().toISOString());
+        }
+        return rows.map(toMessage);
+    }
+    /** Most recent messages regardless of cursor, oldest first. */
+    static recent(count) {
+        const rows = getDatabase().prepare("SELECT id, sender, text, category, timestamp FROM global_messages ORDER BY id DESC LIMIT ?").all(count);
+        return rows.reverse().map(toMessage);
+    }
+    static count() {
+        return getDatabase().prepare("SELECT COUNT(*) AS n FROM global_messages").get().n;
+    }
+    /** Delete the oldest `count` messages. */
+    static pruneOldest(count) {
+        if (count <= 0)
+            return 0;
+        return getDatabase().prepare("DELETE FROM global_messages WHERE id IN (SELECT id FROM global_messages ORDER BY id ASC LIMIT ?)").run(count).changes;
+    }
+    static clear() {
+        return getDatabase().prepare("DELETE FROM global_messages").run().changes;
+    }
+}

package/build/storage/index.js

@@ -3,38 +3,28 @@ import { FILE_ENCODING } from "../constants.js";
 import { NexusPaths } from "./paths.js";
 import { RegistryStorage } from "./registry.js";
 import { ProjectStorage } from "./projects.js";
-import { LogStorage } from "./logs.js";
 import { DocStorage } from "./docs.js";
+import { fileWriteLock, writeFileAtomic, writeJsonAtomic } from "./fs-utils.js";
+export const BLUEPRINT_PLACEHOLDER = "# Global Coordination Blueprint\n\nShared meeting space.";
 export class StorageManager {
     static initialized = false;
     // --- Path Proxies (Backward Compatibility) ---
     static get globalDir() { return NexusPaths.globalDir; }
     static get globalBlueprint() { return NexusPaths.globalBlueprint; }
-    static get globalDiscussion() { return NexusPaths.globalDiscussion; }
     static get projectsRoot() { return NexusPaths.projectsRoot; }
     static get registryFile() { return NexusPaths.registryFile; }
-    static get archivesDir() { return NexusPaths.archivesDir; }
     static async init() {
         if (this.initialized)
             return;
         await fs.mkdir(NexusPaths.root, { recursive: true });
         await fs.mkdir(this.globalDir, { recursive: true });
         await fs.mkdir(this.projectsRoot, { recursive: true });
-        await fs.mkdir(this.archivesDir, { recursive: true });
         // Self-healing initialization for critical files
         await this.loadJsonSafe(this.registryFile, { projects: {} });
-        await this.loadJsonSafe(this.globalDiscussion, []);
         if (!await this.exists(this.globalBlueprint)) {
-            await fs.writeFile(this.globalBlueprint, "# Global Coordination Blueprint\n\nShared meeting space.");
+            await writeFileAtomic(this.globalBlueprint, BLUEPRINT_PLACEHOLDER);
         }
         await DocStorage.init();
-        try {
-            const { initTasksTable } = await import("./tasks.js");
-            initTasksTable();
-        }
-        catch {
-            /* tasks module is optional */
-        }
         this.initialized = true;
     }
     static resetInit() {
@@ -43,7 +33,7 @@ export class StorageManager {
     static async loadJsonSafe(filePath, defaultValue) {
         try {
             if (!await this.exists(filePath)) {
-                await fs.writeFile(filePath, JSON.stringify(defaultValue, null, 2), FILE_ENCODING);
+                await writeJsonAtomic(filePath, defaultValue);
                 return defaultValue;
             }
             const content = await fs.readFile(filePath, FILE_ENCODING);
@@ -51,7 +41,7 @@ export class StorageManager {
         }
         catch {
             console.warn(`[Nexus Storage] Repairing corrupted file: ${filePath}`);
-            await fs.writeFile(filePath, JSON.stringify(defaultValue, null, 2), FILE_ENCODING);
+            await writeJsonAtomic(filePath, defaultValue);
             return defaultValue;
         }
     }
@@ -64,42 +54,55 @@ export class StorageManager {
             return false;
         }
     }
+    // Every mutation of the file store goes through this lock; reads are
+    // lock-free because writes are atomic (temp file + rename).
+    static write(fn) {
+        return fileWriteLock.withLock(fn);
+    }
     // --- Registry Methods ---
     static listRegistry() { return RegistryStorage.listRegistry(); }
     static getProjectManifest(id) { return RegistryStorage.getProjectManifest(id); }
-    static saveProjectManifest(manifest) { return RegistryStorage.saveProjectManifest(manifest); }
-    static patchProjectManifest(id, patch) { return RegistryStorage.patchProjectManifest(id, patch); }
+    static saveProjectManifest(manifest) { return this.write(() => RegistryStorage.saveProjectManifest(manifest)); }
+    /** Manifest and internal docs in one critical section, so a concurrent delete cannot interleave. */
+    static saveProject(manifest, docs) {
+        return this.write(async () => {
+            await RegistryStorage.saveProjectManifest(manifest);
+            await ProjectStorage.saveProjectDocs(manifest.id, docs);
+        });
+    }
+    static patchProjectManifest(id, patch) { return this.write(() => RegistryStorage.patchProjectManifest(id, patch)); }
     static calculateTopology(projectId) { return RegistryStorage.calculateTopology(projectId); }
     // --- Project Methods ---
     static getProjectDocs(id) { return ProjectStorage.getProjectDocs(id); }
-    static saveProjectDocs(id, content) { return ProjectStorage.saveProjectDocs(id, content); }
-    static saveAsset(id, fileName, content) { return ProjectStorage.saveAsset(id, fileName, content); }
-    static async deleteProject(id) {
-        await ProjectStorage.deleteProject(id);
-        await RegistryStorage.deleteProject(id);
+    static saveProjectDocs(id, content) { return this.write(() => ProjectStorage.saveProjectDocs(id, content)); }
+    static saveAsset(id, fileName, content) { return this.write(() => ProjectStorage.saveAsset(id, fileName, content)); }
+    static deleteProject(id) {
+        return this.write(async () => {
+            await ProjectStorage.deleteProject(id);
+            await RegistryStorage.deleteProject(id);
+        });
     }
-    static async renameProject(oldId, newId) {
-        await RegistryStorage.renameProject(oldId, newId);
-        try {
-            const result = await ProjectStorage.renameProject(oldId, newId);
-            if (result === 0) {
-                await RegistryStorage.renameProject(newId, oldId);
+    static renameProject(oldId, newId) {
+        return this.write(async () => {
+            await RegistryStorage.renameProject(oldId, newId);
+            try {
+                const result = await ProjectStorage.renameProject(oldId, newId);
+                if (result === 0) {
+                    await RegistryStorage.renameProject(newId, oldId);
+                }
+                return result;
             }
-            return result;
-        }
-        catch (error) {
-            await RegistryStorage.renameProject(newId, oldId).catch(() => { });
-            throw error;
-        }
+            catch (error) {
+                await RegistryStorage.renameProject(newId, oldId).catch(() => { });
+                throw error;
+            }
+        });
     }
-    // --- Log Methods ---
-    static addGlobalLog(from, text, category) { return LogStorage.addLog(from, text, category); }
-    static getRecentLogs(count = 10) { return LogStorage.getLogs(count); }
-    static pruneGlobalLogs(count) { return LogStorage.pruneLogs(count); }
-    static clearGlobalLogs() { return LogStorage.clearLogs(); }
     // --- Doc Methods ---
     static listGlobalDocs() { return DocStorage.listDocs(); }
     static getGlobalDoc(docId) { return DocStorage.getDoc(docId); }
-    static saveGlobalDoc(docId, title, content, updatedBy) { return DocStorage.saveDoc(docId, title, content, updatedBy); }
-    static deleteGlobalDoc(docId) { return DocStorage.deleteDoc(docId); }
+    static saveGlobalDoc(docId, title, content, updatedBy) { return this.write(() => DocStorage.saveDoc(docId, title, content, updatedBy)); }
+    static deleteGlobalDoc(docId) { return this.write(() => DocStorage.deleteDoc(docId)); }
+    static getGlobalBlueprint() { return DocStorage.getBlueprint(); }
+    static saveGlobalBlueprint(content) { return this.write(() => DocStorage.saveBlueprint(content)); }
 }

package/build/storage/migrations.js

@@ -0,0 +1,79 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { NexusPaths } from "./paths.js";
+import { GlobalMessageStore } from "./global-messages.js";
+import { DocStorage } from "./docs.js";
+import { BLUEPRINT_PLACEHOLDER } from "./index.js";
+import { getDatabase } from "./sqlite.js";
+import { MESSAGE_CATEGORIES } from "../types.js";
+import { FILE_ENCODING } from "../constants.js";
+/**
+ * One-time upgrades of data written by earlier releases. Each step is
+ * idempotent: it runs only while the legacy artifact is present and the
+ * new location is still empty, then renames the artifact out of the way.
+ */
+/** 0.5.0 kept the global chat in global/discussion.json; import it into SQLite. */
+export async function importLegacyDiscussion() {
+    const file = path.join(NexusPaths.globalDir, "discussion.json");
+    let raw;
+    try {
+        raw = await fs.readFile(file, FILE_ENCODING);
+    }
+    catch {
+        return 0;
+    }
+    if (GlobalMessageStore.count() > 0)
+        return 0;
+    let entries;
+    try {
+        entries = JSON.parse(raw.replace(/^\uFEFF/, ""));
+    }
+    catch {
+        console.warn(`[n2n-nexus] Skipping unreadable legacy chat log: ${file}`);
+        return 0;
+    }
+    if (!Array.isArray(entries))
+        return 0;
+    const insert = getDatabase().prepare("INSERT INTO global_messages (sender, text, category, timestamp) VALUES (?, ?, ?, ?)");
+    const imported = getDatabase().transaction((rows) => {
+        let n = 0;
+        for (const row of rows) {
+            if (!row || typeof row !== "object")
+                continue;
+            const e = row;
+            if (typeof e.text !== "string")
+                continue;
+            const category = MESSAGE_CATEGORIES.includes(String(e.category)) ? e.category : null;
+            insert.run(typeof e.from === "string" && e.from ? e.from : "unknown", e.text, category, typeof e.timestamp === "string" && e.timestamp ? e.timestamp : new Date().toISOString());
+            n++;
+        }
+        return n;
+    })(entries);
+    await fs.rename(file, `${file}.migrated`);
+    console.error(`[n2n-nexus] Imported ${imported} legacy global messages from discussion.json`);
+    return imported;
+}
+/** Title 0.5.0's update_global_strategy gave the doc it wrote; a user doc with another title is left alone. */
+export const LEGACY_STRATEGY_TITLE = "Global Collaboration Strategy";
+/**
+ * 0.5.0's update_global_strategy saved the strategy as the global doc
+ * "strategy"; it now lives in global/blueprint.md. Move it there unless the
+ * blueprint has already been written.
+ */
+export async function importLegacyStrategy() {
+    const docs = await DocStorage.listDocs();
+    if (docs.strategy?.title !== LEGACY_STRATEGY_TITLE)
+        return false;
+    const legacy = await DocStorage.getDoc("strategy");
+    const current = await DocStorage.getBlueprint();
+    if (legacy && (!current || current === BLUEPRINT_PLACEHOLDER)) {
+        await DocStorage.saveBlueprint(legacy);
+    }
+    await DocStorage.deleteDoc("strategy");
+    console.error("[n2n-nexus] Moved legacy global doc 'strategy' into global/blueprint.md");
+    return true;
+}
+export async function runMigrations() {
+    await importLegacyDiscussion();
+    await importLegacyStrategy();
+}