@abloatai/ablo 0.9.1 → 0.9.2

package/AGENTS.md

@@ -0,0 +1,84 @@
+# AGENTS.md
+
+Ablo lets AI agents and humans safely edit the same typed data without clobbering each other. When two of them touch the same row, a "claim" makes one wait for the other instead of overwriting it. This file shows a coding assistant the one safe pattern: read a row, claim it, then write.
+
+Claims don't lock. If another writer holds the row, `claim` waits for them and re-reads the fresh row before handing it to you — so two writers serialize instead of clobbering.
+
+## Start here — scaffold with `ablo init`
+
+Don't hand-write the integration. Run the CLI; it generates the current-API schema, client, Data Source endpoint, and (for Next.js) the browser provider + session route:
+
+- **Scaffold:** `npx ablo init --yes` — flag-driven, never prompts. Override defaults with `--framework <nextjs|vite|remix|vanilla>`, `--auth <apikey|…>`, `--storage <datasource|managed>`, `--no-agent`, `--no-pull`, `--no-install`, `--no-login`. (Plain `ablo init` needs a TTY and will **HANG** in an agent/CI run — always pass `--yes`.)
+- **Auth:** set `ABLO_API_KEY` in the environment. Do **NOT** run `ablo login` — it opens a browser device flow and blocks an agent.
+- **Provision your DB (Data Source mode):** `npx ablo migrate` creates the tables for your Ablo models plus the adapter's bookkeeping tables (`ablo_outbox`, `ablo_idempotency`). It does **not** touch your other tables — keep your own migrations (drizzle-kit / prisma migrate) for auth and anything not in the Ablo schema.
+- **Adopt an existing DB schema:** `npx ablo pull prisma [path]` / `pull drizzle <module>` (lossless) or `pull` (live DB, lossy). Writes `ablo/schema.ts`.
+- **Push your schema — REQUIRED before any write works.** The server keeps its OWN copy of the schema. After you create or edit `ablo/schema.ts`, run `npx ablo push` (one-shot) — or `npx ablo dev --no-watch`. **Skip this and every write to a new or changed model fails with `server_execute_unknown_model`.** (Plain `ablo dev` watches forever — never run it bare in an agent.)
+- **Other long-running:** `npx ablo logs --no-follow` (default tails forever). `npx ablo mode test|live` ALWAYS pass the argument. `status`, `push`, `pull`, `check`, `generate` are one-shot — safe as-is.
+
+The generated `ablo/data-source.ts` is the whole Data Source endpoint and needs no hand-editing: `dataSourceNext({ schema, apiKey, adapter: prismaDataSource(prisma, schema) })` (or `drizzleDataSource(db, schema)`). The adapter owns commit / idempotency / outbox.
+
+## Rule
+
+Edit the generated files; teach this API only:
+
+```ts
+const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY });
+```
+
+The schema is the integration contract — it drives typed model clients, React selectors, server and agent writes, the Data Source shape, and schema push. Ablo owns only the models you declare; your auth and other non-synced tables stay in your own ORM schema, side by side in the same database. Don't create a parallel string-keyed write path for rows that belong to a schema model.
+
+Every model verb takes ONE options object. The common loop:
+
+1. **Read** the row — `await ablo.<model>.retrieve({ id })` (async; from the server) or `await ablo.<model>.list({ where })` for many. In React render, read synchronously with `useAblo((a) => a.<model>.get(id))`.
+2. **See who's active** (optional) — `ablo.<model>.claim.state({ id })` (synchronous; never blocks).
+3. **Claim** the row before changing it — `await using claim = await ablo.<model>.claim({ id, action?, ttl? })`. If someone else holds it, this waits for them, then gives you the fresh row on `claim.data`. The claim auto-releases when it goes out of scope (`await using`).
+4. **Write** — `await ablo.<model>.update({ id: claim.data.id, data })`. Because you hold the claim, the write is rejected if the row changed underneath you.
+
+Keep coding assistants on this schema-backed path.
+
+## Minimal example
+
+```ts
+import Ablo from '@abloatai/ablo';
+import { defineSchema, model, z } from '@abloatai/ablo/schema';
+
+const schema = defineSchema({
+  weatherReports: model({
+    location: z.string(),
+    status: z.enum(['pending', 'ready']),
+    forecast: z.string().optional(),
+  }),
+});
+
+const ablo = Ablo({ schema, apiKey: process.env.ABLO_API_KEY });
+
+const report = await ablo.weatherReports.retrieve({ id: 'report_stockholm' });
+if (!report) throw new Error('Report not found');
+
+// If someone else holds the row, claim waits for them and re-reads the fresh
+// row before resolving. Auto-released at the end of this scope (`await using`).
+await using claim = await ablo.weatherReports.claim({
+  id: 'report_stockholm',
+  action: 'forecasting',
+  ttl: '2m',
+});
+const claimed = claim.data;
+
+// Because we hold the claim, update is rejected if the row changed underneath us.
+await ablo.weatherReports.update({
+  id: claimed.id,
+  data: { status: 'ready', forecast: await getForecast(claimed.location) },
+});
+```
+
+## Coordination surface
+
+Claims live on a callable namespace beside `create` / `update` / `retrieve`. Every member takes an options object:
+
+- `await using claim = await ablo.<model>.claim({ id })` — acquire the row (waits if held); read it via `claim.data`; auto-releases on scope exit (or call `claim.release()`).
+- `ablo.<model>.claim.state({ id })` — who is currently working on the row (synchronous; never blocks).
+- `ablo.<model>.claim.queue({ id })` — who is waiting behind the current holder.
+- `ablo.<model>.claim.release({ id })` — release a claim early.
+- `ablo.<model>.claim.reorder({ id, order })` — reorder the waiting queue.
+
+Most users declare a schema and write through `ablo.<model>.update({ id, data })`.

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 0.9.2
+
+### Patch Changes
+
+- Developer-onboarding overhaul so an LLM or a person gets a working integration on the first try.
+  - **`ablo init` scaffolds a project that builds and is current-API.** The Next.js scaffold now ships `app/providers.tsx` + an `app/api/ablo-session` route, uses `useAblo` (the removed `withSync` is gone), object-param verbs, and never bundles your `sk_` key into the browser. The webhook receiver moved off the `[...all]` catch-all.
+  - **Agent docs are accurate and ship.** `AGENTS.md`, `llms.txt`, and `llms-full.txt` are on the 0.9.x API (object-param `create`/`update`/`delete`/`retrieve`, disposable `await using claim`, `AbloProvider client` prop), lead with `ablo init`, and `AGENTS.md` now ships in the package.
+  - **`ablo push` is self-documenting.** Writing to a model the server hasn't seen now fails with an error that tells you to run `ablo push` (the `server_execute_unknown_model` / `unknown_model` messages), instead of a cryptic "unknown model."
+  - **`intents` is deprecated in favor of `claim`** everywhere the docs and the MCP scaffold/prompts teach or generate coordination; the public `ablo.intents` accessor is marked `@internal`.
+  - Docs say Node 24+, and the `drizzle-orm` peer floor is `>=0.44`.
+
+- a88747a: Remove the `turn` primitive and the agent-work `tasks` resource from the client surface — the SDK is now purely `ablo.<model>` + `claim`.
+
+  **Breaking**
+  - `engine.beginTurn()`, the `Turn` handle interface, and the `Ablo.Turn` type are removed. `AbloApi.beginTurn` and the HTTP client's `beginTurn` are gone too.
+  - `CommitCreateOptions.causedByTaskId` is removed. (Lineage is no longer stamped from the client.)
+  - The engine no longer exposes a `protocol` accessor or a public `tasks` work-unit resource. `ablo.tasks` is, and always was, the schema `tasks` model proxy.
+  - The **`agent().run()` helper and the low-level agent/task type family are removed**: `AbloApi.agent(id, options)` and `AbloApi.tasks` (the `TaskResource`), plus the exported types `Agent`, `AgentOptions`, `AgentRunOptions`, `AgentRunResult`/`Done`/`Failed`/`Cancelled`, `AgentRunStatus`, `AgentRunContext`, `AgentModelClient`, `AgentModelReadOptions`, `AgentModelMutationOptions`, `AgentIntentOptions`, `AgentIntentInput`, `Task`, `TaskResource`, `TaskCreateOptions`, `TaskCloseOptions`, `TaskCloseResult` (and the `Ablo.*` namespace aliases for all of them). The `Ablo.Auth.Agent` principal constructor and the schema-backed `tasks` model are unaffected.
+
+  **Why**
+
+  `turn`/`agent_tasks` was a second coordination-and-attribution mechanism living alongside `claim`. It is redundant on the client:
+  - `claim` already serializes writers **and** carries the causal link — its `intent` id rides on every guarded write.
+  - The server stamps `actor` / `onBehalfOf` / `capabilityId` onto each delta from the auth context.
+  - Per-run token/cost is recorded in Langfuse, not the `agent_tasks` table.
+
+  So the only thing the client lost is the audit pane's "show everything this exact prompt produced" filter, which keyed off `caused_by_task_id`; new writes leave that column null.
+
+  **Migration**
+
+  Agents stop opening/closing tasks — just issue `ablo.<model>` writes (schema-backed) or `ablo.commits.create(...)` (schema-less) under a `claim`. Replace `Ablo({ apiKey }).agent(id, opts).run(prompt, handler)` with: mint a scoped credential via `sessions.create({ agent })`, then `claim` the row and `update` / `commits.create`.
+
+  The **server** `agent_tasks` table, the `caused_by_task_id` delta column, the `/api/sync/commit` wire field, and the `agent_actions_log` compliance hash-chain remain in place but **dormant** (client writes leave the field null) — they are load-bearing for the tamper-evident audit chain and historical-row audit JOINs, so they are intentionally NOT dropped. The dead `/v1/tasks` + `/api/agent/turn` route handlers ARE removed (zero live callers).
+
 ## 0.9.1
 
 ### Patch Changes

package/README.md

@@ -3,7 +3,7 @@
 [![npm](https://img.shields.io/npm/v/@abloatai/ablo.svg)](https://www.npmjs.com/package/@abloatai/ablo)
 [![license](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](./LICENSE)
 [![types](https://img.shields.io/badge/types-included-blue.svg)](#)
-[![runtime](https://img.shields.io/badge/node-%E2%89%A522-brightgreen.svg)](#keys--runtime)
+[![runtime](https://img.shields.io/badge/node-%E2%89%A524-brightgreen.svg)](#keys--runtime)
 
 **Let people and AI agents work on the same data without overwriting each other.**
 
@@ -46,7 +46,7 @@ anywhere people and agents change shared state and everyone has to see it live.
 npm install @abloatai/ablo
 ```
 
-**Keys & runtime.** Ablo needs Node 22+ and TypeScript 5+. Grab an `sk_test_*`
+**Keys & runtime.** Ablo needs Node 24+ and TypeScript 5+. Grab an `sk_test_*`
 key for a sandbox
 (`export ABLO_API_KEY=sk_test_...`); keep keys in trusted server runtimes only.
 In the browser, `<AbloProvider>` authenticates with the signed-in user's
@@ -218,12 +218,16 @@ provider and read with hooks, from `@abloatai/ablo/react`. Wrap your tree once;
 everything inside is live.
 
 ```tsx
+import Ablo from '@abloatai/ablo';
 import { AbloProvider, useAblo } from '@abloatai/ablo/react';
 import { schema } from './ablo/schema';
 
+// Build the client once — it authenticates via your session route, no key in the browser.
+const ablo = Ablo({ schema, authEndpoint: '/api/ablo-session' });
+
 function App() {
   return (
-    <AbloProvider schema={schema}>
+    <AbloProvider client={ablo}>
       <Report id="report_stockholm" />
     </AbloProvider>
   );
@@ -250,8 +254,9 @@ method as the server example above.
 `<AbloProvider>` owns the connection — no API key in the browser. That's the
 whole loop: read with `useAblo(selector)`, write with `ablo.<model>`, and every
 other client (human or agent) on that row sees it in real time. See
-[React](./docs/react.md) for the full `<AbloProvider>` prop surface (`userId`,
-`teamIds`, `syncGroups`, `fallback`, `bootstrapMode`) and status hooks.
+[React](./docs/react.md) for the `<AbloProvider>` prop surface (`client`,
+`userId`, `fallback`, `onError`) — schema, scope, and team membership live on the
+`Ablo({ … })` client you pass it — plus status hooks.
 
 ## Identity & Sync Groups
 
@@ -270,7 +275,10 @@ to sync-group strings.
 `userId` / `teamIds` come from your auth, resolved server-side:
 
 ```tsx
-<AbloProvider schema={schema} userId={user.id} teamIds={user.teamIds}>
+// team membership is asserted server-side when the session route mints the token.
+const ablo = Ablo({ schema, authEndpoint: '/api/ablo-session' });
+
+<AbloProvider client={ablo} userId={user.id}>
   <App />
 </AbloProvider>
 ```

package/dist/BaseSyncedStore.js

@@ -421,8 +421,12 @@ export class BaseSyncedStore {
      * emit here, so undo is naturally local-only (you can't undo a teammate).
      */
     subscribeLocalMutations(handler) {
-        return this.syncClient.subscribe('transaction:created', (data) => {
-            const tx = data;
+        // Tap the TransactionQueue directly via `onLocalTransaction`. The previous
+        // `syncClient.subscribe('transaction:created', …)` route registered the
+        // handler on SyncClient's OWN emitter, which never fires that event (only
+        // the queue's emitter does) — so undo recorded nothing. See
+        // `SyncClient.onLocalTransaction` for the full rationale.
+        return this.syncClient.onLocalTransaction((tx) => {
             if (!tx || !tx.type || !tx.modelName || !tx.modelId)
                 return;
             handler({

package/dist/SyncClient.d.ts

@@ -383,6 +383,18 @@ export declare class SyncClient extends EventEmitter {
         error: Error;
         permanent?: boolean;
     }) => void): () => void;
+    /**
+     * Subscribe to LOCAL transaction creation with the full {@link Transaction}
+     * payload (`type`, `modelName`, `modelId`, `data`, `previousData`). This is
+     * the feed `BaseSyncedStore.subscribeLocalMutations` taps for undo recording.
+     *
+     * MUST subscribe to the TransactionQueue's emitter directly — that is the
+     * ONLY emitter that fires `transaction:created`. SyncClient's own emitter
+     * (reached via `subscribe()`) never re-broadcasts it, so routing undo through
+     * `subscribe('transaction:created')` silently records nothing. Mirrors
+     * `onMutationFailure`, which taps the queue for the same reason.
+     */
+    onLocalTransaction(listener: (tx: import('./transactions/TransactionQueue.js').Transaction) => void): () => void;
     /**
      * Wait for the latest in-flight transaction for (modelName, modelId)
      * to be confirmed by the server, or reject if it's rolled back.

package/dist/SyncClient.js

@@ -1298,6 +1298,21 @@ export class SyncClient extends EventEmitter {
         this.transactionQueue.on('transaction:failed', listener);
         return () => this.transactionQueue.off('transaction:failed', listener);
     }
+    /**
+     * Subscribe to LOCAL transaction creation with the full {@link Transaction}
+     * payload (`type`, `modelName`, `modelId`, `data`, `previousData`). This is
+     * the feed `BaseSyncedStore.subscribeLocalMutations` taps for undo recording.
+     *
+     * MUST subscribe to the TransactionQueue's emitter directly — that is the
+     * ONLY emitter that fires `transaction:created`. SyncClient's own emitter
+     * (reached via `subscribe()`) never re-broadcasts it, so routing undo through
+     * `subscribe('transaction:created')` silently records nothing. Mirrors
+     * `onMutationFailure`, which taps the queue for the same reason.
+     */
+    onLocalTransaction(listener) {
+        this.transactionQueue.on('transaction:created', listener);
+        return () => this.transactionQueue.off('transaction:created', listener);
+    }
     /**
      * Wait for the latest in-flight transaction for (modelName, modelId)
      * to be confirmed by the server, or reject if it's rolled back.

package/dist/agent/index.js

@@ -122,7 +122,7 @@
 //   const ctx:  Agent.Context = { perception };
 //   const s:    Agent.SessionOptions = { ... };
 //
-// Everything else (Activity, Claim, Turn, Peer, ActiveIntent, ...)
+// Everything else (Activity, Claim, Peer, ActiveIntent, ...)
 // lives on the `Ablo.*` namespace via
 // `import type { Ablo } from '@abloatai/ablo'`.
 export { Agent } from './Agent.js';

package/dist/api/index.d.ts

@@ -4,7 +4,7 @@
  * Use this build for serverless functions, scripts, and backends that want
  * model reads/writes and commits over HTTP without the realtime sync runtime.
  */
-export { createProtocolClient, createProtocolClient as Ablo, type AbloApi, type AbloApiClientOptions, type AbloApiIntents, type Agent, type AgentIntentInput, type AgentIntentOptions, type AgentOptions, type AgentModelClient, type AgentModelReadOptions, type AgentModelMutationOptions, type AgentRunContext, type AgentRunDone, type AgentRunFailed, type AgentRunCancelled, type AgentRunOptions, type AgentRunResult, type AgentRunStatus, type Capability, type CapabilityCreateOptions, type CapabilityParticipantKind, type CapabilityRecord, type CapabilityResource, type CapabilityRevocation, type CapabilityScope, type Task, type TaskCloseOptions, type TaskCloseResult, type TaskCreateOptions, type TaskResource, } from '../client/ApiClient.js';
+export { createProtocolClient, createProtocolClient as Ablo, type AbloApi, type AbloApiClientOptions, type AbloApiIntents, type Capability, type CapabilityCreateOptions, type CapabilityParticipantKind, type CapabilityRecord, type CapabilityResource, type CapabilityRevocation, type CapabilityScope, } from '../client/ApiClient.js';
 export type { CommitCreateOptions, CommitOperationInput, CommitReceipt, CommitWait, IntentCreateOptions, IntentHandle, IntentWaitOptions, ClaimedOptions, IfClaimedPolicy, ModelClient, ModelClaim, ModelMutationOptions, ModelReadOptions, ModelRead, ModelTarget, } from '../client/Ablo.js';
 import { createProtocolClient } from '../client/ApiClient.js';
 export default createProtocolClient;

package/dist/client/Ablo.d.ts

@@ -28,22 +28,6 @@ import type { IntentStream, IntentWaitOptions, PresenceStream, Snapshot } from '
 import type { ParticipantManager } from '../sync/participants.js';
 import type { ActiveIntent, Duration, Intent, TargetRange } from '../types/streams.js';
 import { type AbloApi, type AbloApiClientOptions, type AbloApiIntents } from './ApiClient.js';
-/**
- * Handle returned by `engine.beginTurn()`. While alive, every commit
- * automatically carries this turn's id on the wire. Call `close(stats?)`
- * when the turn finishes, or `dispose()` to abandon without recording
- * usage. Idempotent.
- */
-export interface Turn {
-    readonly turnId: string;
-    close(stats?: {
-        readonly costInputTokens?: number;
-        readonly costOutputTokens?: number;
-        readonly costComputeMs?: number;
-    }): Promise<void>;
-    dispose(): void;
-    [Symbol.asyncDispose](): Promise<void>;
-}
 /**
  * Async function that resolves an apiKey at request time. Use for
  * credential rotation — rotate from a vault, refresh from session
@@ -809,10 +793,13 @@ export type Ablo<S extends SchemaRecord> = {
      */
     readonly presence: PresenceStream;
     /**
-     * Cooperative-mutex layer over presence — announce "I'm about to do
-     * X on Y" so peers can yield before colliding. Server enforces the
-     * mutex; rejected announcements surface via `intents.onRejected(...)`.
-     * Same socket as entity sync, no second connection.
+     * @internal — the public coordination API is `ablo.<model>.claim`. This
+     * accessor is the internal stream `claim` is built on; it is NOT part of the
+     * supported public surface and will be moved off the public type (it currently
+     * stays only because internal SDK modules are still typed against it).
+     *
+     * Cooperative-mutex layer over presence — announce "I'm about to do X on Y" so
+     * peers can yield before colliding. Same socket as entity sync.
      */
     readonly intents: IntentResource;
     /**
@@ -861,18 +848,6 @@ export type Ablo<S extends SchemaRecord> = {
     snapshot<ModelName extends keyof S & string>(entities: {
         readonly [M in ModelName]: string | readonly string[];
     }): Snapshot<Schema<S>, ModelName>;
-    /**
-     * Open a turn — every commit issued while the returned handle is
-     * alive carries `caused_by_task_id` on the wire so the server
-     * stamps it onto each delta. Powers `agent_tasks` audit trails.
-     * Server: `POST /api/agent/turn` with the capability bearer.
-     */
-    beginTurn(options: {
-        readonly prompt: string;
-        readonly parentTaskId?: string;
-        readonly surface?: string;
-        readonly metadata?: Record<string, unknown>;
-    }): Promise<Turn>;
     /**
      * The internal BaseSyncedStore. Implements SyncStoreContract — pass to
      * SyncContext.Provider so the SDK's useModel/useModels/useMutations hooks
@@ -973,17 +948,6 @@ export declare namespace Ablo {
     type Options<S extends SchemaRecord = SchemaRecord> = AbloOptions<S>;
     type Api = AbloApi;
     type ApiIntents = AbloApiIntents;
-    type Agent = import('./ApiClient.js').Agent;
-    type AgentOptions = import('./ApiClient.js').AgentOptions;
-    type AgentRunOptions = import('./ApiClient.js').AgentRunOptions;
-    type AgentRunStatus = import('./ApiClient.js').AgentRunStatus;
-    type AgentRunResult<T> = import('./ApiClient.js').AgentRunResult<T>;
-    type AgentRunContext = import('./ApiClient.js').AgentRunContext;
-    type AgentModelClient<T = Record<string, unknown>> = import('./ApiClient.js').AgentModelClient<T>;
-    type AgentModelReadOptions = import('./ApiClient.js').AgentModelReadOptions;
-    type AgentModelMutationOptions = import('./ApiClient.js').AgentModelMutationOptions;
-    type AgentIntentOptions = import('./ApiClient.js').AgentIntentOptions;
-    type AgentIntentInput = import('./ApiClient.js').AgentIntentInput;
     type Capability = import('./ApiClient.js').Capability;
     type CapabilityCreateOptions = import('./ApiClient.js').CapabilityCreateOptions;
     type CapabilityRecord = import('./ApiClient.js').CapabilityRecord;
@@ -991,11 +955,6 @@ export declare namespace Ablo {
     type CapabilityRevocation = import('./ApiClient.js').CapabilityRevocation;
     type CapabilityRotateOptions = import('./ApiClient.js').CapabilityRotateOptions;
     type RotatedCapability = import('./ApiClient.js').RotatedCapability;
-    type Task = import('./ApiClient.js').Task;
-    type TaskCreateOptions = import('./ApiClient.js').TaskCreateOptions;
-    type TaskCloseOptions = import('./ApiClient.js').TaskCloseOptions;
-    type TaskCloseResult = import('./ApiClient.js').TaskCloseResult;
-    type TaskResource = import('./ApiClient.js').TaskResource;
     type IfClaimedPolicy = import('./Ablo.js').IfClaimedPolicy;
     type ClaimedOptions = import('./Ablo.js').ClaimedOptions;
     type EntityRef = _Streams.EntityRef;
@@ -1011,7 +970,6 @@ export declare namespace Ablo {
     type IntentRejection = _Streams.IntentRejection;
     type IntentLost = _Streams.IntentLost;
     type Snapshot<TSchema extends _SchemaTypes.Schema = _SchemaTypes.Schema, K extends keyof TSchema['models'] = keyof TSchema['models']> = _Streams.Snapshot<TSchema, K>;
-    type Turn = import('./Ablo.js').Turn;
     namespace Auth {
         type Principal = _Streams.Principal;
         type Session = _Streams.SessionRef;

package/dist/client/Ablo.js

@@ -19,7 +19,7 @@
  *   await sync.reports.delete({ id: reportId });
  */
 import { z } from 'zod';
-import { AbloClaimedError, AbloError, AbloAuthenticationError, AbloConnectionError, AbloValidationError, translateHttpError, hasWireCode, toAbloError } from '../errors.js';
+import { AbloClaimedError, AbloError, AbloAuthenticationError, AbloConnectionError, AbloValidationError, translateHttpError, toAbloError } from '../errors.js';
 import { LoadStrategy, PropertyType } from '../types/index.js';
 import { initSyncEngine } from '../context.js';
 import { noopObservability, browserOnlineStatus, defaultSessionErrorDetector, noopAnalytics, } from '../SyncEngineContext.js';
@@ -812,13 +812,6 @@ export function Ablo(options) {
     // becomes null, so the first Ablo's commits start throwing
     // `ws_not_ready` forever (terminal AgentJob writes hang on retry).
     syncClient.getTransactionQueue().setMutationExecutor(executor);
-    // Active turn id, set by `beginTurn(...)`, cleared on close. While
-    // set, every batch commit attaches `causedByTaskId` so server
-    // delta rows get stamped with it. Single-turn-at-a-time per Ablo
-    // — opening a second turn overwrites the active id without closing
-    // the prior. Callers who need parallel turns construct multiple
-    // Ablo instances, matching the SyncAgent semantics.
-    let activeTurnId = null;
     // Presence + intent streams — built eagerly so `engine.presence`
     // and `engine.intents` return the same reference for the engine's
     // lifetime. The transport doesn't exist yet (BaseSyncedStore.initialize
@@ -1363,9 +1356,7 @@ export function Ablo(options) {
             // SyncClient we already hold from createInternalComponents —
             // no need to leak an accessor through BaseSyncedStore.
             const queue = syncClient.getTransactionQueue();
-            queue.enqueueCommit(clientTxId, operations, {
-                causedByTaskId: activeTurnId,
-            });
+            queue.enqueueCommit(clientTxId, operations);
             if (wait === 'queued') {
                 return { id: clientTxId, status: 'queued' };
             }
@@ -1638,99 +1629,6 @@ export function Ablo(options) {
                 entities,
             });
         },
-        // ── Turn handles ────────────────────────────────────────────────
-        //
-        // Open a turn — every commit issued while the returned handle is
-        // alive carries `caused_by_task_id` on the wire so the server
-        // stamps it onto each delta. The product surface this powers:
-        // `agent_tasks` audit trails ("which AI prompt produced this
-        // mutation"), parent/child turn chains, cost accounting per turn.
-        //
-        // POST /api/agent/turn (capability bearer) → returns turnId.
-        // POST /api/agent/turn/:id/close (capability bearer) → records
-        //   final cost stats. Idempotent.
-        async beginTurn(beginOptions) {
-            const baseUrl = url.replace(/\/+$/, '');
-            const turnUrl = `${baseUrl.replace(/^ws/, 'http')}/api/agent/turn`;
-            const headers = authCredentials.withAuthHeaders({ 'Content-Type': 'application/json' });
-            const res = await fetch(turnUrl, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify({
-                    prompt: beginOptions.prompt,
-                    parentTaskId: beginOptions.parentTaskId,
-                    surface: beginOptions.surface,
-                    metadata: beginOptions.metadata,
-                }),
-            });
-            if (!res.ok) {
-                const text = await res.text().catch(() => '');
-                let parsed = text;
-                if (text) {
-                    try {
-                        parsed = JSON.parse(text);
-                    }
-                    catch {
-                        /* keep raw text */
-                    }
-                }
-                // Preserve the server's structured envelope (code/message/doc_url) when
-                // present; fall back to turn_open_failed for a bare/non-Ablo body.
-                throw hasWireCode(parsed)
-                    ? translateHttpError(res.status, parsed, res.headers.get('x-request-id') ?? undefined)
-                    : new AbloError(`beginTurn failed: ${res.status} ${text}`, {
-                        code: 'turn_open_failed',
-                        httpStatus: res.status,
-                    });
-            }
-            const json = (await res.json());
-            const turnId = json.turnId;
-            activeTurnId = turnId;
-            let closed = false;
-            const close = async (stats) => {
-                if (closed)
-                    return;
-                closed = true;
-                if (activeTurnId === turnId)
-                    activeTurnId = null;
-                const closeUrl = `${turnUrl}/${encodeURIComponent(turnId)}/close`;
-                const closeRes = await fetch(closeUrl, {
-                    method: 'POST',
-                    headers,
-                    body: JSON.stringify({
-                        costInputTokens: stats?.costInputTokens ?? 0,
-                        costOutputTokens: stats?.costOutputTokens ?? 0,
-                        costComputeMs: stats?.costComputeMs ?? 0,
-                    }),
-                });
-                if (!closeRes.ok) {
-                    const text = await closeRes.text().catch(() => '');
-                    let parsed = text;
-                    if (text) {
-                        try {
-                            parsed = JSON.parse(text);
-                        }
-                        catch {
-                            /* keep raw text */
-                        }
-                    }
-                    throw hasWireCode(parsed)
-                        ? translateHttpError(closeRes.status, parsed, closeRes.headers.get('x-request-id') ?? undefined)
-                        : new AbloError(`closeTurn failed: ${closeRes.status} ${text}`, {
-                            code: 'turn_close_failed',
-                            httpStatus: closeRes.status,
-                        });
-                }
-            };
-            const dispose = () => {
-                if (closed)
-                    return;
-                closed = true;
-                if (activeTurnId === turnId)
-                    activeTurnId = null;
-            };
-            return { turnId, close, dispose, [Symbol.asyncDispose]: () => close() };
-        },
     };
     return engine;
 }

package/dist/client/ApiClient.d.ts

@@ -5,7 +5,7 @@
  * IndexedDB, no WebSocket. It maps the public Model / Claim / Commit
  * nouns directly to HTTP routes on sync-server.
  */
-import type { AbloOptions, CommitReceipt, CommitResource, IntentCreateOptions, IntentHandle, IntentWaitOptions, ModelClient, ModelClaim, ModelMutationOptions, ModelReadOptions, ModelRead, ModelTarget, Turn } from './Ablo.js';
+import type { AbloOptions, CommitResource, IntentCreateOptions, IntentHandle, IntentWaitOptions, ModelClient, ModelClaim, ModelTarget } from './Ablo.js';
 import type { Duration } from '../utils/duration.js';
 export type AbloApiClientOptions = Omit<AbloOptions, 'schema'> & {
     readonly schema?: null | undefined;
@@ -115,127 +115,15 @@ export interface CapabilityResource {
      */
     mint(options: CapabilityCreateOptions): Promise<Capability>;
 }
-export interface TaskCreateOptions {
-    readonly prompt: string;
-    readonly parentTaskId?: string;
-    readonly surface?: string;
-    readonly metadata?: Record<string, unknown>;
-}
-export interface TaskCloseOptions {
-    readonly costInputTokens?: number;
-    readonly costOutputTokens?: number;
-    readonly costComputeMs?: number;
-}
-export interface Task {
-    readonly id: string;
-    readonly turnId: string;
-    readonly promptHash?: string;
-    readonly openedAt?: string;
-    close(stats?: TaskCloseOptions): Promise<TaskCloseResult>;
-}
-export interface TaskCloseResult {
-    readonly id: string;
-    readonly turnId: string;
-    readonly closed: boolean;
-    readonly alreadyClosed?: boolean;
-    readonly endedAt?: string;
-}
-export interface TaskResource {
-    create(options: TaskCreateOptions): Promise<Task>;
-    close(id: string, stats?: TaskCloseOptions): Promise<TaskCloseResult>;
-    /**
-     * Alias for `create`. Kept for the agent-run vocabulary; `create` is
-     * the canonical SDK verb.
-     */
-    open(options: TaskCreateOptions): Promise<Task>;
-}
-export interface AgentOptions {
-    readonly can: readonly string[];
-    readonly syncGroups?: readonly string[];
-    readonly label?: string;
-    readonly userMeta?: Record<string, unknown>;
-    /**
-     * Internal lease for the run capability. Most callers should omit it.
-     * The SDK revokes the capability when `run` finishes; the lease exists
-     * to clean up crashed or abandoned runs.
-     */
-    readonly lease?: Duration;
-    readonly leaseSeconds?: number;
-}
-export interface AgentRunOptions extends TaskCreateOptions {
-    readonly signal?: AbortSignal;
-    readonly costInputTokens?: number;
-    readonly costOutputTokens?: number;
-    readonly costComputeMs?: number;
-}
-export type AgentRunStatus = 'done' | 'failed' | 'cancelled';
-export interface AgentRunDone<T> {
-    readonly status: 'done';
-    readonly task: Task;
-    readonly value: T;
-}
-export interface AgentRunFailed {
-    readonly status: 'failed';
-    readonly task?: Task;
-    readonly error: unknown;
-}
-export interface AgentRunCancelled {
-    readonly status: 'cancelled';
-    readonly task?: Task;
-    readonly error?: unknown;
-}
-export type AgentRunResult<T> = AgentRunDone<T> | AgentRunFailed | AgentRunCancelled;
-export interface AgentIntentOptions {
-    readonly action: string;
-    readonly field?: string;
-    readonly ttl?: Duration;
-    readonly target?: Partial<ModelTarget>;
-}
-export type AgentIntentInput = string | AgentIntentOptions;
-export interface AgentModelReadOptions extends ModelReadOptions {
-}
-export interface AgentModelMutationOptions extends Omit<ModelMutationOptions, 'intent'> {
-    readonly intent?: AgentIntentInput | {
-        readonly id: string;
-    } | null;
-}
-export interface AgentModelClient<T = Record<string, unknown>> {
-    retrieve(params: AgentModelReadOptions & {
-        readonly id: string;
-    }): Promise<ModelRead<T>>;
-    create(params: AgentModelMutationOptions & {
-        readonly data: Record<string, unknown>;
-        readonly id?: string | null;
-    }): Promise<CommitReceipt>;
-    update(params: AgentModelMutationOptions & {
-        readonly id: string;
-        readonly data: Record<string, unknown>;
-    }): Promise<CommitReceipt>;
-    delete(params: AgentModelMutationOptions & {
-        readonly id: string;
-    }): Promise<CommitReceipt>;
-}
-export interface AgentRunContext {
-    readonly task: Task;
-    readonly ablo: AbloApi;
-    model<T = Record<string, unknown>>(name: string): AgentModelClient<T>;
-}
-export interface Agent {
-    readonly id: string;
-    run<T>(options: AgentRunOptions, handler: (context: AgentRunContext) => Promise<T> | T): Promise<AgentRunResult<T>>;
-}
 export interface AbloApi {
     ready(): Promise<void>;
     waitForFlush(): Promise<void>;
     dispose(): Promise<void>;
     purge(): Promise<void>;
     readonly capabilities: CapabilityResource;
-    readonly tasks: TaskResource;
     readonly intents: AbloApiIntents;
     readonly commits: CommitResource;
-    agent(id: string, options: AgentOptions): Agent;
     model<T = Record<string, unknown>>(name: string): ModelClient<T>;
-    beginTurn(options: TaskCreateOptions): Promise<Turn>;
     /**
      * Resolve the active bearer credential this client authenticates with — the
      * same token its own requests carry in `Authorization`. Returns `null` when