@taskforcehq/taskforce 0.3.328 → 0.3.330

package/dist/storage/postgresAdapter.js

@@ -3,13 +3,38 @@ import { Worker } from 'worker_threads';
 import { performance } from 'node:perf_hooks';
 import { assertSynchronousTransactionResult, } from './databaseAdapter.js';
 import { recordPostgresWorkerWait } from './postgresRequestDiagnostics.js';
+import { resolvePostgresWorkerDeadlines, } from './postgresWorkerProtocol.js';
 const RESPONSE_STATUS_INDEX = 0;
 const RESPONSE_LENGTH_INDEX = 1;
 const RESPONSE_READY = 1;
 const RESPONSE_INITIAL = 0;
-const RESPONSE_TIMEOUT_MS = 20_000;
 const RESPONSE_BUFFER_BYTES = 2 * 1024 * 1024;
 const MAX_RESPONSE_BUFFER_BYTES = 64 * 1024 * 1024;
+export class PostgresWorkerOutcomeUnknownError extends Error {
+    code = 'POSTGRES_WORKER_OUTCOME_UNKNOWN';
+    operation;
+    constructor(operation, detail = 'response deadline exceeded') {
+        super(`[Taskforce] Postgres worker ${operation} outcome is unknown (${detail}). `
+            + 'Do not retry a write without the same idempotency identity.');
+        this.name = 'PostgresWorkerOutcomeUnknownError';
+        this.operation = operation;
+    }
+}
+export class PostgresWorkerUnavailableError extends Error {
+    code = 'POSTGRES_WORKER_UNAVAILABLE';
+    constructor() {
+        super('[Taskforce] Postgres worker is recovering after a failed operation.');
+        this.name = 'PostgresWorkerUnavailableError';
+    }
+}
+export class PostgresDatabaseError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'PostgresDatabaseError';
+    }
+}
 function isPlainObject(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
@@ -62,39 +87,102 @@ function toRowCount(result) {
 }
 export class PostgresAdapter {
     provider = 'postgres';
-    open = true;
-    worker;
+    worker = null;
+    connectionString;
+    deadlines;
+    retiringWorkers = new WeakSet();
+    consecutiveUnexpectedExits = 0;
+    closed = false;
     encoder = new TextEncoder();
     decoder = new TextDecoder();
     txId = null;
     savepointCounter = 0;
-    constructor(connectionString) {
+    constructor(connectionString, deadlineOptions = {}) {
         if (!connectionString || !connectionString.trim()) {
             throw new Error('[Taskforce] Postgres adapter requires a non-empty connection string.');
         }
-        this.worker = new Worker(new URL('./postgresWorker.js', import.meta.url), {
+        this.connectionString = connectionString;
+        this.deadlines = resolvePostgresWorkerDeadlines(deadlineOptions);
+        this.worker = this.createWorker();
+    }
+    get open() {
+        return !this.closed;
+    }
+    createWorker() {
+        const worker = new Worker(new URL('./postgresWorker.js', import.meta.url), {
             workerData: {
-                connectionString
+                connectionString: this.connectionString,
+                deadlines: this.deadlines,
+            }
+        });
+        worker.on('error', () => {
+            // The exit handler replaces an unexpectedly failed worker. Keeping an error
+            // listener here also prevents Worker from escalating it as an uncaught error.
+        });
+        worker.on('exit', () => {
+            if (this.closed || this.retiringWorkers.has(worker) || this.worker !== worker)
+                return;
+            this.worker = null;
+            if (this.consecutiveUnexpectedExits >= 1)
+                return;
+            this.consecutiveUnexpectedExits += 1;
+            try {
+                this.worker = this.createWorker();
+            }
+            catch {
+                // Leave the adapter unavailable instead of creating an unbounded restart loop.
+            }
+        });
+        return worker;
+    }
+    quarantineWorker(worker) {
+        if (this.worker === worker)
+            this.worker = null;
+        this.txId = null;
+        this.retiringWorkers.add(worker);
+        void worker.terminate()
+            .catch(() => undefined)
+            .finally(() => {
+            if (this.closed || this.worker)
+                return;
+            try {
+                this.worker = this.createWorker();
+            }
+            catch {
+                // A later process-level health check can restart a persistently broken runtime.
             }
         });
     }
     callWorker(payload, responseBufferBytes = RESPONSE_BUFFER_BYTES) {
+        if (this.closed)
+            throw new Error('[Taskforce] Postgres adapter is closed.');
+        const worker = this.worker;
+        if (!worker)
+            throw new PostgresWorkerUnavailableError();
         const statusBuffer = new SharedArrayBuffer(8);
         const status = new Int32Array(statusBuffer);
         status[RESPONSE_STATUS_INDEX] = RESPONSE_INITIAL;
         status[RESPONSE_LENGTH_INDEX] = 0;
         const responseBuffer = new SharedArrayBuffer(responseBufferBytes);
         const responseBytes = new Uint8Array(responseBuffer);
-        this.worker.postMessage({
-            payload,
-            statusBuffer,
-            responseBuffer
-        });
+        try {
+            worker.postMessage({
+                payload,
+                statusBuffer,
+                responseBuffer
+            });
+        }
+        catch (error) {
+            this.quarantineWorker(worker);
+            const detail = error instanceof Error ? error.message : 'worker transport failed';
+            throw new PostgresWorkerOutcomeUnknownError(payload.op, detail);
+        }
         const waitStartedAt = performance.now();
-        const waitResult = Atomics.wait(status, RESPONSE_STATUS_INDEX, RESPONSE_INITIAL, RESPONSE_TIMEOUT_MS);
+        const waitResult = Atomics.wait(status, RESPONSE_STATUS_INDEX, RESPONSE_INITIAL, this.deadlines.responseTimeoutMs);
         recordPostgresWorkerWait(payload.op, performance.now() - waitStartedAt);
         if (waitResult === 'timed-out') {
-            throw new Error('[Taskforce] Postgres worker timed out.');
+            this.quarantineWorker(worker);
+            throw new PostgresWorkerOutcomeUnknownError(payload.op);
         }
         const responseLength = status[RESPONSE_LENGTH_INDEX];
         if (!Number.isFinite(responseLength) || responseLength <= 0 || responseLength > responseBufferBytes) {
@@ -102,6 +190,7 @@ export class PostgresAdapter {
         }
         const body = this.decoder.decode(responseBytes.subarray(0, responseLength));
         const parsed = JSON.parse(body);
+        this.consecutiveUnexpectedExits = 0;
         if (!parsed.ok && parsed.errorCode === 'RESPONSE_BUFFER_TOO_SMALL') {
             const requiredBytes = Number(parsed.requiredBytes);
             const responseToken = String(parsed.responseToken || '').trim();
@@ -114,6 +203,9 @@ export class PostgresAdapter {
             return this.callWorker({ op: 'read-response', responseToken }, requiredBytes);
         }
         if (!parsed.ok) {
+            if (parsed.databaseErrorCode) {
+                throw new PostgresDatabaseError(parsed.error || 'Unknown Postgres database error', parsed.databaseErrorCode);
+            }
             throw new Error(parsed.error || 'Unknown Postgres worker error');
         }
         return parsed;
@@ -230,11 +322,22 @@ export class PostgresAdapter {
         return options?.simple ? null : [];
     }
     close() {
+        if (this.closed)
+            return;
+        const worker = this.worker;
+        if (!worker) {
+            this.closed = true;
+            return;
+        }
         try {
             this.callWorker({ op: 'close' });
         }
         finally {
-            this.worker.terminate();
+            this.closed = true;
+            if (this.worker === worker)
+                this.worker = null;
+            this.retiringWorkers.add(worker);
+            void worker.terminate();
         }
     }
 }

package/dist/storage/postgresWorker.js

@@ -14,11 +14,16 @@ function pruneRetainedResponses(now = Date.now()) {
             retainedResponses.delete(token);
     }
 }
-function createPool(connectionString) {
+function createPool(connectionString, deadlines) {
     const require = createRequire(import.meta.url);
     try {
         const pg = require('pg');
-        return new pg.Pool({ connectionString });
+        return new pg.Pool({
+            connectionString,
+            connectionTimeoutMillis: deadlines.connectionTimeoutMs,
+            statement_timeout: deadlines.statementTimeoutMs,
+            idle_in_transaction_session_timeout: deadlines.idleTransactionTimeoutMs,
+        });
     }
     catch (error) {
         const detail = error instanceof Error ? ` (${error.message})` : '';
@@ -96,11 +101,15 @@ function writeRetainedResponse(statusBuffer, responseBuffer, responseToken) {
     Atomics.store(status, RESPONSE_STATUS_INDEX, RESPONSE_READY);
     Atomics.notify(status, RESPONSE_STATUS_INDEX, 1);
 }
-const connectionString = String(workerData?.connectionString || '').trim();
+const runtimeOptions = workerData;
+const connectionString = String(runtimeOptions?.connectionString || '').trim();
 if (!connectionString) {
     throw new Error('[Taskforce] Postgres worker requires connection string.');
 }
-const pool = createPool(connectionString);
+if (!runtimeOptions.deadlines) {
+    throw new Error('[Taskforce] Postgres worker requires deadline configuration.');
+}
+const pool = createPool(connectionString, runtimeOptions.deadlines);
 const txClients = new Map();
 async function handleMessage(message) {
     const { payload } = message;
@@ -169,6 +178,14 @@ parentPort.on('message', async (message) => {
     }
     catch (error) {
         const messageText = error instanceof Error ? error.message : String(error);
-        writeResponse(message.statusBuffer, message.responseBuffer, { ok: false, error: messageText });
+        const databaseErrorCode = error && typeof error === 'object'
+            && typeof error.code === 'string'
+            ? String(error.code)
+            : undefined;
+        writeResponse(message.statusBuffer, message.responseBuffer, {
+            ok: false,
+            error: messageText,
+            ...(databaseErrorCode ? { databaseErrorCode } : {}),
+        });
     }
 });

package/dist/storage/postgresWorkerProtocol.d.ts

@@ -0,0 +1,30 @@
+export type PostgresWorkerOperation = 'query' | 'begin' | 'commit' | 'rollback' | 'close' | 'read-response';
+export type PostgresWorkerRequestPayload = {
+    op: PostgresWorkerOperation;
+    sql?: string;
+    values?: unknown[];
+    txId?: string;
+    responseToken?: string;
+};
+export type PostgresWorkerQueryResult = {
+    rows: Record<string, unknown>[];
+    rowCount?: number;
+};
+export type PostgresWorkerResponsePayload = {
+    ok: boolean;
+    result?: PostgresWorkerQueryResult;
+    error?: string;
+    errorCode?: 'RESPONSE_BUFFER_TOO_SMALL';
+    databaseErrorCode?: string;
+    requiredBytes?: number;
+    responseToken?: string;
+};
+export type PostgresWorkerDeadlines = {
+    responseTimeoutMs: number;
+    statementTimeoutMs: number;
+    connectionTimeoutMs: number;
+    idleTransactionTimeoutMs: number;
+};
+export type PostgresAdapterDeadlineOptions = Partial<PostgresWorkerDeadlines>;
+export declare const DEFAULT_POSTGRES_WORKER_DEADLINES: PostgresWorkerDeadlines;
+export declare function resolvePostgresWorkerDeadlines(options?: PostgresAdapterDeadlineOptions): PostgresWorkerDeadlines;

package/dist/storage/postgresWorkerProtocol.js

@@ -0,0 +1,30 @@
+export const DEFAULT_POSTGRES_WORKER_DEADLINES = {
+    responseTimeoutMs: 20_000,
+    statementTimeoutMs: 15_000,
+    connectionTimeoutMs: 3_000,
+    idleTransactionTimeoutMs: 60_000,
+};
+const MIN_RESPONSE_MARGIN_MS = 100;
+function positiveInteger(value, name) {
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw new Error(`[Taskforce] ${name} must be a positive integer.`);
+    }
+    return parsed;
+}
+export function resolvePostgresWorkerDeadlines(options = {}) {
+    const deadlines = {
+        responseTimeoutMs: positiveInteger(options.responseTimeoutMs ?? DEFAULT_POSTGRES_WORKER_DEADLINES.responseTimeoutMs, 'Postgres worker response timeout'),
+        statementTimeoutMs: positiveInteger(options.statementTimeoutMs ?? DEFAULT_POSTGRES_WORKER_DEADLINES.statementTimeoutMs, 'Postgres statement timeout'),
+        connectionTimeoutMs: positiveInteger(options.connectionTimeoutMs ?? DEFAULT_POSTGRES_WORKER_DEADLINES.connectionTimeoutMs, 'Postgres connection timeout'),
+        idleTransactionTimeoutMs: positiveInteger(options.idleTransactionTimeoutMs ?? DEFAULT_POSTGRES_WORKER_DEADLINES.idleTransactionTimeoutMs, 'Postgres idle transaction timeout'),
+    };
+    if (deadlines.connectionTimeoutMs
+        + deadlines.statementTimeoutMs
+        + MIN_RESPONSE_MARGIN_MS
+        > deadlines.responseTimeoutMs) {
+        throw new Error('[Taskforce] Postgres connection and statement timeouts must together leave at least '
+            + `${MIN_RESPONSE_MARGIN_MS}ms before the worker response timeout.`);
+    }
+    return deadlines;
+}

package/dist/storage/taskforceAgentConnectionBindingStore.d.ts

@@ -0,0 +1,31 @@
+import type { DatabaseAdapter } from './databaseAdapter.js';
+export interface TaskforceAgentConnectionBindingRecord {
+    tenantId: string;
+    workspaceId: string;
+    agentId: string;
+    connectionId: string;
+    ownerUserId: string;
+    providerKey: string;
+    modelSource: string;
+    createdByUserId: string;
+    updatedByUserId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare class TaskforceAgentConnectionBindingStore {
+    private readonly db;
+    private readonly tenantId;
+    private readonly now;
+    constructor(db: DatabaseAdapter, tenantId: string, now?: () => Date);
+    get(workspaceIdRaw: string, agentIdRaw: string): TaskforceAgentConnectionBindingRecord | null;
+    bind(input: {
+        workspaceId: string;
+        agentId: string;
+        connectionId: string;
+        ownerUserId: string;
+        providerKey: string;
+        modelSource: string;
+        actorUserId: string;
+    }): TaskforceAgentConnectionBindingRecord | null;
+    clear(workspaceIdRaw: string, agentIdRaw: string, ownerUserIdRaw: string): boolean;
+}

package/dist/storage/taskforceAgentConnectionBindingStore.js

@@ -0,0 +1,84 @@
+function normalizeRequired(value, label) {
+    const normalized = String(value || '').trim();
+    if (!normalized)
+        throw new Error(`${label} is required.`);
+    return normalized;
+}
+function mapRow(row) {
+    return {
+        tenantId: String(row.tenant_id || ''),
+        workspaceId: String(row.workspace_id || ''),
+        agentId: String(row.agent_id || ''),
+        connectionId: String(row.connection_id || ''),
+        ownerUserId: String(row.owner_user_id || ''),
+        providerKey: String(row.provider_key || ''),
+        modelSource: String(row.model_source || ''),
+        createdByUserId: String(row.created_by_user_id || ''),
+        updatedByUserId: String(row.updated_by_user_id || ''),
+        createdAt: String(row.created_at || ''),
+        updatedAt: String(row.updated_at || ''),
+    };
+}
+export class TaskforceAgentConnectionBindingStore {
+    db;
+    tenantId;
+    now;
+    constructor(db, tenantId, now = () => new Date()) {
+        this.db = db;
+        this.tenantId = tenantId;
+        this.now = now;
+    }
+    get(workspaceIdRaw, agentIdRaw) {
+        const workspaceId = String(workspaceIdRaw || '').trim();
+        const agentId = String(agentIdRaw || '').trim();
+        if (!workspaceId || !agentId)
+            return null;
+        const row = this.db.prepare(`
+            SELECT *
+            FROM taskforce_agent_connection_bindings
+            WHERE tenant_id = ? AND workspace_id = ? AND agent_id = ?
+            LIMIT 1
+        `).get(this.tenantId, workspaceId, agentId);
+        return row ? mapRow(row) : null;
+    }
+    bind(input) {
+        const workspaceId = normalizeRequired(input.workspaceId, 'Workspace ID');
+        const agentId = normalizeRequired(input.agentId, 'Agent ID');
+        const connectionId = normalizeRequired(input.connectionId, 'Connection ID');
+        const ownerUserId = normalizeRequired(input.ownerUserId, 'Connection owner');
+        const providerKey = normalizeRequired(input.providerKey, 'Provider key');
+        const modelSource = normalizeRequired(input.modelSource, 'Model source');
+        const actorUserId = normalizeRequired(input.actorUserId, 'Actor user');
+        const now = this.now().toISOString();
+        const result = this.db.prepare(`
+            INSERT INTO taskforce_agent_connection_bindings (
+                tenant_id, workspace_id, agent_id, connection_id, owner_user_id,
+                provider_key, model_source, created_by_user_id, updated_by_user_id,
+                created_at, updated_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT (tenant_id, workspace_id, agent_id) DO UPDATE SET
+                connection_id = excluded.connection_id,
+                owner_user_id = excluded.owner_user_id,
+                provider_key = excluded.provider_key,
+                model_source = excluded.model_source,
+                updated_by_user_id = excluded.updated_by_user_id,
+                updated_at = excluded.updated_at
+            WHERE taskforce_agent_connection_bindings.owner_user_id = excluded.owner_user_id
+        `).run(this.tenantId, workspaceId, agentId, connectionId, ownerUserId, providerKey, modelSource, actorUserId, actorUserId, now, now);
+        if (Number(result.changes || 0) === 0)
+            return null;
+        return this.get(workspaceId, agentId);
+    }
+    clear(workspaceIdRaw, agentIdRaw, ownerUserIdRaw) {
+        const workspaceId = String(workspaceIdRaw || '').trim();
+        const agentId = String(agentIdRaw || '').trim();
+        const ownerUserId = String(ownerUserIdRaw || '').trim();
+        if (!workspaceId || !agentId || !ownerUserId)
+            return false;
+        const result = this.db.prepare(`
+            DELETE FROM taskforce_agent_connection_bindings
+            WHERE tenant_id = ? AND workspace_id = ? AND agent_id = ? AND owner_user_id = ?
+        `).run(this.tenantId, workspaceId, agentId, ownerUserId);
+        return Number(result.changes || 0) > 0;
+    }
+}

package/dist/sync/cloudSyncApi.d.ts

@@ -23,10 +23,13 @@ export type WorkspaceContentRequest = Pick<WorkspaceContentManifestEntry, 'kind'
     kind: 'asset';
     assetId: string;
 };
+export type WorkspaceContentMissingRequest = WorkspaceContentRequest & {
+    disposition?: 'retryable' | 'terminal-unavailable';
+};
 export interface WorkspaceContentPullResponse {
     success?: boolean;
     changes?: WorkspaceSyncChange[];
-    missing?: WorkspaceContentRequest[];
+    missing?: WorkspaceContentMissingRequest[];
     remaining?: WorkspaceContentRequest[];
     contentMetadata?: Array<{
         kind: 'document' | 'asset';

package/dist/sync/cloudSyncApi.js

@@ -1,4 +1,4 @@
-import { partitionWorkspaceSyncV2LegacyChanges } from './v3/workspaceSyncV2ProjectionExclusions.js';
+import { normalizeWorkspaceSyncV2ProjectionExclusions, partitionWorkspaceSyncV2LegacyChanges, } from './v3/workspaceSyncV2ProjectionExclusions.js';
 import { validateWorkspaceSyncEngineTransferCompletionGroup, } from './engine/workspaceSyncEngineTransferCompletion.js';
 import { WORKSPACE_SYNC_V3_COMBINED_COVERAGE_SELECTOR, resolveWorkspaceSyncV3CombinedCoverageForExclusions, resolveWorkspaceSyncV3CombinedWireContract } from './v3/workspaceSyncV3CombinedWireContract.js';
 const WORKSPACE_PULL_TIMEOUT_MS = 45_000;
@@ -696,12 +696,17 @@ export async function bootstrapPushWorkspaceSnapshot(resolveCloudAuthUrl, input)
     }));
 }
 export async function applyLocalWorkspaceChanges(workspaceId, changes, options) {
+    const excludedProjections = normalizeWorkspaceSyncV2ProjectionExclusions(options?.excludedProjections || []);
+    const combinedCoverage = excludedProjections.length
+        ? resolveWorkspaceSyncV3CombinedCoverageForExclusions(excludedProjections)
+        : null;
     const applyPayload = JSON.stringify({
         workspaceId,
         changes,
         workspaceMembers: Array.isArray(options?.workspaceMembers) ? options.workspaceMembers : undefined,
         ...(options?.repairMode === true ? { repair: true } : {}),
-        excludedProjections: options?.excludedProjections,
+        excludedProjections,
+        ...(combinedCoverage ? { combinedCoverage } : {}),
         contentPullObligations: options?.contentPullObligations,
         contentPullResolutionClaims: options?.contentPullResolutionClaims,
         ...localBrowserApplyPermitContext(workspaceId, options),

package/dist/sync/contentSyncState.d.ts

@@ -130,7 +130,7 @@ export declare function createContentSyncState(deps: ContentSyncStateDeps): {
         activeLinks: WorkspaceAssetLinkEntry[];
         effectiveUpdatedAt: string;
     };
-    getCanonicalSyncDocumentMetadata: (relativePath: string, workspaceId: string) => Omit<DocumentSyncPayload, "path" | "updatedAt" | "content">;
+    getCanonicalSyncDocumentMetadata: (relativePath: string, workspaceId: string) => Omit<DocumentSyncPayload, "updatedAt" | "path" | "content">;
     hasDocumentSyncMetadataDrift: (workspaceId: string, doc: DocumentSyncPayload, _options?: {
         allowReferenceNumberReassignment?: boolean;
     }) => boolean;

package/dist/sync/coordinator/localSyncExecutionPermitStore.d.ts

@@ -152,6 +152,7 @@ export declare class LocalSyncExecutionPermitStore {
         coordinatorGeneration: number;
         serverInstanceId: string;
         errorCode?: string;
+        readResponseUnavailableBeforeApply?: boolean;
     }): LocalSyncExecutionPermit;
     recoverExpiredPermits(input: {
         currentServerInstanceId: string;

package/dist/sync/coordinator/localSyncExecutionPermitStore.js

@@ -1,4 +1,4 @@
-import { randomUUID } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
 import { assertSynchronousTransactionResult, } from '../../storage/databaseAdapter.js';
 import { validateWorkspaceSyncEngineTransferCompletionGroup, } from '../engine/workspaceSyncEngineTransferCompletion.js';
 import { canonicalWorkspaceSyncJson } from '../v3/canonicalWorkspaceSyncJson.js';
@@ -619,9 +619,15 @@ export class LocalSyncExecutionPermitStore {
             if (current.state === 'local-commit-entered') {
                 throw new LocalSyncExecutionPermitError(`Execution permit ${input.permitId} is owned by the server local commit.`, 'SYNC_COORDINATOR_PERMIT_STATE_CONFLICT');
             }
+            const cleanReadFailure = input.readResponseUnavailableBeforeApply === true
+                && input.errorCode === 'SYNC_COORDINATOR_GATEWAY_REQUEST_FAILED'
+                && current.state === 'gateway-complete-awaiting-apply'
+                && current.upstreamDisposition === 'unknown'
+                && (current.operationClass === 'pull' || current.operationClass === 'repair');
             const clean = current.state === 'issued-idle'
                 || (current.state === 'gateway-complete-awaiting-apply'
-                    && current.upstreamDisposition === 'rejected');
+                    && current.upstreamDisposition === 'rejected')
+                || cleanReadFailure;
             const disposition = current.upstreamDisposition === 'accepted'
                 ? 'accepted'
                 : current.upstreamDisposition === 'rejected'
@@ -1401,36 +1407,67 @@ export class LocalSyncExecutionPermitStore {
         const requiredAction = mutationReplay
             ? 'replay-operation-then-reconcile'
             : 'refetch-from-committed-cursor';
-        const coalescesRepeatedApplyFailure = errorCode === 'WORKSPACE_SYNC_V3_APPLY_NOT_COMMITTED'
+        const coalescesLegacyApplyFailure = errorCode === 'WORKSPACE_SYNC_V3_APPLY_NOT_COMMITTED'
             || errorCode === 'WORKSPACE_SYNC_V3_ATTACHMENT_HYDRATION_NOT_COMMITTED';
-        if (coalescesRepeatedApplyFailure) {
-            const committedBoundary = canonicalWorkspaceSyncJson(permit.lastCommittedCursor);
-            const equivalentOpenObligation = this.db.prepare(`
-                SELECT obligation.*
-                FROM local_sync_recovery_obligations AS obligation
-                INNER JOIN local_sync_execution_permits AS origin
-                    ON origin.permit_id = obligation.permit_id
-                WHERE obligation.workspace_id = ?
-                  AND obligation.operation_class = ?
-                  AND obligation.upstream_disposition = ?
-                  AND obligation.required_action = ?
-                  AND obligation.resolved_at IS NULL
-                  AND origin.error_code = ?
-                ORDER BY obligation.created_at ASC
-            `).all(permit.workspaceId, permit.operationClass, disposition, requiredAction, errorCode).map(mapObligation).some((obligation) => ((obligation.operationIdentity || null) === (permit.operationIdentity || null)
-                && canonicalWorkspaceSyncJson(obligation.lastCommittedCursor) === committedBoundary));
-            if (equivalentOpenObligation)
-                return;
+        const coalescingKey = mutationReplay || coalescesLegacyApplyFailure
+            ? createHash('sha256').update(canonicalWorkspaceSyncJson(mutationReplay ? {
+                workspaceId: permit.workspaceId,
+                operationClass: permit.operationClass,
+                operationIdentity: permit.operationIdentity || null,
+                lastCommittedCursor: permit.lastCommittedCursor,
+                requiredAction,
+            } : {
+                workspaceId: permit.workspaceId,
+                operationClass: permit.operationClass,
+                operationIdentity: permit.operationIdentity || null,
+                upstreamDisposition: disposition,
+                lastCommittedCursor: permit.lastCommittedCursor,
+                requiredAction,
+                errorCode,
+            })).digest('hex')
+            : null;
+        // This store method normally runs inside the permit transition
+        // transaction. The nested transaction gives PostgreSQL a savepoint
+        // boundary while the partial unique index arbitrates concurrent
+        // equivalent inserts without poisoning the outer transaction.
+        let inserted = false;
+        try {
+            this.db.transaction(() => {
+                this.db.prepare(`
+                INSERT INTO local_sync_recovery_obligations (
+                    obligation_id, permit_id, workspace_id, operation_class,
+                    operation_identity, upstream_disposition,
+                    last_committed_cursor_json, required_action, coalescing_key,
+                    created_at, resolved_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)
+            `).run(this.createId(), permit.permitId, permit.workspaceId, permit.operationClass, permit.operationIdentity, disposition, permit.lastCommittedCursor === null
+                    ? null
+                    : JSON.stringify(permit.lastCommittedCursor), requiredAction, coalescingKey, this.now());
+                inserted = true;
+            })();
+        }
+        catch (error) {
+            const existing = coalescingKey
+                ? this.db.prepare(`
+                    SELECT obligation_id
+                    FROM local_sync_recovery_obligations
+                    WHERE coalescing_key = ? AND resolved_at IS NULL
+                `).get(coalescingKey)
+                : undefined;
+            if (!existing?.obligation_id)
+                throw error;
         }
+        if (inserted || !coalescingKey)
+            return;
         this.db.prepare(`
-            INSERT INTO local_sync_recovery_obligations (
-                obligation_id, permit_id, workspace_id, operation_class,
-                operation_identity, upstream_disposition, last_committed_cursor_json,
-                required_action, created_at, resolved_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)
-            ON CONFLICT (permit_id) DO NOTHING
-        `).run(this.createId(), permit.permitId, permit.workspaceId, permit.operationClass, permit.operationIdentity, disposition, permit.lastCommittedCursor === null
-            ? null
-            : JSON.stringify(permit.lastCommittedCursor), requiredAction, this.now());
+            UPDATE local_sync_recovery_obligations
+            SET upstream_disposition = CASE
+                WHEN upstream_disposition = 'accepted' OR ? = 'accepted' THEN 'accepted'
+                WHEN upstream_disposition = 'unknown' OR ? = 'unknown' THEN 'unknown'
+                WHEN upstream_disposition = 'rejected' OR ? = 'rejected' THEN 'rejected'
+                ELSE upstream_disposition
+            END
+            WHERE coalescing_key = ? AND resolved_at IS NULL
+        `).run(disposition, disposition, disposition, coalescingKey);
     }
 }

package/dist/sync/coordinator/localWorkspaceSyncPendingV2PushProgress.d.ts

@@ -0,0 +1,10 @@
+import type { LocalWorkspaceSyncPendingV2Push } from './localWorkspaceSyncRunnerState.js';
+export interface LocalWorkspaceSyncPendingV2PushProgress {
+    effectiveTotalBatches: number;
+    settledBatches: number;
+    effectiveTotalChanges: number;
+    settledChanges: number;
+    remainingChanges: number;
+    firstUnsettledBatchIndex: number | null;
+}
+export declare function resolveLocalWorkspaceSyncPendingV2PushProgress(pending: LocalWorkspaceSyncPendingV2Push | null | undefined): LocalWorkspaceSyncPendingV2PushProgress | null;

package/dist/sync/coordinator/localWorkspaceSyncPendingV2PushProgress.js

@@ -0,0 +1,29 @@
+export function resolveLocalWorkspaceSyncPendingV2PushProgress(pending) {
+    const plan = pending?.preparedPlan;
+    const settledIdentities = pending?.settledBatchOperationIdentities;
+    if (pending?.settlementVersion !== 1
+        || !plan
+        || !Array.isArray(settledIdentities)
+        || plan.batches.length !== plan.batchOperationIdentities.length
+        || new Set(plan.batchOperationIdentities).size !== plan.batchOperationIdentities.length
+        || new Set(settledIdentities).size !== settledIdentities.length
+        || settledIdentities.some((identity) => !plan.batchOperationIdentities.includes(identity))) {
+        return null;
+    }
+    const settled = new Set(settledIdentities);
+    const effectiveTotalChanges = plan.batches.reduce((total, batch) => total + batch.length, 0);
+    const settledChanges = plan.batches.reduce((total, batch, index) => (settled.has(plan.batchOperationIdentities[index])
+        ? total + batch.length
+        : total), 0);
+    const firstUnsettledBatchIndex = plan.batchOperationIdentities.findIndex((identity) => !settled.has(identity));
+    return {
+        effectiveTotalBatches: plan.batches.length,
+        settledBatches: settled.size,
+        effectiveTotalChanges,
+        settledChanges,
+        remainingChanges: effectiveTotalChanges - settledChanges,
+        firstUnsettledBatchIndex: firstUnsettledBatchIndex < 0
+            ? null
+            : firstUnsettledBatchIndex,
+    };
+}