@taskforcehq/taskforce 0.3.329 → 0.3.332

package/dist/storage/postgresWorker.js

@@ -111,6 +111,16 @@ if (!runtimeOptions.deadlines) {
 }
 const pool = createPool(connectionString, runtimeOptions.deadlines);
 const txClients = new Map();
+function withPoolSnapshot(payload) {
+    return {
+        ...payload,
+        pool: {
+            totalCount: Math.max(0, Number(pool.totalCount) || 0),
+            idleCount: Math.max(0, Number(pool.idleCount) || 0),
+            waitingCount: Math.max(0, Number(pool.waitingCount) || 0),
+        },
+    };
+}
 async function handleMessage(message) {
     const { payload } = message;
     const txId = payload.txId ? String(payload.txId) : null;
@@ -174,10 +184,18 @@ parentPort.on('message', async (message) => {
             return;
         }
         const response = await handleMessage(message);
-        writeResponse(message.statusBuffer, message.responseBuffer, response);
+        writeResponse(message.statusBuffer, message.responseBuffer, withPoolSnapshot(response));
     }
     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, withPoolSnapshot({
+            ok: false,
+            error: messageText,
+            ...(databaseErrorCode ? { databaseErrorCode } : {}),
+        }));
     }
 });

package/dist/storage/postgresWorkerProtocol.d.ts

@@ -10,13 +10,20 @@ export type PostgresWorkerQueryResult = {
     rows: Record<string, unknown>[];
     rowCount?: number;
 };
+export type PostgresWorkerPoolSnapshot = {
+    totalCount: number;
+    idleCount: number;
+    waitingCount: number;
+};
 export type PostgresWorkerResponsePayload = {
     ok: boolean;
     result?: PostgresWorkerQueryResult;
     error?: string;
     errorCode?: 'RESPONSE_BUFFER_TOO_SMALL';
+    databaseErrorCode?: string;
     requiredBytes?: number;
     responseToken?: string;
+    pool?: PostgresWorkerPoolSnapshot;
 };
 export type PostgresWorkerDeadlines = {
     responseTimeoutMs: number;

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/storage/workflowStore.d.ts

@@ -200,7 +200,9 @@ export declare class WorkflowStore {
     installAssignmentForSync(workspaceIdRaw: string, snapshot: WorkflowAssignmentSyncRecord, options: {
         authority: 'pending-intent' | 'cloud-execution';
         expectedTaskId: string;
+        replaceAuthoritativeHistory?: boolean;
     }): WorkflowExecutionStateRecord;
+    private runAssignmentSyncTransaction;
     appendExecutionTransition(input: {
         workspaceId: string;
         executionId: string;

package/dist/storage/workflowStore.js

@@ -759,7 +759,7 @@ export class WorkflowStore {
             || snapshot.execution.updatedAt !== snapshotProjection.updatedAt) {
             throw new WorkflowAssignmentSyncConflictError('Workflow assignment execution does not match its event history.');
         }
-        return this.db.transaction(() => {
+        return this.runAssignmentSyncTransaction(Boolean(options.authority === 'cloud-execution' && options.replaceAuthoritativeHistory), () => {
             const existingForTask = this.getActiveExecutionForTask(workspaceId, snapshot.execution.taskId);
             if (existingForTask && existingForTask.id !== snapshot.execution.id) {
                 throw new WorkflowAssignmentSyncConflictError('Task already has a different active workflow execution.');
@@ -852,7 +852,14 @@ export class WorkflowStore {
                     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 `).run(snapshot.execution.id, this.tenantId, workspaceId, snapshot.execution.taskId, snapshot.template.id, snapshot.version.id, snapshot.execution.status, snapshot.execution.currentStepId || null, snapshot.execution.createdByActorId || null, snapshot.execution.updatedByActorId || null, snapshot.execution.createdAt, snapshot.execution.updatedAt, snapshot.execution.startedAt || null, snapshot.execution.completedAt || null, snapshot.execution.endedAt || null, snapshot.execution.deletedAt || null);
             }
-            const canonicalEvents = this.listExecutionEvents(workspaceId, snapshot.execution.id);
+            let canonicalEvents = this.listExecutionEvents(workspaceId, snapshot.execution.id);
+            if (options.authority === 'cloud-execution' && options.replaceAuthoritativeHistory) {
+                this.db.prepare(`
+                    DELETE FROM workflow_execution_events
+                    WHERE tenant_id = ? AND workspace_id = ? AND workflow_execution_id = ?
+                `).run(this.tenantId, workspaceId, snapshot.execution.id);
+                canonicalEvents = [];
+            }
             const authoritativeHistoryIsExactPrefix = options.authority === 'cloud-execution'
                 && snapshot.events.length < canonicalEvents.length
                 && snapshot.events.every((event, index) => canonicalJson(event) === canonicalJson(canonicalEvents[index]));
@@ -908,6 +915,36 @@ export class WorkflowStore {
                 `).run(snapshotProjection.status, snapshotProjection.currentStepId || null, snapshot.execution.updatedByActorId || null, snapshotProjection.updatedAt, snapshotProjection.startedAt || null, snapshotProjection.completedAt || null, snapshotProjection.endedAt || null, snapshot.execution.deletedAt || null, this.tenantId, workspaceId, snapshot.execution.id);
             }
             return this.getExecutionStateSnapshot(workspaceId, snapshot.execution.id);
+        });
+    }
+    runAssignmentSyncTransaction(replaceAuthoritativeHistory, apply) {
+        return this.db.transaction(() => {
+            if (!replaceAuthoritativeHistory)
+                return apply();
+            if (this.db.provider === 'postgres') {
+                throw new WorkflowAssignmentSyncConflictError('Authoritative workflow history replacement is local-runtime only.');
+            }
+            this.db.exec(`
+                DROP TRIGGER IF EXISTS trg_workflow_execution_events_no_update;
+                DROP TRIGGER IF EXISTS trg_workflow_execution_events_no_delete;
+            `);
+            try {
+                return apply();
+            }
+            finally {
+                this.db.exec(`
+                    CREATE TRIGGER IF NOT EXISTS trg_workflow_execution_events_no_update
+                    BEFORE UPDATE ON workflow_execution_events
+                    BEGIN
+                        SELECT RAISE(ABORT, 'Workflow execution events are append-only');
+                    END;
+                    CREATE TRIGGER IF NOT EXISTS trg_workflow_execution_events_no_delete
+                    BEFORE DELETE ON workflow_execution_events
+                    BEGIN
+                        SELECT RAISE(ABORT, 'Workflow execution events are append-only');
+                    END;
+                `);
+            }
         })();
     }
     appendExecutionTransition(input) {

package/dist/sync/cloudSyncApi.js

@@ -558,8 +558,10 @@ export async function prepareWorkspacePushChanges(input, dependencies = {}) {
             .filter((taskId) => taskUpsertIdSet.has(taskId) && !activeV3TaskCreateIds.has(taskId));
     }
     const ownershipFilteredChanges = input.changes.filter((change) => {
-        if (change.op === 'upsert')
-            return !activeV3TaskCreateIds.has(String(change.task?.id || '').trim());
+        if (change.op === 'upsert') {
+            const taskId = String(change.task?.id || '').trim();
+            return !activeV3TaskCreateIds.has(taskId) && !activeV3TaskDeleteIds.has(taskId);
+        }
         if (change.op === 'delete') {
             return !activeV3TaskDeleteIds.has(String(change.taskId || '').trim());
         }

package/dist/sync/collaborationSyncState.js

@@ -32,6 +32,11 @@ export function listWorkspaceSyncDocumentReviewCommentsSnapshot(deps, workspaceI
         authorActorId: comment.authorActorId,
         updatedByActorId: comment.updatedByActorId,
         deletedByActorId: comment.deletedByActorId,
+        parentCommentId: comment.parentCommentId,
+        threadStatus: comment.threadStatus,
+        threadStatusUpdatedAt: comment.threadStatusUpdatedAt,
+        resolvedAt: comment.resolvedAt,
+        resolvedByActorId: comment.resolvedByActorId,
         createdAt: comment.createdAt,
         updatedAt: comment.updatedAt,
         deletedAt: comment.deletedAt,

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';
@@ -1407,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,
+    };
+}

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

@@ -1,6 +1,6 @@
 import type { LocalSyncCoordinatorCommandRecord } from './localSyncCoordinatorTypes.js';
 import type { LocalSyncCoordinatorStore } from './localSyncCoordinatorStore.js';
-import { type LocalWorkspaceSyncRunnerCheckpoint, type LocalWorkspaceSyncRunnerState, type LocalWorkspaceSyncRunnerStateStore } from './localWorkspaceSyncRunnerState.js';
+import { type LocalWorkspaceSyncRunnerCheckpoint, type LocalWorkspaceSyncRunnerRetryKind, type LocalWorkspaceSyncRunnerState, type LocalWorkspaceSyncRunnerStateStore } from './localWorkspaceSyncRunnerState.js';
 import type { WorkspaceSyncCredentialBroker } from './workspaceSyncCredentialBroker.js';
 export interface LocalWorkspaceSyncRunnerOperationInput {
     command: LocalSyncCoordinatorCommandRecord | null;
@@ -55,6 +55,7 @@ export declare class LocalWorkspaceSyncRunnerError extends Error {
     readonly code: 'SYNC_RUNNER_NOT_STARTED' | 'SYNC_RUNNER_ALREADY_STARTED' | 'SYNC_RUNNER_COORDINATOR_FENCE_INVALID' | 'SYNC_RUNNER_COMMAND_INVALID' | 'SYNC_RUNNER_COMMAND_DISABLED' | 'SYNC_RUNNER_DRAIN_TIMEOUT';
     constructor(message: string, code: 'SYNC_RUNNER_NOT_STARTED' | 'SYNC_RUNNER_ALREADY_STARTED' | 'SYNC_RUNNER_COORDINATOR_FENCE_INVALID' | 'SYNC_RUNNER_COMMAND_INVALID' | 'SYNC_RUNNER_COMMAND_DISABLED' | 'SYNC_RUNNER_DRAIN_TIMEOUT');
 }
+export declare function canCoordinatorRecoveryPreemptRetry(kind: LocalWorkspaceSyncRunnerRetryKind): boolean;
 export declare class LocalWorkspaceSyncRunner {
     private readonly options;
     private context;
@@ -87,6 +88,7 @@ export declare class LocalWorkspaceSyncRunner {
     activate(): void;
     executeCommand(commandId: string): Promise<LocalSyncCoordinatorCommandRecord | null>;
     inspect(): Promise<void>;
+    recoverCoordinatorObligationsDue(isRecoveryStillRequired: () => boolean): Promise<void>;
     pullDue(): Promise<void>;
     retryDue(): Promise<void>;
     pushDue(): Promise<void>;

package/dist/sync/coordinator/localWorkspaceSyncRunner.js

@@ -21,6 +21,14 @@ const CONTENT_PREREQUISITE_BYPASSED_RETRY_KINDS = new Set([
     'pull',
     'repair',
 ]);
+const COORDINATOR_RECOVERY_BYPASSED_RETRY_KINDS = new Set([
+    'pull',
+    'push',
+    'v3-dispatch',
+]);
+export function canCoordinatorRecoveryPreemptRetry(kind) {
+    return COORDINATOR_RECOVERY_BYPASSED_RETRY_KINDS.has(kind);
+}
 function cloneCheckpoint(checkpoint) {
     return JSON.parse(canonicalWorkspaceSyncJson(checkpoint));
 }
@@ -140,6 +148,16 @@ export class LocalWorkspaceSyncRunner {
         }
         return this.enqueue(async () => this.runInspection());
     }
+    recoverCoordinatorObligationsDue(isRecoveryStillRequired) {
+        if (!this.context || this.terminated || !this.acceptingWork) {
+            return Promise.resolve();
+        }
+        return this.enqueue(async () => {
+            if (!isRecoveryStillRequired())
+                return;
+            await this.runInspection(this.options.operations.sync, { bypassRetryKinds: COORDINATOR_RECOVERY_BYPASSED_RETRY_KINDS });
+        });
+    }
     pullDue() {
         if (!this.context || this.terminated || !this.acceptingWork) {
             return Promise.resolve();

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

@@ -1,5 +1,5 @@
 import type { DatabaseAdapter } from '../../storage/databaseAdapter.js';
-import type { WorkspaceSyncDeltaDiagnostics, WorkspaceSyncPayload } from '../workspaceSyncModel.js';
+import type { WorkspaceSyncDeltaDiagnostics, WorkspaceSyncDurableTaskRevision, WorkspaceSyncPayload, WorkspaceSyncTaskSnapshot } from '../workspaceSyncModel.js';
 import { type WorkspacePushPreparedPlan } from '../workspacePushPreparedPlan.js';
 import type { WorkspaceSyncPhase, WorkspaceSyncPushBaselineSnapshot } from '../workspaceSyncState.js';
 import type { LocalSyncCoordinatorCommandStatus } from './localSyncCoordinatorTypes.js';
@@ -30,6 +30,7 @@ export interface EncodedWorkspaceSyncPayload {
     currentInitiativeWatermarks: EncodedStringMap;
     currentWorkstreamIds: string[];
     currentWorkstreamWatermarks: EncodedStringMap;
+    currentPlanningIdentityWatermarks?: EncodedStringMap;
     currentAiProfileIds: string[];
     currentAiProfileWatermarks: EncodedStringMap;
     currentAiProfileChangeKeys?: EncodedStringMap;
@@ -68,8 +69,20 @@ export interface LocalWorkspaceSyncPendingV2Push {
     preparedPlan: WorkspacePushPreparedPlan | null;
     preparedPlanFingerprint: string | null;
     acknowledgedNonApplyingBatchOperationIdentities: string[];
+    settlementVersion?: 1;
+    settledBatchOperationIdentities?: string[];
+    settledBatchContributions?: LocalWorkspaceSyncSettledV2PushBatch[];
     lastBatchProgress: LocalWorkspaceSyncPendingV2PushBatchProgress | null;
 }
+export interface LocalWorkspaceSyncSettledV2PushBatch {
+    operationIdentity: string;
+    settlementIdentityFingerprint: string;
+    appliedTaskUpserts: Array<{
+        archived: boolean;
+        task: WorkspaceSyncTaskSnapshot;
+        durableRevision?: WorkspaceSyncDurableTaskRevision;
+    }>;
+}
 export interface LocalWorkspaceSyncPendingV2PushBatchProgress {
     totalBatches: number;
     completedBatches: number;
@@ -144,6 +157,7 @@ export declare function createLocalWorkspaceSyncPendingV2Push(input: {
     repairMode: boolean;
 }): LocalWorkspaceSyncPendingV2Push;
 export declare function fingerprintLocalWorkspaceSyncPreparedPlan(plan: WorkspacePushPreparedPlan): string;
+export declare function upgradeLocalWorkspaceSyncPendingV2PushSettlement(pending: LocalWorkspaceSyncPendingV2Push): LocalWorkspaceSyncPendingV2Push;
 export declare function createDefaultLocalWorkspaceSyncRunnerCheckpoint(): LocalWorkspaceSyncRunnerCheckpoint;
 export declare class LocalWorkspaceSyncRunnerStateStore {
     private readonly db;