claude-memory-layer 1.0.0 → 1.0.2

package/src/core/task/task-projector.ts

@@ -3,7 +3,7 @@
  * AXIOMMIND: Incremental processing with offset tracking
  */
 
-import { Database } from 'duckdb';
+import { dbRun, dbAll, toDate, type Database } from '../db-wrapper.js';
 import { randomUUID } from 'crypto';
 import type { BlockerMode, BlockerRef } from '../types.js';
 
@@ -37,7 +37,8 @@ export class TaskProjector {
    * Get current projection offset
    */
   async getOffset(): Promise<ProjectionOffset> {
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT last_event_id, last_timestamp
        FROM projection_offsets
        WHERE projection_name = ?`,
@@ -60,7 +61,8 @@ export class TaskProjector {
    * Update projection offset
    */
   private async updateOffset(eventId: string, timestamp: Date): Promise<void> {
-    await this.db.run(
+    await dbRun(
+      this.db,
       `INSERT INTO projection_offsets (projection_name, last_event_id, last_timestamp, updated_at)
        VALUES (?, ?, ?, CURRENT_TIMESTAMP)
        ON CONFLICT (projection_name) DO UPDATE SET
@@ -97,13 +99,13 @@ export class TaskProjector {
     query += ` ORDER BY timestamp ASC, id ASC LIMIT ?`;
     params.push(limit);
 
-    const rows = await this.db.all<Array<Record<string, unknown>>>(query, params);
+    const rows = await dbAll<Record<string, unknown>>(this.db, query, params);
 
     return rows.map(row => ({
       id: row.id as string,
       eventType: row.event_type as string,
       sessionId: row.session_id as string,
-      timestamp: new Date(row.timestamp as string),
+      timestamp: toDate(row.timestamp),
       content: typeof row.content === 'string'
         ? JSON.parse(row.content)
         : row.content as Record<string, unknown>
@@ -184,14 +186,16 @@ export class TaskProjector {
 
     // If status changed to 'done', remove all blocked_by edges
     if (toStatus === 'done') {
-      await this.db.run(
+      await dbRun(
+        this.db,
         `DELETE FROM edges
          WHERE src_id = ? AND rel_type IN ('blocked_by', 'blocked_by_suggested')`,
         [taskId]
       );
 
       // Clear blockers cache in entity
-      await this.db.run(
+      await dbRun(
+        this.db,
         `UPDATE entities
          SET current_json = json_remove(json_remove(current_json, '$.blockers'), '$.blockerSuggestions'),
              updated_at = CURRENT_TIMESTAMP
@@ -213,7 +217,8 @@ export class TaskProjector {
 
     if (mode === 'replace') {
       // Delete existing blocked_by edges
-      await this.db.run(
+      await dbRun(
+        this.db,
         `DELETE FROM edges WHERE src_id = ? AND rel_type = 'blocked_by'`,
         [taskId]
       );
@@ -225,7 +230,8 @@ export class TaskProjector {
 
       // Update entity cache
       const blockerIds = blockers.map(b => b.entityId);
-      await this.db.run(
+      await dbRun(
+        this.db,
         `UPDATE entities
          SET current_json = json_set(current_json, '$.blockers', ?),
              updated_at = CURRENT_TIMESTAMP
@@ -236,7 +242,8 @@ export class TaskProjector {
     } else {
       // mode === 'suggest'
       // Delete existing suggested edges
-      await this.db.run(
+      await dbRun(
+        this.db,
         `DELETE FROM edges WHERE src_id = ? AND rel_type = 'blocked_by_suggested'`,
         [taskId]
       );
@@ -248,7 +255,8 @@ export class TaskProjector {
 
       // Update entity cache (suggestions)
       const suggestionIds = blockers.map(b => b.entityId);
-      await this.db.run(
+      await dbRun(
+        this.db,
         `UPDATE entities
          SET current_json = json_set(current_json, '$.blockerSuggestions', ?),
              updated_at = CURRENT_TIMESTAMP
@@ -268,7 +276,8 @@ export class TaskProjector {
   ): Promise<void> {
     const edgeId = randomUUID();
 
-    await this.db.run(
+    await dbRun(
+      this.db,
       `INSERT INTO edges (edge_id, src_type, src_id, rel_type, dst_type, dst_id, meta_json, created_at)
        VALUES (?, 'entity', ?, ?, 'entity', ?, ?, CURRENT_TIMESTAMP)
        ON CONFLICT DO NOTHING`,
@@ -297,7 +306,8 @@ export class TaskProjector {
     };
 
     // Update condition entity
-    await this.db.run(
+    await dbRun(
+      this.db,
       `UPDATE entities
        SET current_json = json_set(json_set(current_json, '$.resolved', true), '$.resolvedTo', ?),
            updated_at = CURRENT_TIMESTAMP
@@ -315,7 +325,8 @@ export class TaskProjector {
     const jobId = randomUUID();
     const embeddingVersion = 'v1';  // Should come from config
 
-    await this.db.run(
+    await dbRun(
+      this.db,
       `INSERT INTO vector_outbox (job_id, item_kind, item_id, embedding_version, status, retry_count)
        VALUES (?, ?, ?, ?, 'pending', 0)
        ON CONFLICT (item_kind, item_id, embedding_version) DO NOTHING`,
@@ -329,12 +340,14 @@ export class TaskProjector {
    */
   async rebuild(): Promise<number> {
     // Clear task-related edges
-    await this.db.run(
+    await dbRun(
+      this.db,
       `DELETE FROM edges WHERE rel_type IN ('blocked_by', 'blocked_by_suggested', 'resolves_to')`
     );
 
     // Reset offset
-    await this.db.run(
+    await dbRun(
+      this.db,
       `DELETE FROM projection_offsets WHERE projection_name = ?`,
       [PROJECTOR_NAME]
     );

package/src/core/task/task-resolver.ts

@@ -3,7 +3,7 @@
  * AXIOMMIND: Task state via event fold, no direct updates
  */
 
-import { Database } from 'duckdb';
+import { dbRun, dbAll, type Database } from '../db-wrapper.js';
 import { randomUUID } from 'crypto';
 import type {
   Entity,
@@ -154,7 +154,8 @@ export class TaskResolver {
     };
 
     // Insert entity
-    await this.db.run(
+    await dbRun(
+      this.db,
       `INSERT INTO entities (
         entity_id, entity_type, canonical_key, title, stage, status,
         current_json, title_norm, search_text, created_at, updated_at
@@ -175,7 +176,8 @@ export class TaskResolver {
     );
 
     // Create alias
-    await this.db.run(
+    await dbRun(
+      this.db,
       `INSERT INTO entity_aliases (entity_type, canonical_key, entity_id, is_primary)
        VALUES (?, ?, ?, TRUE)
        ON CONFLICT (entity_type, canonical_key) DO NOTHING`,
@@ -245,7 +247,8 @@ export class TaskResolver {
     });
 
     // Update entity (projector will do this, but we update for immediate consistency)
-    await this.db.run(
+    await dbRun(
+      this.db,
       `UPDATE entities
        SET current_json = json_set(current_json, '$.status', ?),
            updated_at = ?
@@ -278,7 +281,8 @@ export class TaskResolver {
     });
 
     // Update entity
-    await this.db.run(
+    await dbRun(
+      this.db,
       `UPDATE entities
        SET current_json = json_set(current_json, '$.priority', ?),
            updated_at = ?
@@ -348,7 +352,8 @@ export class TaskResolver {
     );
 
     // Check for duplicate
-    const existing = await this.db.all<Array<{ event_id: string }>>(
+    const existing = await dbAll<{ event_id: string }>(
+      this.db,
       `SELECT event_id FROM event_dedup WHERE dedupe_key = ?`,
       [dedupeKey]
     );
@@ -358,7 +363,8 @@ export class TaskResolver {
     }
 
     // Insert event
-    await this.db.run(
+    await dbRun(
+      this.db,
       `INSERT INTO events (
         id, event_type, session_id, timestamp, content,
         canonical_key, dedupe_key, metadata
@@ -376,7 +382,8 @@ export class TaskResolver {
     );
 
     // Insert dedup record
-    await this.db.run(
+    await dbRun(
+      this.db,
       `INSERT INTO event_dedup (dedupe_key, event_id)
        VALUES (?, ?)
        ON CONFLICT DO NOTHING`,
@@ -402,7 +409,8 @@ export class TaskResolver {
     });
 
     // Create resolves_to edge
-    await this.db.run(
+    await dbRun(
+      this.db,
       `INSERT INTO edges (edge_id, src_type, src_id, rel_type, dst_type, dst_id, meta_json)
        VALUES (?, 'entity', ?, 'resolves_to', 'entity', ?, ?)
        ON CONFLICT DO NOTHING`,

package/src/core/vector-outbox.ts

@@ -3,7 +3,7 @@
  * AXIOMMIND Principle 6: DuckDB → outbox → LanceDB unidirectional flow
  */
 
-import { Database } from 'duckdb';
+import { dbRun, dbAll, toDate, type Database } from './db-wrapper.js';
 import { randomUUID } from 'crypto';
 import type {
   OutboxJob,
@@ -56,7 +56,8 @@ export class VectorOutbox {
     const jobId = randomUUID();
     const now = new Date().toISOString();
 
-    await this.db.run(
+    await dbRun(
+      this.db,
       `INSERT INTO vector_outbox (
         job_id, item_kind, item_id, embedding_version, status, retry_count, created_at, updated_at
       ) VALUES (?, ?, ?, ?, 'pending', 0, ?, ?)
@@ -74,7 +75,8 @@ export class VectorOutbox {
     const now = new Date().toISOString();
 
     // Atomic claim using UPDATE RETURNING
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `UPDATE vector_outbox
        SET status = 'processing', updated_at = ?
        WHERE job_id IN (
@@ -94,7 +96,8 @@ export class VectorOutbox {
    * Mark job as done
    */
   async markDone(jobId: string): Promise<void> {
-    await this.db.run(
+    await dbRun(
+      this.db,
       `UPDATE vector_outbox
        SET status = 'done', updated_at = ?
        WHERE job_id = ?`,
@@ -109,7 +112,8 @@ export class VectorOutbox {
     const now = new Date().toISOString();
 
     // Check retry count
-    const rows = await this.db.all<Array<{ retry_count: number }>>(
+    const rows = await dbAll<{ retry_count: number }>(
+      this.db,
       `SELECT retry_count FROM vector_outbox WHERE job_id = ?`,
       [jobId]
     );
@@ -121,7 +125,8 @@ export class VectorOutbox {
       ? 'failed'
       : 'pending';  // Will retry
 
-    await this.db.run(
+    await dbRun(
+      this.db,
       `UPDATE vector_outbox
        SET status = ?, error = ?, retry_count = retry_count + 1, updated_at = ?
        WHERE job_id = ?`,
@@ -133,7 +138,8 @@ export class VectorOutbox {
    * Get job by ID
    */
   async getJob(jobId: string): Promise<OutboxJob | null> {
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT * FROM vector_outbox WHERE job_id = ?`,
       [jobId]
     );
@@ -146,7 +152,8 @@ export class VectorOutbox {
    * Get jobs by status
    */
   async getJobsByStatus(status: OutboxStatus, limit: number = 100): Promise<OutboxJob[]> {
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT * FROM vector_outbox
        WHERE status = ?
        ORDER BY created_at ASC
@@ -165,7 +172,8 @@ export class VectorOutbox {
     const stuckThreshold = new Date(now.getTime() - this.config.stuckThresholdMs);
 
     // Recover stuck processing jobs
-    const recoveredResult = await this.db.run(
+    await dbRun(
+      this.db,
       `UPDATE vector_outbox
        SET status = 'pending', updated_at = ?
        WHERE status = 'processing'
@@ -174,7 +182,8 @@ export class VectorOutbox {
     );
 
     // Retry failed jobs that haven't exceeded max retries
-    const retriedResult = await this.db.run(
+    await dbRun(
+      this.db,
       `UPDATE vector_outbox
        SET status = 'pending', updated_at = ?
        WHERE status = 'failed'
@@ -183,7 +192,8 @@ export class VectorOutbox {
     );
 
     // Get counts (DuckDB doesn't return affected rows easily)
-    const recoveredRows = await this.db.all<Array<{ count: number }>>(
+    const recoveredRows = await dbAll<{ count: number }>(
+      this.db,
       `SELECT COUNT(*) as count FROM vector_outbox
        WHERE status = 'pending' AND updated_at = ?`,
       [now.toISOString()]
@@ -202,7 +212,8 @@ export class VectorOutbox {
     const threshold = new Date();
     threshold.setDate(threshold.getDate() - this.config.cleanupDays);
 
-    await this.db.run(
+    await dbRun(
+      this.db,
       `DELETE FROM vector_outbox
        WHERE status = 'done'
        AND updated_at < ?`,
@@ -216,13 +227,15 @@ export class VectorOutbox {
    * Get metrics
    */
   async getMetrics(): Promise<OutboxMetrics> {
-    const statusCounts = await this.db.all<Array<{ status: string; count: number }>>(
+    const statusCounts = await dbAll<{ status: string; count: number }>(
+      this.db,
       `SELECT status, COUNT(*) as count
        FROM vector_outbox
        GROUP BY status`
     );
 
-    const oldestPending = await this.db.all<Array<{ created_at: string }>>(
+    const oldestPending = await dbAll<{ created_at: string }>(
+      this.db,
       `SELECT created_at FROM vector_outbox
        WHERE status = 'pending'
        ORDER BY created_at ASC
@@ -288,8 +301,8 @@ export class VectorOutbox {
       status: row.status as OutboxStatus,
       retryCount: row.retry_count as number,
       error: row.error as string | undefined,
-      createdAt: new Date(row.created_at as string),
-      updatedAt: new Date(row.updated_at as string)
+      createdAt: toDate(row.created_at),
+      updatedAt: toDate(row.updated_at)
     };
   }
 }

package/src/core/vector-store.ts

@@ -121,7 +121,11 @@ export class VectorStore {
 
     const { limit = 5, minScore = 0.7, sessionId } = options;
 
-    let query = this.table.search(queryVector).limit(limit * 2); // Get more for filtering
+    // Use cosine distance for semantic similarity
+    let query = this.table
+      .search(queryVector)
+      .distanceType('cosine')
+      .limit(limit * 2); // Get more for filtering
 
     // Apply session filter if specified
     if (sessionId) {
@@ -132,20 +136,27 @@ export class VectorStore {
 
     return results
       .filter(r => {
-        // Convert distance to score (assuming cosine distance)
-        const score = 1 - (r._distance || 0);
+        // Convert cosine distance to similarity score
+        // Cosine distance ranges from 0 (identical) to 2 (opposite)
+        // Score = 1 - (distance / 2) gives range [0, 1]
+        const distance = r._distance || 0;
+        const score = 1 - (distance / 2);
         return score >= minScore;
       })
       .slice(0, limit)
-      .map(r => ({
-        id: r.id as string,
-        eventId: r.eventId as string,
-        content: r.content as string,
-        score: 1 - (r._distance || 0),
-        sessionId: r.sessionId as string,
-        eventType: r.eventType as string,
-        timestamp: r.timestamp as string
-      }));
+      .map(r => {
+        const distance = r._distance || 0;
+        const score = 1 - (distance / 2);
+        return {
+          id: r.id as string,
+          eventId: r.eventId as string,
+          content: r.content as string,
+          score,
+          sessionId: r.sessionId as string,
+          eventType: r.eventType as string,
+          timestamp: r.timestamp as string
+        };
+      });
   }
 
   /**

package/src/core/vector-worker.ts

@@ -186,7 +186,7 @@ export function createVectorWorker(
 // Vector Worker V2 - Extended for Task Entity System
 // ============================================================
 
-import { Database } from 'duckdb';
+import { dbAll, type Database } from './db-wrapper.js';
 import { VectorOutbox } from './vector-outbox.js';
 import type { OutboxJob, OutboxItemKind } from './types.js';
 
@@ -240,7 +240,8 @@ export class DefaultContentProvider implements ContentProvider {
     content: string;
     metadata: Record<string, unknown>;
   } | null> {
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT title, content_json, entry_type FROM entries WHERE entry_id = ?`,
       [entryId]
     );
@@ -265,7 +266,8 @@ export class DefaultContentProvider implements ContentProvider {
     content: string;
     metadata: Record<string, unknown>;
   } | null> {
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT title, search_text, current_json FROM entities
        WHERE entity_id = ? AND entity_type = 'task'`,
       [taskId]
@@ -287,7 +289,8 @@ export class DefaultContentProvider implements ContentProvider {
     content: string;
     metadata: Record<string, unknown>;
   } | null> {
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT content, event_type, session_id FROM events WHERE id = ?`,
       [eventId]
     );

package/src/core/working-set-store.ts

@@ -5,7 +5,7 @@
  */
 
 import { randomUUID } from 'crypto';
-import { Database } from 'duckdb';
+import { dbRun, dbAll, toDate, type Database } from './db-wrapper.js';
 import type {
   MemoryEvent,
   EndlessModeConfig,
@@ -32,7 +32,8 @@ export class WorkingSetStore {
       Date.now() + this.config.workingSet.timeWindowHours * 60 * 60 * 1000
     );
 
-    await this.db.run(
+    await dbRun(
+      this.db,
       `INSERT OR REPLACE INTO working_set (id, event_id, added_at, relevance_score, topics, expires_at)
        VALUES (?, ?, CURRENT_TIMESTAMP, ?, ?, ?)`,
       [
@@ -56,7 +57,8 @@ export class WorkingSetStore {
     await this.cleanup();
 
     // Get working set items with their events
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT ws.*, e.*
        FROM working_set ws
        JOIN events e ON ws.event_id = e.id
@@ -69,7 +71,7 @@ export class WorkingSetStore {
       id: row.id as string,
       eventType: row.event_type as 'user_prompt' | 'agent_response' | 'session_summary' | 'tool_observation',
       sessionId: row.session_id as string,
-      timestamp: new Date(row.timestamp as string),
+      timestamp: toDate(row.timestamp),
       content: row.content as string,
       canonicalKey: row.canonical_key as string,
       dedupeKey: row.dedupe_key as string,
@@ -87,17 +89,18 @@ export class WorkingSetStore {
    * Get working set items (metadata only)
    */
   async getItems(): Promise<WorkingSetItem[]> {
-    const rows = await this.db.all<Array<Record<string, unknown>>>(
+    const rows = await dbAll<Record<string, unknown>>(
+      this.db,
       `SELECT * FROM working_set ORDER BY relevance_score DESC, added_at DESC`
     );
 
     return rows.map(row => ({
       id: row.id as string,
       eventId: row.event_id as string,
-      addedAt: new Date(row.added_at as string),
+      addedAt: toDate(row.added_at),
       relevanceScore: row.relevance_score as number,
       topics: row.topics ? JSON.parse(row.topics as string) : undefined,
-      expiresAt: new Date(row.expires_at as string)
+      expiresAt: toDate(row.expires_at)
     }));
   }
 
@@ -105,7 +108,8 @@ export class WorkingSetStore {
    * Update relevance score for an event
    */
   async updateRelevance(eventId: string, score: number): Promise<void> {
-    await this.db.run(
+    await dbRun(
+      this.db,
       `UPDATE working_set SET relevance_score = ? WHERE event_id = ?`,
       [score, eventId]
     );
@@ -118,7 +122,8 @@ export class WorkingSetStore {
     if (eventIds.length === 0) return;
 
     const placeholders = eventIds.map(() => '?').join(',');
-    await this.db.run(
+    await dbRun(
+      this.db,
       `DELETE FROM working_set WHERE event_id IN (${placeholders})`,
       eventIds
     );
@@ -128,7 +133,8 @@ export class WorkingSetStore {
    * Get the count of items in working set
    */
   async count(): Promise<number> {
-    const result = await this.db.all<Array<{ count: number }>>(
+    const result = await dbAll<{ count: number }>(
+      this.db,
       `SELECT COUNT(*) as count FROM working_set`
     );
     return result[0]?.count || 0;
@@ -138,14 +144,15 @@ export class WorkingSetStore {
    * Clear the entire working set
    */
   async clear(): Promise<void> {
-    await this.db.run(`DELETE FROM working_set`);
+    await dbRun(this.db, `DELETE FROM working_set`);
   }
 
   /**
    * Check if an event is in the working set
    */
   async contains(eventId: string): Promise<boolean> {
-    const result = await this.db.all<Array<{ count: number }>>(
+    const result = await dbAll<{ count: number }>(
+      this.db,
       `SELECT COUNT(*) as count FROM working_set WHERE event_id = ?`,
       [eventId]
     );
@@ -160,7 +167,8 @@ export class WorkingSetStore {
       Date.now() + this.config.workingSet.timeWindowHours * 60 * 60 * 1000
     );
 
-    await this.db.run(
+    await dbRun(
+      this.db,
       `UPDATE working_set SET expires_at = ? WHERE event_id = ?`,
       [newExpiresAt.toISOString(), eventId]
     );
@@ -170,7 +178,8 @@ export class WorkingSetStore {
    * Clean up expired items
    */
   private async cleanup(): Promise<void> {
-    await this.db.run(
+    await dbRun(
+      this.db,
       `DELETE FROM working_set WHERE expires_at < datetime('now')`
     );
   }
@@ -183,7 +192,8 @@ export class WorkingSetStore {
     const maxEvents = this.config.workingSet.maxEvents;
 
     // Get IDs to keep (highest relevance, most recent)
-    const keepIds = await this.db.all<Array<{ id: string }>>(
+    const keepIds = await dbAll<{ id: string }>(
+      this.db,
       `SELECT id FROM working_set
        ORDER BY relevance_score DESC, added_at DESC
        LIMIT ?`,
@@ -196,7 +206,8 @@ export class WorkingSetStore {
     const placeholders = keepIdList.map(() => '?').join(',');
 
     // Delete everything not in the keep list
-    await this.db.run(
+    await dbRun(
+      this.db,
       `DELETE FROM working_set WHERE id NOT IN (${placeholders})`,
       keepIdList
     );
@@ -206,7 +217,8 @@ export class WorkingSetStore {
    * Calculate continuity score based on recent context transitions
    */
   private async calculateContinuityScore(): Promise<number> {
-    const result = await this.db.all<Array<{ avg_score: number | null }>>(
+    const result = await dbAll<{ avg_score: number | null }>(
+      this.db,
       `SELECT AVG(continuity_score) as avg_score
        FROM continuity_log
        WHERE created_at > datetime('now', '-1 hour')`
@@ -219,7 +231,8 @@ export class WorkingSetStore {
    * Get topics from current working set for context matching
    */
   async getActiveTopics(): Promise<string[]> {
-    const rows = await this.db.all<Array<{ topics: string }>>(
+    const rows = await dbAll<{ topics: string }>(
+      this.db,
       `SELECT topics FROM working_set WHERE topics IS NOT NULL`
     );
 

package/src/hooks/session-end.ts

@@ -4,7 +4,7 @@
  * Called when session ends - generates and stores session summary
  */
 
-import { getDefaultMemoryService } from '../services/memory-service.js';
+import { getMemoryServiceForSession } from '../services/memory-service.js';
 import type { SessionEndInput } from '../core/types.js';
 
 async function main(): Promise<void> {
@@ -12,7 +12,8 @@ async function main(): Promise<void> {
   const inputData = await readStdin();
   const input: SessionEndInput = JSON.parse(inputData);
 
-  const memoryService = getDefaultMemoryService();
+  // Get project-specific memory service via session lookup
+  const memoryService = getMemoryServiceForSession(input.session_id);
 
   try {
     // Get session history