@jamesaphoenix/tx 0.1.0 → 0.3.0

package/dist/create-tx.d.ts

@@ -0,0 +1,147 @@
+/**
+ * createTx - Factory function to create a configured tx client
+ *
+ * This module provides the main entry point for SDK consumers who want
+ * to customize tx behavior, such as providing a custom retriever.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createTx } from "@jamesaphoenix/tx";
+ *
+ * const tx = createTx();
+ * const ready = await tx.run(tasks.getReady({ limit: 5 }));
+ * ```
+ *
+ * @example Custom retriever
+ * ```typescript
+ * import { createTx, RetrieverService } from "@jamesaphoenix/tx";
+ * import { Effect, Layer } from "effect";
+ *
+ * const myRetriever = Layer.succeed(RetrieverService, {
+ *   search: (query, options) => Effect.gen(function* () {
+ *     return yield* pineconeQuery(query);
+ *   }),
+ *   isAvailable: () => Effect.succeed(true)
+ * });
+ *
+ * const tx = createTx({ retriever: myRetriever });
+ * ```
+ */
+import { Effect, Exit, Layer } from "effect";
+import { RetrieverService } from "@tx/core";
+/**
+ * Options for configuring createTx().
+ *
+ * All options are optional - defaults provide a fully functional tx instance.
+ */
+export interface CreateTxOptions {
+    /**
+     * Path to SQLite database file.
+     * @default ".tx/tasks.db"
+     */
+    readonly dbPath?: string;
+    /**
+     * Custom retriever layer to use instead of the default BM25+vector hybrid.
+     *
+     * When provided, this layer replaces RetrieverServiceLive entirely.
+     * The layer must satisfy the RetrieverService interface.
+     *
+     * @example Pinecone retriever
+     * ```typescript
+     * const myRetriever = Layer.succeed(RetrieverService, {
+     *   search: (query, options) => Effect.gen(function* () {
+     *     const results = yield* pineconeQuery(query);
+     *     return results.map(toLearningWithScore);
+     *   }),
+     *   isAvailable: () => Effect.succeed(true)
+     * });
+     *
+     * const tx = createTx({ retriever: myRetriever });
+     * ```
+     */
+    readonly retriever?: Layer.Layer<RetrieverService>;
+}
+/**
+ * The tx client returned by createTx().
+ *
+ * Provides methods to run Effects against the configured layer
+ * and access commonly-used services directly.
+ */
+export interface TxClient {
+    /**
+     * Run an Effect against the configured tx layer.
+     *
+     * @example
+     * ```typescript
+     * const ready = await tx.run(
+     *   Effect.gen(function* () {
+     *     const tasks = yield* TaskService;
+     *     return yield* tasks.getReady({ limit: 5 });
+     *   })
+     * );
+     * ```
+     */
+    readonly run: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A>;
+    /**
+     * Run an Effect and return an Exit (success or failure).
+     * Useful when you need to handle errors programmatically.
+     */
+    readonly runExit: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<Exit.Exit<A, unknown>>;
+    /**
+     * The composed Layer for advanced use cases.
+     * Can be used with Effect.provide() directly.
+     */
+    readonly layer: Layer.Layer<any, any, any>;
+    /**
+     * Clean up resources (close database, etc.).
+     * Call this when done using the client.
+     */
+    readonly close: () => Promise<void>;
+}
+/**
+ * Create a tx client with optional configuration.
+ *
+ * This is the main entry point for SDK consumers who want to:
+ * - Use a custom database path
+ * - Provide a custom retriever (Pinecone, Weaviate, etc.)
+ *
+ * @param options - Configuration options (all optional)
+ * @returns A TxClient for running Effects against the configured layer
+ *
+ * @example Basic usage (defaults)
+ * ```typescript
+ * const tx = createTx();
+ *
+ * const ready = await tx.run(
+ *   Effect.gen(function* () {
+ *     const tasks = yield* TaskService;
+ *     return yield* tasks.getReady({ limit: 5 });
+ *   })
+ * );
+ *
+ * await tx.close();
+ * ```
+ *
+ * @example Custom retriever
+ * ```typescript
+ * import { createTx, RetrieverService } from "@jamesaphoenix/tx";
+ * import { Effect, Layer } from "effect";
+ *
+ * const pineconeRetriever = Layer.succeed(RetrieverService, {
+ *   search: (query, options) => Effect.gen(function* () {
+ *     // Your Pinecone/Weaviate/Chroma implementation
+ *     const results = yield* queryExternalVectorDB(query, options);
+ *     return results;
+ *   }),
+ *   isAvailable: () => Effect.succeed(true)
+ * });
+ *
+ * const tx = createTx({
+ *   dbPath: "./my-app/.tx/tasks.db",
+ *   retriever: pineconeRetriever
+ * });
+ * ```
+ */
+export declare const createTx: (options?: CreateTxOptions) => TxClient;
+export { RetrieverService } from "@tx/core";
+//# sourceMappingURL=create-tx.d.ts.map

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

@@ -0,0 +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"}

package/dist/create-tx.js

@@ -0,0 +1,102 @@
+/**
+ * createTx - Factory function to create a configured tx client
+ *
+ * This module provides the main entry point for SDK consumers who want
+ * to customize tx behavior, such as providing a custom retriever.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createTx } from "@jamesaphoenix/tx";
+ *
+ * const tx = createTx();
+ * const ready = await tx.run(tasks.getReady({ limit: 5 }));
+ * ```
+ *
+ * @example Custom retriever
+ * ```typescript
+ * import { createTx, RetrieverService } from "@jamesaphoenix/tx";
+ * import { Effect, Layer } from "effect";
+ *
+ * const myRetriever = Layer.succeed(RetrieverService, {
+ *   search: (query, options) => Effect.gen(function* () {
+ *     return yield* pineconeQuery(query);
+ *   }),
+ *   isAvailable: () => Effect.succeed(true)
+ * });
+ *
+ * const tx = createTx({ retriever: myRetriever });
+ * ```
+ */
+import { Layer, ManagedRuntime } from "effect";
+import { makeAppLayer } from "@tx/core";
+/**
+ * Create a tx client with optional configuration.
+ *
+ * This is the main entry point for SDK consumers who want to:
+ * - Use a custom database path
+ * - Provide a custom retriever (Pinecone, Weaviate, etc.)
+ *
+ * @param options - Configuration options (all optional)
+ * @returns A TxClient for running Effects against the configured layer
+ *
+ * @example Basic usage (defaults)
+ * ```typescript
+ * const tx = createTx();
+ *
+ * const ready = await tx.run(
+ *   Effect.gen(function* () {
+ *     const tasks = yield* TaskService;
+ *     return yield* tasks.getReady({ limit: 5 });
+ *   })
+ * );
+ *
+ * await tx.close();
+ * ```
+ *
+ * @example Custom retriever
+ * ```typescript
+ * import { createTx, RetrieverService } from "@jamesaphoenix/tx";
+ * import { Effect, Layer } from "effect";
+ *
+ * const pineconeRetriever = Layer.succeed(RetrieverService, {
+ *   search: (query, options) => Effect.gen(function* () {
+ *     // Your Pinecone/Weaviate/Chroma implementation
+ *     const results = yield* queryExternalVectorDB(query, options);
+ *     return results;
+ *   }),
+ *   isAvailable: () => Effect.succeed(true)
+ * });
+ *
+ * const tx = createTx({
+ *   dbPath: "./my-app/.tx/tasks.db",
+ *   retriever: pineconeRetriever
+ * });
+ * ```
+ */
+export const createTx = (options = {}) => {
+    const { dbPath = ".tx/tasks.db", retriever } = options;
+    // Build the base app layer
+    const baseLayer = makeAppLayer(dbPath);
+    // If custom retriever provided, merge it on top to override the default
+    // Layer.provideMerge gives priority to the first layer for overlapping services
+    const appLayer = retriever
+        ? Layer.provideMerge(retriever, baseLayer)
+        : baseLayer;
+    // Create a managed runtime that handles resource lifecycle
+    const managedRuntime = ManagedRuntime.make(appLayer);
+    return {
+        run: async (effect) => {
+            return managedRuntime.runPromise(effect);
+        },
+        runExit: async (effect) => {
+            return managedRuntime.runPromiseExit(effect);
+        },
+        layer: appLayer,
+        close: async () => {
+            await managedRuntime.dispose();
+        }
+    };
+};
+// Re-export RetrieverService for custom retriever implementations
+export { RetrieverService } from "@tx/core";
+//# sourceMappingURL=create-tx.js.map

package/dist/create-tx.js.map

@@ -0,0 +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"}

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @jamesaphoenix/tx - TanStack for AI agents
+ *
+ * Headless primitives for memory, tasks, and orchestration.
+ *
+ * @example
+ * ```typescript
+ * import { TaskService, LearningService, makeAppLayer } from "@jamesaphoenix/tx";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const tasks = yield* TaskService;
+ *   const ready = yield* tasks.getReady({ limit: 5 });
+ *   return ready;
+ * });
+ * ```
+ *
+ * @example Custom Retriever
+ * ```typescript
+ * import { createTx, RetrieverService } from "@jamesaphoenix/tx";
+ * import { Effect, Layer } from "effect";
+ *
+ * // Custom Pinecone retriever
+ * const myRetriever = Layer.succeed(RetrieverService, {
+ *   search: (query, options) => Effect.gen(function* () {
+ *     const results = yield* pineconeQuery(query);
+ *     return results.map(toLearningWithScore);
+ *   }),
+ *   isAvailable: () => Effect.succeed(true)
+ * });
+ *
+ * const tx = createTx({
+ *   retriever: myRetriever  // optional override
+ * });
+ * ```
+ */
+export * from "@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";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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"}

package/dist/index.js

@@ -1,17 +1,43 @@
-// Public API for programmatic use
-export * from "./schema.js";
-export * from "./errors.js";
-export * from "./layer.js";
-// Services
-export { TaskService, TaskServiceLive } from "./services/task-service.js";
-export { DependencyService, DependencyServiceLive } from "./services/dep-service.js";
-export { ReadyService, ReadyServiceLive } from "./services/ready-service.js";
-export { HierarchyService, HierarchyServiceLive } from "./services/hierarchy-service.js";
-export { ScoreService, ScoreServiceLive } from "./services/score-service.js";
-export { SyncService, SyncServiceLive } from "./services/sync-service.js";
-// Repositories (for advanced use)
-export { TaskRepository, TaskRepositoryLive } from "./repo/task-repo.js";
-export { DependencyRepository, DependencyRepositoryLive } from "./repo/dep-repo.js";
-// Database
-export { SqliteClient, SqliteClientLive } from "./db.js";
+/**
+ * @jamesaphoenix/tx - TanStack for AI agents
+ *
+ * Headless primitives for memory, tasks, and orchestration.
+ *
+ * @example
+ * ```typescript
+ * import { TaskService, LearningService, makeAppLayer } from "@jamesaphoenix/tx";
+ * import { Effect } from "effect";
+ *
+ * const program = Effect.gen(function* () {
+ *   const tasks = yield* TaskService;
+ *   const ready = yield* tasks.getReady({ limit: 5 });
+ *   return ready;
+ * });
+ * ```
+ *
+ * @example Custom Retriever
+ * ```typescript
+ * import { createTx, RetrieverService } from "@jamesaphoenix/tx";
+ * import { Effect, Layer } from "effect";
+ *
+ * // Custom Pinecone retriever
+ * const myRetriever = Layer.succeed(RetrieverService, {
+ *   search: (query, options) => Effect.gen(function* () {
+ *     const results = yield* pineconeQuery(query);
+ *     return results.map(toLearningWithScore);
+ *   }),
+ *   isAvailable: () => Effect.succeed(true)
+ * });
+ *
+ * const tx = createTx({
+ *   retriever: myRetriever  // optional override
+ * });
+ * ```
+ */
+// Re-export everything from @tx/core
+export * from "@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";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAE1B,WAAW;AACX,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AACzE,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACpF,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAC5E,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAA;AACxF,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAC5E,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAA;AAEzE,kCAAkC;AAClC,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACxE,OAAO,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAA;AAEnF,WAAW;AACX,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA"}
+{"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"}

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Type-only exports for @jamesaphoenix/tx
+ *
+ * Use this for type-only imports when you don't need runtime code.
+ *
+ * @example
+ * ```typescript
+ * import type { Task, Learning } from "@jamesaphoenix/tx/types";
+ * ```
+ */
+export * from "@tx/types";
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

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

package/dist/types.js

@@ -0,0 +1,12 @@
+/**
+ * Type-only exports for @jamesaphoenix/tx
+ *
+ * Use this for type-only imports when you don't need runtime code.
+ *
+ * @example
+ * ```typescript
+ * import type { Task, Learning } from "@jamesaphoenix/tx/types";
+ * ```
+ */
+export * from "@tx/types";
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

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

package/package.json

@@ -1,16 +1,41 @@
 {
   "name": "@jamesaphoenix/tx",
-  "version": "0.1.0",
-  "description": "A lean task management system for AI agents and humans",
+  "version": "0.3.0",
+  "description": "TanStack for AI agents - headless primitives for memory, tasks, and orchestration",
   "type": "module",
-  "bin": {
-    "tx": "./dist/cli.js"
-  },
   "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    }
+  },
   "files": [
-    "dist",
-    "migrations"
+    "dist"
   ],
+  "scripts": {
+    "build": "tsc -b",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@tx/core": "*",
+    "@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"
@@ -18,35 +43,10 @@
   "keywords": [
     "task-management",
     "ai-agents",
-    "cli",
     "effect-ts",
-    "mcp"
+    "mcp",
+    "orchestration"
   ],
   "author": "James Phoenix",
-  "license": "MIT",
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsx src/cli.ts",
-    "test": "vitest --run",
-    "test:watch": "vitest",
-    "validate": "npm run build && npm test && npm link"
-  },
-  "dependencies": {
-    "@effect/cli": "^0.73.1",
-    "@effect/platform": "^0.94.2",
-    "@effect/platform-node": "^0.104.1",
-    "@modelcontextprotocol/sdk": "^1.25.3",
-    "better-sqlite3": "^11.7.0",
-    "effect": "^3.19.15"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.12",
-    "@types/node": "^22.10.0",
-    "tsx": "^4.19.0",
-    "typescript": "^5.7.0",
-    "vitest": "^3.0.0"
-  },
-  "engines": {
-    "node": ">=20"
-  }
+  "license": "MIT"
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 James Phoenix
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,125 +0,0 @@
-# tx
-
-A lean task management system for AI agents and humans, built with Effect-TS.
-
-## Why
-
-AI coding agents lose context across sessions. Markdown plans go stale, git issue trackers are designed for humans, and session-scoped todo lists vanish when the conversation ends.
-
-**tx** gives agents a persistent, queryable, dependency-aware task store that works across sessions and can be programmatically manipulated through CLI, MCP, or TypeScript API.
-
-## Core Ideas
-
-- **Persistent** -- Tasks survive across agent sessions and machine restarts via SQLite
-- **Fast** -- Sub-100ms queries for common operations (list, ready, get)
-- **Dependency-aware** -- Explicit blocking relationships so agents never work on blocked tasks
-- **Ready detection** -- `tx ready` returns the highest-priority unblocked tasks, sorted by score
-- **Hierarchical** -- Flexible N-level nesting (epics, milestones, tasks, subtasks)
-- **Multi-interface** -- CLI for humans, MCP server for Claude Code, TypeScript API for custom agents
-- **Minimal** -- Single dependency (SQLite), no external services required for core features
-- **LLM-optional** -- Core commands work without an API key; LLM features (dedupe, compact, reprioritize) use Claude when available
-
-## How It Works
-
-```
-tx add "Implement authentication" --score 800
-tx add "Design auth schema" --parent tx-a1b2c3
-tx block tx-d4e5f6 tx-a1b2c3
-tx ready                          # returns highest-priority unblocked tasks
-tx done tx-a1b2c3                 # completes task, unblocks dependents
-```
-
-Agents query `tx ready` to pick up work, create subtasks as they decompose problems, and mark tasks done to unblock the next piece of work. Humans review, reprioritize, and add context.
-
-## Architecture
-
-```
-CLI / MCP Server / TypeScript API
-         |
-    Service Layer (Effect-TS)
-    TaskService, ReadyService, ScoreService, HierarchyService
-         |
-    Repository Layer
-    TaskRepository, DependencyRepository
-         |
-    SQLite (better-sqlite3, WAL mode)
-```
-
-All business logic uses Effect-TS for typed errors, service composition, and layer-based dependency injection. Two layer configurations:
-
-- **AppMinimalLive** -- No LLM, used by CLI core commands, MCP server, Agent SDK
-- **AppLive** -- Includes LLM, used by dedupe/compact/reprioritize
-
-## Status Lifecycle
-
-```
-backlog -> ready -> planning -> active -> blocked -> review -> human_needs_to_review -> done
-```
-
-A task is **ready** when its status is workable and all blockers have status `done`.
-
-## Interfaces
-
-| Interface | Consumer | Protocol |
-|-----------|----------|----------|
-| CLI (`tx`) | Humans, scripts | stdin/stdout (text or JSON) |
-| MCP Server | Claude Code | JSON-RPC over stdio |
-| TypeScript API | Custom agents | Effect types |
-| Agent SDK | Anthropic SDK | Tool definitions |
-
-## LLM Features (optional)
-
-These commands require `ANTHROPIC_API_KEY`:
-
-- **`tx dedupe`** -- Find and merge semantically duplicate tasks
-- **`tx compact`** -- Summarize completed tasks, extract learnings, export to CLAUDE.md
-- **`tx reprioritize`** -- LLM recalculates scores based on context
-
-## RALPH Loop — Autonomous Development
-
-tx uses an adapted [RALPH loop](https://ghuntley.com/ralph) for autonomous development. Fresh agent instances are spawned per task — memory persists through files (CLAUDE.md, git, `.tx/tasks.db`), not conversation history.
-
-```bash
-./scripts/ralph.sh           # Run until all tasks done
-./scripts/ralph.sh --max 10  # Run at most 10 iterations
-```
-
-The orchestrator picks the highest-priority task from `tx ready`, dispatches it to a specialized agent, and loops until all work is complete.
-
-### Specialized Agents
-
-Agents are defined as markdown files in `.claude/agents/`:
-
-| Agent | Role |
-|-------|------|
-| `tx-planner` | Research codebase, create implementation plan, decompose into subtasks |
-| `tx-implementer` | Write Effect-TS code for a single task, following doctrine |
-| `tx-reviewer` | Review code changes against all 7 doctrine rules |
-| `tx-tester` | Write integration tests with SHA256 deterministic fixtures |
-| `tx-decomposer` | Break large tasks into atomic subtasks for single iterations |
-
-Agents can also be used programmatically via the [Claude Agent SDK](https://docs.anthropic.com/en/docs/agent-sdk).
-
-## Project Structure
-
-```
-tx/
-├── CLAUDE.md              # Doctrine, PRDs, design docs
-├── .claude/
-│   └── agents/            # Specialized agent definitions
-│       ├── tx-planner.md
-│       ├── tx-implementer.md
-│       ├── tx-reviewer.md
-│       ├── tx-tester.md
-│       └── tx-decomposer.md
-├── scripts/
-│   └── ralph.sh           # RALPH loop orchestrator
-├── docs/
-│   ├── prd/               # Product Requirements Documents
-│   └── design/            # Design Documents
-└── src/                   # Implementation
-```
-
-## License
-
-MIT