@abloatai/ablo 0.10.1 → 0.11.1

package/dist/Database.js

@@ -20,6 +20,17 @@ export class Database {
     get helper() {
         return this.bootstrapHelper;
     }
+    /**
+     * PURE scoped snapshot fetch for hydrate-on-enter (P4). Returns the FULL
+     * current rows of the given sync groups, with NO side effects — unlike
+     * {@link bootstrapFromServer}, it does not persist to IndexedDB and does not
+     * touch the connection's `subscribedSyncGroups` (which the shrinkage check
+     * owns). The caller applies the result to the pool via the SCOPED apply path.
+     */
+    async fetchScopedBootstrapData(syncGroups) {
+        // No lastSyncId → a full snapshot of exactly these groups.
+        return this.bootstrapHelper.fetchBootstrap(undefined, syncGroups);
+    }
     // Database state
     currentDbInfo = null;
     workspaceDb = null;
@@ -764,7 +775,10 @@ export class Database {
             // ========================================================================
             // CONFLICT CHECK: Skip UPDATE/INSERT if DELETE exists with higher syncId
             // ========================================================================
-            if (delta.actionType === 'U' || delta.actionType === 'I' || delta.actionType === 'C') {
+            if (delta.actionType === 'U' ||
+                delta.actionType === 'I' ||
+                delta.actionType === 'C' ||
+                delta.actionType === 'M') {
                 const key = `${delta.modelName}:${delta.modelId}`;
                 const deleteSyncId = deleteSyncIds.get(key);
                 if (deleteSyncId !== undefined) {

package/dist/SyncClient.d.ts

@@ -503,7 +503,18 @@ export declare class SyncClient extends EventEmitter {
     applyBootstrapDataToPool(bootstrapData: {
         models?: Record<string, unknown[]>;
         failedModels?: string[];
-    }, protectedIds?: ReadonlySet<string>): {
+    }, protectedIds?: ReadonlySet<string>, options?: {
+        /**
+         * SCOPED backfill (P4 hydrate-on-enter): the snapshot covers only the
+         * groups just entered, NOT the whole type. Two behaviors change to keep
+         * it from corrupting the pool:
+         *   - upsert is version-guarded ({@link ObjectPool.upsertIfNewer}) so a
+         *     concurrent live delta isn't clobbered back to the snapshot version;
+         *   - ghost removal is SKIPPED — a subset snapshot must never evict rows
+         *     of the same type that belong to other (unhydrated) groups.
+         */
+        scoped?: boolean;
+    }): {
         added: number;
         updated: number;
         removed: number;

package/dist/SyncClient.js

@@ -7,6 +7,7 @@
  * - Send mutations to server via API client
  * - Handle conflict resolution for local changes
  */
+import { runInAction } from 'mobx';
 import { ModelScope } from './ObjectPool.js';
 // ModelRegistry instance accessed via this.objectPool.registry
 import { LoadStrategy } from './types/index.js';
@@ -17,6 +18,31 @@ import { NetworkMonitor } from './NetworkMonitor.js';
 import { TransactionQueue } from './transactions/TransactionQueue.js';
 import { OptimisticEchoTracker, } from './transactions/OptimisticEchoTracker.js';
 import { SyncPosition } from './sync/syncPosition.js';
+/**
+ * Is the raw snapshot record strictly newer than the pooled model? Compares
+ * server-stamped `updatedAt` (the engine has no numeric row version; the delta
+ * pipeline is arrival-ordered last-write-wins). An undefined incoming time is
+ * treated as NOT newer (don't clobber a known row); an undefined existing time
+ * means the pool row is unversioned, so the incoming record wins. Used by the
+ * scoped hydrate-on-enter apply to drop snapshot rows a live delta already
+ * advanced past the snapshot watermark.
+ */
+function rawRecordIsNewer(data, existing) {
+    const raw = data.updatedAt;
+    const inMs = raw instanceof Date
+        ? raw.getTime()
+        : typeof raw === 'string'
+            ? (Number.isNaN(Date.parse(raw)) ? undefined : Date.parse(raw))
+            : typeof raw === 'number'
+                ? raw
+                : undefined;
+    const exMs = existing.updatedAt instanceof Date ? existing.updatedAt.getTime() : undefined;
+    if (inMs === undefined)
+        return false;
+    if (exMs === undefined)
+        return true;
+    return inMs > exMs;
+}
 export class SyncClient extends EventEmitter {
     objectPool;
     database;
@@ -292,7 +318,10 @@ export class SyncClient extends EventEmitter {
         // server processes it, we drain on rollback too so a stale id
         // doesn't permanently silence a foreign delta sharing the same id
         // (vanishingly unlikely for UUIDs, but cheap insurance).
-        this.transactionQueue.on('transaction:created', (tx) => this.echoTracker.markPending(tx.id));
+        this.transactionQueue.on('transaction:created', (tx) => {
+            if (!tx.localOnly)
+                this.echoTracker.markPending(tx.id);
+        });
         this.transactionQueue.on('optimistic:rollback', (event) => {
             this.echoTracker.drainOnRollback(event.transaction.id);
         });
@@ -654,6 +683,20 @@ export class SyncClient extends EventEmitter {
      * @see src/sync-engine/types/TrackableModel.ts for change capture pattern
      */
     mutate(type, model, poolAction, writeOptions) {
+        // No-op UPDATE guard (O(1)). An update with no dirty fields would travel
+        // to the server, get dropped by `coalesceOperations` Rule 4 (empty input),
+        // and — if it was the only op — come back as `lastSyncId: 0`. That trips
+        // `captureCommitZeroSyncId` (false-positive Sentry anomaly) AND parks the
+        // tx in `awaiting_delta` for a 30s reconciliation timeout on a write that
+        // changed nothing. `Model.hasChanges` reads `modifiedProperties.size`, so
+        // this costs O(1) with no allocation (vs. O(N) materializing getChanges()).
+        //
+        // Strict `=== false` is deliberate: `rowAsModel` only casts, so a non-Model
+        // object can reach here with `hasChanges === undefined`. `undefined === false`
+        // is false → we fall through to the normal path rather than risk dropping a
+        // real write. Only a genuine Model with an empty dirty-set is skipped.
+        if (type === 'update' && model.hasChanges === false)
+            return;
         // CRITICAL FIX: Capture changes BEFORE pool action
         // Pool operations (especially upsert) can clear _local changes
         // By capturing first, we ensure changes are never lost
@@ -720,6 +763,13 @@ export class SyncClient extends EventEmitter {
         const capturedChanges = changes && Object.keys(changes).length > 0
             ? Object.freeze({ ...changes })
             : this.captureModelChanges(model);
+        // No-op UPDATE guard: neither an explicit change set nor model dirty-fields.
+        // `captureModelChanges` already returns undefined for an empty dirty-set, so
+        // an undefined here means there is genuinely nothing to send — skip rather
+        // than emit an empty-input update that the server coalesces to lastSyncId 0
+        // (see the same guard in `mutate`).
+        if (capturedChanges === undefined)
+            return;
         this.objectPool.upsert(model, ModelScope.live);
         this.queueMutation({ type: 'update', model, timestamp: new Date(), capturedChanges });
         this.notifyObservers({
@@ -1552,25 +1602,39 @@ export class SyncClient extends EventEmitter {
                     break;
             }
         }
-        // Batch ObjectPool mutations — minimal MobX actions
-        if (modelsToAdd.length > 0)
-            this.objectPool.addBatch(modelsToAdd, ModelScope.live);
-        if (modelsToUpsert.length > 0)
-            this.objectPool.upsertBatch(modelsToUpsert, ModelScope.live);
-        if (idsToRemove.length > 0)
-            this.objectPool.removeBatch(idsToRemove);
-        for (const id of idsToArchive)
-            this.objectPool.updateScope(id, ModelScope.archived);
-        // Emit changed model types so QueryProcessor can auto-invalidate
-        const changedTypes = new Set(dbResults.map(r => r.modelName));
-        if (changedTypes.size > 0)
-            this.emit('models:changed', changedTypes);
+        // Reveal the whole frame in ONE MobX action. `addBatch`/`upsertBatch`/
+        // `removeBatch`/`updateScope` are each individually `action`-wrapped,
+        // so calling them sequentially flushes reactions at every action
+        // boundary — a catch-up frame that adds + updates + removes would fire
+        // every dependent reaction (the decks gallery, each open editor) 3-4×
+        // in a row, re-rendering and re-sorting on each. Wrapping them in a
+        // single outer `runInAction` defers all reaction flushes to ONE
+        // boundary: dependents recompute exactly once regardless of how many
+        // models or how many op-kinds the frame touched. This is the MobX
+        // equivalent of Replicache's "atomically reveal the new state" — the
+        // app never observes a partially-applied frame.
+        runInAction(() => {
+            if (modelsToAdd.length > 0)
+                this.objectPool.addBatch(modelsToAdd, ModelScope.live);
+            if (modelsToUpsert.length > 0)
+                this.objectPool.upsertBatch(modelsToUpsert, ModelScope.live);
+            if (idsToRemove.length > 0)
+                this.objectPool.removeBatch(idsToRemove);
+            for (const id of idsToArchive)
+                this.objectPool.updateScope(id, ModelScope.archived);
+            // Emit changed model types so QueryProcessor can auto-invalidate.
+            // Kept inside the action so any observable query-cache state it
+            // flips is part of the same atomic reveal.
+            const changedTypes = new Set(dbResults.map(r => r.modelName));
+            if (changedTypes.size > 0)
+                this.emit('models:changed', changedTypes);
+        });
     }
     /**
      * Apply bootstrap data to the ObjectPool with ghost removal.
      * Owns: model creation, batch upsert, ghost detection + removal.
      */
-    applyBootstrapDataToPool(bootstrapData, protectedIds) {
+    applyBootstrapDataToPool(bootstrapData, protectedIds, options) {
         if (!bootstrapData.models) {
             return { added: 0, updated: 0, removed: 0, skipped: 0, healed: 0 };
         }
@@ -1605,6 +1669,19 @@ export class SyncClient extends EventEmitter {
                 const recordId = data.id;
                 if (recordId)
                     idsForType.add(recordId);
+                // Scoped backfill (P4 hydrate-on-enter): a subset snapshot is taken at
+                // a server watermark. If a concurrent live delta already advanced this
+                // row past the snapshot, skip it — `createFromData` mutates the pooled
+                // model IN PLACE (the "keep instances alive" Linear pattern), so this
+                // version guard MUST run BEFORE it; an upsert-layer guard would be too
+                // late, the row would already be clobbered.
+                if (options?.scoped && recordId) {
+                    const existing = this.objectPool.get(recordId);
+                    if (existing && !rawRecordIsNewer(data, existing)) {
+                        skippedCount++;
+                        continue;
+                    }
+                }
                 try {
                     const model = this.objectPool.createFromData(data);
                     if (model)
@@ -1615,23 +1692,30 @@ export class SyncClient extends EventEmitter {
                 }
             }
         }
-        // Batch upsert
+        // Upsert. The scoped stale-skip above already guarded the version, so a
+        // plain upsert is correct here for both paths.
         const beforeSize = this.objectPool.size;
         this.objectPool.upsertBatch(allModels, ModelScope.live);
         const addedCount = this.objectPool.size - beforeSize;
         const updatedCount = allModels.length - addedCount;
-        // Ghost removal — remove pool entities not in server snapshot
-        const ghostIds = [];
-        for (const [modelType, serverIds] of serverIdsByType) {
-            const poolIds = this.objectPool.getIdsByModelType(modelType);
-            if (!poolIds)
-                continue;
-            for (const poolId of poolIds) {
-                if (!serverIds.has(poolId) && !protectedIds?.has(poolId))
-                    ghostIds.push(poolId);
+        // Ghost removal — remove pool entities not in the server snapshot. Only
+        // valid for a FULL bootstrap, where the snapshot is authoritative for each
+        // returned type. A SCOPED subset snapshot must NOT remove rows of the same
+        // type that belong to other (unhydrated) groups.
+        let removedCount = 0;
+        if (!options?.scoped) {
+            const ghostIds = [];
+            for (const [modelType, serverIds] of serverIdsByType) {
+                const poolIds = this.objectPool.getIdsByModelType(modelType);
+                if (!poolIds)
+                    continue;
+                for (const poolId of poolIds) {
+                    if (!serverIds.has(poolId) && !protectedIds?.has(poolId))
+                        ghostIds.push(poolId);
+                }
             }
+            removedCount = this.objectPool.removeBatch(ghostIds);
         }
-        const removedCount = this.objectPool.removeBatch(ghostIds);
         // Emit changed model types so QueryProcessor can auto-invalidate
         const changedTypes = new Set(Object.keys(bootstrapData.models));
         if (changedTypes.size > 0)

package/dist/agent/Agent.d.ts

@@ -40,10 +40,10 @@
  * for custom integrations outside the AI SDK.
  */
 import type { PresenceAnnouncer, AgentContext } from './types.js';
-import type { Activity, IntentClaim } from '../types/streams.js';
+import type { Activity, WireClaim } from '../types/streams.js';
 import { createAgentSession } from './session.js';
 export type { AgentContext } from './types.js';
-export type { IntentClaim } from '../types/streams.js';
+export type { WireClaim } from '../types/streams.js';
 /**
  * Shape returned by the sync server's REST `/api/presence` endpoint.
  *
@@ -62,7 +62,7 @@ interface WirePeer {
     activity?: Activity;
     updatedAt?: number;
     organizationId?: string;
-    activeIntents?: IntentClaim[];
+    activeClaims?: WireClaim[];
 }
 import type { SyncLogger } from '../interfaces/index.js';
 export interface AgentOptions {
@@ -125,13 +125,13 @@ export interface FreshnessCheck {
     /** Human-readable summary — feed this back to the LLM when stale. */
     summary?: string;
     /**
-     * Pending-mutation intents from OTHER participants targeting this
-     * entity (self-intents filtered out). Empty = no one else is
+     * Pending-mutation claims from OTHER participants targeting this
+     * entity (self-claims filtered out). Empty = no one else is
      * currently generating against this entity. Non-empty is ADVISORY
      * — the agent can proceed, wait, or defer. Stale-read protection
      * that predates committed deltas.
      */
-    pendingIntents?: IntentClaim[];
+    pendingClaims?: WireClaim[];
 }
 /** Subset of AI SDK's ModelMessage — structural. */
 export interface AgentMessage {
@@ -299,13 +299,13 @@ export declare class Agent implements PresenceAnnouncer {
      */
     checkFreshness(entityType: string, entityId: string, lastSeenAt: number): Promise<FreshnessCheck>;
     /**
-     * Pull the org's presence, filter to intents targeting the given
-     * entity (self-intents excluded). Advisory — returns empty on any
+     * Pull the org's presence, filter to claims targeting the given
+     * entity (self-claims excluded). Advisory — returns empty on any
      * error so `checkFreshness` stays usable when the presence endpoint
      * is down. Case-insensitive match on entityType + entityId to absorb
      * PascalCase / lowercase divergence.
      */
-    private fetchPendingIntentsFor;
+    private fetchPendingClaimsFor;
     /**
      * Build a `prepareStep` hook for AI SDK's generateText / streamText /
      * ToolLoopAgent. Called before each step — injects a system message

package/dist/agent/Agent.js

@@ -201,14 +201,14 @@ export class Agent {
      */
     async checkFreshness(entityType, entityId, lastSeenAt) {
         // Parallel fan-out: freshness (entity state vs lastSeenAt) + pending
-        // intents (other agents about to mutate). Both are advisory — if
+        // claims (other agents about to mutate). Both are advisory — if
         // either request fails the check still returns a usable result.
-        const [queryRes, pendingIntents] = await Promise.all([
+        const [queryRes, pendingClaims] = await Promise.all([
             this.request('POST', '/api/sync/query', {
                 organizationId: this.opts.organizationId,
                 queries: [{ model: entityType, ids: [entityId] }],
             }).catch((err) => ({ ok: false, status: 0, _err: err })),
-            this.fetchPendingIntentsFor(entityType, entityId),
+            this.fetchPendingClaimsFor(entityType, entityId),
         ]);
         try {
             const res = queryRes;
@@ -217,7 +217,7 @@ export class Agent {
                     stale: false,
                     reason: 'ok',
                     summary: `Freshness check inconclusive: ${('status' in res ? res.status : 'error')}`,
-                    pendingIntents,
+                    pendingClaims,
                 };
             }
             const body = (await res.json());
@@ -227,7 +227,7 @@ export class Agent {
                     stale: true,
                     reason: 'not_found',
                     summary: `${entityType} ${entityId} no longer exists. Another actor may have deleted it.`,
-                    pendingIntents,
+                    pendingClaims,
                 };
             }
             const entity = rows[0];
@@ -251,7 +251,7 @@ export class Agent {
                     summary: `${entityType} ${entityId} was modified by ${lastModifiedBy ?? 'another actor'} ` +
                         `${ago}s ago. Your planned change is based on stale state. ` +
                         `Re-read the entity and adjust your approach.`,
-                    pendingIntents,
+                    pendingClaims,
                 };
             }
             return {
@@ -260,7 +260,7 @@ export class Agent {
                 currentState: entity,
                 lastModifiedBy,
                 lastModifiedAt,
-                pendingIntents,
+                pendingClaims,
             };
         }
         catch (err) {
@@ -270,29 +270,29 @@ export class Agent {
                 stale: false,
                 reason: 'ok',
                 summary: `Freshness check error: ${err.message}`,
-                pendingIntents,
+                pendingClaims,
             };
         }
     }
     /**
-     * Pull the org's presence, filter to intents targeting the given
-     * entity (self-intents excluded). Advisory — returns empty on any
+     * Pull the org's presence, filter to claims targeting the given
+     * entity (self-claims excluded). Advisory — returns empty on any
      * error so `checkFreshness` stays usable when the presence endpoint
      * is down. Case-insensitive match on entityType + entityId to absorb
      * PascalCase / lowercase divergence.
      */
-    async fetchPendingIntentsFor(entityType, entityId) {
+    async fetchPendingClaimsFor(entityType, entityId) {
         const etLower = entityType.toLowerCase();
         const idLower = entityId.toLowerCase();
         const entries = await this.fetchPresence(true);
         const result = [];
         for (const entry of entries) {
-            if (!entry.activeIntents)
+            if (!entry.activeClaims)
                 continue;
-            for (const intent of entry.activeIntents) {
-                if (intent.entityType.toLowerCase() === etLower &&
-                    intent.entityId.toLowerCase() === idLower) {
-                    result.push(intent);
+            for (const claim of entry.activeClaims) {
+                if (claim.entityType.toLowerCase() === etLower &&
+                    claim.entityId.toLowerCase() === idLower) {
+                    result.push(claim);
                 }
             }
         }

package/dist/agent/index.d.ts

@@ -8,7 +8,7 @@
  * ─────────────────────────────────────────────────────────────────────────
  * Use the unified `Ablo({...})` factory directly with `kind: 'agent'`.
  * The factory holds the WebSocket, reactive subscriptions, mutations, and
- * presence/intents — same surface as a browser user, just with a
+ * presence/claims — same surface as a browser user, just with a
  * server-issued capability token instead of session cookies.
  *
  * ```ts

package/dist/agent/index.js

@@ -8,7 +8,7 @@
  * ─────────────────────────────────────────────────────────────────────────
  * Use the unified `Ablo({...})` factory directly with `kind: 'agent'`.
  * The factory holds the WebSocket, reactive subscriptions, mutations, and
- * presence/intents — same surface as a browser user, just with a
+ * presence/claims — same surface as a browser user, just with a
  * server-issued capability token instead of session cookies.
  *
  * ```ts
@@ -122,7 +122,7 @@
 //   const ctx:  Agent.Context = { perception };
 //   const s:    Agent.SessionOptions = { ... };
 //
-// Everything else (Activity, Claim, Peer, ActiveIntent, ...)
+// Everything else (Activity, Claim, Peer, ActiveClaim, ...)
 // lives on the `Ablo.*` namespace via
 // `import type { Ablo } from '@abloatai/ablo'`.
 export { Agent } from './Agent.js';

package/dist/agent/types.d.ts

@@ -1,6 +1,6 @@
 /**
  * Agent-SDK abstractions. The engine's data vocabulary
- * (`Peer`, `Activity`, `IntentClaim`, `ActiveIntent`,
+ * (`Peer`, `Activity`, `Claim`, `ActiveClaim`,
  * `PresenceUpdatePayload`, `PresenceKind`) lives in
  * `../types/streams.ts`. This file holds only the bits that are
  * specific to the agent module: the `PresenceAnnouncer` abstraction

package/dist/agent/types.js

@@ -1,6 +1,6 @@
 /**
  * Agent-SDK abstractions. The engine's data vocabulary
- * (`Peer`, `Activity`, `IntentClaim`, `ActiveIntent`,
+ * (`Peer`, `Activity`, `Claim`, `ActiveClaim`,
  * `PresenceUpdatePayload`, `PresenceKind`) lives in
  * `../types/streams.ts`. This file holds only the bits that are
  * specific to the agent module: the `PresenceAnnouncer` abstraction

package/dist/ai-sdk/{intent-broadcast.d.ts → claim-broadcast.d.ts}

@@ -1,7 +1,7 @@
 /**
- * Intent broadcast middleware — wraps a language model so the agent
+ * Claim broadcast middleware — wraps a language model so the agent
  * declares "I'm about to edit entity X" over the sync engine's
- * intent primitive at stream start, and abandons the claim at
+ * claim primitive at stream start, and abandons the claim at
  * stream end.
  *
  * Cross-cutting by design — composes via the AI SDK's
@@ -13,20 +13,20 @@
  * the package's own `SyncAgent`. No app-specific assumptions —
  * Ablo's web app uses this, but so can any consumer of `@abloatai/ablo`.
  *
- * Cost: one WS frame at stream start (`intent_begin`), one at end
- * (`intent_abandon`). No DB I/O, no extra LLM tokens.
+ * Cost: one WS frame at stream start (`claim_begin`), one at end
+ * (`claim_abandon`). No DB I/O, no extra LLM tokens.
  */
 import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
 import type { Ablo } from '../client/Ablo.js';
 import type { SchemaRecord } from '../schema/schema.js';
 /**
- * Target entity for the intent broadcast.
+ * Target entity for the claim broadcast.
  *
  * `entityType` is a free-form string — convention is the schema's
  * typename (e.g. `'SlideDeck'`, `'Task'`, `'Matter'`) so peers can
  * filter consistently. The wire format treats it opaquely.
  */
-export interface IntentTarget {
+export interface ClaimTarget {
     readonly entityType: string;
     readonly entityId: string;
     /** Optional path for file/document-like targets. */
@@ -52,11 +52,11 @@ export interface IntentTarget {
      */
     readonly estimatedMs?: number;
 }
-export interface IntentBroadcastMiddlewareOptions<R extends SchemaRecord = SchemaRecord> {
+export interface ClaimBroadcastMiddlewareOptions<R extends SchemaRecord = SchemaRecord> {
     /** Connected Ablo. Null disables the middleware (no-op). */
     readonly agent: Ablo<R> | null;
     /** Target entity. Null skips the broadcast (purely conversational). */
-    readonly target: IntentTarget | null;
+    readonly target: ClaimTarget | null;
     /**
      * Action verb describing what the agent is doing. Convention:
      * `'edit'`, `'read'`, `'review'`, `'generate'`. Default `'edit'`.
@@ -64,7 +64,7 @@ export interface IntentBroadcastMiddlewareOptions<R extends SchemaRecord = Schem
     readonly action?: string;
     /**
      * Peer-visible explanation of the specific work this model call is about to
-     * perform. Surfaces to other agents through `ActiveIntent.description`.
+     * perform. Surfaces to other agents through `ActiveClaim.description`.
      */
     readonly description?: string;
 }
@@ -79,4 +79,4 @@ export interface IntentBroadcastMiddlewareOptions<R extends SchemaRecord = Schem
  * widened version collapses model proxies to an index signature
  * that clashes with the named methods (`ready`, `dispose`, etc.).
  */
-export declare function intentBroadcastMiddleware<R extends SchemaRecord = SchemaRecord>(options: IntentBroadcastMiddlewareOptions<R>): LanguageModelV3Middleware;
+export declare function claimBroadcastMiddleware<R extends SchemaRecord = SchemaRecord>(options: ClaimBroadcastMiddlewareOptions<R>): LanguageModelV3Middleware;

package/dist/ai-sdk/{intent-broadcast.js → claim-broadcast.js}

@@ -1,7 +1,7 @@
 /**
- * Intent broadcast middleware — wraps a language model so the agent
+ * Claim broadcast middleware — wraps a language model so the agent
  * declares "I'm about to edit entity X" over the sync engine's
- * intent primitive at stream start, and abandons the claim at
+ * claim primitive at stream start, and abandons the claim at
  * stream end.
  *
  * Cross-cutting by design — composes via the AI SDK's
@@ -13,8 +13,8 @@
  * the package's own `SyncAgent`. No app-specific assumptions —
  * Ablo's web app uses this, but so can any consumer of `@abloatai/ablo`.
  *
- * Cost: one WS frame at stream start (`intent_begin`), one at end
- * (`intent_abandon`). No DB I/O, no extra LLM tokens.
+ * Cost: one WS frame at stream start (`claim_begin`), one at end
+ * (`claim_abandon`). No DB I/O, no extra LLM tokens.
  */
 /**
  * Build the middleware. When `agent` or `target` is null, returns a
@@ -27,14 +27,14 @@
  * widened version collapses model proxies to an index signature
  * that clashes with the named methods (`ready`, `dispose`, etc.).
  */
-export function intentBroadcastMiddleware(options) {
+export function claimBroadcastMiddleware(options) {
     const { agent, target } = options;
     const action = options.action ?? 'edit';
     const description = options.description;
     const openClaim = () => {
         if (!agent || !target)
             return null;
-        return agent.intents.claim({
+        return agent.claims.claim({
             type: target.entityType,
             id: target.entityId,
             path: target.path,

package/dist/ai-sdk/coordination-context.d.ts

@@ -1,9 +1,9 @@
 /**
- * Coordination context middleware — reads peer intents on the same
+ * Coordination context middleware — reads peer claims on the same
  * entity from the sync engine's presence stream and injects a brief
  * coordination note into the prompt before the LLM call.
  *
- * The complement of `intent-broadcast.ts`: that one declares what
+ * The complement of `claim-broadcast.ts`: that one declares what
  * THIS agent is about to do; this one reads what OTHERS are doing
  * and tells the LLM about it. Together they make multiplayer-with-
  * AI structurally real — the AI knows when a human or another
@@ -23,28 +23,28 @@
 import type { LanguageModelV3Middleware } from '@ai-sdk/provider';
 import type { Ablo } from '../client/Ablo.js';
 import type { SchemaRecord } from '../schema/schema.js';
-import type { IntentTarget } from './intent-broadcast.js';
+import type { ClaimTarget } from './claim-broadcast.js';
 export interface CoordinationContextMiddlewareOptions<R extends SchemaRecord = SchemaRecord> {
     readonly agent: Ablo<R> | null;
-    readonly target: IntentTarget | null;
+    readonly target: ClaimTarget | null;
     /**
-     * Optional intentId(s) to exclude from the read — typically this
+     * Optional claimId(s) to exclude from the read — typically this
      * agent's own active claim so the coordination note doesn't tell
      * the AI "you yourself are editing this." When middleware is
-     * composed with `intentBroadcastMiddleware` in the standard order,
+     * composed with `claimBroadcastMiddleware` in the standard order,
      * `transformParams` runs BEFORE the broadcast's `wrapStream`
      * declares its claim, so the agent's own claim isn't yet in the
      * cached presence and self-filtering isn't needed. The hook is
      * here for callers that compose differently or for fleet
-     * coordination (filter sibling worker intents).
+     * coordination (filter sibling worker claims).
      */
-    readonly excludeIntentIds?: readonly string[];
+    readonly excludeClaimIds?: readonly string[];
 }
 /**
  * Build the middleware. When `agent` or `target` is null, returns a
  * pass-through.
  *
- * Generic over the schema record — see `intentBroadcastMiddleware`
+ * Generic over the schema record — see `claimBroadcastMiddleware`
  * for why `Ablo<S>` and `Ablo<SchemaRecord>` aren't structurally
  * assignable.
  */

package/dist/ai-sdk/coordination-context.js

@@ -1,9 +1,9 @@
 /**
- * Coordination context middleware — reads peer intents on the same
+ * Coordination context middleware — reads peer claims on the same
  * entity from the sync engine's presence stream and injects a brief
  * coordination note into the prompt before the LLM call.
  *
- * The complement of `intent-broadcast.ts`: that one declares what
+ * The complement of `claim-broadcast.ts`: that one declares what
  * THIS agent is about to do; this one reads what OTHERS are doing
  * and tells the LLM about it. Together they make multiplayer-with-
  * AI structurally real — the AI knows when a human or another
@@ -24,24 +24,24 @@
  * Build the middleware. When `agent` or `target` is null, returns a
  * pass-through.
  *
- * Generic over the schema record — see `intentBroadcastMiddleware`
+ * Generic over the schema record — see `claimBroadcastMiddleware`
  * for why `Ablo<S>` and `Ablo<SchemaRecord>` aren't structurally
  * assignable.
  */
 export function coordinationContextMiddleware(options) {
     const { agent, target } = options;
-    const excludeIntentIds = new Set(options.excludeIntentIds ?? []);
+    const excludeClaimIds = new Set(options.excludeClaimIds ?? []);
     return {
         specificationVersion: 'v3',
         transformParams: async ({ params }) => {
             if (!agent || !target)
                 return params;
-            // Read peer intents on the same target. Synchronous lookup
-            // against the engine's reactive intents.others array — no I/O.
-            const peerClaims = agent.intents.others.filter((claim) => claim.target.type === target.entityType &&
+            // Read peer claims on the same target. Synchronous lookup
+            // against the engine's reactive claims.others array — no I/O.
+            const peerClaims = agent.claims.others.filter((claim) => claim.target.type === target.entityType &&
                 claim.target.id === target.entityId &&
                 targetsOverlap(claim.target, target) &&
-                !excludeIntentIds.has(claim.id));
+                !excludeClaimIds.has(claim.id));
             if (peerClaims.length === 0)
                 return params;
             const note = formatCoordinationNote(peerClaims, target);