@abloatai/humans 0.57.0 → 0.59.0

package/src/local/sync/createClaimStream.ts

@@ -25,7 +25,7 @@
 import type {
   WsTransport,
   PresenceUpdate,
-} from '@abloatai/transaction/transport/wsTransport';
+} from '@abloatai/transaction/transport/websocket';
 import type {
   ClaimOptions,
   ClaimTarget,
@@ -52,10 +52,15 @@ import {
   streamTarget,
   wireTarget,
   type ClaimTargetDetails,
-} from '@abloatai/transaction/coordination/locator';
-import { declaredMeta } from '@abloatai/transaction/coordination/claimMeta';
+} from '@abloatai/transaction/claims';
+import {
+  bindClaimLifetime,
+  createClaimLifetime,
+  type ClaimLifetime,
+} from '@abloatai/transaction/claims/lifetime';
+import { declaredMeta } from '@abloatai/transaction/claims';
 import { AbloClaimedError, AbloConnectionError } from '@abloatai/transaction/errors';
-import { resolveHeartbeatOptions } from '@abloatai/transaction/coordination/claimHeartbeatLoop';
+import { resolveHeartbeatOptions } from '@abloatai/transaction/claims';
 import { noopLogger, type Logger } from '@abloatai/transaction/logger';
 
 /**
@@ -114,13 +119,11 @@ export interface AttachableClaimStream extends ClaimStream {
 }
 
 /**
- * What this participant needs to remember about a claim it holds, so it can
- * re-announce it after a reconnect.
+ * What this participant needs to remember about one open grant.
  *
  * The sub-entity locator is taken from {@link ClaimTargetDetails} rather than
- * listed again: a member this record forgot would be a member the re-announced
- * claim silently lost, which is a narrower claim than the one the holder
- * believes it has.
+ * listed again: a member this record forgot would be a member release or loss
+ * bookkeeping silently narrowed relative to the handle the caller holds.
  */
 type OwnClaim = ClaimTargetDetails & {
   readonly entityType: string;
@@ -133,6 +136,11 @@ type OwnClaim = ClaimTargetDetails & {
   readonly queue?: boolean;
 };
 
+interface OwnGrant {
+  readonly claim: OwnClaim;
+  readonly lifetime: ClaimLifetime;
+}
+
 export function createClaimStream(
   config: ClaimStreamConfig,
   transport: ClaimTransport | null = null,
@@ -146,8 +154,8 @@ export function createClaimStream(
   const activeByClaimId = new Map<string, Claim>();
   let claimsSnapshot: readonly Claim[] = Object.freeze([]);
 
-  // ── State: our own open claims (for re-announce on reconnect) ───
-  const ownClaims = new Map<string, OwnClaim>();
+  // ── State: our own open grants, keyed by the exact claim id ─────
+  const ownClaims = new Map<string, OwnGrant>();
 
   // ── State: per-entity wait queues, from `claim_queue` frames ────
   // Keyed `type:id`; the value is the FIFO line of queued claims. Powers
@@ -290,7 +298,8 @@ export function createClaimStream(
     unsubs.push(
       t.subscribe('claim_rejected', (rejection) => {
         if (!rejection.claimId) return;
-        if (ownClaims.has(rejection.claimId)) {
+        const own = ownClaims.get(rejection.claimId);
+        if (own) {
           const tgt = rejection.target
             ? claimLabel(rejection.target.entityType, rejection.target.entityId, rejection.target.field)
             : rejection.claimId;
@@ -299,9 +308,17 @@ export function createClaimStream(
             { claimId: rejection.claimId, reason: rejection.reason },
           );
         }
-        // Drop the rejected own-claim so reconnect doesn't re-announce
-        // a claim the server already rejected (would just spam both
-        // sides with conflicts).
+        own?.lifetime.end(
+          new AbloClaimedError(
+            rejection.message ?? `Claim ${rejection.claimId} was rejected.`,
+            {
+              code:
+                rejection.reason === 'conflict'
+                  ? 'claim_conflict'
+                  : 'claim_lease_unavailable',
+            },
+          ),
+        );
         ownClaims.delete(rejection.claimId);
         // A holder on another server may have claimed before this client joined
         // the row group, so its one-shot presence frame was missed. A conflict
@@ -336,15 +353,20 @@ export function createClaimStream(
       // The frame is validated by the transport's dispatcher against the same
       // schema this parameter's type comes from, so it arrives proven.
       t.subscribe('claim_lost', (lost) => {
-        if (ownClaims.has(lost.claimId)) {
-          const c = ownClaims.get(lost.claimId);
+        const own = ownClaims.get(lost.claimId);
+        if (own) {
+          const c = own.claim;
           logger.info(
-            `claim: lost ${c ? claimLabel(c.entityType, c.entityId, c.field) : lost.claimId} (preempted or expired)`,
+            `claim: lost ${claimLabel(c.entityType, c.entityId, c.field)} (preempted or expired)`,
             { claimId: lost.claimId },
           );
         }
-        // Drop the lost own-claim so reconnect doesn't re-announce a lease we
-        // no longer hold.
+        own?.lifetime.end(
+          new AbloClaimedError(
+            `Claim ${lost.claimId} was lost because it ${lost.reason === 'expired' ? 'expired' : 'was preempted'}. Re-acquire it before continuing.`,
+            { code: 'claim_lost' },
+          ),
+        );
         ownClaims.delete(lost.claimId);
         for (const l of lostListeners) {
           try {
@@ -418,25 +440,35 @@ export function createClaimStream(
             });
             return;
           }
-          const c = ownClaims.get(ack.claimId);
-          reject(
-            new AbloClaimedError(
-              `The lease behind ${c ? claimLabel(c.entityType, c.entityId, c.field) : `claim ${ack.claimId}`} is no longer held — it expired or was granted onward while this participant was working. Re-acquire the claim and retry; a write attempted under the old lease is rejected by its \`readAt\` guard.`,
-              { code: 'claim_lost' },
-            ),
+          const own = ownClaims.get(ack.claimId);
+          const c = own?.claim;
+          const error = new AbloClaimedError(
+            `The lease behind ${c ? claimLabel(c.entityType, c.entityId, c.field) : `claim ${ack.claimId}`} is no longer held — it expired or was granted onward while this participant was working. Re-acquire the claim and retry; a write attempted under the old lease is rejected by its \`readAt\` guard.`,
+            { code: 'claim_lost' },
           );
+          own?.lifetime.end(error);
+          ownClaims.delete(ack.claimId);
+          reject(error);
         });
       }),
     );
 
-    // (3) On reconnect, re-announce every open self-claim — the
-    //     server's claim state is in-memory and is lost across
-    //     restarts. Without this, peers would see our claims vanish
-    //     whenever the connection blipped.
+    // (3) A granted handle belongs to this connection's exact grant. The server
+    //     releases the participant's claims when its last socket leaves; trying
+    //     to recreate them on `connected` silently swapped the lease beneath an
+    //     old `data` / `readAt` / fenceToken tuple. End them instead. A caller
+    //     reconnects, re-reads, and takes a fresh handle.
     unsubs.push(
-      t.subscribe('connected', () => {
-        for (const [claimId, claim] of ownClaims) {
-          sendBegin(claimId, claim);
+      t.subscribe('disconnected', () => {
+        const error = new AbloConnectionError(
+          'The connection holding this claim ended. Reconnect and acquire a fresh claim before continuing.',
+        );
+        for (const { lifetime } of ownClaims.values()) {
+          lifetime.end(error);
+        }
+        ownClaims.clear();
+        for (const claimId of [...pendingHeartbeats.keys()]) {
+          settleHeartbeat(claimId, ({ reject }) => reject(error));
         }
       }),
     );
@@ -480,8 +512,8 @@ export function createClaimStream(
 
   /**
    * Send one heartbeat and await its ack. Rejects with
-   * {@link AbloConnectionError} (transient — the auto-heartbeat loop retries
-   * on its next tick) when the socket is down or the ack times out, and with
+   * {@link AbloConnectionError} when the socket is down or the ack times out,
+   * and with
    * {@link AbloClaimedError} (definitive) when the server answers that the
    * lease is no longer ours.
    */
@@ -493,7 +525,7 @@ export function createClaimStream(
     if (!attached?.isConnected()) {
       return Promise.reject(
         new AbloConnectionError(
-          `The heartbeat for ${claimLabel(claim.entityType, claim.entityId, claim.field)} was skipped because the connection is down. The keepalive renews held leases automatically on reconnect; the next beat retries.`,
+          `The heartbeat for ${claimLabel(claim.entityType, claim.entityId, claim.field)} was skipped because the connection is down. This connection's grant has ended; reconnect and acquire a fresh claim.`,
         ),
       );
     }
@@ -567,7 +599,8 @@ export function createClaimStream(
       estimatedMs,
       queue: args.queue,
     };
-    ownClaims.set(claimId, claim);
+    const lifetime = createClaimLifetime();
+    ownClaims.set(claimId, { claim, lifetime });
     sendBegin(claimId, claim);
     // Coordination trace (info): the creator can see their human/agent claims.
     logger.info(
@@ -580,6 +613,7 @@ export function createClaimStream(
     const revoke = () => {
       if (revoked) return;
       revoked = true;
+      lifetime.end();
       ownClaims.delete(claimId);
       sendAbandon(claimId, claim);
       logger.info(
@@ -588,7 +622,7 @@ export function createClaimStream(
       );
     };
 
-    return {
+    return bindClaimLifetime({
       object: 'claim',
       id: claimId,
       status: 'active',
@@ -607,7 +641,7 @@ export function createClaimStream(
       [Symbol.asyncDispose]: async () => {
         revoke();
       },
-    };
+    }, lifetime);
   }
 
   function resolveTarget(target: PresenceTarget): ClaimTarget {
@@ -686,6 +720,10 @@ export function createClaimStream(
           );
         });
       }
+      const error = new AbloConnectionError(
+        'The claim stream was disposed. Acquire a fresh claim before continuing.',
+      );
+      for (const { lifetime } of ownClaims.values()) lifetime.end(error);
       listeners.clear();
       rejectionListeners.clear();
       lostListeners.clear();

package/src/local/sync/credentialLifecycle.ts

@@ -15,4 +15,4 @@ export {
   type CredentialRefreshResult,
   type CredentialRefresher,
   type CredentialLifecycleContext,
-} from '@abloatai/transaction/transport/credentialLifecycle';
+} from '@abloatai/transaction/transport/connection';

package/src/local/sync/participants.ts

@@ -1,4 +1,4 @@
-import type { JoinOptions } from '@abloatai/transaction/resources/modelOperations';
+import type { JoinOptions } from '@abloatai/transaction/client/resources/modelOperations';
 import type { SyncWebSocket } from './SyncWebSocket.js';
 import type { Schema, SchemaRecord } from '@abloatai/transaction/schema/schema';
 import { scopeKindOf, type ModelDef } from '@abloatai/transaction/schema/model';

package/src/local/sync/schemaDrift.ts

@@ -15,13 +15,18 @@
  * Pure and transport-free; the BootstrapFetcher owns fetching the surface.
  */
 
+import { reconcileClientToActive } from '@abloatai/transaction/schema';
+
 /** One model as the server's schema read-back reports it. */
 export interface ServerSchemaModel {
   readonly key: string;
   /** Per-model content hash; absent on servers older than this check. */
   readonly hash?: string;
+  readonly fields?: Readonly<Record<string, { readonly type: string; readonly isOptional: boolean }>>;
 }
 
+export interface SchemaFieldDrift { readonly model: string; readonly field: string; readonly direction: 'client_only' | 'active_only' | 'changed'; readonly detail: string; }
+
 export type SchemaDriftFinding =
   /** Every model this client declares exists server-side with matching content
    *  (the server may know more — that's an additive lead, not drift). */
@@ -35,6 +40,7 @@ export type SchemaDriftFinding =
       readonly kind: 'changed';
       readonly models: readonly string[];
       readonly unpushed: readonly string[];
+      readonly fields?: readonly SchemaFieldDrift[];
     }
   /** The server surface carries no per-model hashes (older server) — the
    *  caller falls back to the whole-hash comparison. */
@@ -43,6 +49,7 @@ export type SchemaDriftFinding =
 export function classifySchemaDrift(
   clientModels: Readonly<Record<string, string>>,
   serverModels: readonly ServerSchemaModel[],
+  clientShapes: Readonly<Record<string, Readonly<Record<string, { readonly type: string; readonly isOptional: boolean }>>>> = {},
 ): SchemaDriftFinding {
   if (serverModels.length > 0 && serverModels.every((m) => !m.hash)) {
     return { kind: 'unknown' };
@@ -50,12 +57,24 @@ export function classifySchemaDrift(
   const server = new Map(serverModels.map((m) => [m.key, m.hash]));
   const unpushed: string[] = [];
   const changed: string[] = [];
+  const fields: SchemaFieldDrift[] = [];
   for (const [key, hash] of Object.entries(clientModels)) {
     const serverHash = server.get(key);
     if (serverHash === undefined) unpushed.push(key);
-    else if (serverHash !== hash) changed.push(key);
+    else if (serverHash !== hash) {
+      changed.push(key);
+      const clientFields = clientShapes[key];
+      const activeFields = serverModels.find((model) => model.key === key)?.fields;
+      if (clientFields && activeFields) for (const field of new Set([...Object.keys(clientFields), ...Object.keys(activeFields)])) {
+        const client = clientFields[field];
+        const active = activeFields[field];
+        if (!active) fields.push({ model: key, field, direction: 'client_only', detail: 'present in this build but absent from the active schema' });
+        else if (!client) fields.push({ model: key, field, direction: 'active_only', detail: 'present in the active schema but absent from this build' });
+        else if (client.type !== active.type || client.isOptional !== active.isOptional) fields.push({ model: key, field, direction: 'changed', detail: `${client.type}${client.isOptional ? ' optional' : ' required'} in this build and ${active.type}${active.isOptional ? ' optional' : ' required'} in the active schema` });
+      }
+    }
   }
-  if (changed.length > 0) return { kind: 'changed', models: changed, unpushed };
+  if (changed.length > 0) return { kind: 'changed', models: changed, unpushed, ...(fields.length ? { fields } : {}) };
   if (unpushed.length > 0) return { kind: 'unpushed', models: unpushed };
   return { kind: 'aligned' };
 }
@@ -69,18 +88,15 @@ export function describeSchemaDrift(
   finding: Extract<SchemaDriftFinding, { kind: 'unpushed' | 'changed' }>,
   serverLabel: string,
 ): string {
-  if (finding.kind === 'unpushed') {
-    return (
-      `Ablo: This build declares models the server at ${serverLabel} doesn't have yet ` +
-      `(${finding.models.join(', ')}). Writes to them will be declined until the schema is ` +
-      `pushed — run \`ablo push\` (and \`ablo status\` to confirm it targets this server).`
-    );
-  }
-  const alsoUnpushed = finding.unpushed.length > 0 ? ` (${finding.unpushed.join(', ')} not pushed yet)` : '';
-  return (
-    `Ablo: These models differ between this build and the server at ${serverLabel}: ` +
-    `${finding.models.join(', ')}${alsoUnpushed}. Reads and writes touching what changed may be ` +
-    `declined — \`ablo status\` shows the deployed shape; pushing your schema or deploying a ` +
-    `current build aligns them.`
-  );
+  const findings = finding.kind === 'unpushed'
+    ? reconcileClientToActive([], finding.models, serverLabel)
+    : reconcileClientToActive(finding.models, finding.unpushed, serverLabel, finding.fields ?? []);
+  const changed = findings.filter(({ code }) => code === 'model_changed').map(({ model }) => model).filter(Boolean);
+  const unpushed = findings.filter(({ code }) => code === 'model_unpushed').map(({ model }) => model).filter(Boolean);
+  const summary = [
+    ...findings.filter(({ field }) => field !== undefined).map(({ message }) => message),
+    ...(changed.length ? [`Models ${changed.join(', ')} differ between this build and the active schema at ${serverLabel}.`] : []),
+    ...(unpushed.length ? [`Models ${unpushed.join(', ')} are declared by this build but are not active at ${serverLabel}.`] : []),
+  ];
+  return `Ablo: ${summary.join(' ')} ${findings.map(({ action }) => action).filter((value, index, all) => all.indexOf(value) === index).join(' ')}`;
 }

package/src/local/sync/schemas.ts

@@ -10,7 +10,7 @@ import { z } from 'zod';
 import { globalRuntime } from "../context.js";
 import type { RuntimeContext } from "../RuntimeContext.js";
 import { AbloValidationError } from "@abloatai/transaction/errors";
-import { syncDeltaWireCoreSchema } from '@abloatai/transaction/wire/delta';
+import { syncDeltaWireCoreSchema } from '@abloatai/transaction/observation';
 
 // ─── Server Delta Schema ─────────────────────────────────────────────────────
 

package/src/local/sync/wsFrameHandlers.ts

@@ -17,4 +17,4 @@ export {
   type WsInboundFrame,
   type WsSession,
   type WsFrameHandler,
-} from '@abloatai/transaction/transport/wsFrameHandlers';
+} from '@abloatai/transaction/transport/websocket';

package/src/local/transactions/databaseCommitOutbox.ts

@@ -1,7 +1,7 @@
 import type {
   DurableWriteStore,
-} from '@abloatai/transaction/durableWrites';
-import type { PendingWrite } from '@abloatai/transaction/transactions/confirmation/pendingWrite';
+} from '@abloatai/transaction/commit';
+import type { PendingWrite } from '@abloatai/transaction/commit';
 
 export interface CommitOutboxDatabase {
   sealTransactionRecord(

package/src/local/transactions/mutations/MutationQueue.ts

@@ -27,11 +27,11 @@ import {
   type LogPositionPort,
 } from '../../logPosition.js';
 import type { WriteOptions } from '../../interfaces/index.js';
-import type { OnStaleMode, StaleNotification, ReadDependency, TrackDependency } from '@abloatai/transaction/coordination/schema';
+import type { ReadDependency } from '@abloatai/transaction/coordination/schema';
 import {
   type CommitOperationResult,
   type MutationCommitResult,
-} from '@abloatai/transaction/wire/commit';
+} from '@abloatai/transaction/commit';
 import {
   computePriorityScore,
   normalizeModelKey,
@@ -74,9 +74,8 @@ import {
   createCommitEnvelopeMember,
   type DurableCommitEnvelope,
   type CommitOutboxScope,
-} from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+} from '@abloatai/transaction/commit';
 import type { DurableWriteStore } from './durableWriteStore.js';
-import { stableStringify } from '@abloatai/transaction/utils/json';
 import {
   createLocalMutationPort,
   type LocalMutationPort,
@@ -108,7 +107,7 @@ import {
 import { enqueueTransaction, type QueueCoalescingContext } from './queueCoalescing.js';
 import { processBatch, type BatchProcessingContext } from './batchProcessing.js';
 import { handleFailure, type FailureHandlingContext } from './failureHandling.js';
-import { handleConflict as resolveConflict, isPermanentError as classifyPermanentError, isDefinitiveRejection as classifyDefinitiveRejection, type ConflictPolicyContext } from './failurePolicy.js';
+import { handleConflict as resolveConflict, isPermanentError as classifyPermanentError, isDefinitiveRejection as classifyDefinitiveRejection, type ConflictResolutionContext } from './failurePolicy.js';
 import { takeNextExecutionBatch as selectExecutionBatch, takePendingDrainBatch as selectPendingDrainBatch } from './executionSelection.js';
 import { scheduleProcessing as scheduleProcessingExternal, type ProcessingSchedulerContext } from './processingScheduler.js';
 import {
@@ -314,7 +313,6 @@ export class MutationQueue extends EventEmitter {
         retryBackoff: this.config.retryBackoff,
       },
       commitLane: this.commitLane,
-      commitNotifications: this.commitNotifications,
       commitMissingIds: this.commitMissingIds,
       commitProcessing: this.commitProcessing,
       setCommitProcessing: (value) => { this.commitProcessing = value; },
@@ -325,7 +323,6 @@ export class MutationQueue extends EventEmitter {
         await this.dispatchCommitBounded(envelope.operations, {
           idempotencyKey: envelope.idempotencyKey,
           ...(envelope.commitOptions.reads ? { reads: envelope.commitOptions.reads } : {}),
-          ...(envelope.commitOptions.track ? { track: envelope.commitOptions.track } : {}),
         }),
       ),
       persistDurableCommitAcceptance: (envelope, result) => this.persistDurableCommitAcceptance(envelope, result),
@@ -350,7 +347,6 @@ export class MutationQueue extends EventEmitter {
   private get commitReceiptContext(): CommitReceiptContext {
     return {
       commitStore: this.commitStore,
-      commitNotifications: this.commitNotifications,
       commitMissingIds: this.commitMissingIds,
       replicationLagErrors: this.replicationLagErrors,
       on: (event, listener) => this.on(event, listener),
@@ -437,7 +433,6 @@ export class MutationQueue extends EventEmitter {
       store: this.store,
       enqueue: (transaction) => { this.enqueue(transaction); },
       optimisticUpdates: this.localMutationPort.updates,
-      commitNotifications: this.commitNotifications,
       commitMissingIds: this.commitMissingIds,
       sourceMutationIdsFor: (batch) => this.sourceMutationIdsFor(batch),
       dispatchCommitBounded: (...args) => this.dispatchCommitBounded(...args),
@@ -447,8 +442,6 @@ export class MutationQueue extends EventEmitter {
       assertEnvelopeInsideReplayWindow: (envelope) => { this.assertEnvelopeInsideReplayWindow(envelope); },
       sealDurableCommit: (input) => this.sealDurableCommit(input),
       noteAck: (syncId) => { this.noteAck(syncId); },
-      classifyReceiptNotifications: (operations, notifications) => this.classifyReceiptNotifications(operations, notifications),
-      receiptTargetKey: (modelName, modelId) => this.receiptTargetKey(modelName, modelId),
       scheduleReplicationLagTimeout: (transactionId, clientTxId, correlationId) => { this.scheduleReplicationLagTimeout(transactionId, clientTxId, correlationId); },
       scheduleDeltaConfirmationTimeout: (transaction, timeoutMs) => { this.scheduleDeltaConfirmationTimeout(transaction, timeoutMs); },
       clearReplicationLagState: (transactionId) => { this.clearReplicationLagState(transactionId); },
@@ -479,7 +472,7 @@ export class MutationQueue extends EventEmitter {
     };
   }
 
-  private get conflictPolicyContext(): ConflictPolicyContext {
+  private get conflictResolutionContext(): ConflictResolutionContext {
     return {
       config: this.config,
       store: this.store,
@@ -623,80 +616,7 @@ export class MutationQueue extends EventEmitter {
     return entityKey(modelName, modelId);
   }
 
-  /** Collision-safe receipt target identity across models sharing a row id. */
-  private receiptTargetKey(modelName: string, modelId: string): string {
-    return stableStringify([normalizeModelKey(modelName), modelId]);
-  }
-
-  /**
-   * Relates stale notifications back to write targets without assuming the
-   * server's canonical model name uses the same spelling as the public schema
-   * key (`Item` versus `items`). Exact `(model,id)` wins; a globally unique id
-   * is the compatibility fallback. An ambiguous same-id cross-model mismatch
-   * is deliberately left unclassified, so it cannot falsely settle a queued
-   * write. A notification with no write-target id (or an explicit group) is a
-   * declared-read conflict and holds the whole batch.
-   */
-  private classifyReceiptNotifications(
-    operations: readonly { model: string; id: string }[],
-    notifications: readonly StaleNotification[],
-  ): {
-    holdsEntireBatch: boolean;
-    heldTargets: Set<string>;
-    notificationsByTarget: Map<string, StaleNotification[]>;
-  } {
-    const targets = operations.map((operation) => ({
-      id: operation.id,
-      key: this.receiptTargetKey(operation.model, operation.id),
-    }));
-    const heldTargets = new Set<string>();
-    const notificationsByTarget = new Map<string, StaleNotification[]>();
-    let holdsEntireBatch = false;
-
-    for (const notification of notifications) {
-      // Scope is decided before any target matching. A group premise fires over
-      // the WHOLE batch by convention, and its `target` now names the row that
-      // actually moved — which may well be a row this batch is writing, so
-      // matching first would misread a batch-wide hold as a per-row one.
-      if (notification.scope === 'group') {
-        holdsEntireBatch = true;
-        continue;
-      }
-      const candidates = targets.filter(
-        (target) => target.id === notification.target.id,
-      );
-      const notificationKey = this.receiptTargetKey(
-        notification.target.model,
-        notification.target.id,
-      );
-      const exactTargets = candidates.filter(
-        (target) => target.key === notificationKey,
-      );
-      const candidateKeys = new Set(
-        (exactTargets.length > 0 ? exactTargets : candidates).map(
-          (target) => target.key,
-        ),
-      );
-
-      if (candidates.length === 0) {
-        holdsEntireBatch = true;
-        continue;
-      }
-      if (candidateKeys.size !== 1) {
-        // Same id across multiple differently named models with no exact match:
-        // the id-only compatibility fallback is ambiguous. Await the echo.
-        continue;
-      }
-      const [targetKey] = candidateKeys;
-      if (!targetKey) continue;
-      heldTargets.add(targetKey);
-      const targetNotifications = notificationsByTarget.get(targetKey) ?? [];
-      targetNotifications.push(notification);
-      notificationsByTarget.set(targetKey, targetNotifications);
-    }
-
-    return { holdsEntireBatch, heldTargets, notificationsByTarget };
-  }
+  /* Stale receipt classification was removed; stale premises now reject. */
 
   private resolveConfirmation(transaction: QueuedMutation): void {
     const resolver = this.confirmationResolvers.get(transaction.id);
@@ -807,11 +727,6 @@ export class MutationQueue extends EventEmitter {
 
   private readonly localMutationPort: LocalMutationPort;
 
-  // Stale-context notifications, keyed by transaction id. When the server
-  // accepts a commit but reports that an operation's premise had moved,
-  // the notification lands here from the commit acknowledgement and is drained
-  // by `waitForCommitReceipt`, so the receipt can carry it back to the caller.
-  private commitNotifications = new Map<string, StaleNotification[]>();
   /** Zero-row targets returned on a successful atomic commit receipt. */
   private commitMissingIds = new Map<string, string[]>();
 
@@ -1674,7 +1589,7 @@ export class MutationQueue extends EventEmitter {
   async enqueueCommit(
     clientTxId: string,
     operations: CommitTransaction['operations'],
-    options: { reads?: ReadDependency[] | null; track?: TrackDependency[] | null } = {},
+    options: { reads?: ReadDependency[] | null } = {},
   ): Promise<void> {
     return enqueueCommit(this.commitApiContext, clientTxId, operations, options);
   }
@@ -1687,7 +1602,6 @@ export class MutationQueue extends EventEmitter {
     clientTxId: string,
   ): Promise<{
     lastSyncId: number;
-    notifications?: StaleNotification[];
     missingIds?: string[];
     operationResults?: CommitOperationResult[];
   }> {
@@ -1712,7 +1626,7 @@ export class MutationQueue extends EventEmitter {
   }
 
   async handleConflict(transaction: QueuedMutation, serverData: MutationInput): Promise<void> {
-    await resolveConflict(this.conflictPolicyContext, transaction, serverData);
+    await resolveConflict(this.conflictResolutionContext, transaction, serverData);
   }
 
   private applyOptimisticCreate(model: LocalModel, transaction: QueuedMutation): void {
@@ -2013,7 +1927,6 @@ export class MutationQueue extends EventEmitter {
     this.recentDeltaCorrelations.clear();
     this.commitLane = [];
     this.commitStore.clear();
-    this.commitNotifications.clear();
     this.commitMissingIds.clear();
 
     // Clear event listeners

package/src/local/transactions/mutations/batchProcessing.ts

@@ -3,10 +3,9 @@ import type { MutationQueueConfig } from './MutationQueue.js';
 import type { MutationInput, QueuedMutation } from './commitPayload.js';
 import type { MutationStore } from './MutationStore.js';
 import type { OptimisticUpdateEntry } from './localMutation.js';
-import type { StaleNotification } from '@abloatai/transaction/coordination/schema';
 import type { DeltaConfirmationTracker } from './deltaConfirmation.js';
-import type { MutationCommitResult } from '@abloatai/transaction/wire/commit';
-import type { DurableCommitEnvelope } from '@abloatai/transaction/transactions/confirmation/commitEnvelope';
+import type { MutationCommitResult } from '@abloatai/transaction/commit';
+import type { DurableCommitEnvelope } from '@abloatai/transaction/commit';
 import { AbloError, AbloNotFoundError } from '@abloatai/transaction/errors';
 import { applyWriteOptions, normalizeModelKey, TX_TYPE_TO_MUTATION_OP, type WriteOperationFields } from './commitPayload.js';
 import type { MutationOperationType } from '@abloatai/transaction/types';
@@ -30,7 +29,6 @@ export interface BatchProcessingContext {
   readonly store: MutationStore;
   readonly enqueue: (transaction: QueuedMutation) => void;
   readonly optimisticUpdates: Map<string, OptimisticUpdateEntry>;
-  readonly commitNotifications: Map<string, StaleNotification[]>;
   readonly commitMissingIds: Map<string, string[]>;
   readonly sourceMutationIdsFor: (batch: readonly QueuedMutation[]) => string[];
   readonly dispatchCommitBounded: (...args: Parameters<import('../../interfaces/index.js').MutationExecutor['commit']>) => ReturnType<import('../../interfaces/index.js').MutationExecutor['commit']>;
@@ -40,11 +38,6 @@ export interface BatchProcessingContext {
   readonly assertEnvelopeInsideReplayWindow: (envelope: DurableCommitEnvelope) => void;
   readonly sealDurableCommit: (input: Parameters<typeof import('./commitTransport.js').sealDurableCommit>[1]) => Promise<DurableCommitEnvelope>;
   readonly noteAck: (syncId: number | undefined) => void;
-  readonly classifyReceiptNotifications: (
-    operations: readonly { model: string; id: string }[],
-    notifications: readonly StaleNotification[],
-  ) => { holdsEntireBatch: boolean; heldTargets: Set<string>; notificationsByTarget: Map<string, StaleNotification[]> };
-  readonly receiptTargetKey: (modelName: string, modelId: string) => string;
   readonly scheduleReplicationLagTimeout: (transactionId: string, clientTxId?: string, correlationId?: string) => void;
   readonly scheduleDeltaConfirmationTimeout: (transaction: QueuedMutation, timeoutMs: number) => void;
   readonly clearReplicationLagState: (transactionId: string) => void;
@@ -170,24 +163,6 @@ export async function processBatch(ctx: BatchProcessingContext): Promise<void> {
               );
               const lastSyncId = result.lastSyncId;
 
-              const notifications = result.notifications;
-              const {
-                holdsEntireBatch,
-                heldTargets,
-                notificationsByTarget,
-              } = ctx.classifyReceiptNotifications(
-                batchOps.map(({ op }) => ({ model: op.model, id: op.id })),
-                notifications ?? [],
-              );
-              for (const { tx } of batchOps) {
-                const txTarget = ctx.receiptTargetKey(tx.modelKey, tx.modelId);
-                const txNotifs = holdsEntireBatch
-                  ? notifications
-                  : notificationsByTarget.get(txTarget);
-                if (txNotifs && txNotifs.length > 0) {
-                  ctx.commitNotifications.set(tx.id, txNotifs);
-                }
-              }
               const missingIds = new Set(result.missingIds ?? []);
               const settlingBatchOps: typeof batchOps = [];
               for (const entry of batchOps) {
@@ -202,17 +177,6 @@ export async function processBatch(ctx: BatchProcessingContext): Promise<void> {
                   );
                   continue;
                 }
-                if (
-                  holdsEntireBatch ||
-                  heldTargets.has(ctx.receiptTargetKey(tx.modelKey, tx.modelId))
-                ) {
-                  await ctx.rollbackOptimistic(tx, 'conflict_server_wins');
-                  ctx.store.updateStatus(tx.id, 'completed');
-                  ctx.emit('transaction:completed', tx);
-                  ctx.emit(`transaction:completed:${tx.id}`, tx);
-                  ctx.optimisticUpdates.delete(tx.id);
-                  continue;
-                }
                 settlingBatchOps.push(entry);
               }