@jamesaphoenix/tx-core 0.4.1 → 0.4.3

package/README.md

@@ -0,0 +1,480 @@
+# tx
+
+**TanStack for AI agents.** Primitives, not frameworks.
+
+Headless infrastructure for memory, tasks, and orchestration.
+
+```bash
+npm install -g @jamesaphoenix/tx
+tx init
+```
+
+---
+
+## The Problem
+
+Your agents lose context between sessions. Tasks collide when multiple agents work in parallel. Learnings vanish into conversation history. You're rebuilding the same infrastructure every project.
+
+## The Solution
+
+Composable primitives that handle the hard parts. You keep control of the orchestration.
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  Your Orchestration (your code, your rules)             │
+├─────────────────────────────────────────────────────────┤
+│  tx primitives                                          │
+│                                                         │
+│   tx ready     tx done      tx context    tx learn      │
+│   tx claim     tx block     tx handoff    tx sync       │
+│                                                         │
+└─────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Primitives
+
+### Memory
+
+Learnings that persist and surface when relevant.
+
+```bash
+# Store knowledge (with optional file path)
+tx learning:add "Use bcrypt for passwords, not SHA256" --file src/auth/hash.ts
+tx learning:add "Redis cache invalidation has race conditions"
+
+# Retrieve via search or task context
+tx learning:search "authentication"
+tx context tx-abc123  # Get relevant learnings for a task
+```
+
+Learnings can be tagged with file paths for organization. Hybrid search (BM25 + vector) finds relevant knowledge.
+
+### Tasks
+
+Dependency-aware task management. Agents only see work they can actually do.
+
+```bash
+# Create with dependencies
+tx add "Implement auth service" --score 800
+tx add "Design auth schema" --score 900
+tx block tx-impl tx-schema  # impl waits for schema
+
+# Work on what's ready
+tx ready                    # Only unblocked tasks
+tx done tx-schema           # Completes → unblocks dependents
+```
+
+Full hierarchy support. Epics contain milestones contain tasks contain subtasks.
+
+### Coordination
+
+Primitives for multi-agent workflows without prescribing the pattern.
+
+```bash
+tx claim tx-abc123           # Prevent collisions
+tx checkpoint tx-abc123 \
+  --note "API done, UI next"  # Save progress
+tx handoff tx-abc123 \
+  --to reviewer              # Transfer with context
+```
+
+---
+
+## Your Loop, Your Rules
+
+We ship **example loops**, not **the loop**:
+
+```bash
+# Simple: one agent, one task
+while task=$(tx ready --limit 1 --json | jq -r '.[0].id'); do
+  claude "Work on task $task, then run: tx done $task"
+done
+```
+
+```bash
+# Parallel: N agents pulling from queue
+for i in {1..5}; do
+  (while task=$(tx claim --next); do
+    claude "Complete $task" && tx done $task
+  done) &
+done
+wait
+```
+
+```bash
+# Human-in-loop: agent proposes, human approves
+task=$(tx ready --limit 1)
+claude "Plan implementation for $task" > plan.md
+read -p "Approve? [y/n] " && claude "Execute plan.md"
+tx done $task
+```
+
+**The flow is yours.** Serial, parallel, swarm, human-in-loop. Your call.
+
+---
+
+## Why tx?
+
+|  | Native Tasks | CLAUDE.md | tx |
+|---|---|---|---|
+| **Persistence** | Session-scoped | File grows forever | Git-native, branch-aware |
+| **Multi-agent** | Collisions | Manual coordination | Claim, block, handoff |
+| **Knowledge** | Lost each session | Static dump | Graph RAG, contextual retrieval |
+| **Orchestration** | None | None | Primitives for any pattern |
+
+---
+
+## Design Principles
+
+- **No opinions on orchestration.** Serial, parallel, swarm, human-in-loop. Your call.
+- **Powerful defaults.** `tx ready` just works. So does dependency resolution.
+- **Escape hatches everywhere.** Raw SQL access, JSONL export, custom scoring.
+- **Framework agnostic.** CLI, MCP, REST API, TypeScript SDK. Use what fits.
+- **Local-first.** SQLite + git. No server required. Works offline.
+
+---
+
+## Non-Goals
+
+- **Not an agent framework.** You bring your own orchestration.
+- **Not a hosted memory product.** Local-first, your data stays yours.
+- **Not a prompt library.** Primitives, not templates.
+- **Not a replacement for your issue tracker.** (Unless you want it to be.)
+
+---
+
+## Three Systems
+
+### 1. Knowledge System
+
+**Working today:**
+- Learnings stored with file path tags
+- Basic hybrid search (BM25 + vector)
+- Retrieval by task ID via `tx context`
+
+```bash
+tx learning:add "Use bcrypt for passwords" --file src/auth/hash.ts
+tx learning:search "authentication"
+tx context tx-abc123  # Get learnings relevant to a task
+```
+
+**Research in progress:**
+- Symbol anchoring (AST-based code references, not just file paths)
+- Knowledge graph expansion (automatic relationship discovery)
+- Auto-invalidation when code changes
+
+### 2. Task System
+
+**Working today:**
+- N-level hierarchy (epics → tasks → subtasks)
+- Explicit dependencies with cycle detection
+- Priority scoring
+- Claim/release with lease expiry
+
+```
+Epic: "User Authentication"
+├── Task: "Design schema" ✓ done
+├── Task: "Implement service" ● ready (unblocked)
+│   └── blocks: "Write tests", "Add endpoints"
+└── Task: "Write tests" ○ blocked
+```
+
+**Research in progress:**
+- LLM-based reprioritization
+- Automatic task decomposition
+
+### 3. Worker System
+
+**Working today:**
+- `runWorker()` with execute/captureIO hooks
+- Lease-based claims (prevents collisions)
+- Automatic lease renewal
+- Coordinator reconciliation (dead worker recovery)
+
+```typescript
+runWorker({
+  execute: async (task, ctx) => {
+    await ctx.renewLease()  // For long tasks
+    return { success: true }
+  }
+})
+```
+
+**Research in progress:**
+- Daemon watching `~/.claude/projects/**/*.jsonl`
+- Automatic learning extraction from sessions
+- Confidence scoring for auto-promotion
+
+---
+
+## Worker Orchestration (TypeScript SDK)
+
+For programmatic control, the TypeScript SDK provides `runWorker()` — a headless worker that executes tasks using your hooks.
+
+### Two Hooks. That's It.
+
+```typescript
+import { runWorker } from "@jamesaphoenix/tx-core"
+
+runWorker({
+  name: "my-worker",
+  execute: async (task, ctx) => {
+    // YOUR LOGIC HERE
+    console.log(`Working on: ${task.title}`)
+
+    // Use ctx.renewLease() for long tasks
+    await ctx.renewLease()
+
+    // Return success or failure
+    return { success: true, output: "Done!" }
+  },
+  captureIO: (runId, task) => ({
+    transcriptPath: `.tx/runs/${runId}.jsonl`,
+    stderrPath: `.tx/runs/${runId}.stderr`
+  })
+})
+```
+
+| Hook | Required | Purpose |
+|------|----------|---------|
+| `execute` | Yes | Your task execution logic |
+| `captureIO` | No | Paths for transcript/stderr/stdout capture |
+
+### WorkerContext
+
+The `ctx` object provides tx primitives:
+
+```typescript
+interface WorkerContext {
+  workerId: string              // This worker's ID
+  runId: string                 // Unique ID for this execution
+  renewLease: () => Promise<void>  // Extend lease for long tasks
+  log: (message: string) => void   // Log with worker prefix
+  state: Record<string, unknown>   // Mutable state within task
+}
+```
+
+### Custom Context
+
+Pass your own primitives via generics:
+
+```typescript
+interface MyContext {
+  llm: AnthropicClient
+  db: Database
+}
+
+runWorker<MyContext>({
+  context: {
+    llm: new Anthropic(),
+    db: myDatabase
+  },
+  execute: async (task, ctx) => {
+    // ctx.llm and ctx.db available here
+    const response = await ctx.llm.messages.create(...)
+    return { success: true }
+  }
+})
+```
+
+### Claims and Leases
+
+Workers use a lease-based system to prevent collisions:
+
+```
+Worker A claims task → Lease expires in 30 min → Renew or lose it
+Worker B tries to claim same task → Rejected (already claimed)
+Worker A dies → Lease expires → Coordinator reclaims task
+```
+
+Key points:
+- **Claims are atomic** — only one worker can claim a task
+- **Leases expire** — prevents stuck tasks from dead workers
+- **Auto-renewal** — `runWorker()` renews automatically; use `ctx.renewLease()` for extra-long tasks
+- **Coordinator reconciles** — dead workers detected, orphaned tasks recovered
+
+### Example Worker Loops
+
+#### Basic: One Worker
+
+```typescript
+import { Effect, Layer } from "effect"
+import { runWorker, makeMinimalLayer, SqliteClientLive } from "@jamesaphoenix/tx-core"
+
+const layer = makeMinimalLayer.pipe(
+  Layer.provide(SqliteClientLive(".tx/tasks.db"))
+)
+
+Effect.runPromise(
+  runWorker({
+    execute: async (task, ctx) => {
+      ctx.log(`Processing: ${task.title}`)
+      // ... your logic
+      return { success: true }
+    }
+  }).pipe(Effect.provide(layer))
+)
+```
+
+#### With Claude Code
+
+```typescript
+import { spawn } from "child_process"
+
+runWorker({
+  execute: async (task, ctx) => {
+    return new Promise((resolve) => {
+      const proc = spawn("claude", [
+        "--print",
+        `Work on task ${task.id}: ${task.title}`
+      ])
+
+      proc.on("close", (code) => {
+        resolve({
+          success: code === 0,
+          error: code !== 0 ? `Exit code ${code}` : undefined
+        })
+      })
+    })
+  }
+})
+```
+
+#### Parallel Workers
+
+```typescript
+// Start N workers (each in its own process or fiber)
+for (let i = 0; i < 5; i++) {
+  Effect.fork(
+    runWorker({
+      name: `worker-${i}`,
+      execute: async (task, ctx) => {
+        // Workers automatically coordinate via claims
+        return { success: true }
+      }
+    })
+  )
+}
+```
+
+#### Long-Running Tasks
+
+```typescript
+runWorker({
+  execute: async (task, ctx) => {
+    for (let step = 0; step < 100; step++) {
+      // Periodic lease renewal for tasks > 30 min
+      if (step % 10 === 0) {
+        await ctx.renewLease()
+      }
+
+      // Track progress in mutable state
+      ctx.state.progress = step
+
+      await doExpensiveWork(step)
+    }
+    return { success: true }
+  }
+})
+```
+
+---
+
+## Interfaces
+
+| Interface | Use Case |
+|-----------|----------|
+| **CLI** | Scripts, terminal workflows, RALPH loops |
+| **MCP Server** | Claude Code integration (16 tools) |
+| **REST API** | Custom dashboards, external integrations |
+| **TypeScript SDK** | Programmatic access from your agents |
+| **Dashboard** | Visual monitoring and management |
+
+---
+
+## Quick Reference
+
+```bash
+# Tasks
+tx add <title>              # Create
+tx ready                    # List unblocked
+tx done <id>                # Complete
+tx block <id> <blocker>     # Add dependency
+tx tree <id>                # Show hierarchy
+
+# Memory
+tx learning:add <content>   # Store
+tx learning:search <query>  # Find
+tx context <task-id>        # Contextual retrieval
+
+# Coordination
+tx claim <id>               # Prevent collisions
+tx handoff <id> --to <agent>
+tx checkpoint <id> --note "..."
+
+# Sync
+tx sync export              # SQLite → JSONL (git-friendly)
+tx sync import              # JSONL → SQLite
+```
+
+---
+
+## Storage
+
+```
+.tx/
+├── tasks.db           # SQLite (gitignored)
+├── tasks.jsonl        # Git-tracked
+├── learnings.jsonl    # Git-tracked
+└── runs.jsonl         # Git-tracked
+```
+
+Local SQLite for speed. JSONL for git sync. Branch your knowledge with your code.
+
+---
+
+## Status
+
+**Shipping now (concrete, tested):**
+- Core task primitives: add, ready, done, block, claim, handoff
+- Dependency management with cycle detection
+- Worker orchestration via `runWorker()` with claims/leases
+- Learnings with file path tagging
+- Hybrid search (BM25 + vector)
+- CLI (20+ commands), MCP server (16 tools)
+- 389+ tests
+
+**Research in progress (not yet stable):**
+- Symbol anchoring (AST-based code references)
+- Knowledge graph expansion
+- Auto-invalidation when code changes
+- Daemon-based learning extraction
+- LLM reprioritization
+
+---
+
+## Documentation
+
+- **[CLAUDE.md](CLAUDE.md)**: Doctrine and quick reference
+- **[docs/](docs/)**: Full documentation (17 PRDs, 17 Design Docs)
+
+### Docs Site
+
+Run the documentation site locally:
+
+```bash
+cd apps/docs
+npm run dev    # Development server at http://localhost:3000
+npm run build  # Production build
+npm run start  # Serve production build
+```
+
+The docs site is built with [Fumadocs](https://fumadocs.vercel.app/) and Next.js, featuring full-text search, syntax highlighting, and automatic navigation from the markdown files in `docs/`.
+
+---
+
+## License
+
+MIT

package/dist/db.d.ts

@@ -1,42 +1,56 @@
 import { Context, Effect, Layer } from "effect";
-import Database from "better-sqlite3";
+import { DatabaseError } from "./errors.js";
+/**
+ * Result type for SQL statement run operations.
+ * Compatible with bun:sqlite's return type.
+ */
+export interface SqliteRunResult {
+    lastInsertRowid: number | bigint;
+    changes: number;
+}
 /**
  * Minimal interface for SQL statement objects.
- * Describes what we need from better-sqlite3's Statement type.
+ * Describes what we need from bun:sqlite's Statement type.
  */
 export interface SqliteStatement<TResult = unknown> {
-    run(...params: unknown[]): Database.RunResult;
-    get(...params: unknown[]): TResult | undefined;
+    run(...params: unknown[]): SqliteRunResult;
+    get(...params: unknown[]): TResult | null;
     all(...params: unknown[]): TResult[];
 }
 /**
  * Minimal interface for the SQLite database.
- * Describes what we need from better-sqlite3's Database type.
+ * Describes what we need from bun:sqlite's Database type.
  * This allows declaration generation without exposing private types.
  */
 export interface SqliteDatabase {
     prepare<T = unknown>(sql: string): SqliteStatement<T>;
-    exec(sql: string): this;
-    pragma(pragma: string, options?: {
-        simple?: boolean;
-    }): unknown;
+    run(sql: string, ...params: unknown[]): SqliteRunResult;
+    exec(sql: string): void;
     close(): void;
+    /** Wrap a function in a transaction. Commits on success, rolls back on throw. */
+    transaction<T>(fn: () => T): () => T;
 }
 declare const SqliteClient_base: Context.TagClass<SqliteClient, "SqliteClient", SqliteDatabase>;
-/** The SqliteClient service provides a better-sqlite3 Database instance. */
+/** The SqliteClient service provides a bun:sqlite Database instance. */
 export declare class SqliteClient extends SqliteClient_base {
 }
 /**
  * Get the current schema version from a database instance.
  * Exported for use in tests and CLI commands.
+ *
+ * Accepts SqliteDatabase interface to work with both bun:sqlite and better-sqlite3.
  */
-export declare const getSchemaVersion: (db: Database.Database) => number;
+export declare const getSchemaVersion: (db: SqliteDatabase) => number;
 /**
  * Apply all pending migrations to the database.
  * Uses the centralized MIGRATIONS from migration-service.ts.
+ * Each migration is wrapped in BEGIN IMMEDIATE/COMMIT/ROLLBACK
+ * to ensure atomicity and prevent concurrent application.
+ *
+ * Accepts SqliteDatabase interface to work with both bun:sqlite and better-sqlite3.
  */
-export declare const applyMigrations: (db: Database.Database) => void;
-export declare const makeSqliteClient: (dbPath: string) => Effect.Effect<Database.Database>;
-export declare const SqliteClientLive: (dbPath: string) => Layer.Layer<SqliteClient, never, never>;
+export declare const applyMigrations: (db: SqliteDatabase) => void;
+export declare const makeSqliteClient: (dbPath: string) => Effect.Effect<SqliteDatabase, DatabaseError>;
+export declare const SqliteClientLive: (dbPath: string) => Layer.Layer<SqliteClient, DatabaseError, never>;
 export {};
 //# sourceMappingURL=db.d.ts.map

package/dist/db.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../src/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAC/C,OAAO,QAAQ,MAAM,gBAAgB,CAAA;AAKrC;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,OAAO,GAAG,OAAO;IAChD,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,QAAQ,CAAC,SAAS,CAAA;IAC7C,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,SAAS,CAAA;IAC9C,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAAA;CACrC;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,CAAA;IACrD,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAA;IAC/D,KAAK,IAAI,IAAI,CAAA;CACd;;AAED,4EAA4E;AAC5E,qBAAa,YAAa,SAAQ,iBAG/B;CAAG;AAEN;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,IAAI,QAAQ,CAAC,QAAQ,KAAG,MAOxD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAI,IAAI,QAAQ,CAAC,QAAQ,KAAG,IAQvD,CAAA;AAED,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAW7E,CAAA;AAEJ,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,4CAI5C,CAAA"}
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../src/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAI/C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAM3C;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,MAAM,GAAG,MAAM,CAAA;IAChC,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,OAAO,GAAG,OAAO;IAChD,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,eAAe,CAAA;IAC1C,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,GAAG,IAAI,CAAA;IACzC,GAAG,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAAA;CACrC;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,CAAA;IACrD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,eAAe,CAAA;IACvD,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,KAAK,IAAI,IAAI,CAAA;IACb,iFAAiF;IACjF,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,CAAA;CACrC;;AAED,wEAAwE;AACxE,qBAAa,YAAa,SAAQ,iBAG/B;CAAG;AAEN;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,GAAI,IAAI,cAAc,KAAG,MAOrD,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,IAAI,cAAc,KAAG,IAepD,CAAA;AA6CD,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,cAAc,EAAE,aAAa,CAoCzF,CAAA;AAEJ,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,oDAO5C,CAAA"}

package/dist/db.js

@@ -1,14 +1,16 @@
 import { Context, Effect, Layer } from "effect";
-import Database from "better-sqlite3";
 import { mkdirSync, existsSync } from "fs";
 import { dirname } from "path";
 import { MIGRATIONS } from "./services/migration-service.js";
-/** The SqliteClient service provides a better-sqlite3 Database instance. */
+import { DatabaseError } from "./errors.js";
+/** The SqliteClient service provides a bun:sqlite Database instance. */
 export class SqliteClient extends Context.Tag("SqliteClient")() {
 }
 /**
  * Get the current schema version from a database instance.
  * Exported for use in tests and CLI commands.
+ *
+ * Accepts SqliteDatabase interface to work with both bun:sqlite and better-sqlite3.
  */
 export const getSchemaVersion = (db) => {
     try {
@@ -22,25 +24,111 @@ export const getSchemaVersion = (db) => {
 /**
  * Apply all pending migrations to the database.
  * Uses the centralized MIGRATIONS from migration-service.ts.
+ * Each migration is wrapped in BEGIN IMMEDIATE/COMMIT/ROLLBACK
+ * to ensure atomicity and prevent concurrent application.
+ *
+ * Accepts SqliteDatabase interface to work with both bun:sqlite and better-sqlite3.
  */
 export const applyMigrations = (db) => {
     const currentVersion = getSchemaVersion(db);
     for (const migration of MIGRATIONS) {
         if (migration.version > currentVersion) {
-            db.exec(migration.sql);
+            db.exec("BEGIN IMMEDIATE");
+            try {
+                db.exec(migration.sql);
+                db.exec("COMMIT");
+            }
+            catch (e) {
+                db.exec("ROLLBACK");
+                throw e;
+            }
         }
     }
 };
-export const makeSqliteClient = (dbPath) => Effect.sync(() => {
-    const dir = dirname(dbPath);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    const db = new Database(dbPath);
-    db.pragma("journal_mode = WAL");
-    db.pragma("foreign_keys = ON");
-    applyMigrations(db);
-    return db;
+/**
+ * Wrap a better-sqlite3 Database as SqliteDatabase.
+ * Used by makeSqliteClient when running under Vitest.
+ * Inlined here to avoid circular dependency on test-utils.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function wrapBetterSqlite3ForClient(raw) {
+    return {
+        prepare(sql) {
+            const stmt = raw.prepare(sql);
+            return {
+                run(...params) {
+                    const r = stmt.run(...params);
+                    return { lastInsertRowid: r.lastInsertRowid ?? 0, changes: r.changes ?? 0 };
+                },
+                get(...params) { return stmt.get(...params) ?? null; },
+                all(...params) { return stmt.all(...params); }
+            };
+        },
+        run(sql, ...params) {
+            const trimmed = sql.trim();
+            if (trimmed.toUpperCase().startsWith("PRAGMA")) {
+                raw.pragma(trimmed.slice(6).trim());
+                return { lastInsertRowid: 0, changes: 0 };
+            }
+            const r = raw.prepare(sql).run(...params);
+            return { lastInsertRowid: r.lastInsertRowid ?? 0, changes: r.changes ?? 0 };
+        },
+        exec(sql) { raw.exec(sql); },
+        close() { raw.close(); },
+        transaction(fn) {
+            if (typeof raw.transaction === "function") {
+                return raw.transaction(fn);
+            }
+            return () => {
+                raw.exec("BEGIN");
+                try {
+                    const r = fn();
+                    raw.exec("COMMIT");
+                    return r;
+                }
+                catch (e) {
+                    raw.exec("ROLLBACK");
+                    throw e;
+                }
+            };
+        }
+    };
+}
+export const makeSqliteClient = (dbPath) => Effect.tryPromise({
+    try: async () => {
+        const dir = dirname(dbPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        // Detect Vitest (uses better-sqlite3) vs Bun (uses bun:sqlite)
+        // Check both VITEST env var AND that we're NOT running under Bun.
+        // Tests spawn CLI subprocesses that inherit VITEST=true but should use bun:sqlite.
+        const isVitest = typeof process !== "undefined" && process.env.VITEST === "true"
+            && typeof globalThis.Bun === "undefined";
+        if (isVitest) {
+            // Vitest: use better-sqlite3 wrapped as SqliteDatabase
+            const { default: BetterDatabase } = await import("better-sqlite3");
+            const raw = new BetterDatabase(dbPath);
+            raw.pragma("journal_mode = WAL");
+            raw.pragma("foreign_keys = ON");
+            raw.pragma("busy_timeout = " + (process.env.TX_DB_BUSY_TIMEOUT || "5000"));
+            const db = wrapBetterSqlite3ForClient(raw);
+            applyMigrations(db);
+            return db;
+        }
+        // Bun: use bun:sqlite
+        const { Database } = await import("bun:sqlite");
+        const db = new Database(dbPath);
+        db.run("PRAGMA busy_timeout = " + (process.env.TX_DB_BUSY_TIMEOUT || "5000"));
+        db.run("PRAGMA journal_mode = WAL");
+        db.run("PRAGMA foreign_keys = ON");
+        applyMigrations(db);
+        return db;
+    },
+    catch: (cause) => new DatabaseError({ cause })
 });
-export const SqliteClientLive = (dbPath) => Layer.effect(SqliteClient, makeSqliteClient(dbPath));
+export const SqliteClientLive = (dbPath) => Layer.scoped(SqliteClient, Effect.acquireRelease(makeSqliteClient(dbPath), (db) => Effect.sync(() => { try {
+    db.close();
+}
+catch { /* already closed */ } })));
 //# sourceMappingURL=db.js.map