@taskforcehq/taskforce 0.3.327 → 0.3.329

package/dist/shared/taskforceAgentModels.js

@@ -214,6 +214,20 @@ export const TASKFORCE_AGENT_MODEL_OPTIONS = [
         supportsTemperature: true,
         defaultMaxTokens: 512,
     },
+    {
+        key: 'openai.codex-gpt-5-6-sol',
+        providerKey: 'openai',
+        label: 'Codex GPT-5.6 Sol',
+        source: 'subscription_dev',
+        runtime: 'subscription-dev',
+        defaultTier: 'advanced',
+        runtimeModelId: 'gpt-5.6-sol',
+        availability: 'configured',
+        visible: true,
+        supportsTemperature: false,
+        defaultMaxTokens: 1024,
+        devOnly: true,
+    },
     {
         key: 'openai.gpt-5-4',
         providerKey: 'openai',
@@ -228,8 +242,20 @@ export const TASKFORCE_AGENT_MODEL_OPTIONS = [
         defaultMaxTokens: 1024,
     },
 ];
+function isTruthy(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+export function isTaskforceAgentSubscriptionDevModelsEnabled() {
+    const globals = globalThis;
+    return (typeof __TASKFORCE_AGENT_SUBSCRIPTION_DEV_MODELS__ !== 'undefined' && __TASKFORCE_AGENT_SUBSCRIPTION_DEV_MODELS__)
+        || isTruthy(globals.__TASKFORCE_AGENT_SUBSCRIPTION_DEV_MODELS__)
+        || isTruthy(globals.process?.env?.TASKFORCE_AGENT_SUBSCRIPTION_DEV_MODELS);
+}
 export function isTaskforceAgentModelVisible(model) {
-    return model.visible && model.availability !== 'account_unavailable';
+    return model.visible
+        && model.availability !== 'account_unavailable'
+        && (!model.devOnly || isTaskforceAgentSubscriptionDevModelsEnabled());
 }
 export function getTaskforceAgentModel(modelKey) {
     const key = String(modelKey || '').trim();
@@ -292,6 +318,9 @@ export function normalizeTaskforceAgentModelSelection(input) {
         && !connectionScope) {
         return null;
     }
+    if (modelSource === 'subscription_dev' && connectionScope !== 'local_dev') {
+        return null;
+    }
     const connectionId = String(input.connectionId || '').trim();
     return {
         providerKey: model.providerKey,

package/dist/storage/postgresAdapter.d.ts

@@ -1,4 +1,14 @@
 import { type DatabaseAdapter, type DatabaseStatement } from './databaseAdapter.js';
+import { type PostgresAdapterDeadlineOptions, type PostgresWorkerOperation } from './postgresWorkerProtocol.js';
+export declare class PostgresWorkerOutcomeUnknownError extends Error {
+    readonly code = "POSTGRES_WORKER_OUTCOME_UNKNOWN";
+    readonly operation: PostgresWorkerOperation;
+    constructor(operation: PostgresWorkerOperation, detail?: string);
+}
+export declare class PostgresWorkerUnavailableError extends Error {
+    readonly code = "POSTGRES_WORKER_UNAVAILABLE";
+    constructor();
+}
 export declare function replaceQMarkParams(sql: string, params: unknown[]): {
     text: string;
     values: unknown[];
@@ -6,13 +16,20 @@ export declare function replaceQMarkParams(sql: string, params: unknown[]): {
 export declare function translateInsertOrReplace(sql: string): string;
 export declare class PostgresAdapter implements DatabaseAdapter {
     readonly provider: "postgres";
-    readonly open = true;
-    private readonly worker;
+    private worker;
+    private readonly connectionString;
+    private readonly deadlines;
+    private readonly retiringWorkers;
+    private consecutiveUnexpectedExits;
+    private closed;
     private readonly encoder;
     private readonly decoder;
     private txId;
     private savepointCounter;
-    constructor(connectionString?: string);
+    constructor(connectionString?: string, deadlineOptions?: PostgresAdapterDeadlineOptions);
+    get open(): boolean;
+    private createWorker;
+    private quarantineWorker;
     private callWorker;
     private query;
     private bindParams;

package/dist/storage/postgresAdapter.js

@@ -1,13 +1,32 @@
 import { TextDecoder, TextEncoder } from 'util';
 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';
+    }
+}
 function isPlainObject(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
@@ -60,37 +79,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
-        });
-        const waitResult = Atomics.wait(status, RESPONSE_STATUS_INDEX, RESPONSE_INITIAL, RESPONSE_TIMEOUT_MS);
+        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, 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) {
@@ -98,6 +182,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();
@@ -226,11 +311,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/postgresRequestDiagnostics.d.ts

@@ -0,0 +1,8 @@
+export type RequestPerformanceDiagnostics = {
+    postgresQueryCount: number;
+    postgresWorkerCallCount: number;
+    postgresWorkerWaitMs: number;
+};
+export declare function runWithRequestPerformanceDiagnostics<T>(enabled: boolean, callback: () => T): T;
+export declare function recordPostgresWorkerWait(operation: string, durationMs: number): void;
+export declare function getRequestPerformanceDiagnostics(): RequestPerformanceDiagnostics | null;

package/dist/storage/postgresRequestDiagnostics.js

@@ -0,0 +1,24 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+const requestPerformanceStorage = new AsyncLocalStorage();
+export function runWithRequestPerformanceDiagnostics(enabled, callback) {
+    if (!enabled)
+        return callback();
+    return requestPerformanceStorage.run({
+        postgresQueryCount: 0,
+        postgresWorkerCallCount: 0,
+        postgresWorkerWaitMs: 0,
+    }, callback);
+}
+export function recordPostgresWorkerWait(operation, durationMs) {
+    const diagnostics = requestPerformanceStorage.getStore();
+    if (!diagnostics)
+        return;
+    diagnostics.postgresWorkerCallCount += 1;
+    if (operation === 'query')
+        diagnostics.postgresQueryCount += 1;
+    diagnostics.postgresWorkerWaitMs += Math.max(0, durationMs);
+}
+export function getRequestPerformanceDiagnostics() {
+    const diagnostics = requestPerformanceStorage.getStore();
+    return diagnostics ? { ...diagnostics } : null;
+}

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;

package/dist/storage/postgresWorkerProtocol.d.ts

@@ -0,0 +1,29 @@
+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';
+    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/workspaceAssetStore.d.ts

@@ -67,11 +67,43 @@ export interface WorkspaceAssetLinkEntry {
     updatedAt: string;
     deletedAt: string | null;
 }
+export interface WorkspaceAssetUploadDraftEntry {
+    workspaceId: string;
+    draftId: string;
+    assetId: string;
+    storageKey: string;
+    purpose: string;
+    createdByUserId: string;
+    createdAt: string;
+    retiredAt: string | null;
+}
 export declare class WorkspaceAssetStore {
     private readonly db;
     private readonly tenantId;
     private supportsTargetTypeCache;
     constructor(db: DatabaseAdapter, tenantId: string);
+    recordUploadDraft(input: {
+        workspaceId: string;
+        draftId: string;
+        assetId: string;
+        storageKey: string;
+        purpose: string;
+        createdByUserId: string;
+        createdAt?: string;
+    }): WorkspaceAssetUploadDraftEntry;
+    listUploadDrafts(input: {
+        workspaceId: string;
+        draftId?: string;
+        createdByUserId?: string;
+        createdBefore?: string;
+        includeRetired?: boolean;
+    }): WorkspaceAssetUploadDraftEntry[];
+    retireUploadDraft(input: {
+        workspaceId: string;
+        draftId: string;
+        assetId: string;
+        retiredAt?: string;
+    }): boolean;
     private isPlanningTargetDurablyOwned;
     assertAssetDeletionAllowed(assetIdRaw: string, workspaceIdRaw: string): void;
     private runDurableAssetMutation;

package/dist/storage/workspaceAssetStore.js

@@ -114,6 +114,76 @@ export class WorkspaceAssetStore {
         this.db = db;
         this.tenantId = tenantId;
     }
+    recordUploadDraft(input) {
+        const workspaceId = normalizeWorkspaceId(input.workspaceId);
+        const draftId = normalizeId(input.draftId);
+        const assetId = normalizeId(input.assetId);
+        const storageKey = normalizeId(input.storageKey);
+        const purpose = normalizeId(input.purpose);
+        const createdByUserId = normalizeId(input.createdByUserId, 'anonymous');
+        const createdAt = normalizeId(input.createdAt, new Date().toISOString());
+        if (!draftId || !assetId || !storageKey || !purpose) {
+            throw new Error('Draft upload identity, asset, storage key, and purpose are required.');
+        }
+        this.db.prepare(`
+            INSERT INTO workspace_asset_upload_drafts (
+                tenant_id, workspace_id, draft_id, asset_id, storage_key,
+                purpose, created_by_user_id, created_at, retired_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL)
+            ON CONFLICT (tenant_id, workspace_id, draft_id, asset_id) DO UPDATE SET
+                storage_key = EXCLUDED.storage_key,
+                purpose = EXCLUDED.purpose,
+                created_by_user_id = EXCLUDED.created_by_user_id
+        `).run(this.tenantId, workspaceId, draftId, assetId, storageKey, purpose, createdByUserId, createdAt);
+        return {
+            workspaceId, draftId, assetId, storageKey, purpose,
+            createdByUserId, createdAt, retiredAt: null,
+        };
+    }
+    listUploadDrafts(input) {
+        const workspaceId = normalizeWorkspaceId(input.workspaceId);
+        const clauses = ['tenant_id = ?', 'workspace_id = ?'];
+        const values = [this.tenantId, workspaceId];
+        if (input.draftId) {
+            clauses.push('draft_id = ?');
+            values.push(normalizeId(input.draftId));
+        }
+        if (input.createdByUserId) {
+            clauses.push('created_by_user_id = ?');
+            values.push(normalizeId(input.createdByUserId));
+        }
+        if (input.createdBefore) {
+            clauses.push('created_at <= ?');
+            values.push(normalizeId(input.createdBefore));
+        }
+        if (!input.includeRetired)
+            clauses.push('retired_at IS NULL');
+        const rows = this.db.prepare(`
+            SELECT workspace_id, draft_id, asset_id, storage_key, purpose,
+                   created_by_user_id, created_at, retired_at
+            FROM workspace_asset_upload_drafts
+            WHERE ${clauses.join(' AND ')}
+            ORDER BY created_at ASC, asset_id ASC
+        `).all(...values);
+        return rows.map((row) => ({
+            workspaceId: String(row.workspace_id || ''),
+            draftId: String(row.draft_id || ''),
+            assetId: String(row.asset_id || ''),
+            storageKey: String(row.storage_key || ''),
+            purpose: String(row.purpose || ''),
+            createdByUserId: String(row.created_by_user_id || ''),
+            createdAt: String(row.created_at || ''),
+            retiredAt: row.retired_at == null ? null : String(row.retired_at),
+        }));
+    }
+    retireUploadDraft(input) {
+        const result = this.db.prepare(`
+            UPDATE workspace_asset_upload_drafts
+            SET retired_at = COALESCE(retired_at, ?)
+            WHERE tenant_id = ? AND workspace_id = ? AND draft_id = ? AND asset_id = ?
+        `).run(normalizeId(input.retiredAt, new Date().toISOString()), this.tenantId, normalizeWorkspaceId(input.workspaceId), normalizeId(input.draftId), normalizeId(input.assetId));
+        return Number(result.changes || 0) > 0;
+    }
     isPlanningTargetDurablyOwned(workspaceId, targetType, targetId) {
         if (targetType !== 'initiative' && targetType !== 'workstream')
             return false;

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

@@ -4,6 +4,8 @@ import type { WorkspaceSyncEngineV2PushBoundary } from '../engine/workspaceSyncE
 import { type LocalSyncExecutionPermitCleanAbandonResult, type LocalSyncExecutionPermitDrainSnapshot, type LocalSyncExecutionPermit, type LocalSyncExecutionPermitOwnerMode, type LocalSyncExecutionPermitState, type LocalSyncGatewayOperationClass, type LocalSyncRecoveryObligation, type LocalSyncUpstreamDisposition } from './localSyncExecutionPermitTypes.js';
 export declare const LOCAL_SYNC_PERMIT_RETENTION_MIN_AGE_MS: number;
 export declare const LOCAL_SYNC_PERMIT_RETENTION_SOFT_LIMIT = 1000;
+export declare const LOCAL_SYNC_PERMIT_RETENTION_HARD_LIMIT = 10000;
+export declare const LOCAL_SYNC_OBLIGATION_RETENTION_HARD_LIMIT = 2000;
 export declare const LOCAL_SYNC_PERMIT_RETENTION_DELETE_BATCH = 250;
 export declare const LOCAL_SYNC_PERMIT_RETENTION_SWEEP_LIMIT = 5000;
 type LocalSyncPermitCompletionGroupFence = {
@@ -60,6 +62,12 @@ export declare class LocalSyncExecutionPermitStore {
         byState: Partial<Record<LocalSyncExecutionPermitState, number>>;
         recoveryObligations: number;
         localCommitInvariantViolation: boolean;
+        history: {
+            terminalPermits: number;
+            oldestTerminalPermitAt: string | null;
+            resolvedRecoveryObligations: number;
+            oldestResolvedRecoveryObligationAt: string | null;
+        };
     };
     inspectGenerationDrain(input: {
         workspaceId: string;
@@ -110,6 +118,14 @@ export declare class LocalSyncExecutionPermitStore {
         ownerMode: LocalSyncExecutionPermitOwnerMode;
         serverInstanceId: string;
     }): LocalSyncExecutionPermit;
+    renewAcceptedApplyCompletion(input: {
+        permitId: string;
+        workspaceId: string;
+        coordinatorGeneration: number;
+        serverInstanceId: string;
+        ownerMode: LocalSyncExecutionPermitOwnerMode;
+        deadlineAt: string;
+    }): LocalSyncExecutionPermit;
     completeAcceptedV3Dispatch<T>(input: {
         permitId: string;
         workspaceId: string;
@@ -136,6 +152,7 @@ export declare class LocalSyncExecutionPermitStore {
         coordinatorGeneration: number;
         serverInstanceId: string;
         errorCode?: string;
+        readResponseUnavailableBeforeApply?: boolean;
     }): LocalSyncExecutionPermit;
     recoverExpiredPermits(input: {
         currentServerInstanceId: string;