@psiclawops/hypermem 0.1.0

package/dist/seed.js

@@ -0,0 +1,177 @@
+/**
+ * HyperMem Workspace Seeder
+ *
+ * Reads ACA workspace files, chunks them by logical section, and indexes
+ * into HyperMem for demand-loaded retrieval (ACA offload).
+ *
+ * Usage:
+ *   const seeder = new WorkspaceSeeder(hypermem);
+ *   const result = await seeder.seedWorkspace('/path/to/workspace', { agentId: 'forge' });
+ *
+ * Idempotent: skips files whose source hash hasn't changed since last index.
+ * Atomic: each file's chunks are swapped in a single transaction.
+ *
+ * Files seeded (from ACA_COLLECTIONS):
+ *   POLICY.md      → governance/policy   (shared-fleet)
+ *   CHARTER.md     → governance/charter  (per-tier)
+ *   COMMS.md       → governance/comms    (shared-fleet)
+ *   AGENTS.md      → operations/agents   (per-tier)
+ *   TOOLS.md       → operations/tools    (per-agent)
+ *   SOUL.md        → identity/soul       (per-agent)
+ *   JOB.md         → identity/job        (per-agent)
+ *   MOTIVATIONS.md → identity/motivations(per-agent)
+ *   MEMORY.md      → memory/decisions    (per-agent)
+ *   memory/*.md    → memory/daily        (per-agent)
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import * as path from 'node:path';
+import { chunkFile, inferCollection, ACA_COLLECTIONS, hashContent } from './doc-chunker.js';
+import { DocChunkStore } from './doc-chunk-store.js';
+// ─── Seeder ──────────────────────────────────────────────────────
+export class WorkspaceSeeder {
+    db;
+    chunkStore;
+    constructor(db) {
+        this.db = db;
+        this.chunkStore = new DocChunkStore(db);
+    }
+    /**
+     * Seed all ACA files from a workspace directory.
+     */
+    async seedWorkspace(workspaceDir, opts = {}) {
+        const result = {
+            files: [],
+            totalInserted: 0,
+            totalDeleted: 0,
+            skipped: 0,
+            reindexed: 0,
+            errors: [],
+        };
+        const filesToProcess = this.discoverFiles(workspaceDir, opts);
+        for (const { filePath, collectionDef } of filesToProcess) {
+            // Skip if collection filter provided
+            if (opts.collections && !opts.collections.includes(collectionDef.collection)) {
+                continue;
+            }
+            try {
+                const chunks = chunkFile(filePath, {
+                    collection: collectionDef.collection,
+                    scope: collectionDef.scope,
+                    tier: collectionDef.scope === 'per-tier' ? (opts.tier ?? 'all') : undefined,
+                    agentId: collectionDef.scope === 'per-agent' ? opts.agentId : undefined,
+                });
+                if (chunks.length === 0)
+                    continue;
+                // Force re-index if requested
+                if (opts.force) {
+                    this.chunkStore.deleteSource(filePath, collectionDef.collection);
+                }
+                const indexResult = this.chunkStore.indexChunks(chunks);
+                result.files.push({ filePath, collection: collectionDef.collection, result: indexResult });
+                result.totalInserted += indexResult.inserted;
+                result.totalDeleted += indexResult.deleted;
+                if (indexResult.skipped)
+                    result.skipped++;
+                if (indexResult.reindexed)
+                    result.reindexed++;
+            }
+            catch (err) {
+                result.errors.push({
+                    filePath,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * Seed a single file explicitly.
+     */
+    seedFile(filePath, collection, opts = {}) {
+        const collectionDef = Object.values(ACA_COLLECTIONS).find(d => d.collection === collection)
+            ?? { collection, scope: 'per-agent', description: '' };
+        if (opts.force) {
+            this.chunkStore.deleteSource(filePath, collection);
+        }
+        const chunks = chunkFile(filePath, {
+            collection,
+            scope: collectionDef.scope,
+            tier: collectionDef.scope === 'per-tier' ? (opts.tier ?? 'all') : undefined,
+            agentId: collectionDef.scope === 'per-agent' ? opts.agentId : undefined,
+        });
+        const indexResult = this.chunkStore.indexChunks(chunks);
+        return { filePath, collection, result: indexResult };
+    }
+    /**
+     * Check which workspace files need re-indexing.
+     */
+    checkStaleness(workspaceDir, opts = {}) {
+        const filesToProcess = this.discoverFiles(workspaceDir, opts);
+        return filesToProcess.map(({ filePath, collectionDef }) => {
+            try {
+                const content = readFileSync(filePath, 'utf-8');
+                const hash = hashContent(content);
+                const needsReindex = this.chunkStore.needsReindex(filePath, collectionDef.collection, hash);
+                return { filePath, collection: collectionDef.collection, needsReindex };
+            }
+            catch {
+                return { filePath, collection: collectionDef.collection, needsReindex: true };
+            }
+        });
+    }
+    /**
+     * Get stats about what's currently indexed.
+     */
+    getIndexStats() {
+        return this.chunkStore.getStats();
+    }
+    /**
+     * Query indexed chunks by collection.
+     */
+    queryChunks(collection, opts = {}) {
+        return this.chunkStore.queryChunks({ collection, ...opts });
+    }
+    // ─── Private helpers ─────────────────────────────────────────
+    discoverFiles(workspaceDir, opts) {
+        const files = [];
+        // Known ACA files in workspace root
+        for (const fileName of Object.keys(ACA_COLLECTIONS)) {
+            const filePath = path.join(workspaceDir, fileName);
+            if (!existsSync(filePath))
+                continue;
+            const collectionDef = inferCollection(fileName, opts.agentId);
+            if (!collectionDef)
+                continue;
+            files.push({ filePath, collectionDef });
+        }
+        // Daily memory files
+        if (opts.includeDailyMemory !== false) {
+            const memoryDir = path.join(workspaceDir, 'memory');
+            if (existsSync(memoryDir)) {
+                const memFiles = readdirSync(memoryDir)
+                    .filter(f => /^\d{4}-\d{2}-\d{2}\.md$/.test(f))
+                    .sort()
+                    .reverse(); // Most recent first
+                const limit = opts.dailyMemoryLimit ?? 30;
+                for (const memFile of memFiles.slice(0, limit)) {
+                    const filePath = path.join(memoryDir, memFile);
+                    const collectionDef = inferCollection(memFile, opts.agentId);
+                    if (collectionDef) {
+                        files.push({ filePath, collectionDef });
+                    }
+                }
+            }
+        }
+        return files;
+    }
+}
+// ─── Standalone seed function ────────────────────────────────────
+/**
+ * Seed a workspace directly from a DatabaseSync instance.
+ * Convenience wrapper for use in the hook handler and CLI.
+ */
+export async function seedWorkspace(db, workspaceDir, opts = {}) {
+    const seeder = new WorkspaceSeeder(db);
+    return seeder.seedWorkspace(workspaceDir, opts);
+}
+//# sourceMappingURL=seed.js.map

package/dist/system-store.d.ts

@@ -0,0 +1,73 @@
+/**
+ * HyperMem System Registry Store
+ *
+ * Server config, service states, operational flags.
+ * Lives in the central library DB.
+ * The source of truth for "what's running and what state is it in."
+ */
+import type { DatabaseSync } from 'node:sqlite';
+export interface SystemState {
+    id: number;
+    category: string;
+    key: string;
+    value: unknown;
+    updatedAt: string;
+    updatedBy: string | null;
+    ttl: string | null;
+}
+export interface SystemEvent {
+    id: number;
+    category: string;
+    key: string;
+    eventType: string;
+    oldValue: unknown;
+    newValue: unknown;
+    agentId: string | null;
+    createdAt: string;
+    metadata: Record<string, unknown> | null;
+}
+export declare class SystemStore {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    /**
+     * Set a system state value. Records a change event if the value changed.
+     */
+    set(category: string, key: string, value: unknown, opts?: {
+        updatedBy?: string;
+        ttl?: string;
+    }): SystemState;
+    /**
+     * Get a system state value.
+     */
+    get(category: string, key: string): SystemState | null;
+    /**
+     * Get all state in a category.
+     */
+    getCategory(category: string): SystemState[];
+    /**
+     * Delete a system state entry.
+     */
+    delete(category: string, key: string, agentId?: string): boolean;
+    /**
+     * Record an event without changing state (e.g., restart, error, warning).
+     */
+    recordEvent(category: string, key: string, eventType: string, opts?: {
+        agentId?: string;
+        metadata?: Record<string, unknown>;
+    }): void;
+    /**
+     * Get recent events for a category/key.
+     */
+    getEvents(opts?: {
+        category?: string;
+        key?: string;
+        eventType?: string;
+        since?: string;
+        limit?: number;
+    }): SystemEvent[];
+    /**
+     * Prune expired TTL entries.
+     */
+    pruneExpired(): number;
+}
+//# sourceMappingURL=system-store.d.ts.map

package/dist/system-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-store.d.ts","sourceRoot":"","sources":["../src/system-store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAMhD,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC1C;AAqCD,qBAAa,WAAW;IACV,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,YAAY;IAE7C;;OAEG;IACH,GAAG,CACD,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,OAAO,EACd,IAAI,CAAC,EAAE;QACL,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,GACA,WAAW;IA8Bd;;OAEG;IACH,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAsBtD;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,EAAE;IAW5C;;OAEG;IACH,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO;IAmBhE;;OAEG;IACH,WAAW,CACT,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE;QACL,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACpC,GACA,IAAI;IAcP;;OAEG;IACH,SAAS,CAAC,IAAI,CAAC,EAAE;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,GAAG,WAAW,EAAE;IA4BjB;;OAEG;IACH,YAAY,IAAI,MAAM;CAQvB"}

package/dist/system-store.js

@@ -0,0 +1,182 @@
+/**
+ * HyperMem System Registry Store
+ *
+ * Server config, service states, operational flags.
+ * Lives in the central library DB.
+ * The source of truth for "what's running and what state is it in."
+ */
+function nowIso() {
+    return new Date().toISOString();
+}
+function parseStateRow(row) {
+    let value;
+    try {
+        value = JSON.parse(row.value);
+    }
+    catch {
+        value = row.value;
+    }
+    return {
+        id: row.id,
+        category: row.category,
+        key: row.key,
+        value,
+        updatedAt: row.updated_at,
+        updatedBy: row.updated_by || null,
+        ttl: row.ttl || null,
+    };
+}
+function parseEventRow(row) {
+    let oldValue;
+    let newValue;
+    let metadata = null;
+    try {
+        oldValue = row.old_value ? JSON.parse(row.old_value) : null;
+    }
+    catch {
+        oldValue = row.old_value;
+    }
+    try {
+        newValue = row.new_value ? JSON.parse(row.new_value) : null;
+    }
+    catch {
+        newValue = row.new_value;
+    }
+    try {
+        metadata = row.metadata ? JSON.parse(row.metadata) : null;
+    }
+    catch { /* ignore */ }
+    return {
+        id: row.id,
+        category: row.category,
+        key: row.key,
+        eventType: row.event_type,
+        oldValue,
+        newValue,
+        agentId: row.agent_id || null,
+        createdAt: row.created_at,
+        metadata,
+    };
+}
+export class SystemStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Set a system state value. Records a change event if the value changed.
+     */
+    set(category, key, value, opts) {
+        const now = nowIso();
+        const valueStr = JSON.stringify(value);
+        // Get old value for change tracking
+        const old = this.db.prepare('SELECT value FROM system_state WHERE category = ? AND key = ?').get(category, key);
+        this.db.prepare(`
+      INSERT INTO system_state (category, key, value, updated_at, updated_by, ttl)
+      VALUES (?, ?, ?, ?, ?, ?)
+      ON CONFLICT(category, key) DO UPDATE SET
+        value = excluded.value,
+        updated_at = excluded.updated_at,
+        updated_by = excluded.updated_by,
+        ttl = COALESCE(excluded.ttl, ttl)
+    `).run(category, key, valueStr, now, opts?.updatedBy || null, opts?.ttl || null);
+        // Record change event if value actually changed
+        if (!old || old.value !== valueStr) {
+            this.db.prepare(`
+        INSERT INTO system_events (category, key, event_type, old_value, new_value, agent_id, created_at)
+        VALUES (?, ?, 'changed', ?, ?, ?, ?)
+      `).run(category, key, old?.value || null, valueStr, opts?.updatedBy || null, now);
+        }
+        return this.get(category, key);
+    }
+    /**
+     * Get a system state value.
+     */
+    get(category, key) {
+        const row = this.db.prepare('SELECT * FROM system_state WHERE category = ? AND key = ?').get(category, key);
+        if (!row)
+            return null;
+        // Check TTL
+        const state = parseStateRow(row);
+        if (state.ttl) {
+            const ttlDate = new Date(state.ttl);
+            if (ttlDate < new Date()) {
+                // Expired — delete and return null
+                this.db.prepare('DELETE FROM system_state WHERE category = ? AND key = ?')
+                    .run(category, key);
+                return null;
+            }
+        }
+        return state;
+    }
+    /**
+     * Get all state in a category.
+     */
+    getCategory(category) {
+        const rows = this.db.prepare('SELECT * FROM system_state WHERE category = ? ORDER BY key').all(category);
+        return rows.map(parseStateRow).filter(s => {
+            if (s.ttl && new Date(s.ttl) < new Date())
+                return false;
+            return true;
+        });
+    }
+    /**
+     * Delete a system state entry.
+     */
+    delete(category, key, agentId) {
+        const old = this.db.prepare('SELECT value FROM system_state WHERE category = ? AND key = ?').get(category, key);
+        const result = this.db.prepare('DELETE FROM system_state WHERE category = ? AND key = ?').run(category, key);
+        if (old && result.changes > 0) {
+            this.db.prepare(`
+        INSERT INTO system_events (category, key, event_type, old_value, agent_id, created_at)
+        VALUES (?, ?, 'deleted', ?, ?, ?)
+      `).run(category, key, old.value, agentId || null, nowIso());
+        }
+        return result.changes > 0;
+    }
+    /**
+     * Record an event without changing state (e.g., restart, error, warning).
+     */
+    recordEvent(category, key, eventType, opts) {
+        this.db.prepare(`
+      INSERT INTO system_events (category, key, event_type, agent_id, created_at, metadata)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(category, key, eventType, opts?.agentId || null, nowIso(), opts?.metadata ? JSON.stringify(opts.metadata) : null);
+    }
+    /**
+     * Get recent events for a category/key.
+     */
+    getEvents(opts) {
+        let sql = 'SELECT * FROM system_events WHERE 1=1';
+        const params = [];
+        if (opts?.category) {
+            sql += ' AND category = ?';
+            params.push(opts.category);
+        }
+        if (opts?.key) {
+            sql += ' AND key = ?';
+            params.push(opts.key);
+        }
+        if (opts?.eventType) {
+            sql += ' AND event_type = ?';
+            params.push(opts.eventType);
+        }
+        if (opts?.since) {
+            sql += ' AND created_at > ?';
+            params.push(opts.since);
+        }
+        sql += ' ORDER BY created_at DESC LIMIT ?';
+        params.push(opts?.limit || 50);
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(parseEventRow);
+    }
+    /**
+     * Prune expired TTL entries.
+     */
+    pruneExpired() {
+        const now = nowIso();
+        const result = this.db.prepare("DELETE FROM system_state WHERE ttl IS NOT NULL AND ttl < ?").run(now);
+        return result.changes;
+    }
+}
+//# sourceMappingURL=system-store.js.map

package/dist/topic-store.d.ts

@@ -0,0 +1,45 @@
+/**
+ * HyperMem Topic Store
+ *
+ * Cross-session topic tracking. Topics are conversation threads that
+ * can span multiple sessions and channels.
+ * Lives in the central library DB.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+import type { Topic, TopicStatus } from './types.js';
+export declare class TopicStore {
+    private readonly db;
+    constructor(db: DatabaseSync);
+    /**
+     * Create a new topic.
+     */
+    create(agentId: string, name: string, description?: string, visibility?: string): Topic;
+    /**
+     * Touch a topic — update activity tracking.
+     */
+    touch(topicId: number, sessionKey: string, messagesDelta?: number): void;
+    /**
+     * Get active topics for an agent.
+     */
+    getActive(agentId: string, limit?: number): Topic[];
+    /**
+     * Get all topics for an agent.
+     */
+    getAll(agentId: string, opts?: {
+        status?: TopicStatus;
+        limit?: number;
+    }): Topic[];
+    /**
+     * Find topics matching a query.
+     */
+    search(agentId: string, query: string, limit?: number): Topic[];
+    /**
+     * Mark dormant topics (no activity for dormantAfterHours).
+     */
+    markDormant(agentId: string, dormantAfterHours?: number): number;
+    /**
+     * Close dormant topics.
+     */
+    closeDormant(agentId: string, closedAfterDays?: number): number;
+}
+//# sourceMappingURL=topic-store.d.ts.map

package/dist/topic-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"topic-store.d.ts","sourceRoot":"","sources":["../src/topic-store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAqBrD,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,YAAY;IAE7C;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK;IAwBvF;;OAEG;IACH,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,GAAE,MAAU,GAAG,IAAI;IAY3E;;OAEG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW,GAAG,KAAK,EAAE;IAWvD;;OAEG;IACH,MAAM,CACJ,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAC9C,KAAK,EAAE;IAoBV;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,GAAE,MAAW,GAAG,KAAK,EAAE;IAanE;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,GAAE,MAAW,GAAG,MAAM;IAYpE;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,eAAe,GAAE,MAAU,GAAG,MAAM;CAWnE"}

package/dist/topic-store.js

@@ -0,0 +1,136 @@
+/**
+ * HyperMem Topic Store
+ *
+ * Cross-session topic tracking. Topics are conversation threads that
+ * can span multiple sessions and channels.
+ * Lives in the central library DB.
+ */
+function nowIso() {
+    return new Date().toISOString();
+}
+function parseTopicRow(row) {
+    return {
+        id: row.id,
+        agentId: row.agent_id,
+        name: row.name,
+        description: row.description || null,
+        status: row.status,
+        visibility: row.visibility || 'org',
+        lastSessionKey: row.last_session_key || null,
+        messageCount: row.message_count,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export class TopicStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Create a new topic.
+     */
+    create(agentId, name, description, visibility) {
+        const now = nowIso();
+        const result = this.db.prepare(`
+      INSERT INTO topics (agent_id, name, description, status, visibility, message_count, created_at, updated_at)
+      VALUES (?, ?, ?, 'active', ?, 0, ?, ?)
+    `).run(agentId, name, description || null, visibility || 'org', now, now);
+        const id = Number(result.lastInsertRowid);
+        return {
+            id,
+            agentId,
+            name,
+            description: description || null,
+            status: 'active',
+            visibility: visibility || 'org',
+            lastSessionKey: null,
+            messageCount: 0,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    /**
+     * Touch a topic — update activity tracking.
+     */
+    touch(topicId, sessionKey, messagesDelta = 1) {
+        const now = nowIso();
+        this.db.prepare(`
+      UPDATE topics
+      SET last_session_key = ?,
+          message_count = message_count + ?,
+          status = 'active',
+          updated_at = ?
+      WHERE id = ?
+    `).run(sessionKey, messagesDelta, now, topicId);
+    }
+    /**
+     * Get active topics for an agent.
+     */
+    getActive(agentId, limit = 20) {
+        const rows = this.db.prepare(`
+      SELECT * FROM topics
+      WHERE agent_id = ? AND status = 'active'
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(agentId, limit);
+        return rows.map(parseTopicRow);
+    }
+    /**
+     * Get all topics for an agent.
+     */
+    getAll(agentId, opts) {
+        let sql = 'SELECT * FROM topics WHERE agent_id = ?';
+        const params = [agentId];
+        if (opts?.status) {
+            sql += ' AND status = ?';
+            params.push(opts.status);
+        }
+        sql += ' ORDER BY updated_at DESC';
+        if (opts?.limit) {
+            sql += ' LIMIT ?';
+            params.push(opts.limit);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map(parseTopicRow);
+    }
+    /**
+     * Find topics matching a query.
+     */
+    search(agentId, query, limit = 10) {
+        const rows = this.db.prepare(`
+      SELECT * FROM topics
+      WHERE agent_id = ?
+      AND (name LIKE ? OR description LIKE ?)
+      AND status != 'closed'
+      ORDER BY updated_at DESC
+      LIMIT ?
+    `).all(agentId, `%${query}%`, `%${query}%`, limit);
+        return rows.map(parseTopicRow);
+    }
+    /**
+     * Mark dormant topics (no activity for dormantAfterHours).
+     */
+    markDormant(agentId, dormantAfterHours = 24) {
+        const cutoff = new Date(Date.now() - dormantAfterHours * 60 * 60 * 1000).toISOString();
+        const result = this.db.prepare(`
+      UPDATE topics
+      SET status = 'dormant', updated_at = ?
+      WHERE agent_id = ? AND status = 'active' AND updated_at < ?
+    `).run(nowIso(), agentId, cutoff);
+        return result.changes;
+    }
+    /**
+     * Close dormant topics.
+     */
+    closeDormant(agentId, closedAfterDays = 7) {
+        const cutoff = new Date(Date.now() - closedAfterDays * 24 * 60 * 60 * 1000).toISOString();
+        const result = this.db.prepare(`
+      UPDATE topics
+      SET status = 'closed', updated_at = ?
+      WHERE agent_id = ? AND status = 'dormant' AND updated_at < ?
+    `).run(nowIso(), agentId, cutoff);
+        return result.changes;
+    }
+}
+//# sourceMappingURL=topic-store.js.map