squish-memory 1.0.2 → 1.1.5

package/dist/{drizzle → db/drizzle}/schema.d.ts

@@ -1,4 +1,4 @@
-export type MemoryType = 'observation' | 'fact' | 'decision' | 'context' | 'preference';
+export type MemoryType = 'observation' | 'fact' | 'decision' | 'context' | 'preference' | 'reflection' | 'note';
 /**
  * Users - represents Claude Code users
  */
@@ -914,15 +914,15 @@ export declare const messages: import("drizzle-orm/pg-core").PgTableWithColumns<
     dialect: "pg";
 }>;
 /**
- * Observations - auto-captured tool usage and events
+ * Learnings - agent learnings: success, failure, fix, insight
  */
-export declare const observations: import("drizzle-orm/pg-core").PgTableWithColumns<{
-    name: "observations";
+export declare const learnings: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "learnings";
     schema: undefined;
     columns: {
         id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "string";
             columnType: "PgUUID";
             data: string;
@@ -939,7 +939,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         projectId: import("drizzle-orm/pg-core").PgColumn<{
             name: "project_id";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "string";
             columnType: "PgUUID";
             data: string;
@@ -956,7 +956,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         conversationId: import("drizzle-orm/pg-core").PgColumn<{
             name: "conversation_id";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "string";
             columnType: "PgUUID";
             data: string;
@@ -973,10 +973,10 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         type: import("drizzle-orm/pg-core").PgColumn<{
             name: "type";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "string";
             columnType: "PgText";
-            data: "error" | "tool_use" | "file_change" | "pattern" | "insight" | "user_prompt";
+            data: "success" | "failure" | "fix" | "insight";
             driverParam: string;
             notNull: true;
             hasDefault: false;
@@ -988,11 +988,11 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
             identity: undefined;
             generated: undefined;
         }, {}, {
-            $type: "error" | "tool_use" | "file_change" | "pattern" | "insight" | "user_prompt";
+            $type: "success" | "failure" | "fix" | "insight";
         }>;
         action: import("drizzle-orm/pg-core").PgColumn<{
             name: "action";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -1009,7 +1009,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         target: import("drizzle-orm/pg-core").PgColumn<{
             name: "target";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -1026,7 +1026,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         summary: import("drizzle-orm/pg-core").PgColumn<{
             name: "summary";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -1043,7 +1043,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         details: import("drizzle-orm/pg-core").PgColumn<{
             name: "details";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "json";
             columnType: "PgJsonb";
             data: Record<string, unknown>;
@@ -1062,7 +1062,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }>;
         embedding: import("drizzle-orm/pg-core").PgColumn<{
             name: "embedding";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "array";
             columnType: "PgVector";
             data: number[];
@@ -1079,9 +1079,26 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {
             dimensions: 1536;
         }>;
+        memoryId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "memory_id";
+            tableName: "learnings";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         folderPath: import("drizzle-orm/pg-core").PgColumn<{
             name: "folder_path";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -1098,7 +1115,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         projectPath: import("drizzle-orm/pg-core").PgColumn<{
             name: "project_path";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -1115,7 +1132,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         isPrivate: import("drizzle-orm/pg-core").PgColumn<{
             name: "is_private";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "boolean";
             columnType: "PgBoolean";
             data: boolean;
@@ -1132,7 +1149,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         hasSecrets: import("drizzle-orm/pg-core").PgColumn<{
             name: "has_secrets";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "boolean";
             columnType: "PgBoolean";
             data: boolean;
@@ -1149,7 +1166,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         relevanceScore: import("drizzle-orm/pg-core").PgColumn<{
             name: "relevance_score";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "number";
             columnType: "PgInteger";
             data: number;
@@ -1166,7 +1183,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         category: import("drizzle-orm/pg-core").PgColumn<{
             name: "category";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -1183,7 +1200,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         importance: import("drizzle-orm/pg-core").PgColumn<{
             name: "importance";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "number";
             columnType: "PgInteger";
             data: number;
@@ -1200,7 +1217,7 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {}>;
         metadata: import("drizzle-orm/pg-core").PgColumn<{
             name: "metadata";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "json";
             columnType: "PgJsonb";
             data: Record<string, unknown>;
@@ -1217,9 +1234,26 @@ export declare const observations: import("drizzle-orm/pg-core").PgTableWithColu
         }, {}, {
             $type: Record<string, unknown>;
         }>;
+        isImported: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_imported";
+            tableName: "learnings";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         createdAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "created_at";
-            tableName: "observations";
+            tableName: "learnings";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -1410,6 +1444,18 @@ export declare const entities: import("drizzle-orm/pg-core").PgTableWithColumns<
  * Namespaces - Hierarchical folder-like namespaces for memory organization
  */
 export declare const namespaces: any;
+/**
+ * Places - Spatial memory organization (Method of Loci)
+ */
+export declare const places: any;
+/**
+ * Memory-Place assignments
+ */
+export declare const memoryPlaces: any;
+/**
+ * Place auto-assignment rules
+ */
+export declare const placeRules: any;
 /**
  * Memory Layers - Tiered L0/L1/L2 summaries for token-efficient retrieval
  */
@@ -3943,7 +3989,7 @@ export declare const usersRelations: import("drizzle-orm").Relations<"users", {
 export declare const projectsRelations: import("drizzle-orm").Relations<"projects", {
     memories: import("drizzle-orm").Many<any>;
     conversations: import("drizzle-orm").Many<"conversations">;
-    observations: import("drizzle-orm").Many<"observations">;
+    learnings: import("drizzle-orm").Many<"learnings">;
     entities: import("drizzle-orm").Many<"entities">;
 }>;
 export declare const memoriesRelations: import("drizzle-orm").Relations<string, {
@@ -3954,14 +4000,15 @@ export declare const conversationsRelations: import("drizzle-orm").Relations<"co
     project: import("drizzle-orm").One<"projects", false>;
     user: import("drizzle-orm").One<"users", false>;
     messages: import("drizzle-orm").Many<"messages">;
-    observations: import("drizzle-orm").Many<"observations">;
-}>;
-export declare const messagesRelations: import("drizzle-orm").Relations<"messages", {
-    conversation: import("drizzle-orm").One<"conversations", true>;
+    learnings: import("drizzle-orm").Many<"learnings">;
 }>;
-export declare const observationsRelations: import("drizzle-orm").Relations<"observations", {
+export declare const learningsRelations: import("drizzle-orm").Relations<"learnings", {
     project: import("drizzle-orm").One<"projects", false>;
     conversation: import("drizzle-orm").One<"conversations", false>;
+    memory: import("drizzle-orm").One<any, false>;
+}>;
+export declare const messagesRelations: import("drizzle-orm").Relations<"messages", {
+    conversation: import("drizzle-orm").One<"conversations", true>;
 }>;
 export declare const entitiesRelations: import("drizzle-orm").Relations<"entities", {
     project: import("drizzle-orm").One<"projects", false>;
@@ -4007,8 +4054,8 @@ export type Conversation = typeof conversations.$inferSelect;
 export type NewConversation = typeof conversations.$inferInsert;
 export type Message = typeof messages.$inferSelect;
 export type NewMessage = typeof messages.$inferInsert;
-export type Observation = typeof observations.$inferSelect;
-export type NewObservation = typeof observations.$inferInsert;
+export type Learning = typeof learnings.$inferSelect;
+export type NewLearning = typeof learnings.$inferInsert;
 export type Entity = typeof entities.$inferSelect;
 export type NewEntity = typeof entities.$inferInsert;
 export type EntityRelation = typeof entityRelations.$inferSelect;

package/dist/{drizzle → db/drizzle}/schema.js

@@ -1,6 +1,5 @@
 import { pgTable, text, timestamp, uuid, integer, boolean, jsonb, index, vector, numeric } from 'drizzle-orm/pg-core';
 import { relations } from 'drizzle-orm';
-// ============================================================================
 // Core Tables
 // ============================================================================
 /**
@@ -15,7 +14,6 @@ export const users = pgTable('users', {
     createdAt: timestamp('created_at').defaultNow().notNull(),
     updatedAt: timestamp('updated_at').defaultNow().notNull(),
 });
-// ============================================================================
 // Memory Editing Tables
 // ============================================================================
 /**
@@ -74,7 +72,8 @@ export const memories = pgTable('memories', {
     embedding: vector('embedding', { dimensions: 1536 }), // OpenAI ada-002 compatible
     // Metadata
     source: text('source'), // Where this memory came from (tool, hook, user)
-    confidence: integer('confidence').default(100), // 0-100 confidence score
+    confidence: integer('confidence').default(50), // 0-100 confidence score (default: speculative)
+    confidenceLevel: text('confidence_level').default('speculative').$type(), // Iteration 3: Confidence flags (default: speculative)
     tags: text('tags').array(),
     metadata: jsonb('metadata').$type(),
     // v0.2.0: Privacy and relevance
@@ -84,7 +83,12 @@ export const memories = pgTable('memories', {
     // v0.3.0: Lifecycle Management
     sector: text('sector').default('episodic').$type(),
     tier: text('tier').default('hot').$type(),
-    decayRate: integer('decay_rate').default(30), // days until decay
+    status: text('status').notNull().default('active'),
+    encrypted_content: text('encrypted_content'),
+    encryption_nonce: text('encryption_nonce'),
+    is_encrypted: boolean('is_encrypted').default(false),
+    // Per-memory decay rate (integer percentage, e.g., 30 = 30% decay per cycle)
+    decayRate: integer('decay_rate').default(30),
     coactivationScore: integer('coactivation_score').default(0), // 0-100
     lastDecayAt: timestamp('last_decay_at').defaultNow(),
     // v0.3.0: Agent-Aware
@@ -124,10 +128,15 @@ export const memories = pgTable('memories', {
     // v0.4.2: Namespace support
     namespaceId: uuid('namespace_id').references(() => namespaces.id, { onDelete: 'set null' }),
     namespacePath: text('namespace_path'),
+    // v1.1.5: Places support (spatial memory organization)
+    placeId: uuid('place_id').references(() => places.id, { onDelete: 'set null' }),
+    placeLociIndex: integer('place_loci_index'),
     // v0.4.3: Layer support
     hasL0Abstract: boolean('has_l0_abstract').default(false),
     hasL1Overview: boolean('has_l1_overview').default(false),
     lastLayerUpdate: timestamp('last_layer_update'),
+    // v1.0.x: Token tracking
+    tokensEstimate: integer('tokens_estimate').default(0).notNull(),
     createdAt: timestamp('created_at').defaultNow().notNull(),
     updatedAt: timestamp('updated_at').defaultNow().notNull(),
 }, (table) => [
@@ -205,41 +214,46 @@ export const messages = pgTable('messages', {
     index('messages_created_idx').on(table.createdAt),
 ]);
 /**
- * Observations - auto-captured tool usage and events
+ * Learnings - agent learnings: success, failure, fix, insight
  */
-export const observations = pgTable('observations', {
+export const learnings = pgTable('learnings', {
     id: uuid('id').primaryKey().defaultRandom(),
     projectId: uuid('project_id').references(() => projects.id, { onDelete: 'cascade' }),
     conversationId: uuid('conversation_id').references(() => conversations.id, { onDelete: 'set null' }),
-    // What happened
+    // Learning type: success, failure, fix, insight
     type: text('type').notNull().$type(),
-    action: text('action').notNull(), // e.g., 'Edit', 'Read', 'Bash'
-    target: text('target'), // e.g., file path, command
+    action: text('action').notNull(),
+    target: text('target'),
     // Details
     summary: text('summary').notNull(),
     details: jsonb('details').$type(),
     // Semantic search
     embedding: vector('embedding', { dimensions: 1536 }),
-    // v0.2.0: Folder-scoped observations
+    // Optional link to a memory
+    memoryId: uuid('memory_id').references(() => memories.id, { onDelete: 'set null' }),
+    // Folder-scoped
     folderPath: text('folder_path'),
     projectPath: text('project_path'),
-    // v0.2.0: Privacy and relevance
+    // Privacy and relevance
     isPrivate: boolean('is_private').default(false),
     hasSecrets: boolean('has_secrets').default(false),
-    relevanceScore: integer('relevance_score').default(50), // 0-100
+    relevanceScore: integer('relevance_score').default(50),
     // Classification
-    category: text('category'), // e.g., 'refactoring', 'debugging', 'feature'
-    importance: integer('importance').default(50), // 0-100
+    category: text('category'),
+    importance: integer('importance').default(50),
     metadata: jsonb('metadata').$type(),
+    // Migration tracking
+    isImported: boolean('is_imported').default(false),
     createdAt: timestamp('created_at').defaultNow().notNull(),
 }, (table) => [
-    index('observations_project_idx').on(table.projectId),
-    index('observations_type_idx').on(table.type),
-    index('observations_action_idx').on(table.action),
-    index('observations_created_idx').on(table.createdAt),
-    index('observations_folder_idx').on(table.folderPath),
-    index('observations_relevance_idx').on(table.relevanceScore),
-    index('observations_private_idx').on(table.isPrivate),
+    index('learnings_project_idx').on(table.projectId),
+    index('learnings_type_idx').on(table.type),
+    index('learnings_action_idx').on(table.action),
+    index('learnings_created_idx').on(table.createdAt),
+    index('learnings_folder_idx').on(table.folderPath),
+    index('learnings_relevance_idx').on(table.relevanceScore),
+    index('learnings_private_idx').on(table.isPrivate),
+    index('learnings_memory_idx').on(table.memoryId),
 ]);
 /**
  * Entities - knowledge graph nodes
@@ -277,6 +291,63 @@ export const namespaces = pgTable('namespaces', {
     index('namespaces_project_idx').on(table.projectId),
     index('namespaces_parent_idx').on(table.parentId),
 ]);
+/**
+ * Places - Spatial memory organization (Method of Loci)
+ */
+export const places = pgTable('places', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    projectId: uuid('project_id').references(() => projects.id, { onDelete: 'cascade' }).notNull(),
+    name: text('name').notNull(),
+    placeType: text('place_type').notNull(),
+    parentId: uuid('parent_id').references(() => places.id, { onDelete: 'set null' }),
+    lociIndex: integer('loci_index').default(0),
+    positionX: integer('position_x').default(0),
+    positionY: integer('position_y').default(0),
+    description: text('description'),
+    purpose: text('purpose'),
+    memoryCount: integer('memory_count').default(0),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+    updatedAt: timestamp('updated_at').defaultNow().notNull(),
+}, (table) => [
+    index('places_project_idx').on(table.projectId),
+    index('places_type_idx').on(table.placeType),
+    index('places_parent_idx').on(table.parentId),
+    index('places_loci_idx').on(table.projectId, table.lociIndex),
+]);
+/**
+ * Memory-Place assignments
+ */
+export const memoryPlaces = pgTable('memory_places', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    memoryId: uuid('memory_id').references(() => memories.id, { onDelete: 'cascade' }).notNull(),
+    placeId: uuid('place_id').references(() => places.id, { onDelete: 'cascade' }).notNull(),
+    isManual: boolean('is_manual').default(false),
+    ruleId: uuid('rule_id'),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+}, (table) => [
+    index('memory_places_memory_idx').on(table.memoryId),
+    index('memory_places_place_idx').on(table.placeId),
+]);
+/**
+ * Place auto-assignment rules
+ */
+export const placeRules = pgTable('place_rules', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    projectId: uuid('project_id').references(() => projects.id, { onDelete: 'cascade' }).notNull(),
+    name: text('name').notNull(),
+    placeType: text('place_type').notNull(),
+    matchTool: text('match_tool'),
+    matchKeyword: text('match_keyword'),
+    matchTag: text('match_tag'),
+    matchMemoryType: text('match_memory_type'),
+    priority: integer('priority').default(0),
+    enabled: boolean('enabled').default(true),
+    createdAt: timestamp('created_at').defaultNow().notNull(),
+    updatedAt: timestamp('updated_at').defaultNow().notNull(),
+}, (table) => [
+    index('place_rules_project_idx').on(table.projectId),
+    index('place_rules_type_idx').on(table.placeType),
+]);
 /**
  * Memory Layers - Tiered L0/L1/L2 summaries for token-efficient retrieval
  */
@@ -308,7 +379,6 @@ export const entityRelations = pgTable('entity_relations', {
     index('relations_to_idx').on(table.toEntityId),
     index('relations_type_idx').on(table.type),
 ]);
-// ============================================================================
 // v0.3.0: Lifecycle & Governance Tables
 // ============================================================================
 /**
@@ -366,7 +436,6 @@ export const memorySnapshots = pgTable('memory_snapshots', {
     index('snapshots_type_idx').on(table.snapshotType),
     index('snapshots_created_idx').on(table.createdAt),
 ]);
-// ============================================================================
 // Progressive Disclosure & Context Paging Tables
 // ============================================================================
 /**
@@ -415,7 +484,6 @@ export const contextPagingSessions = pgTable('context_paging_sessions', {
     index('context_paging_project_idx').on(table.projectId),
     index('context_paging_created_idx').on(table.createdAt),
 ]);
-// ============================================================================
 // Memory Merging Tables
 // ============================================================================
 /**
@@ -559,7 +627,6 @@ export const contextSessions = pgTable('context_sessions', {
     index('context_sessions_project_idx').on(table.projectId),
     index('context_sessions_created_idx').on(table.createdAt),
 ]);
-// ============================================================================
 // Relations (Drizzle ORM)
 // ============================================================================
 export const usersRelations = relations(users, ({ many }) => ({
@@ -569,7 +636,7 @@ export const usersRelations = relations(users, ({ many }) => ({
 export const projectsRelations = relations(projects, ({ many }) => ({
     memories: many(memories),
     conversations: many(conversations),
-    observations: many(observations),
+    learnings: many(learnings),
     entities: many(entities),
 }));
 export const memoriesRelations = relations(memories, ({ one }) => ({
@@ -592,21 +659,25 @@ export const conversationsRelations = relations(conversations, ({ one, many }) =
         references: [users.id],
     }),
     messages: many(messages),
-    observations: many(observations),
+    learnings: many(learnings),
 }));
-export const messagesRelations = relations(messages, ({ one }) => ({
+export const learningsRelations = relations(learnings, ({ one }) => ({
+    project: one(projects, {
+        fields: [learnings.projectId],
+        references: [projects.id],
+    }),
     conversation: one(conversations, {
-        fields: [messages.conversationId],
+        fields: [learnings.conversationId],
         references: [conversations.id],
     }),
-}));
-export const observationsRelations = relations(observations, ({ one }) => ({
-    project: one(projects, {
-        fields: [observations.projectId],
-        references: [projects.id],
+    memory: one(memories, {
+        fields: [learnings.memoryId],
+        references: [memories.id],
     }),
+}));
+export const messagesRelations = relations(messages, ({ one }) => ({
     conversation: one(conversations, {
-        fields: [observations.conversationId],
+        fields: [messages.conversationId],
         references: [conversations.id],
     }),
 }));

package/dist/db/drizzle.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("drizzle-kit").Config;
+export default _default;
+//# sourceMappingURL=drizzle.config.d.ts.map

package/dist/db/drizzle.config.js

@@ -0,0 +1,12 @@
+import { defineConfig } from 'drizzle-kit';
+export default defineConfig({
+    schema: './drizzle/schema.ts',
+    out: './drizzle/migrations',
+    dialect: 'postgresql',
+    dbCredentials: {
+        url: process.env.DATABASE_URL || 'postgres://squish:squish_dev@localhost:5432/squish',
+    },
+    verbose: true,
+    strict: true,
+});
+//# sourceMappingURL=drizzle.config.js.map

package/dist/db/index.d.ts

@@ -1,10 +1,6 @@
 import { createDb } from './adapter.js';
 import { config } from '../config.js';
-export declare function getDb(): Promise<(import("drizzle-orm/node-postgres").NodePgDatabase<typeof import("../drizzle/schema.js")> & {
-    $client: import("pg").Pool;
-}) | (import("drizzle-orm/better-sqlite3").BetterSQLite3Database<typeof import("../drizzle/schema-sqlite.js")> & {
-    $client: import("better-sqlite3").Database;
-}) | import("drizzle-orm/sql-js").SQLJsDatabase<typeof import("../drizzle/schema-sqlite.js")>>;
+export declare function getDb(): Promise<any>;
 export declare function checkDatabaseHealth(): Promise<boolean>;
 export { config };
 export { createDb };

package/dist/db/index.js

@@ -1,6 +1,9 @@
 import { createDb } from './adapter.js';
 import { config } from '../config.js';
 import { logger } from '../core/logger.js';
+import { isDatabaseUnavailableError } from '../core/lib/utils.js';
+// Use any for db to avoid type conflicts between different drivers
+// The actual type will be determined at runtime based on mode
 let db = null;
 let dbError = null;
 export async function getDb() {
@@ -9,7 +12,38 @@ export async function getDb() {
     }
     if (!db) {
         try {
-            db = await createDb();
+            // Priority: remote (user's Supabase/Neon) > team (PostgreSQL) > local (SQLite)
+            if (config.isRemoteMode) {
+                if (config.remoteBackend === 'neon' && config.neonProjectId && config.neonServiceKey) {
+                    const { createNeonClient } = await import('./neon.js');
+                    db = await createNeonClient();
+                }
+                else if (config.supabaseUrl && config.supabaseKey) {
+                    const { createSupabaseClient } = await import('./supabase.js');
+                    db = await createSupabaseClient();
+                }
+                else {
+                    throw new Error('Remote backend not configured (need SUPABASE_URL or NEON_PROJECT_ID)');
+                }
+            }
+            else if (config.isTeamMode) {
+                // Team mode: PostgreSQL (or Supabase/Neon if explicitly configured)
+                if (config.teamBackend === 'supabase' && config.supabaseUrl && config.supabaseKey) {
+                    const { createSupabaseClient } = await import('./supabase.js');
+                    db = await createSupabaseClient();
+                }
+                else if (config.teamBackend === 'neon' && config.neonProjectId && config.neonServiceKey) {
+                    const { createNeonClient } = await import('./neon.js');
+                    db = await createNeonClient();
+                }
+                else {
+                    db = await createDb();
+                }
+            }
+            else {
+                // Local mode: SQLite
+                db = await createDb();
+            }
         }
         catch (error) {
             dbError = error instanceof Error ? error.message : 'Database initialization failed';
@@ -21,21 +55,30 @@ export async function getDb() {
 export async function checkDatabaseHealth() {
     try {
         const database = await getDb();
-        // Try a simple query - use a raw query that's guaranteed to work
-        const dbClient = database.$client;
+        const dbClient = database.$client ?? database;
         if (dbClient && typeof dbClient.query === 'function') {
             await dbClient.query('SELECT 1');
         }
+        else if (dbClient && typeof dbClient.exec === 'function') {
+            dbClient.exec('SELECT 1');
+        }
         else if (dbClient && typeof dbClient.prepare === 'function') {
-            dbClient.prepare('SELECT 1').get();
+            const statement = dbClient.prepare('SELECT 1');
+            if (typeof statement.get === 'function') {
+                statement.get();
+            }
+            else if (typeof statement.step === 'function') {
+                statement.step();
+            }
+            if (typeof statement.free === 'function') {
+                statement.free();
+            }
         }
         return true;
     }
     catch (error) {
-        // Check if it's a known database unavailability issue
-        if (error.message?.includes('not a valid Win32 application') ||
-            error.message?.includes('Database unavailable')) {
-            return false; // Graceful degradation - database unavailable but not an error
+        if (isDatabaseUnavailableError(error)) {
+            return false;
         }
         logger.error('Database health check failed', error);
         return false;

package/dist/db/neon.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Neon client wrapper that returns a Drizzle HTTP client.
+ * Neon HTTP driver is faster for single non-interactive transactions.
+ */
+export declare function createNeonClient(): Promise<import("drizzle-orm/neon-http").NeonHttpDatabase<Record<string, never>> & {
+    $client: import("@neondatabase/serverless").NeonQueryFunction<false, false>;
+}>;
+//# sourceMappingURL=neon.d.ts.map