@psiclawops/hypermem 0.5.0 → 0.5.1

package/dist/repair-tool-pairs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair-tool-pairs.d.ts","sourceRoot":"","sources":["../src/repair-tool-pairs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE1C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,UAAU,EAAE,CAmHpE"}

package/dist/repair-tool-pairs.js

@@ -0,0 +1,138 @@
+/**
+ * repair-tool-pairs.ts
+ *
+ * Strips orphaned tool result entries from a pi-agent message array.
+ *
+ * Background: HyperMem compaction and in-memory trim passes can remove assistant
+ * messages that contain tool_use/toolCall blocks without removing the corresponding
+ * tool result messages that follow them. Anthropic and Gemini reject these orphaned
+ * tool results with a 400 error.
+ *
+ * This module provides a pure repair function that can be applied at any output
+ * boundary to sanitise the message list before it reaches the provider.
+ *
+ * Supported formats:
+ *   - pi-agent: role:'toolResult' messages with toolCallId field
+ *   - Anthropic native: user messages with content blocks of type:'tool_result' and tool_use_id
+ *
+ * Returns a new array. Does not mutate the input.
+ */
+/**
+ * Repair orphaned tool pairs in a pi-agent / OpenClaw message array.
+ *
+ * Orphan types handled:
+ *   1. role:'toolResult' message whose toolCallId has no matching toolCall/tool_use
+ *      block in any assistant message in the array.
+ *   2. User message whose content contains only type:'tool_result' blocks where all
+ *      of those blocks reference a tool_use_id that does not appear in any assistant
+ *      message in the array. (Anthropic-native format.)
+ *
+ * Also strips orphaned assistant messages that contain ONLY tool_use/toolCall blocks
+ * where none of those calls has a corresponding tool result anywhere in the array.
+ *
+ * Returns a new array (does not mutate input).
+ */
+export function repairToolPairs(messages) {
+    if (!Array.isArray(messages) || messages.length === 0)
+        return messages;
+    // ── Pass 1: Collect all valid tool call IDs from assistant messages ────────
+    const validCallIds = new Set();
+    for (const msg of messages) {
+        if (msg.role !== 'assistant')
+            continue;
+        // NeutralMessage format: msg.toolCalls[]
+        if (Array.isArray(msg.toolCalls)) {
+            for (const tc of msg.toolCalls) {
+                if (typeof tc.id === 'string' && tc.id)
+                    validCallIds.add(tc.id);
+            }
+        }
+        // Content array format: type:'toolCall' or type:'tool_use' blocks
+        if (Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if ((block.type === 'toolCall' || block.type === 'tool_use') &&
+                    typeof block.id === 'string' &&
+                    block.id) {
+                    validCallIds.add(block.id);
+                }
+            }
+        }
+    }
+    // ── Pass 2: Collect all result IDs that have a valid call ─────────────────
+    const validResultIds = new Set();
+    for (const msg of messages) {
+        // pi-agent ToolResultMessage
+        if (msg.role === 'toolResult') {
+            const id = typeof msg.toolCallId === 'string' ? msg.toolCallId :
+                typeof msg.tool_call_id === 'string' ? msg.tool_call_id : '';
+            if (id && validCallIds.has(id))
+                validResultIds.add(id);
+        }
+        // Anthropic-native tool_result blocks inside user messages
+        if (msg.role === 'user' && Array.isArray(msg.content)) {
+            for (const block of msg.content) {
+                if (block.type === 'tool_result' && typeof block.tool_use_id === 'string' && block.tool_use_id) {
+                    if (validCallIds.has(block.tool_use_id))
+                        validResultIds.add(block.tool_use_id);
+                }
+            }
+        }
+    }
+    // ── Pass 3: Filter out orphaned messages / blocks ─────────────────────────
+    const result = [];
+    for (const msg of messages) {
+        // ── pi-agent ToolResultMessage ─────────────────────────────────────────
+        if (msg.role === 'toolResult') {
+            const id = typeof msg.toolCallId === 'string' ? msg.toolCallId :
+                typeof msg.tool_call_id === 'string' ? msg.tool_call_id : '';
+            if (!id || !validCallIds.has(id)) {
+                // Orphaned — drop
+                continue;
+            }
+            result.push(msg);
+            continue;
+        }
+        // ── Anthropic-native: user message with tool_result content blocks ─────
+        if (msg.role === 'user' && Array.isArray(msg.content)) {
+            const content = msg.content;
+            const hasToolResultBlocks = content.some(b => b.type === 'tool_result');
+            if (hasToolResultBlocks) {
+                const filteredContent = content.filter(block => {
+                    if (block.type !== 'tool_result')
+                        return true; // keep non-tool_result blocks
+                    const toolUseId = typeof block.tool_use_id === 'string' ? block.tool_use_id : '';
+                    return toolUseId && validCallIds.has(toolUseId);
+                });
+                // If the message became empty after stripping all orphaned tool_result blocks, skip it
+                if (filteredContent.length === 0)
+                    continue;
+                result.push({ ...msg, content: filteredContent });
+                continue;
+            }
+        }
+        // ── Assistant message with ONLY unmatched tool_use/toolCall blocks ─────
+        if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+            const content = msg.content;
+            const toolCallBlocks = content.filter(b => b.type === 'toolCall' || b.type === 'tool_use');
+            const nonToolCallBlocks = content.filter(b => b.type !== 'toolCall' && b.type !== 'tool_use');
+            // Only strip if the assistant message is purely tool-calls (no text)
+            if (toolCallBlocks.length > 0 && nonToolCallBlocks.length === 0) {
+                const hasAnyResult = toolCallBlocks.some(b => {
+                    const id = typeof b.id === 'string' ? b.id : '';
+                    return id && validResultIds.has(id);
+                });
+                if (!hasAnyResult) {
+                    // Pure tool-call block with no paired results — drop
+                    continue;
+                }
+            }
+        }
+        result.push(msg);
+    }
+    const dropped = messages.length - result.length;
+    if (dropped > 0) {
+        console.log(`[hypermem] repairToolPairs: dropped ${dropped} orphaned message(s) (${messages.length} → ${result.length})`);
+    }
+    return result;
+}
+//# sourceMappingURL=repair-tool-pairs.js.map

package/dist/retrieval-policy.d.ts

@@ -0,0 +1,51 @@
+/**
+ * hypermem Retrieval Policy
+ *
+ * Single enforced policy layer for scope-based access control during retrieval.
+ * Called by the compositor to filter items before they are injected into context.
+ *
+ * Scope rules:
+ *   'agent' (default / null / undefined): allowed if agentId matches OR is null/undefined (global)
+ *   'session': allowed if both agentId AND sessionKey match
+ *   'user': allowed if agentId matches
+ *   'global': always allowed
+ *   any other value: denied with reason 'ambiguous_scope'
+ */
+export type RetrievalScope = 'agent' | 'session' | 'user' | 'global';
+export interface RetrievalContext {
+    agentId: string;
+    sessionKey: string;
+}
+export interface ScopeCheckResult {
+    allowed: boolean;
+    /** One of: 'allowed' | 'scope_filtered' | 'ambiguous_scope' */
+    reason: string;
+}
+/**
+ * Check whether a single item is accessible in the given retrieval context.
+ *
+ * @param itemScope       The scope stored on the item (null/undefined → defaults to 'agent')
+ * @param itemAgentId     The agentId stored on the item (null/undefined → global)
+ * @param itemSessionKey  The sessionKey stored on the item (null/undefined → any)
+ * @param ctx             The requester's retrieval context
+ */
+export declare function checkScope(itemScope: string | null | undefined, itemAgentId: string | null | undefined, itemSessionKey: string | null | undefined, ctx: RetrievalContext): ScopeCheckResult;
+/**
+ * Filter an array of items by scope, returning allowed items and a filtered count.
+ *
+ * Items are expected to have optional `agentId`, `sessionKey`, and `scope` fields.
+ * Null/undefined fields are treated as "unset" (permissive for their slot).
+ *
+ * @param items  Array of items to filter
+ * @param ctx    The requester's retrieval context
+ * @returns      { allowed: T[], filteredCount: number }
+ */
+export declare function filterByScope<T extends {
+    agentId?: string | null;
+    sessionKey?: string | null;
+    scope?: string | null;
+}>(items: T[], ctx: RetrievalContext): {
+    allowed: T[];
+    filteredCount: number;
+};
+//# sourceMappingURL=retrieval-policy.d.ts.map

package/dist/retrieval-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retrieval-policy.d.ts","sourceRoot":"","sources":["../src/retrieval-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;AAErE,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACpC,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACtC,cAAc,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACzC,GAAG,EAAE,gBAAgB,GACpB,gBAAgB,CAqClB;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS;IACtC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,EACC,KAAK,EAAE,CAAC,EAAE,EACV,GAAG,EAAE,gBAAgB,GACpB;IAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAczC"}

package/dist/retrieval-policy.js

@@ -0,0 +1,77 @@
+/**
+ * hypermem Retrieval Policy
+ *
+ * Single enforced policy layer for scope-based access control during retrieval.
+ * Called by the compositor to filter items before they are injected into context.
+ *
+ * Scope rules:
+ *   'agent' (default / null / undefined): allowed if agentId matches OR is null/undefined (global)
+ *   'session': allowed if both agentId AND sessionKey match
+ *   'user': allowed if agentId matches
+ *   'global': always allowed
+ *   any other value: denied with reason 'ambiguous_scope'
+ */
+/**
+ * Check whether a single item is accessible in the given retrieval context.
+ *
+ * @param itemScope       The scope stored on the item (null/undefined → defaults to 'agent')
+ * @param itemAgentId     The agentId stored on the item (null/undefined → global)
+ * @param itemSessionKey  The sessionKey stored on the item (null/undefined → any)
+ * @param ctx             The requester's retrieval context
+ */
+export function checkScope(itemScope, itemAgentId, itemSessionKey, ctx) {
+    const scope = itemScope ?? 'agent';
+    switch (scope) {
+        case 'agent':
+            // Global agent facts (null/undefined agentId) are readable by all agents.
+            // Agent-specific facts are only readable by the owning agent.
+            if (itemAgentId == null || itemAgentId === ctx.agentId) {
+                return { allowed: true, reason: 'allowed' };
+            }
+            return { allowed: false, reason: 'scope_filtered' };
+        case 'session':
+            // Session-scoped: both agentId AND sessionKey must match.
+            if ((itemAgentId == null || itemAgentId === ctx.agentId) &&
+                (itemSessionKey == null || itemSessionKey === ctx.sessionKey)) {
+                return { allowed: true, reason: 'allowed' };
+            }
+            return { allowed: false, reason: 'scope_filtered' };
+        case 'user':
+            // User-scoped: agentId must match (user prefs are keyed by agent).
+            if (itemAgentId == null || itemAgentId === ctx.agentId) {
+                return { allowed: true, reason: 'allowed' };
+            }
+            return { allowed: false, reason: 'scope_filtered' };
+        case 'global':
+            // Global: always accessible.
+            return { allowed: true, reason: 'allowed' };
+        default:
+            // Unknown scope — deny with ambiguous_scope.
+            return { allowed: false, reason: 'ambiguous_scope' };
+    }
+}
+/**
+ * Filter an array of items by scope, returning allowed items and a filtered count.
+ *
+ * Items are expected to have optional `agentId`, `sessionKey`, and `scope` fields.
+ * Null/undefined fields are treated as "unset" (permissive for their slot).
+ *
+ * @param items  Array of items to filter
+ * @param ctx    The requester's retrieval context
+ * @returns      { allowed: T[], filteredCount: number }
+ */
+export function filterByScope(items, ctx) {
+    const allowed = [];
+    let filteredCount = 0;
+    for (const item of items) {
+        const result = checkScope(item.scope, item.agentId, item.sessionKey, ctx);
+        if (result.allowed) {
+            allowed.push(item);
+        }
+        else {
+            filteredCount++;
+        }
+    }
+    return { allowed, filteredCount };
+}
+//# sourceMappingURL=retrieval-policy.js.map

package/dist/schema.d.ts

@@ -0,0 +1,15 @@
+/**
+ * hypermem Agent Message Schema
+ *
+ * Per-agent database: ~/.openclaw/hypermem/agents/{agentId}/messages.db
+ * Write-heavy, temporal, rotatable.
+ * Contains ONLY conversation data — structured knowledge lives in library.db.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+export declare const LATEST_SCHEMA_VERSION = 6;
+/**
+ * Run migrations on an agent message database.
+ */
+export declare function migrate(db: DatabaseSync): void;
+export { LATEST_SCHEMA_VERSION as SCHEMA_VERSION };
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAgJvC;;GAEG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CA4F9C;AAED,OAAO,EAAE,qBAAqB,IAAI,cAAc,EAAE,CAAC"}

package/dist/schema.js

@@ -0,0 +1,229 @@
+/**
+ * hypermem Agent Message Schema
+ *
+ * Per-agent database: ~/.openclaw/hypermem/agents/{agentId}/messages.db
+ * Write-heavy, temporal, rotatable.
+ * Contains ONLY conversation data — structured knowledge lives in library.db.
+ */
+export const LATEST_SCHEMA_VERSION = 6;
+function nowIso() {
+    return new Date().toISOString();
+}
+/**
+ * V1–V3: Legacy schema (monolithic agent DB with facts/knowledge/episodes).
+ * Kept for migration detection — if we open an old DB, we know what version it is.
+ */
+/**
+ * V4: Messages-only schema.
+ * Facts, knowledge, episodes, topics moved to library.db.
+ * Agent DB now contains only conversations, messages, summaries, and agent metadata.
+ */
+function applyV4MessagesOnly(db) {
+    // -- Agent metadata (kept here for self-identification) --
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_meta (
+      id TEXT PRIMARY KEY,
+      display_name TEXT,
+      tier TEXT,
+      org TEXT,
+      config TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+    // -- Conversations (sessions) --
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS conversations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_key TEXT NOT NULL UNIQUE,
+      session_id TEXT,
+      agent_id TEXT NOT NULL,
+      channel_type TEXT NOT NULL,
+      channel_id TEXT,
+      provider TEXT,
+      model TEXT,
+      status TEXT DEFAULT 'active',
+      message_count INTEGER DEFAULT 0,
+      token_count_in INTEGER DEFAULT 0,
+      token_count_out INTEGER DEFAULT 0,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      ended_at TEXT
+    )
+  `);
+    db.exec('CREATE INDEX IF NOT EXISTS idx_conv_agent ON conversations(agent_id, status, updated_at DESC)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_conv_channel ON conversations(agent_id, channel_type, channel_id)');
+    // -- Messages (provider-neutral, structured) --
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      conversation_id INTEGER NOT NULL REFERENCES conversations(id),
+      agent_id TEXT NOT NULL,
+      role TEXT NOT NULL,
+      text_content TEXT,
+      tool_calls TEXT,
+      tool_results TEXT,
+      metadata TEXT,
+      token_count INTEGER,
+      message_index INTEGER NOT NULL,
+      is_heartbeat INTEGER DEFAULT 0,
+      created_at TEXT NOT NULL
+    )
+  `);
+    db.exec('CREATE INDEX IF NOT EXISTS idx_msg_conv ON messages(conversation_id, message_index)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_msg_agent_time ON messages(agent_id, created_at DESC)');
+    // -- FTS5 for message full-text search --
+    db.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+      text_content,
+      content='messages',
+      content_rowid='id'
+    )
+  `);
+    db.exec(`
+    CREATE TRIGGER IF NOT EXISTS msg_fts_ai AFTER INSERT ON messages BEGIN
+      INSERT INTO messages_fts(rowid, text_content) VALUES (new.id, new.text_content);
+    END
+  `);
+    db.exec(`
+    CREATE TRIGGER IF NOT EXISTS msg_fts_ad AFTER DELETE ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, text_content) VALUES('delete', old.id, old.text_content);
+    END
+  `);
+    db.exec(`
+    CREATE TRIGGER IF NOT EXISTS msg_fts_au AFTER UPDATE ON messages BEGIN
+      INSERT INTO messages_fts(messages_fts, rowid, text_content) VALUES('delete', old.id, old.text_content);
+      INSERT INTO messages_fts(rowid, text_content) VALUES (new.id, new.text_content);
+    END
+  `);
+    // -- Summaries (hierarchical compaction) --
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS summaries (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      conversation_id INTEGER NOT NULL REFERENCES conversations(id),
+      agent_id TEXT NOT NULL,
+      depth INTEGER NOT NULL DEFAULT 0,
+      content TEXT NOT NULL,
+      token_count INTEGER,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    )
+  `);
+    db.exec('CREATE INDEX IF NOT EXISTS idx_summaries_conv ON summaries(conversation_id, depth)');
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS summary_messages (
+      summary_id INTEGER NOT NULL REFERENCES summaries(id),
+      message_id INTEGER NOT NULL REFERENCES messages(id),
+      PRIMARY KEY (summary_id, message_id)
+    )
+  `);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS summary_parents (
+      parent_summary_id INTEGER NOT NULL REFERENCES summaries(id),
+      child_summary_id INTEGER NOT NULL REFERENCES summaries(id),
+      PRIMARY KEY (parent_summary_id, child_summary_id)
+    )
+  `);
+    // -- Index events (for tracking what's been vectorized) --
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS index_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      target_table TEXT,
+      target_id INTEGER,
+      details TEXT,
+      created_at TEXT NOT NULL
+    )
+  `);
+    db.exec('CREATE INDEX IF NOT EXISTS idx_index_events ON index_events(agent_id, created_at DESC)');
+}
+/**
+ * Run migrations on an agent message database.
+ */
+export function migrate(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      version INTEGER PRIMARY KEY,
+      applied_at TEXT NOT NULL
+    )
+  `);
+    const row = db
+        .prepare('SELECT MAX(version) AS version FROM schema_version')
+        .get();
+    const currentVersion = typeof row?.version === 'number' ? row.version : 0;
+    if (currentVersion > LATEST_SCHEMA_VERSION) {
+        console.warn(`[hypermem] Database schema version (${currentVersion}) is newer than this engine (${LATEST_SCHEMA_VERSION}).`);
+        return;
+    }
+    // For fresh DBs (version 0), jump straight to v4 (messages-only).
+    // For existing DBs (v1–v3), we skip the old schema — those tables will be
+    // left in place but unused. Data migration to library is a separate step.
+    if (currentVersion < 4) {
+        if (currentVersion === 0) {
+            // Fresh DB — create messages-only schema directly
+            applyV4MessagesOnly(db);
+        }
+        else {
+            // Existing DB with old schema (v1–v3).
+            // The old tables (facts, knowledge, episodes, topics, agents) remain
+            // but are no longer written to. New tables get created alongside.
+            applyV4MessagesOnly(db);
+            // Note: old tables like 'facts', 'knowledge', etc. are left in place
+            // for data migration. A separate migration tool will move them to library.db.
+        }
+        db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)')
+            .run(4, nowIso());
+    }
+    // v4 → v5: add cursor columns to conversations table for dual-write durability
+    if (currentVersion < 5) {
+        // ALTER TABLE ADD COLUMN is safe on existing rows — all default to NULL
+        const cols = db.prepare('PRAGMA table_info(conversations)').all()
+            .map(r => r.name);
+        if (!cols.includes('cursor_last_sent_id')) {
+            db.exec('ALTER TABLE conversations ADD COLUMN cursor_last_sent_id INTEGER');
+        }
+        if (!cols.includes('cursor_last_sent_index')) {
+            db.exec('ALTER TABLE conversations ADD COLUMN cursor_last_sent_index INTEGER');
+        }
+        if (!cols.includes('cursor_last_sent_at')) {
+            db.exec('ALTER TABLE conversations ADD COLUMN cursor_last_sent_at TEXT');
+        }
+        if (!cols.includes('cursor_window_size')) {
+            db.exec('ALTER TABLE conversations ADD COLUMN cursor_window_size INTEGER');
+        }
+        if (!cols.includes('cursor_token_count')) {
+            db.exec('ALTER TABLE conversations ADD COLUMN cursor_token_count INTEGER');
+        }
+        db.prepare('INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (?, ?)')
+            .run(5, nowIso());
+    }
+    // v5 → v6: add topic_id to messages, add per-session topics table
+    if (currentVersion < 6) {
+        // Add topic_id column to messages (nullable TEXT)
+        const msgCols = db.prepare('PRAGMA table_info(messages)').all()
+            .map(r => r.name);
+        if (!msgCols.includes('topic_id')) {
+            db.exec('ALTER TABLE messages ADD COLUMN topic_id TEXT');
+        }
+        // Add index on messages.topic_id
+        db.exec('CREATE INDEX IF NOT EXISTS idx_messages_topic_id ON messages(topic_id)');
+        // Add per-session topics table (in messages.db for session-scoped topic tracking)
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS topics (
+        id TEXT PRIMARY KEY,
+        session_key TEXT NOT NULL,
+        name TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        last_active_at INTEGER NOT NULL,
+        message_count INTEGER DEFAULT 0,
+        metadata TEXT
+      )
+    `);
+        db.exec('CREATE INDEX IF NOT EXISTS idx_topics_session_key ON topics(session_key)');
+        db.prepare('INSERT OR IGNORE INTO schema_version (version, applied_at) VALUES (?, ?)')
+            .run(6, nowIso());
+    }
+}
+export { LATEST_SCHEMA_VERSION as SCHEMA_VERSION };
+//# sourceMappingURL=schema.js.map

package/dist/secret-scanner.d.ts

@@ -0,0 +1,51 @@
+/**
+ * hypermem Secret Scanner
+ *
+ * Lightweight regex-based gate to prevent secrets from leaking into
+ * shared memory (visibility >= 'org'). Runs before any write that
+ * promotes content to org/council/fleet visibility.
+ *
+ * Design principles:
+ *   - Fast: regex-only, no LLM dependency
+ *   - Conservative: false positives are okay; false negatives are not
+ *   - Auditable: each hit includes the rule name and matched region (redacted)
+ *   - Not a full DLP system: blocks the obvious leaks; does not guarantee clean content
+ *
+ * Patterns sourced from:
+ *   - gitleaks ruleset (https://github.com/gitleaks/gitleaks)
+ *   - trufflehog common patterns
+ *   - Manual additions for OpenClaw-specific secrets
+ */
+export interface ScanResult {
+    clean: boolean;
+    hits: ScanHit[];
+}
+export interface ScanHit {
+    rule: string;
+    description: string;
+    /** Redacted match — only first/last 3 chars of the matched value */
+    redactedMatch: string;
+    /** Character offset of the match start */
+    offset: number;
+}
+/**
+ * Scan content for secrets before promoting to shared visibility.
+ *
+ * Returns { clean: true } when no secrets found.
+ * Returns { clean: false, hits } when secrets are detected.
+ *
+ * Callers must NOT write content with visibility >= 'org' when clean is false.
+ */
+export declare function scanForSecrets(content: string): ScanResult;
+/**
+ * Returns true when content is safe to promote to shared visibility (>= 'org').
+ * Convenience wrapper around scanForSecrets.
+ */
+export declare function isSafeForSharedVisibility(content: string): boolean;
+/**
+ * Check whether a visibility level requires secret scanning.
+ * Scanning is required for 'org', 'council', and 'fleet'.
+ * 'private' content stays with the owner — no cross-agent risk.
+ */
+export declare function requiresScan(visibility: string): boolean;
+//# sourceMappingURL=secret-scanner.d.ts.map

package/dist/secret-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-scanner.d.ts","sourceRoot":"","sources":["../src/secret-scanner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,oEAAoE;IACpE,aAAa,EAAE,MAAM,CAAC;IACtB,0CAA0C;IAC1C,MAAM,EAAE,MAAM,CAAC;CAChB;AAmMD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CA+B1D;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAElE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAExD"}