n2n-nexus 0.4.2 → 0.6.0

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/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)

package/build/storage/sqlite.js

@@ -1,5 +1,4 @@
 import Database from "better-sqlite3";
-import { createRequire } from "module";
 import { NexusPaths } from "./paths.js";
 let db = null;
 /**
@@ -50,6 +49,46 @@ CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages(timestamp);
 CREATE INDEX IF NOT EXISTS idx_decisions_meeting ON decisions(meeting_id);
 CREATE INDEX IF NOT EXISTS idx_meetings_status ON meetings(status);
 
+-- Global (non-meeting) chat stream
+CREATE TABLE IF NOT EXISTS global_messages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    sender TEXT NOT NULL,
+    text TEXT NOT NULL,
+    category TEXT CHECK(category IN ('MEETING_START', 'PROPOSAL', 'DECISION', 'UPDATE', 'CHAT')),
+    timestamp TEXT NOT NULL
+);
+
+-- Audit trail of state changes made through the daemon
+CREATE TABLE IF NOT EXISTS events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    timestamp TEXT NOT NULL,
+    actor TEXT NOT NULL,
+    action TEXT NOT NULL,
+    target TEXT,
+    detail TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_events_action ON events(action);
+
+-- Tasks managed by assistants
+CREATE TABLE IF NOT EXISTS tasks (
+    id TEXT PRIMARY KEY,
+    status TEXT NOT NULL CHECK(status IN ('pending', 'running', 'completed', 'failed', 'cancelled')) DEFAULT 'pending',
+    progress REAL DEFAULT 0.0 CHECK(progress >= 0.0 AND progress <= 1.0),
+    source_meeting_id TEXT,
+    metadata TEXT,
+    result_uri TEXT,
+    error_message TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+    ttl INTEGER,
+    FOREIGN KEY (source_meeting_id) REFERENCES meetings(id) ON DELETE SET NULL
+);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_meeting ON tasks(source_meeting_id);
+-- updateTask sets updated_at itself in ISO 8601; the old trigger overwrote it
+-- with datetime('now') in a different format, breaking timestamp comparisons.
+DROP TRIGGER IF EXISTS tasks_updated_at;
+
 -- Read cursors table (tracks each IDE's last read message per context)
 CREATE TABLE IF NOT EXISTS read_cursors (
     instance_id TEXT NOT NULL,
@@ -76,6 +115,7 @@ export function initDatabase() {
     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);
     // Migration: Add initiator column if it doesn't exist (Upgrade from v0.1.7)
@@ -116,26 +156,3 @@ export function closeDatabase() {
         console.error("[Nexus] SQLite database closed");
     }
 }
-export function isSqliteAvailable() {
-    const require = createRequire(import.meta.url);
-    try {
-        // Try to load better-sqlite3
-        require("better-sqlite3");
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// Cleanup on process exit
-process.on("exit", () => {
-    closeDatabase();
-});
-process.on("SIGINT", () => {
-    closeDatabase();
-    process.exit(0);
-});
-process.on("SIGTERM", () => {
-    closeDatabase();
-    process.exit(0);
-});

package/build/storage/tasks.js

@@ -6,59 +6,13 @@
  */
 import { getDatabase } from "./sqlite.js";
 import { TASK_CLEANUP_MAX_AGE_MS } from "../constants.js";
+export const TASK_STATUSES = ["pending", "running", "completed", "failed", "cancelled"];
 // Generate unique task ID
 function generateTaskId() {
     const timestamp = new Date().toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
     const random = Math.random().toString(36).substring(2, 6);
     return `task_${timestamp}_${random}`;
 }
-let initialized = false;
-/**
- * Initialize the tasks table (run migrations)
- */
-export function initTasksTable() {
-    if (initialized)
-        return;
-    const db = getDatabase();
-    const TASKS_SCHEMA = `
-    CREATE TABLE IF NOT EXISTS tasks (
-        id TEXT PRIMARY KEY,
-        status TEXT NOT NULL CHECK(status IN ('pending', 'running', 'completed', 'failed', 'cancelled')) DEFAULT 'pending',
-        progress REAL DEFAULT 0.0 CHECK(progress >= 0.0 AND progress <= 1.0),
-        source_meeting_id TEXT,
-        metadata TEXT,
-        result_uri TEXT,
-        error_message TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now')),
-        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
-        ttl INTEGER,
-        FOREIGN KEY (source_meeting_id) REFERENCES meetings(id) ON DELETE SET NULL
-    );
-    
-    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
-    CREATE INDEX IF NOT EXISTS idx_tasks_meeting ON tasks(source_meeting_id);
-    `;
-    db.exec(TASKS_SCHEMA);
-    // Add trigger for auto-updating updated_at (separate exec to handle IF NOT EXISTS)
-    try {
-        db.exec(`
-            CREATE TRIGGER IF NOT EXISTS tasks_updated_at
-            AFTER UPDATE ON tasks
-            FOR EACH ROW
-            BEGIN
-                UPDATE tasks SET updated_at = datetime('now') WHERE id = OLD.id;
-            END;
-        `);
-    }
-    catch {
-        // Trigger may already exist in older SQLite versions without IF NOT EXISTS support
-    }
-    console.error("[Nexus] Tasks table initialized");
-    initialized = true;
-}
-export function resetTasksInit() {
-    initialized = false;
-}
 /**
  * Create a new task
  */
@@ -73,14 +27,7 @@ export function createTask(input = {}) {
     stmt.run(id, input.source_meeting_id || null, input.metadata ? JSON.stringify(input.metadata) : null, now, now, input.ttl || null);
     return getTask(id);
 }
-/**
- * Get a task by ID
- */
-export function getTask(id) {
-    const db = getDatabase();
-    const row = db.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
-    if (!row)
-        return null;
+function rowToTask(row) {
     return {
         id: row.id,
         status: row.status,
@@ -94,6 +41,13 @@ export function getTask(id) {
         ttl: row.ttl || null
     };
 }
+/**
+ * Get a task by ID
+ */
+export function getTask(id) {
+    const row = getDatabase().prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+    return row ? rowToTask(row) : null;
+}
 /**
  * Update task status and progress
  */
@@ -141,39 +95,7 @@ export function listTasks(status, limit = 50) {
     sql += " ORDER BY created_at DESC LIMIT ?";
     params.push(limit);
     const rows = db.prepare(sql).all(...params);
-    return rows.map(row => ({
-        id: row.id,
-        status: row.status,
-        progress: row.progress,
-        source_meeting_id: row.source_meeting_id || null,
-        metadata: row.metadata ? JSON.parse(row.metadata) : {},
-        result_uri: row.result_uri || null,
-        error_message: row.error_message || null,
-        created_at: row.created_at,
-        updated_at: row.updated_at,
-        ttl: row.ttl || null
-    }));
-}
-/**
- * Get tasks by meeting ID
- */
-export function getTasksByMeeting(meetingId) {
-    const db = getDatabase();
-    const rows = db.prepare(`
-        SELECT * FROM tasks WHERE source_meeting_id = ? ORDER BY created_at DESC
-    `).all(meetingId);
-    return rows.map(row => ({
-        id: row.id,
-        status: row.status,
-        progress: row.progress,
-        source_meeting_id: row.source_meeting_id || null,
-        metadata: row.metadata ? JSON.parse(row.metadata) : {},
-        result_uri: row.result_uri || null,
-        error_message: row.error_message || null,
-        created_at: row.created_at,
-        updated_at: row.updated_at,
-        ttl: row.ttl || null
-    }));
+    return rows.map(rowToTask);
 }
 /**
  * Cancel a pending or running task
@@ -187,26 +109,30 @@ export function cancelTask(id) {
     updateTask(id, { status: "cancelled" });
     return true;
 }
+/**
+ * Mark pending/running tasks whose TTL has elapsed as failed.
+ */
+export function expireTasks(now = Date.now()) {
+    return getDatabase().prepare(`
+        UPDATE tasks
+        SET status = 'failed', error_message = 'TTL expired', updated_at = ?
+        WHERE status IN ('pending', 'running')
+          AND ttl IS NOT NULL
+          AND strftime('%s', created_at) * 1000 + ttl < ?
+    `).run(new Date(now).toISOString(), now).changes;
+}
 /**
  * Delete completed/failed/cancelled tasks older than specified age
  */
-export function cleanupTasks(maxAgeMs = TASK_CLEANUP_MAX_AGE_MS) {
-    const db = getDatabase();
-    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
-    const result = db.prepare(`
+export function cleanupTasks(maxAgeMs = TASK_CLEANUP_MAX_AGE_MS, now = Date.now()) {
+    const cutoff = new Date(now - maxAgeMs).toISOString();
+    return getDatabase().prepare(`
         DELETE FROM tasks 
         WHERE status IN ('completed', 'failed', 'cancelled') 
         AND updated_at < ?
-    `).run(cutoff);
-    return result.changes;
+    `).run(cutoff).changes;
 }
-/**
- * Get active (pending/running) task count
- */
-export function getActiveTaskCount() {
-    const db = getDatabase();
-    const row = db.prepare(`
-        SELECT COUNT(*) as count FROM tasks WHERE status IN ('pending', 'running')
-    `).get();
-    return row.count;
+/** Expire overdue tasks, then purge finished ones past the retention window. */
+export function runTaskMaintenance(now = Date.now()) {
+    return { expired: expireTasks(now), removed: cleanupTasks(TASK_CLEANUP_MAX_AGE_MS, now) };
 }

package/build/types.js

@@ -1 +1 @@
-export {};
+export const MESSAGE_CATEGORIES = ["MEETING_START", "PROPOSAL", "DECISION", "UPDATE", "CHAT"];