n2n-nexus 0.4.2 → 0.7.0

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,58 @@ 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 () => {
+            if (!await RegistryStorage.getProjectManifest(oldId))
+                throw new Error(`Project '${oldId}' not found.`);
+            const renamed = await RegistryStorage.renameProject(oldId, newId);
+            if (renamed === 0)
+                throw new Error(`Project '${oldId}' could not be renamed.`);
+            try {
+                const result = await ProjectStorage.renameProject(oldId, newId);
+                if (result === 0)
+                    throw new Error(`Project '${oldId}' could not be renamed.`);
+                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,86 @@
+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: migrated artifacts are retired or completion is persisted.
+ */
+/** 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";
+const LEGACY_STRATEGY_MIGRATION = "migration:legacy_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. Record completion even when there
+ * is nothing to move, so later user documents cannot become legacy data.
+ */
+export async function importLegacyStrategy() {
+    const db = getDatabase();
+    if (db.prepare("SELECT 1 FROM meeting_state WHERE key = ?").get(LEGACY_STRATEGY_MIGRATION))
+        return false;
+    const docs = await DocStorage.listDocs();
+    let moved = false;
+    if (docs.strategy?.title === LEGACY_STRATEGY_TITLE) {
+        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");
+            moved = true;
+            console.error("[n2n-nexus] Moved legacy global doc 'strategy' into global/blueprint.md");
+        }
+    }
+    db.prepare("INSERT INTO meeting_state (key, value) VALUES (?, ?)").run(LEGACY_STRATEGY_MIGRATION, "complete");
+    return moved;
+}
+export async function runMigrations() {
+    await importLegacyDiscussion();
+    await importLegacyStrategy();
+}

package/build/storage/paths.js

@@ -4,10 +4,8 @@ export class NexusPaths {
     static get root() { return getRootPath(); }
     static get globalDir() { return path.join(this.root, "global"); }
     static get globalBlueprint() { return path.join(this.globalDir, "blueprint.md"); }
-    static get globalDiscussion() { return path.join(this.globalDir, "discussion.json"); }
     static get projectsRoot() { return path.join(this.root, "projects"); }
     static get registryFile() { return path.join(this.root, "registry.json"); }
-    static get archivesDir() { return path.join(this.root, "archives"); }
     static assertSafeSegment(value, label) {
         if (!/^[a-zA-Z0-9._-]+$/.test(value) || value === "." || value === "..") {
             throw new Error(`Invalid ${label}: '${value}'. Use only letters, numbers, dots, underscores, and hyphens.`);
@@ -19,7 +17,6 @@ export class NexusPaths {
     static projectManifestPath(id) { return path.join(this.projectDir(id), "manifest.json"); }
     static projectAssetsDir(id) { return path.join(this.projectDir(id), "assets"); }
     static get dbFile() { return path.join(this.root, "nexus.db"); }
-    static taskFile() { return path.join(this.root, "tasks.json"); }
     static docsDir() { return path.join(this.globalDir, "docs"); }
     static get docsIndexFile() { return path.join(this.globalDir, "docs_index.json"); }
     static docFile(docId) { return path.join(this.docsDir(), `${this.assertSafeSegment(docId, "document id")}.md`); }

package/build/storage/projects.js

@@ -2,6 +2,7 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { NexusPaths } from "./paths.js";
 import { FILE_ENCODING } from "../constants.js";
+import { writeFileAtomic, writeJsonAtomic } from "./fs-utils.js";
 export class ProjectStorage {
     static projectFilePath(projectId) {
         return {
@@ -22,15 +23,13 @@ export class ProjectStorage {
     }
     static async saveProjectDocs(projectId, content) {
         const paths = this.projectFilePath(projectId);
-        await fs.mkdir(paths.projectDir, { recursive: true });
-        await fs.writeFile(paths.docsPath, content, FILE_ENCODING);
+        await writeFileAtomic(paths.docsPath, content);
     }
     static async saveAsset(projectId, fileName, content) {
         const safeName = this.sanitizeFileName(fileName);
         const paths = this.projectFilePath(projectId);
-        await fs.mkdir(paths.assetsDir, { recursive: true });
         const assetPath = path.join(paths.assetsDir, safeName);
-        await fs.writeFile(assetPath, content, FILE_ENCODING);
+        await writeFileAtomic(assetPath, content);
         return path.relative(NexusPaths.root, assetPath);
     }
     static async deleteProject(projectId) {
@@ -60,7 +59,7 @@ export class ProjectStorage {
             const manifestRaw = await fs.readFile(newPath.manifestPath, FILE_ENCODING);
             const manifest = JSON.parse(manifestRaw);
             manifest.id = newId;
-            await fs.writeFile(newPath.manifestPath, JSON.stringify(manifest, null, 2), FILE_ENCODING);
+            await writeJsonAtomic(newPath.manifestPath, manifest);
         }
         catch {
             // Manifest is optional for some flows.

package/build/storage/registry.js

@@ -1,6 +1,7 @@
 import { promises as fs } from "node:fs";
 import { NexusPaths } from "./paths.js";
-const emptyRegistry = { projects: {} };
+import { toDict, writeJsonAtomic } from "./fs-utils.js";
+const emptyRegistry = () => ({ projects: toDict() });
 async function readRegistry() {
     try {
         const raw = await fs.readFile(NexusPaths.registryFile, "utf-8");
@@ -8,17 +9,17 @@ async function readRegistry() {
         return sanitizeRegistry(parsed);
     }
     catch {
-        return { ...emptyRegistry };
+        return emptyRegistry();
     }
 }
 function sanitizeRegistry(data) {
     if (!data || typeof data !== "object")
-        return { ...emptyRegistry };
+        return emptyRegistry();
     const root = data;
     if (!root.projects || typeof root.projects !== "object")
-        return { ...emptyRegistry };
+        return emptyRegistry();
     return {
-        projects: Object.fromEntries(Object.entries(root.projects).map(([id, item]) => {
+        projects: toDict(Object.entries(root.projects).map(([id, item]) => {
             if (!item || typeof item !== "object") {
                 return [id, {
                         summary: "",
@@ -35,8 +36,7 @@ function sanitizeRegistry(data) {
     };
 }
 async function writeRegistry(data) {
-    await fs.mkdir(NexusPaths.root, { recursive: true });
-    await fs.writeFile(NexusPaths.registryFile, JSON.stringify(data, null, 2), "utf-8");
+    await writeJsonAtomic(NexusPaths.registryFile, data);
 }
 async function readProjectManifest(id) {
     try {
@@ -47,6 +47,46 @@ async function readProjectManifest(id) {
         return null;
     }
 }
+const RELATION_TYPES = ["dependency", "parent", "child", "related"];
+const str = (v, fallback = "") => (typeof v === "string" ? v : fallback);
+const objects = (v) => Array.isArray(v) ? v.filter((x) => !!x && typeof x === "object" && !Array.isArray(x)) : [];
+const stringRecord = (v) => {
+    if (!v || typeof v !== "object" || Array.isArray(v))
+        return undefined;
+    return Object.fromEntries(Object.entries(v).filter(([, x]) => typeof x === "string"));
+};
+/** Relations with a string targetId; an unknown or missing type reads as "related". */
+export function normalizeRelations(v) {
+    return objects(v)
+        .filter((r) => typeof r.targetId === "string" && r.targetId)
+        .map((r) => ({
+        targetId: r.targetId,
+        type: RELATION_TYPES.includes(r.type) ? r.type : "related"
+    }));
+}
+function normalizeManifestFields(raw) {
+    const m = (raw ?? {});
+    const billing = m.billing && typeof m.billing === "object"
+        ? { plain: str(m.billing.plain), price: str(m.billing.price) }
+        : undefined;
+    const tiers = ["standard", "advanced", "team"];
+    return {
+        name: typeof m.name === "string" ? m.name : undefined,
+        description: typeof m.description === "string" ? m.description : undefined,
+        techStack: Array.isArray(m.techStack) ? m.techStack.filter((t) => typeof t === "string") : [],
+        relations: normalizeRelations(m.relations),
+        lastUpdated: typeof m.lastUpdated === "string" && m.lastUpdated ? m.lastUpdated : undefined,
+        repositoryUrl: str(m.repositoryUrl),
+        localPath: typeof m.localPath === "string" && m.localPath ? m.localPath : undefined,
+        endpoints: objects(m.endpoints).map((e) => ({ name: str(e.name), url: str(e.url), description: str(e.description) })),
+        apiSpec: objects(m.apiSpec).map((e) => ({ method: str(e.method), path: str(e.path), summary: str(e.summary) })),
+        billing,
+        apiDependencies: stringRecord(m.apiDependencies),
+        gatewayCompatibility: typeof m.gatewayCompatibility === "string" ? m.gatewayCompatibility : undefined,
+        api_versions: stringRecord(m.api_versions),
+        feature_tier: tiers.includes(m.feature_tier) ? m.feature_tier : undefined
+    };
+}
 export class RegistryStorage {
     static async listRegistry() {
         return readRegistry();
@@ -62,29 +102,30 @@ export class RegistryStorage {
         };
         await writeRegistry(registry);
         await fs.mkdir(projectDir, { recursive: true });
-        await fs.writeFile(manifestPath, JSON.stringify({ ...manifest, lastUpdated: manifest.lastUpdated || new Date().toISOString() }, null, 2), "utf-8");
+        await writeJsonAtomic(manifestPath, { ...manifest, lastUpdated: manifest.lastUpdated || new Date().toISOString() });
     }
     static async getProjectManifest(id) {
         const registry = await readRegistry();
         const entry = registry.projects[id];
         if (!entry)
             return null;
-        const rawManifest = await readProjectManifest(id);
+        const m = normalizeManifestFields(await readProjectManifest(id));
         return {
             id,
-            name: entry.name || rawManifest?.name || id,
-            description: entry.summary || rawManifest?.description || "",
-            techStack: rawManifest?.techStack || [],
-            relations: rawManifest?.relations || [],
-            lastUpdated: rawManifest?.lastUpdated || entry.lastActive,
-            repositoryUrl: rawManifest?.repositoryUrl || "",
-            localPath: rawManifest?.localPath || NexusPaths.projectDir(id),
-            endpoints: rawManifest?.endpoints || [],
-            apiSpec: rawManifest?.apiSpec || [],
-            apiDependencies: rawManifest?.apiDependencies,
-            gatewayCompatibility: rawManifest?.gatewayCompatibility,
-            api_versions: rawManifest?.api_versions,
-            feature_tier: rawManifest?.feature_tier
+            name: entry.name || m.name || id,
+            description: entry.summary || m.description || "",
+            techStack: m.techStack,
+            relations: m.relations,
+            lastUpdated: m.lastUpdated || entry.lastActive,
+            repositoryUrl: m.repositoryUrl,
+            localPath: m.localPath || NexusPaths.projectDir(id),
+            endpoints: m.endpoints,
+            apiSpec: m.apiSpec,
+            billing: m.billing,
+            apiDependencies: m.apiDependencies,
+            gatewayCompatibility: m.gatewayCompatibility,
+            api_versions: m.api_versions,
+            feature_tier: m.feature_tier
         };
     }
     static async patchProjectManifest(id, patch) {
@@ -111,12 +152,13 @@ export class RegistryStorage {
             localPath: patch.localPath ?? manifest.localPath ?? NexusPaths.projectDir(id),
             endpoints: patch.endpoints ?? manifest.endpoints ?? [],
             apiSpec: patch.apiSpec ?? manifest.apiSpec ?? [],
+            billing: patch.billing ?? manifest.billing,
             apiDependencies: patch.apiDependencies ?? manifest.apiDependencies,
             gatewayCompatibility: patch.gatewayCompatibility ?? manifest.gatewayCompatibility,
             api_versions: patch.api_versions ?? manifest.api_versions,
             feature_tier: patch.feature_tier ?? manifest.feature_tier
         };
-        await fs.writeFile(NexusPaths.projectManifestPath(id), JSON.stringify(patchedManifest, null, 2), "utf-8");
+        await writeJsonAtomic(NexusPaths.projectManifestPath(id), patchedManifest);
     }
     static async calculateTopology(projectId) {
         const registry = await readRegistry();
@@ -127,7 +169,7 @@ export class RegistryStorage {
                 name: manifest?.name || project.name || id,
                 summary: project.summary,
                 lastActive: project.lastActive,
-                relations: manifest?.relations || []
+                relations: normalizeRelations(manifest?.relations)
             };
         }));
         const nodeMap = new Map(projectRecords.map((record) => [record.id, record]));
@@ -222,7 +264,7 @@ export class RegistryStorage {
                 manifest.relations = relations;
             }
             if (changed) {
-                await fs.writeFile(NexusPaths.projectManifestPath(manifestId), JSON.stringify(manifest, null, 2), "utf-8");
+                await writeJsonAtomic(NexusPaths.projectManifestPath(manifestId), manifest);
             }
         }
         return 1;

package/build/storage/sessions.js

@@ -0,0 +1,77 @@
+import { getDatabase } from "./sqlite.js";
+export const SESSION_LEASE_MS = 60_000;
+function toSession(row, now) {
+    return {
+        sessionId: row.session_id, instanceId: row.instance_id, name: row.name,
+        clientName: row.client_name, workspace: row.workspace, projectId: row.project_id,
+        inbound: row.inbound, reception: "pull",
+        online: row.connected === 1 && now - Date.parse(row.last_seen_at) < SESSION_LEASE_MS,
+        createdAt: row.created_at, lastSeenAt: row.last_seen_at
+    };
+}
+export class SessionStore {
+    static register(input, now = Date.now()) {
+        const db = getDatabase();
+        return db.transaction(() => {
+            const existing = this.get(input.sessionId, now);
+            if (existing && existing.instanceId !== input.instanceId)
+                throw new Error("Session belongs to another instance");
+            const timestamp = new Date(now).toISOString();
+            if (existing) {
+                db.prepare("UPDATE sessions SET client_name = ?, workspace = ?, connected = 1, last_seen_at = ? WHERE session_id = ?")
+                    .run(input.clientName ?? existing.clientName, input.workspace ?? existing.workspace, timestamp, input.sessionId);
+            }
+            else {
+                db.prepare("INSERT INTO sessions (session_id, instance_id, name, client_name, workspace, created_at, last_seen_at) VALUES (?, ?, ?, ?, ?, ?, ?)")
+                    .run(input.sessionId, input.instanceId, `session-${input.sessionId.slice(0, 8)}`, input.clientName ?? "", input.workspace ?? "", timestamp, timestamp);
+            }
+            return this.get(input.sessionId, now);
+        })();
+    }
+    static get(sessionId, now = Date.now()) {
+        const row = getDatabase().prepare("SELECT * FROM sessions WHERE session_id = ?").get(sessionId);
+        return row ? toSession(row, now) : null;
+    }
+    static require(sessionId, instanceId) {
+        const session = this.get(sessionId);
+        if (!session)
+            throw new Error(`Unknown session: ${sessionId}`);
+        if (instanceId !== undefined && session.instanceId !== instanceId)
+            throw new Error("Session belongs to another instance");
+        return session;
+    }
+    static list(options = {}, now = Date.now()) {
+        const clauses = [];
+        const params = [];
+        if (options.projectId !== undefined) {
+            clauses.push("project_id = ?");
+            params.push(options.projectId);
+        }
+        if (options.onlineOnly) {
+            clauses.push("connected = 1 AND last_seen_at > ?");
+            params.push(new Date(now - SESSION_LEASE_MS).toISOString());
+        }
+        const rows = getDatabase().prepare(`SELECT * FROM sessions ${clauses.length ? `WHERE ${clauses.join(" AND ")}` : ""} ORDER BY last_seen_at DESC, rowid DESC LIMIT ?`)
+            .all(...params, options.limit ?? 100);
+        return rows.map(row => toSession(row, now));
+    }
+    static update(sessionId, changes, now = Date.now()) {
+        const db = getDatabase();
+        return db.transaction(() => {
+            const existing = this.require(sessionId);
+            db.prepare("UPDATE sessions SET name = ?, project_id = ?, inbound = ? WHERE session_id = ?")
+                .run(changes.name ?? existing.name, changes.projectId === undefined ? existing.projectId : changes.projectId, changes.inbound ?? existing.inbound, sessionId);
+            if (changes.inbound === "refuse") {
+                db.prepare("UPDATE direct_messages SET status = 'expired', reason = 'Message TTL elapsed' WHERE to_session_id = ? AND status IN ('accepted', 'fetched') AND expires_at <= ?")
+                    .run(sessionId, new Date(now).toISOString());
+                db.prepare("UPDATE direct_messages SET status = 'refused', reason = 'recipient_refused' WHERE to_session_id = ? AND status IN ('accepted', 'fetched')")
+                    .run(sessionId);
+            }
+            return this.get(sessionId, now);
+        })();
+    }
+    static disconnect(sessionId, instanceId) {
+        this.require(sessionId, instanceId);
+        getDatabase().prepare("UPDATE sessions SET connected = 0 WHERE session_id = ?").run(sessionId);
+    }
+}

package/build/storage/sqlite-meeting.js

@@ -154,13 +154,7 @@ export class SqliteMeetingStore {
         const activeMeetings = this.getActiveMeetingIds().filter(id => id !== meetingId);
         this.updateState("active_meetings", JSON.stringify(activeMeetings));
         this.updateState("default_meeting", activeMeetings.length > 0 ? activeMeetings[activeMeetings.length - 1] : "");
-        // Refresh meeting data
-        const updatedMeeting = this.getMeeting(meetingId);
-        // Suggest sync targets based on participants
-        const suggestedSyncTargets = updatedMeeting.participants
-            .map(p => p.split("@")[1])
-            .filter((v, i, a) => v && v !== "Global" && a.indexOf(v) === i);
-        return { meeting: updatedMeeting, suggestedSyncTargets };
+        return this.getMeeting(meetingId);
     }
     /**
      * Archive a meeting
@@ -182,13 +176,17 @@ export class SqliteMeetingStore {
     /**
      * Reopen a closed or archived meeting
      */
-    static reopenMeeting(meetingId, _callerId) {
+    static reopenMeeting(meetingId, callerId) {
         const db = getDatabase();
         const meeting = this.getMeeting(meetingId);
         if (!meeting)
             throw new Error(`Meeting '${meetingId}' not found.`);
         if (meeting.status === "active")
             throw new Error(`Meeting '${meetingId}' is already active.`);
+        // Permission check: Only initiator can reopen (same rule as end/archive)
+        if (callerId && meeting.initiator && meeting.initiator !== callerId) {
+            throw new Error(`Permission denied: Only initiator (${meeting.initiator}) can reopen this meeting.`);
+        }
         // Update status to active
         const stmt = db.prepare("UPDATE meetings SET status = 'active', closed_at = NULL WHERE id = ?");
         stmt.run(meetingId);
@@ -204,33 +202,47 @@ export class SqliteMeetingStore {
     /**
      * List meetings with optional status filter
      */
-    static listMeetings(status) {
+    static listMeetings(status, limit = 50) {
         const db = getDatabase();
-        let query = "SELECT id, topic, status, participants, created_at FROM meetings";
-        const params = [];
-        if (status) {
-            query += " WHERE status = ?";
-            params.push(status);
-        }
-        query += " ORDER BY created_at DESC";
-        const stmt = db.prepare(query);
-        const meetings = (params.length > 0 ? stmt.all(...params) : stmt.all());
-        return meetings.map(m => ({
+        const rows = db.prepare(`
+            SELECT m.id, m.topic, m.status, m.initiator, m.participants, m.created_at, m.closed_at, m.summary,
+                   (SELECT COUNT(*) FROM messages WHERE meeting_id = m.id) AS message_count,
+                   (SELECT COUNT(*) FROM decisions WHERE meeting_id = m.id) AS decision_count
+            FROM meetings m
+            WHERE (? IS NULL OR m.status = ?)
+            ORDER BY m.created_at DESC
+            LIMIT ?
+        `).all(status ?? null, status ?? null, limit);
+        return rows.map(m => ({
             id: m.id,
             topic: m.topic,
             status: m.status,
+            initiator: m.initiator || "Unknown",
             startTime: m.created_at,
-            participantCount: JSON.parse(m.participants).length
+            endTime: m.closed_at || undefined,
+            participants: JSON.parse(m.participants),
+            messageCount: m.message_count,
+            decisionCount: m.decision_count,
+            summary: m.summary || undefined
         }));
     }
     /**
-     * Get the current active meeting
+     * Id of the current default meeting, if it is still active.
+     * Cheap: does not load the meeting's messages.
      */
-    static getActiveMeeting() {
+    static getActiveMeetingId() {
         const defaultId = this.getState("default_meeting");
         if (!defaultId)
             return null;
-        return this.getMeeting(defaultId);
+        const row = getDatabase().prepare("SELECT id FROM meetings WHERE id = ? AND status = 'active'").get(defaultId);
+        return row?.id ?? null;
+    }
+    /**
+     * Get the current active meeting
+     */
+    static getActiveMeeting() {
+        const id = this.getActiveMeetingId();
+        return id ? this.getMeeting(id) : null;
     }
     /**
      * Get recent messages from a meeting (incremental read based on instance cursor)