@jamesaphoenix/tx 0.4.0 → 0.4.3

package/README.md

@@ -1,68 +1,479 @@
-# @jamesaphoenix/tx
+# tx
 
-**TanStack for AI agents.** Headless primitives for memory, tasks, and orchestration.
+**TanStack for AI agents.** Primitives, not frameworks.
 
-## Installation
+Headless infrastructure for memory, tasks, and orchestration.
 
 ```bash
-npm install @jamesaphoenix/tx better-sqlite3 effect
+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 }
+  }
+})
 ```
 
-## Quick Start
+**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 { createTx } from '@jamesaphoenix/tx'
+import { runWorker } from "@jamesaphoenix/tx-core"
 
-// Initialize tx
-const tx = createTx()
+runWorker({
+  name: "my-worker",
+  execute: async (task, ctx) => {
+    // YOUR LOGIC HERE
+    console.log(`Working on: ${task.title}`)
 
-// Create a task
-const task = await tx.add({
-  title: 'Implement feature X',
-  status: 'ready'
+    // 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`
+  })
 })
+```
 
-// Get next workable task
-const next = await tx.ready()
+| Hook | Required | Purpose |
+|------|----------|---------|
+| `execute` | Yes | Your task execution logic |
+| `captureIO` | No | Paths for transcript/stderr/stdout capture |
 
-// Complete a task
-await tx.done(task.id)
+### 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
+}
 ```
 
-## CLI Usage
+### 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
-# Install globally
-npm install -g @jamesaphoenix/tx
+# Tasks
+tx add <title>              # Create
+tx ready                    # List unblocked
+tx done <id>                # Complete
+tx block <id> <blocker>     # Add dependency
+tx tree <id>                # Show hierarchy
 
-# Create tasks
-tx add "Implement feature X"
+# Memory
+tx learning:add <content>   # Store
+tx learning:search <query>  # Find
+tx context <task-id>        # Contextual retrieval
 
-# Get next ready task
-tx ready
+# 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
+```
 
-# Complete a task
-tx done <task-id>
+---
 
-# View task tree
-tx tree <task-id>
+## Storage
+
+```
+.tx/
+├── tasks.db           # SQLite (gitignored)
+├── tasks.jsonl        # Git-tracked
+├── learnings.jsonl    # Git-tracked
+└── runs.jsonl         # Git-tracked
 ```
 
-## Philosophy: Primitives, Not Frameworks
+Local SQLite for speed. JSONL for git sync. Branch your knowledge with your code.
+
+---
+
+## Status
 
-tx provides headless infrastructure for AI agent orchestration. You own your orchestration logic - tx owns the primitives.
+**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
 
-| Primitive | Purpose |
-|-----------|---------|
-| `tx ready` | Get next workable task (unblocked, highest priority) |
-| `tx claim <id>` | Mark task as being worked by an agent |
-| `tx done <id>` | Complete task, potentially unblocking others |
-| `tx block <id> <blocker>` | Declare dependencies |
-| `tx handoff <id> --to <agent>` | Transfer task with context |
+**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
 
-Full documentation: [github.com/jamesaphoenix/tx](https://github.com/jamesaphoenix/tx)
+- **[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
 

package/dist/create-tx.d.ts

@@ -28,7 +28,7 @@
  * ```
  */
 import { Effect, Exit, Layer } from "effect";
-import { RetrieverService } from "@tx/core";
+import { RetrieverService } from "@jamesaphoenix/tx-core";
 /**
  * Options for configuring createTx().
  *
@@ -143,5 +143,5 @@ export interface TxClient {
  * ```
  */
 export declare const createTx: (options?: CreateTxOptions) => TxClient;
-export { RetrieverService } from "@tx/core";
+export { RetrieverService } from "@jamesaphoenix/tx-core";
 //# sourceMappingURL=create-tx.d.ts.map

package/dist/create-tx.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-tx.d.ts","sourceRoot":"","sources":["../src/create-tx.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAkB,MAAM,QAAQ,CAAA;AAC5D,OAAO,EAEL,gBAAgB,EACjB,MAAM,UAAU,CAAA;AAEjB;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IAExB;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAA;CACnD;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;IAEtE;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAA;IAE9F;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IAE1C;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,QAAQ,GAAI,UAAS,eAAoB,KAAG,QAiCxD,CAAA;AAGD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA"}
+{"version":3,"file":"create-tx.d.ts","sourceRoot":"","sources":["../src/create-tx.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAkB,MAAM,QAAQ,CAAA;AAC5D,OAAO,EAEL,gBAAgB,EACjB,MAAM,wBAAwB,CAAA;AAE/B;;;;GAIG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IAExB;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAA;CACnD;AAED;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;IAEtE;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAA;IAE9F;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IAE1C;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,QAAQ,GAAI,UAAS,eAAoB,KAAG,QAiCxD,CAAA;AAGD,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/create-tx.js

@@ -28,7 +28,7 @@
  * ```
  */
 import { Layer, ManagedRuntime } from "effect";
-import { makeAppLayer } from "@tx/core";
+import { makeAppLayer } from "@jamesaphoenix/tx-core";
 /**
  * Create a tx client with optional configuration.
  *
@@ -98,5 +98,5 @@ export const createTx = (options = {}) => {
     };
 };
 // Re-export RetrieverService for custom retriever implementations
-export { RetrieverService } from "@tx/core";
+export { RetrieverService } from "@jamesaphoenix/tx-core";
 //# sourceMappingURL=create-tx.js.map

package/dist/create-tx.js.map

@@ -1 +1 @@
-{"version":3,"file":"create-tx.js","sourceRoot":"","sources":["../src/create-tx.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAgB,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAC5D,OAAO,EACL,YAAY,EAEb,MAAM,UAAU,CAAA;AA6EjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,UAA2B,EAAE,EAAY,EAAE;IAClE,MAAM,EACJ,MAAM,GAAG,cAAc,EACvB,SAAS,EACV,GAAG,OAAO,CAAA;IAEX,2BAA2B;IAC3B,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,CAAA;IAEtC,wEAAwE;IACxE,gFAAgF;IAChF,MAAM,QAAQ,GAAG,SAAS;QACxB,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,EAAE,SAAS,CAAC;QAC1C,CAAC,CAAC,SAAS,CAAA;IAEb,2DAA2D;IAC3D,MAAM,cAAc,GAAG,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IAEpD,OAAO;QACL,GAAG,EAAE,KAAK,EAAQ,MAAkC,EAAc,EAAE;YAClE,OAAO,cAAc,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;QAC1C,CAAC;QAED,OAAO,EAAE,KAAK,EAAQ,MAAkC,EAAkC,EAAE;YAC1F,OAAO,cAAc,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;QAC9C,CAAC;QAED,KAAK,EAAE,QAAQ;QAEf,KAAK,EAAE,KAAK,IAAmB,EAAE;YAC/B,MAAM,cAAc,CAAC,OAAO,EAAE,CAAA;QAChC,CAAC;KACF,CAAA;AACH,CAAC,CAAA;AAED,kEAAkE;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA"}
+{"version":3,"file":"create-tx.js","sourceRoot":"","sources":["../src/create-tx.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAgB,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAC5D,OAAO,EACL,YAAY,EAEb,MAAM,wBAAwB,CAAA;AA6E/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,UAA2B,EAAE,EAAY,EAAE;IAClE,MAAM,EACJ,MAAM,GAAG,cAAc,EACvB,SAAS,EACV,GAAG,OAAO,CAAA;IAEX,2BAA2B;IAC3B,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,CAAA;IAEtC,wEAAwE;IACxE,gFAAgF;IAChF,MAAM,QAAQ,GAAG,SAAS;QACxB,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,SAAS,EAAE,SAAS,CAAC;QAC1C,CAAC,CAAC,SAAS,CAAA;IAEb,2DAA2D;IAC3D,MAAM,cAAc,GAAG,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IAEpD,OAAO;QACL,GAAG,EAAE,KAAK,EAAQ,MAAkC,EAAc,EAAE;YAClE,OAAO,cAAc,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;QAC1C,CAAC;QAED,OAAO,EAAE,KAAK,EAAQ,MAAkC,EAAkC,EAAE;YAC1F,OAAO,cAAc,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;QAC9C,CAAC;QAED,KAAK,EAAE,QAAQ;QAEf,KAAK,EAAE,KAAK,IAAmB,EAAE;YAC/B,MAAM,cAAc,CAAC,OAAO,EAAE,CAAA;QAChC,CAAC;KACF,CAAA;AACH,CAAC,CAAA;AAED,kEAAkE;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/index.d.ts

@@ -34,8 +34,8 @@
  * });
  * ```
  */
-export * from "@tx/core";
+export * from "@jamesaphoenix/tx-core";
 export { createTx, type CreateTxOptions, type TxClient } from "./create-tx.js";
-export type { TaskStatus, TaskId, Task, TaskWithDeps, TaskTree, TaskDependency, CreateTaskInput, UpdateTaskInput, TaskFilter, LearningSourceType, LearningId, Learning, LearningWithScore, CreateLearningInput, UpdateLearningInput, LearningQuery, ContextOptions, ContextResult, RetrievalOptions, AttemptOutcome, AttemptId, Attempt, CreateAttemptInput, RunId, RunStatus, Run, CreateRunInput, UpdateRunInput, AnchorId, AnchorType, AnchorStatus, Anchor, CreateAnchorInput, EdgeId, NodeType, EdgeType, Edge, CreateEdgeInput, } from "@tx/types";
-export { TASK_STATUSES, VALID_TRANSITIONS, LEARNING_SOURCE_TYPES, ATTEMPT_OUTCOMES, RUN_STATUSES, ANCHOR_TYPES, ANCHOR_STATUSES, NODE_TYPES, EDGE_TYPES, } from "@tx/types";
+export type { TaskStatus, TaskId, Task, TaskWithDeps, TaskTree, TaskDependency, CreateTaskInput, UpdateTaskInput, TaskFilter, LearningSourceType, LearningId, Learning, LearningWithScore, CreateLearningInput, UpdateLearningInput, LearningQuery, ContextOptions, ContextResult, RetrievalOptions, AttemptOutcome, AttemptId, Attempt, CreateAttemptInput, RunId, RunStatus, Run, CreateRunInput, UpdateRunInput, } from "@jamesaphoenix/tx-types";
+export { TASK_STATUSES, VALID_TRANSITIONS, LEARNING_SOURCE_TYPES, ATTEMPT_OUTCOMES, RUN_STATUSES, } from "@jamesaphoenix/tx-types";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAGH,cAAc,UAAU,CAAC;AAGzB,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/E,YAAY,EAEV,UAAU,EACV,MAAM,EACN,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,cAAc,EACd,eAAe,EACf,eAAe,EACf,UAAU,EAEV,kBAAkB,EAClB,UAAU,EACV,QAAQ,EACR,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,cAAc,EACd,aAAa,EACb,gBAAgB,EAEhB,cAAc,EACd,SAAS,EACT,OAAO,EACP,kBAAkB,EAElB,KAAK,EACL,SAAS,EACT,GAAG,EACH,cAAc,EACd,cAAc,EAEd,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,MAAM,EACN,iBAAiB,EAEjB,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,IAAI,EACJ,eAAe,GAChB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,UAAU,EACV,UAAU,GACX,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAGH,cAAc,wBAAwB,CAAC;AAGvC,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/E,YAAY,EAEV,UAAU,EACV,MAAM,EACN,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,cAAc,EACd,eAAe,EACf,eAAe,EACf,UAAU,EAEV,kBAAkB,EAClB,UAAU,EACV,QAAQ,EACR,iBAAiB,EACjB,mBAAmB,EACnB,mBAAmB,EACnB,aAAa,EACb,cAAc,EACd,aAAa,EACb,gBAAgB,EAEhB,cAAc,EACd,SAAS,EACT,OAAO,EACP,kBAAkB,EAElB,KAAK,EACL,SAAS,EACT,GAAG,EACH,cAAc,EACd,cAAc,GACf,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,GACb,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -34,10 +34,10 @@
  * });
  * ```
  */
-// Re-export everything from @tx/core
-export * from "@tx/core";
+// Re-export everything from @jamesaphoenix/tx-core
+export * from "@jamesaphoenix/tx-core";
 // Export createTx and related types
 export { createTx } from "./create-tx.js";
 // Re-export constants from types
-export { TASK_STATUSES, VALID_TRANSITIONS, LEARNING_SOURCE_TYPES, ATTEMPT_OUTCOMES, RUN_STATUSES, ANCHOR_TYPES, ANCHOR_STATUSES, NODE_TYPES, EDGE_TYPES, } from "@tx/types";
+export { TASK_STATUSES, VALID_TRANSITIONS, LEARNING_SOURCE_TYPES, ATTEMPT_OUTCOMES, RUN_STATUSES, } from "@jamesaphoenix/tx-types";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,qCAAqC;AACrC,cAAc,UAAU,CAAC;AAEzB,oCAAoC;AACpC,OAAO,EAAE,QAAQ,EAAuC,MAAM,gBAAgB,CAAC;AAkD/E,iCAAiC;AACjC,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,UAAU,EACV,UAAU,GACX,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,mDAAmD;AACnD,cAAc,wBAAwB,CAAC;AAEvC,oCAAoC;AACpC,OAAO,EAAE,QAAQ,EAAuC,MAAM,gBAAgB,CAAC;AAsC/E,iCAAiC;AACjC,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,GACb,MAAM,yBAAyB,CAAC"}

package/dist/types.d.ts

@@ -8,5 +8,5 @@
  * import type { Task, Learning } from "@jamesaphoenix/tx/types";
  * ```
  */
-export * from "@tx/types";
+export * from "@jamesaphoenix/tx-types";
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,WAAW,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,yBAAyB,CAAC"}

package/dist/types.js

@@ -8,5 +8,5 @@
  * import type { Task, Learning } from "@jamesaphoenix/tx/types";
  * ```
  */
-export * from "@tx/types";
+export * from "@jamesaphoenix/tx-types";
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,WAAW,CAAC"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,cAAc,yBAAyB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jamesaphoenix/tx",
-  "version": "0.4.0",
+  "version": "0.4.3",
   "description": "TanStack for AI agents - headless primitives for memory, tasks, and orchestration",
   "type": "module",
   "main": "./dist/index.js",
@@ -25,21 +25,16 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@tx/core": "*",
-    "@tx/types": "*"
+    "@jamesaphoenix/tx-core": "*",
+    "@jamesaphoenix/tx-types": "*"
   },
   "peerDependencies": {
-    "better-sqlite3": "^11.0.0",
     "effect": "^3.0.0"
   },
-  "peerDependenciesMeta": {
-    "better-sqlite3": {
-      "optional": false
-    }
-  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/jamesaphoenix/tx.git"
+    "url": "https://github.com/jamesaphoenix/tx.git",
+    "directory": "packages/tx"
   },
   "keywords": [
     "task-management",