n2n-nexus 0.8.1 → 0.8.2

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.8.2] - 2026-10-22
+
+### Fixed
+
+- Two daemons starting together on a fresh storage root: the loser no longer crashes with `SqliteError: database is locked` before reaching the port; database initialisation waits for the other process and the loser exits on `EADDRINUSE` as intended.
+- Reads of the file store (`get_project`, `search_projects`, topology, global docs) share a read-write lock with the writes, so a read during `rename_project` no longer returns an entry with empty docs and tech stack.
+- `sync_project_assets` and `update_project` write the manifest and docs first and the registry last, and restore the files they wrote when a later step fails; a failed create no longer leaves a project without a directory, and a failed update no longer mixes new and old fields.
+- Tasks whose timestamps were written before 0.6.0 (`YYYY-MM-DD HH:MM:SS`) are converted to ISO 8601 on startup, so they are no longer purged up to a day early.
+- `n2n-nexus uninstall` (and `install`) report a failing `mcp remove` when the server is still registered in the client's configuration, exit with code 1 and say what to do; "not registered" is still ignored.
+
 ## [0.8.1] - 2026-10-22
 
 ### Added

package/build/cli/doctor.js

@@ -7,11 +7,10 @@
  */
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
 import { HOOK_CLIENTS, MCP_SERVER_NAME, isHookClient } from "../daemon/hook-contract.js";
 import { pkg } from "../config/index.js";
-import { InstallError, VERSIONED_NODE_DIR, configFile, isOurs, parseVersion, readConfig, satisfiesEngines } from "./install.js";
+import { VERSIONED_NODE_DIR, configFile, isOurs, parseVersion, readConfig, satisfiesEngines } from "./install.js";
+import { mcpConfigFile, readMcpCommand } from "./mcp-config.js";
 const ok = (text) => ({ ok: true, text });
 const bad = (text) => ({ ok: false, text });
 const VERSIONED_NOTE = "in a version directory that an upgrade may remove";
@@ -39,57 +38,6 @@ export function checkNode(node) {
     return ok(`${text}${VERSIONED_NODE_DIR.test(node) ? `, ${VERSIONED_NOTE}` : ""}`);
 }
 const checkEntry = (entry) => fs.existsSync(entry) ? ok("ok") : bad("missing");
-/** Where the client keeps the MCP server command. */
-export function mcpConfigFile(client) {
-    if (client === "claude") {
-        return path.join(process.env.CLAUDE_CONFIG_DIR || os.homedir(), ".claude.json");
-    }
-    return path.join(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"), "config.toml");
-}
-/** The MCP server command the client has for n2n-nexus, or undefined when not registered. */
-export function readMcpCommand(client, file) {
-    let text;
-    try {
-        text = fs.readFileSync(file, "utf8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw error;
-    }
-    if (client === "claude") {
-        let parsed;
-        try {
-            parsed = JSON.parse(text);
-        }
-        catch (error) {
-            throw new InstallError(`${file} is not valid JSON (${error.message}).`);
-        }
-        const servers = parsed?.mcpServers;
-        const server = servers?.[MCP_SERVER_NAME];
-        if (!server || typeof server.command !== "string")
-            return undefined;
-        return { command: server.command, args: Array.isArray(server.args) ? server.args.map(String) : [] };
-    }
-    // Codex: a TOML table [mcp_servers.n2n-nexus] (the key may be quoted) with command = "..." and args = [...].
-    const lines = text.split("\n");
-    const start = lines.findIndex((line) => new RegExp(`^\\s*\\[mcp_servers\\.("?)${MCP_SERVER_NAME}\\1\\]\\s*$`).test(line));
-    if (start === -1)
-        return undefined;
-    let command;
-    let args = [];
-    for (const line of lines.slice(start + 1)) {
-        if (/^\s*\[/.test(line))
-            break;
-        const c = /^\s*command\s*=\s*"((?:[^"\\]|\\.)*)"/.exec(line);
-        if (c)
-            command = JSON.parse(`"${c[1]}"`);
-        const a = /^\s*args\s*=\s*\[(.*)\]/.exec(line);
-        if (a)
-            args = [...a[1].matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((m) => JSON.parse(`"${m[1]}"`));
-    }
-    return command === undefined ? undefined : { command, args };
-}
 /** Check one client; prints the report and returns whether everything passed, or undefined when nothing is installed. */
 function doctorClient(client) {
     const hooksFile = configFile(client);

package/build/cli/install.js

@@ -17,6 +17,7 @@ import path from "node:path";
 import { CLAUDE_PRE_TOOL_MATCHER, HOOK_STOP_TIMEOUT_SEC, HOOK_TIMEOUT_SEC, MCP_SERVER_NAME, isHookClient } from "../daemon/hook-contract.js";
 import { pkg } from "../config/index.js";
 import { entryScript } from "./autostart.js";
+import { mcpConfigFile, readMcpCommand } from "./mcp-config.js";
 const EVENTS = {
     claude: ["SessionStart", "SessionEnd", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Stop"],
     codex: ["SessionStart", "SessionEnd", "UserPromptSubmit", "PostToolUse", "Stop"]
@@ -187,6 +188,40 @@ function mcpAddArgs(client, node, entry, endpoint) {
     const scope = client === "claude" ? ["--scope", "user"] : [];
     return ["mcp", "add", ...scope, MCP_SERVER_NAME, ...env, "--", node, entry, "mcp"];
 }
+/**
+ * Run `<client> mcp remove`. A failure is ignored only when `<client> mcp get`
+ * shows the server is not registered (never installed, or already removed);
+ * otherwise the removal really failed and we stop before `mcp add`.
+ */
+function removeMcpServer(client, action, hooksRemoved) {
+    const removeArgs = mcpRemoveArgs(client);
+    try {
+        execFileSync(client, removeArgs, { encoding: "utf8", stdio: ["ignore", "ignore", "pipe"] });
+        if (action === "uninstall")
+            process.stdout.write(`Ran: ${client} ${removeArgs.join(" ")}\n`);
+        return;
+    }
+    catch (error) {
+        // "Not registered" is the one failure to ignore; the registration is read from the
+        // client's configuration file (an unreadable file counts as still registered).
+        let registered = true;
+        try {
+            registered = readMcpCommand(client, mcpConfigFile(client)) !== undefined;
+        }
+        catch {
+            // Keep registered = true: the error below tells the user what to look at.
+        }
+        if (!registered)
+            return;
+        const failure = error;
+        const stderr = typeof failure.stderr === "string" ? failure.stderr.trim() : "";
+        const detail = stderr || (typeof failure.status === "number" ? `exit code ${failure.status}` : failure.message);
+        const state = action === "uninstall"
+            ? `${hooksRemoved ? "The hooks were removed; t" : "T"}he MCP server is still registered in ${mcpConfigFile(client)}.`
+            : "The hooks were written; the existing MCP server registration was left unchanged.";
+        throw new InstallError(`"${client} ${removeArgs.join(" ")}" failed: ${detail}\n${state} Fix the error and run "n2n-nexus ${action} ${client}" again.`);
+    }
+}
 /** Install or uninstall; prints what it did and returns the exit code. */
 export function runInstall(options) {
     const { action, client, endpoint } = options;
@@ -211,15 +246,7 @@ export function runInstall(options) {
             writeConfig(file, config);
             process.stdout.write(`${action === "install" ? "Wrote hooks to" : "Removed hooks from"} ${file}\n`);
         }
-        const removeArgs = mcpRemoveArgs(client);
-        try {
-            execFileSync(client, removeArgs, { stdio: "ignore" });
-            if (action === "uninstall")
-                process.stdout.write(`Ran: ${client} ${removeArgs.join(" ")}\n`);
-        }
-        catch {
-            // Not registered yet (or already removed): nothing to undo.
-        }
+        removeMcpServer(client, action, removed);
         if (action === "install" && node) {
             const addArgs = mcpAddArgs(client, node, entry, endpoint);
             execFileSync(client, addArgs, { stdio: ["ignore", "ignore", "inherit"] });

package/build/cli/mcp-config.js

@@ -0,0 +1,62 @@
+/**
+ * Where Claude Code and Codex keep their MCP server registrations, and how to
+ * read the n2n-nexus entry: `~/.claude.json` (user scope) and
+ * `$CODEX_HOME/config.toml`. `claude mcp get` is not used for this because it
+ * looks in every scope, not only the user scope that install writes to, and
+ * it starts the server for a health check.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { MCP_SERVER_NAME } from "../daemon/hook-contract.js";
+/** Where the client keeps the MCP server command. */
+export function mcpConfigFile(client) {
+    if (client === "claude") {
+        return path.join(process.env.CLAUDE_CONFIG_DIR || os.homedir(), ".claude.json");
+    }
+    return path.join(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"), "config.toml");
+}
+/** The MCP server command the client has for n2n-nexus, or undefined when not registered. */
+export function readMcpCommand(client, file) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+    if (client === "claude") {
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch (error) {
+            throw new Error(`${file} is not valid JSON (${error.message}).`, { cause: error });
+        }
+        const servers = parsed?.mcpServers;
+        const server = servers?.[MCP_SERVER_NAME];
+        if (!server || typeof server.command !== "string")
+            return undefined;
+        return { command: server.command, args: Array.isArray(server.args) ? server.args.map(String) : [] };
+    }
+    // Codex: a TOML table [mcp_servers.n2n-nexus] (the key may be quoted) with command = "..." and args = [...].
+    const lines = text.split("\n");
+    const start = lines.findIndex((line) => new RegExp(`^\\s*\\[mcp_servers\\.("?)${MCP_SERVER_NAME}\\1\\]\\s*$`).test(line));
+    if (start === -1)
+        return undefined;
+    let command;
+    let args = [];
+    for (const line of lines.slice(start + 1)) {
+        if (/^\s*\[/.test(line))
+            break;
+        const c = /^\s*command\s*=\s*"((?:[^"\\]|\\.)*)"/.exec(line);
+        if (c)
+            command = JSON.parse(`"${c[1]}"`);
+        const a = /^\s*args\s*=\s*\[(.*)\]/.exec(line);
+        if (a)
+            args = [...a[1].matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((m) => JSON.parse(`"${m[1]}"`));
+    }
+    return command === undefined ? undefined : { command, args };
+}

package/build/storage/fs-utils.js

@@ -1,13 +1,14 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
-import { AsyncMutex } from "../utils/async-mutex.js";
+import { AsyncRWLock } from "../utils/async-rwlock.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.
+ * Guards the file store inside the daemon. HTTP requests are handled
+ * concurrently: writes take it exclusively, so read-modify-write sequences on
+ * registry.json, manifests and the docs index are queued; reads take it
+ * shared, so they never observe a multi-file write (such as a rename) halfway.
  */
-export const fileWriteLock = new AsyncMutex();
+export const fileStoreLock = new AsyncRWLock();
 /**
  * Write to a temp file in the same directory, then rename over the target so
  * readers never observe a partially written file.
@@ -40,3 +41,48 @@ export function toDict(entries = []) {
 export function writeJsonAtomic(filePath, value) {
     return writeFileAtomic(filePath, JSON.stringify(value, null, 2));
 }
+export async function snapshotFile(filePath) {
+    const dir = path.dirname(filePath);
+    let createsDir = false;
+    try {
+        await fs.access(dir);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        createsDir = true;
+    }
+    let original = null;
+    if (!createsDir) {
+        try {
+            original = await fs.readFile(filePath);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    return { path: filePath, original, createsDir };
+}
+/**
+ * Puts a file back as snapshotFile recorded it: original bytes rewritten,
+ * a file that did not exist removed, and a directory the write created
+ * removed with everything in it. Best effort: an undo failure is swallowed
+ * so the caller can rethrow the error that caused the rollback.
+ */
+export async function restoreFile(snapshot) {
+    try {
+        if (snapshot.createsDir) {
+            await fs.rm(path.dirname(snapshot.path), { recursive: true, force: true });
+        }
+        else if (snapshot.original === null) {
+            await fs.rm(snapshot.path, { force: true });
+        }
+        else {
+            await writeFileAtomic(snapshot.path, snapshot.original);
+        }
+    }
+    catch {
+        // Best effort, see above.
+    }
+}

package/build/storage/index.js

@@ -4,7 +4,7 @@ import { NexusPaths } from "./paths.js";
 import { RegistryStorage } from "./registry.js";
 import { ProjectStorage } from "./projects.js";
 import { DocStorage } from "./docs.js";
-import { fileWriteLock, writeFileAtomic, writeJsonAtomic } from "./fs-utils.js";
+import { fileStoreLock, restoreFile, snapshotFile, writeFileAtomic, writeJsonAtomic } from "./fs-utils.js";
 export const BLUEPRINT_PLACEHOLDER = "# Global Coordination Blueprint\n\nShared meeting space.";
 export class StorageManager {
     static initialized = false;
@@ -54,26 +54,51 @@ 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).
+    // Every mutation of the file store takes the lock exclusively and every
+    // public read takes it shared. Single files are written atomically (temp
+    // file + rename), but some writes span several files (a rename moves the
+    // directory before the registry switches ids), and a read between those
+    // steps would see a registry entry whose files are gone. Code inside
+    // write() or read() must call the sub-modules directly, never these locked
+    // StorageManager methods: the lock is not reentrant (a read inside a read
+    // deadlocks as soon as a writer is queued between them).
     static write(fn) {
-        return fileWriteLock.withLock(fn);
+        return fileStoreLock.withWrite(fn);
+    }
+    static read(fn) {
+        return fileStoreLock.withRead(fn);
     }
     // --- Registry Methods ---
-    static listRegistry() { return RegistryStorage.listRegistry(); }
-    static getProjectManifest(id) { return RegistryStorage.getProjectManifest(id); }
+    static listRegistry() { return this.read(() => RegistryStorage.listRegistry()); }
+    static getProjectManifest(id) { return this.read(() => RegistryStorage.getProjectManifest(id)); }
     static saveProjectManifest(manifest) { return this.write(() => RegistryStorage.saveProjectManifest(manifest)); }
-    /** Manifest and internal docs in one critical section, so a concurrent delete cannot interleave. */
+    /**
+     * Manifest and internal docs in one critical section, so a concurrent
+     * delete cannot interleave. Docs are written first and
+     * saveProjectManifest writes the registry last, so the registry only
+     * lists the project once all its files are in place. If anything fails,
+     * the docs file is put back to its original bytes (removed if it did not
+     * exist, with the project directory if this call created it) and the
+     * original error is rethrown; saveProjectManifest rolls back its own
+     * manifest write.
+     */
     static saveProject(manifest, docs) {
         return this.write(async () => {
-            await RegistryStorage.saveProjectManifest(manifest);
-            await ProjectStorage.saveProjectDocs(manifest.id, docs);
+            const snapshot = await snapshotFile(NexusPaths.projectDocPath(manifest.id));
+            try {
+                await ProjectStorage.saveProjectDocs(manifest.id, docs);
+                await RegistryStorage.saveProjectManifest(manifest);
+            }
+            catch (error) {
+                await restoreFile(snapshot);
+                throw error;
+            }
         });
     }
     static patchProjectManifest(id, patch) { return this.write(() => RegistryStorage.patchProjectManifest(id, patch)); }
-    static calculateTopology(projectId) { return RegistryStorage.calculateTopology(projectId); }
+    static calculateTopology(projectId) { return this.read(() => RegistryStorage.calculateTopology(projectId)); }
     // --- Project Methods ---
-    static getProjectDocs(id) { return ProjectStorage.getProjectDocs(id); }
+    static getProjectDocs(id) { return this.read(() => ProjectStorage.getProjectDocs(id)); }
     static saveProjectDocs(id, content) { return this.write(() => ProjectStorage.saveProjectDocs(id, content)); }
     /**
      * The existence check runs inside the write lock: writeFileAtomic creates
@@ -107,10 +132,10 @@ export class StorageManager {
         });
     }
     // --- Doc Methods ---
-    static listGlobalDocs() { return DocStorage.listDocs(); }
-    static getGlobalDoc(docId) { return DocStorage.getDoc(docId); }
+    static listGlobalDocs() { return this.read(() => DocStorage.listDocs()); }
+    static getGlobalDoc(docId) { return this.read(() => DocStorage.getDoc(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 getGlobalBlueprint() { return this.read(() => DocStorage.getBlueprint()); }
     static saveGlobalBlueprint(content) { return this.write(() => DocStorage.saveBlueprint(content)); }
 }

package/build/storage/registry.js

@@ -1,6 +1,6 @@
 import { promises as fs } from "node:fs";
 import { NexusPaths } from "./paths.js";
-import { toDict, writeFileAtomic, writeJsonAtomic } from "./fs-utils.js";
+import { restoreFile, snapshotFile, toDict, writeFileAtomic, writeJsonAtomic } from "./fs-utils.js";
 const emptyRegistry = () => ({ projects: toDict() });
 async function readRegistry() {
     try {
@@ -91,8 +91,14 @@ export class RegistryStorage {
     static async listRegistry() {
         return readRegistry();
     }
+    /**
+     * Creates or replaces a project. Order: manifest first, registry last, so
+     * the registry never lists a project whose manifest was not written. If
+     * the registry write fails, the manifest is put back to its original
+     * bytes (removed if it did not exist, together with the project directory
+     * if this call created it) and the original error is rethrown.
+     */
     static async saveProjectManifest(manifest) {
-        const projectDir = NexusPaths.projectDir(manifest.id);
         const manifestPath = NexusPaths.projectManifestPath(manifest.id);
         const registry = await readRegistry();
         registry.projects[manifest.id] = {
@@ -100,9 +106,15 @@ export class RegistryStorage {
             summary: manifest.description || "",
             lastActive: new Date().toISOString()
         };
-        await writeRegistry(registry);
-        await fs.mkdir(projectDir, { recursive: true });
+        const snapshot = await snapshotFile(manifestPath);
         await writeJsonAtomic(manifestPath, { ...manifest, lastUpdated: manifest.lastUpdated || new Date().toISOString() });
+        try {
+            await writeRegistry(registry);
+        }
+        catch (error) {
+            await restoreFile(snapshot);
+            throw error;
+        }
     }
     static async getProjectManifest(id) {
         const registry = await readRegistry();
@@ -128,6 +140,11 @@ export class RegistryStorage {
             feature_tier: m.feature_tier
         };
     }
+    /**
+     * Applies a patch to the manifest and the registry entry. Same order and
+     * rollback as saveProjectManifest: manifest first, registry last; if the
+     * registry write fails the manifest is restored to its original bytes.
+     */
     static async patchProjectManifest(id, patch) {
         const registry = await readRegistry();
         const existing = registry.projects[id];
@@ -139,7 +156,8 @@ export class RegistryStorage {
             name: patch.name ?? existing.name,
             lastActive: new Date().toISOString()
         };
-        await writeRegistry(registry);
+        const manifestPath = NexusPaths.projectManifestPath(id);
+        const snapshot = await snapshotFile(manifestPath);
         const manifest = await readProjectManifest(id) || {};
         const patchedManifest = {
             id,
@@ -158,7 +176,14 @@ export class RegistryStorage {
             api_versions: patch.api_versions ?? manifest.api_versions,
             feature_tier: patch.feature_tier ?? manifest.feature_tier
         };
-        await writeJsonAtomic(NexusPaths.projectManifestPath(id), patchedManifest);
+        await writeJsonAtomic(manifestPath, patchedManifest);
+        try {
+            await writeRegistry(registry);
+        }
+        catch (error) {
+            await restoreFile(snapshot);
+            throw error;
+        }
     }
     static async calculateTopology(projectId) {
         const registry = await readRegistry();

package/build/storage/sqlite.js

@@ -162,19 +162,64 @@ CREATE INDEX IF NOT EXISTS idx_tool_use_bindings_created ON tool_use_bindings(cr
 export function getDbPath() {
     return NexusPaths.dbFile;
 }
+/** Longest a first start waits for another process that is initialising the same database. */
+const INIT_BUSY_WAIT_MS = 10_000;
+const INIT_RETRY_DELAY_MS = 50;
+const sleepSync = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+const isBusy = (error) => error?.code === "SQLITE_BUSY";
 /**
- * Initialize the SQLite database with WAL mode
+ * Open the database, switch it to WAL and create the schema. Throws SQLITE_BUSY
+ * (from the pragma or the schema statements) while another process is writing.
  */
-export function initDatabase() {
+function openDatabase(dbPath) {
+    const candidate = new Database(dbPath);
+    try {
+        // WAL for better concurrent access. The pragma answers with the mode in effect;
+        // anything but "wal" (an in-memory database, a VFS without shared memory) would
+        // leave the daemon in rollback-journal mode, which the startup race cannot survive.
+        const mode = candidate.pragma("journal_mode = WAL", { simple: true });
+        if (mode !== "wal")
+            throw new Error(`WAL mode is not available for ${dbPath}: journal_mode stayed "${mode}".`);
+        candidate.pragma("foreign_keys = ON");
+        candidate.exec(SCHEMA);
+        return candidate;
+    }
+    catch (error) {
+        candidate.close();
+        throw error;
+    }
+}
+/**
+ * Initialize the SQLite database with WAL mode.
+ *
+ * Two daemons starting on a fresh root reach this together. SQLite answers the
+ * second one with SQLITE_BUSY at once (not through the busy timeout) while the
+ * first holds its write lock in rollback-journal mode, so the open is retried
+ * until the other process has finished; no retry starts after `busyWaitMs`.
+ */
+export function initDatabase(options = {}) {
     if (db)
         return db;
     const dbPath = getDbPath();
-    db = new Database(dbPath);
-    // Enable WAL mode for better concurrent access
-    db.pragma("journal_mode = WAL");
-    db.pragma("foreign_keys = ON");
-    // Initialize schema
-    db.exec(SCHEMA);
+    const started = Date.now();
+    const deadline = started + (options.busyWaitMs ?? INIT_BUSY_WAIT_MS);
+    let opened;
+    for (;;) {
+        try {
+            opened = openDatabase(dbPath);
+            break;
+        }
+        catch (error) {
+            if (!isBusy(error))
+                throw error;
+            if (Date.now() >= deadline) {
+                error.message += ` (gave up after ${Date.now() - started} ms waiting for another process initialising ${dbPath})`;
+                throw error;
+            }
+            sleepSync(INIT_RETRY_DELAY_MS);
+        }
+    }
+    db = opened;
     // Migration: Add initiator column if it doesn't exist (Upgrade from v0.1.7)
     try {
         const columns = db.prepare("PRAGMA table_info(meetings)").all();
@@ -187,6 +232,21 @@ export function initDatabase() {
     catch (e) {
         console.error("[Nexus] Migration check failed:", e);
     }
+    // Migration: Convert task timestamps written by the pre-0.6.0 trigger and
+    // column defaults (datetime('now'), 'YYYY-MM-DD HH:MM:SS') to ISO 8601, so
+    // string comparisons against new Date().toISOString() order correctly.
+    try {
+        for (const column of ["created_at", "updated_at"]) {
+            const { changes } = db.prepare(`UPDATE tasks SET ${column} = strftime('%Y-%m-%dT%H:%M:%fZ', ${column})
+                 WHERE ${column} NOT LIKE '%T%' AND strftime('%Y-%m-%dT%H:%M:%fZ', ${column}) IS NOT NULL`).run();
+            if (changes > 0) {
+                console.error(`[Nexus] Migrating database: Converted ${changes} 'tasks.${column}' value(s) to ISO 8601.`);
+            }
+        }
+    }
+    catch (e) {
+        console.error("[Nexus] Migration check failed:", e);
+    }
     // Initialize default state if not exists
     const stmt = db.prepare("INSERT OR IGNORE INTO meeting_state (key, value) VALUES (?, ?)");
     stmt.run("active_meetings", "[]");

package/build/utils/async-rwlock.js

@@ -0,0 +1,64 @@
+/**
+ * Readers-writer lock for async code. Any number of readers run together; a
+ * writer runs alone. Waiters are served in FIFO order and writers take
+ * priority: once a writer is queued, readers that arrive later queue behind
+ * it instead of joining the readers already running, so a steady stream of
+ * reads cannot starve a write.
+ */
+export class AsyncRWLock {
+    readers = 0;
+    writing = false;
+    queue = [];
+    acquire(write) {
+        // A reader may join running readers only while nothing is queued (a queued entry is either a writer or a reader behind one).
+        const free = write ? !this.writing && this.readers === 0 : !this.writing && this.queue.length === 0;
+        if (free) {
+            if (write)
+                this.writing = true;
+            else
+                this.readers++;
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => this.queue.push({ write, resolve }));
+    }
+    release(write) {
+        if (write)
+            this.writing = false;
+        else
+            this.readers--;
+        if (this.writing || this.readers > 0)
+            return;
+        // Lock is free: wake the next writer alone, or every reader up to the next queued writer.
+        const next = this.queue[0];
+        if (!next)
+            return;
+        if (next.write) {
+            this.queue.shift();
+            this.writing = true;
+            next.resolve();
+            return;
+        }
+        while (this.queue.length > 0 && !this.queue[0].write) {
+            this.readers++;
+            this.queue.shift().resolve();
+        }
+    }
+    async withRead(fn) {
+        await this.acquire(false);
+        try {
+            return await fn();
+        }
+        finally {
+            this.release(false);
+        }
+    }
+    async withWrite(fn) {
+        await this.acquire(true);
+        try {
+            return await fn();
+        }
+        finally {
+            this.release(true);
+        }
+    }
+}

package/docs/ARCHITECTURE.md

@@ -92,7 +92,7 @@ All data lives under the daemon's storage root (default `~/.n2n-nexus`):
 
 **SQLite WAL mode**: Only the daemon process opens the database. MCP adapters never touch it — they go through HTTP.
 
-**File-store writes**: HTTP requests are handled concurrently, so every mutation of `registry.json`, manifests and the docs index is queued behind one daemon-wide lock and written atomically (temp file + rename).
+**File-store access**: HTTP requests are handled concurrently, so every mutation of `registry.json`, manifests and the docs index holds one daemon-wide read-write lock alone and is written atomically (temp file + rename); reads share the lock, so a rename or update is never observed half-done. A write orders its files so that `registry.json` goes last and restores what it had already written when a later step fails.
 
 **Activity log**: state changes made through the daemon (project sync/rename/delete, meeting start/end, doc sync, ...) are recorded as structured events in SQLite and read with `list_events` / `GET /api/events`; they are not mixed into chat streams.
 

package/docs/ARCHITECTURE_zh.md

@@ -92,7 +92,7 @@ Stop                           ◀── decision: block   ◀─┘  每次结
 
 **SQLite WAL 模式**：只有 daemon 进程打开数据库。MCP 适配器不直接访问，全部经由 HTTP。
 
-**文件存储写入**：HTTP 请求是并发处理的，因此对 `registry.json`、manifest 和文档索引的每次修改都排在一把 daemon 级写锁后面，并以原子方式写入（临时文件 + rename）。
+**文件存储访问**：HTTP 请求是并发处理的，因此对 `registry.json`、manifest 和文档索引的每次修改都独占一把 daemon 级读写锁，并以原子方式写入（临时文件 + rename）；读取共享这把锁，所以不会读到改名或更新进行到一半的状态。写入时各文件按 `registry.json` 最后写的顺序进行，后一步失败就还原已写的文件。
 
 **活动日志**：经由 daemon 发生的状态变更（项目同步/重命名/删除、会议开始/结束、文档同步等）以结构化事件记录在 SQLite 中，通过 `list_events` / `GET /api/events` 读取，不混入聊天流。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n2n-nexus",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "Local-first MCP coordination hub from N2NS Lab for multi-AI assistant collaboration.",
   "main": "build/index.js",
   "type": "module",

package/build/utils/async-mutex.js

@@ -1,36 +0,0 @@
-/**
- * Simple mutex lock for preventing concurrent file writes.
- * Ensures that only one write operation can happen at a time.
- */
-export class AsyncMutex {
-    locked = false;
-    queue = [];
-    async acquire() {
-        if (!this.locked) {
-            this.locked = true;
-            return;
-        }
-        return new Promise((resolve) => {
-            this.queue.push(resolve);
-        });
-    }
-    release() {
-        if (this.queue.length > 0) {
-            const next = this.queue.shift();
-            if (next)
-                next();
-        }
-        else {
-            this.locked = false;
-        }
-    }
-    async withLock(fn) {
-        await this.acquire();
-        try {
-            return await fn();
-        }
-        finally {
-            this.release();
-        }
-    }
-}