@taskforcehq/taskforce 0.3.327 → 0.3.328

package/dist/core/Taskforce.js

@@ -3,11 +3,13 @@ import * as path from 'path';
 import * as os from 'os';
 import { createHash, pbkdf2Sync, randomBytes, timingSafeEqual } from 'crypto';
 import { fileURLToPath } from 'url';
+import { assertPlanningIdentityColor, assertPlanningIdentityIcon, } from '../shared/planningIdentity.js';
 import { createDatabaseAdapter } from '../storage/createDatabaseAdapter.js';
 import { assertLocalDataOwnerPermit, } from '../server/localDataOwnerPermit.js';
 import { resolveLocalDatabaseIdentity } from '../server/localDatabaseIdentity.js';
 import { compareWorkspaceSyncStateRevisions, normalizeWorkspaceSyncStateRevision, } from '../sync/workspaceSyncState.js';
 import { WorkspaceSyncDurabilityStore } from '../sync/v3/syncDurabilityStore.js';
+import { workspaceSyncV3RepairEntityReadBatchSize } from '../sync/v3/workspaceSyncV3RepairSqlBatching.js';
 import { isTaskMetadataActivityEventId } from '../sync/v3/taskMetadataActivityIdentity.js';
 import { isTaskLifecycleActivityEventId } from '../sync/v3/taskLifecycleActivityIdentity.js';
 import { resolveV3OwnedTaskLifecycleIds, resolveV3OwnedTaskMetadataIds, resolveV3OwnedTaskTaxonomyIds, } from '../sync/v3/taskMetadataCoexistence.js';
@@ -23,7 +25,7 @@ import { archiveAiProfileService, bindAiProfileConnectionService, getAiProfileBy
 import { syncCanonicalAttachmentLinksForTargetService, syncCanonicalTaskAttachmentLinksService, } from './AttachmentLinkService.js';
 import { listTaskAttachmentLinksForDurableSync as listTaskAttachmentLinksForDurableSyncService, listWorkspaceTaskAttachmentLinksForDurableSync as listWorkspaceTaskAttachmentLinksForDurableSyncService, normalizeTaskAttachmentDescriptorsForDurableSync as normalizeTaskAttachmentDescriptorsForDurableSyncService, resolveTaskAttachmentLinksForDurableSync as resolveTaskAttachmentLinksForDurableSyncService, } from './TaskAttachmentLinksDurableMutationService.js';
 import { EntityEventIdentityCollisionError, addEntityEventService, addTaskEventService, buildEntityActivityService, buildTaskActivityService, getEntityEventForSyncService, getTaskEventForSyncService, listEntityEventsInternalService, listWorkspaceEntityEventsForSyncService, listTaskEventsInternalService, listWorkspaceTaskEventsForSyncService, replaceEntityEventsService, replaceTaskCommentsService, replaceTaskEventsService, upsertEntityEventForSyncService, deleteEntityEventForSyncService, upsertTaskEventForSyncService, } from './TaskActivityService.js';
-import { addDeletedTaskRecordService, getDeletedTaskService, listDeletedTasksService, mapDeletedTaskRowService, normalizeTaskSnapshotForRestoreService, normalizeDeletedTaskRestoreLifecycleService, purgeExpiredDeletedTasksService, } from './DeletedTaskLifecycleService.js';
+import { addDeletedTaskRecordService, getDeletedTaskService, listDeletedTasksService, listDeletedTasksReadOnlyService, mapDeletedTaskRowService, normalizeTaskSnapshotForRestoreService, normalizeDeletedTaskRestoreLifecycleService, purgeExpiredDeletedTasksService, } from './DeletedTaskLifecycleService.js';
 import { DELETED_TASK_RETENTION_DAYS } from '../shared/deletedTaskRetention.js';
 import { applyWorkspaceSyncSnapshotService, claimPushIdempotencyService, completePushIdempotencyClaimService, deleteDocumentWatermarkService, deleteDocumentWatermarkStrictService, getDocumentWatermarkService, listTasksForSyncService, listWorkspaceSyncDeletesSinceService, readPushIdempotencyService, releasePushIdempotencyClaimService, renewPushIdempotencyClaimService, recordSyncEventDurablyService, recordSyncEventService, upsertDocumentWatermarkService, upsertDocumentWatermarkStrictService, writePushIdempotencyService, } from './SyncReconciliationService.js';
 import { getGlobalSettingsService, hasPersistedGlobalSettingsService, readGlobalConfigService, updateGlobalSettingsService, writeGlobalConfigService, } from './GlobalSettingsService.js';
@@ -1375,9 +1377,13 @@ export class TaskforceCore {
         // Initialize Database Adapter (SQLite default; Postgres scaffolded)
         const provider = config.database?.provider || 'sqlite';
         const connectionString = config.database?.connectionString || process.env.TASKFORCE_DATABASE_URL;
+        const isCloudReadWorker = config.initializationMode === 'cloud-read-worker';
         if (provider === 'postgres' && !connectionString) {
             throw new Error('[Taskforce] Postgres provider requires a connection string (TASKFORCE_DATABASE_URL).');
         }
+        if (isCloudReadWorker && (this.runtimeMode !== 'cloud' || provider !== 'postgres')) {
+            throw new Error('[Taskforce] Cloud read-worker initialization requires cloud runtime with PostgreSQL.');
+        }
         if (this.runtimeMode === 'local') {
             assertLocalDataOwnerPermit({
                 permit: config.localDataOwnerPermit,
@@ -1391,8 +1397,10 @@ export class TaskforceCore {
                 databaseIdentityKind: provider === 'sqlite' ? 'path' : 'opaque',
             });
         }
-        this.ensureDirectories();
-        this.migrateLegacyGlobalSettingsDbIfNeeded();
+        if (!isCloudReadWorker) {
+            this.ensureDirectories();
+            this.migrateLegacyGlobalSettingsDbIfNeeded();
+        }
         this.db = createDatabaseAdapter({
             provider,
             sqliteDbPath: this.dbPath,
@@ -1428,53 +1436,59 @@ export class TaskforceCore {
                 throw new Error(`[Taskforce] Failed to initialize global settings DB at ${this.globalSettingsDbPath}: ${String(error?.message || error)}`);
             }
         }
-        this.initializeSchema();
-        ensureTaskApproachRemoved(this.db);
-        ensureTenantSchema(this.db);
-        ensureWorkspaceSchema(this.db);
-        ensureWorkspaceSyncDurabilitySchema(this.db);
-        if (this.runtimeMode === 'local') {
-            ensureLocalSyncCoordinatorSchema(this.db);
-        }
-        ensureScheduleTaskSchema(this.db);
-        ensureWorkstreamTaskOrderSchema(this.db);
-        ensureAssigneeTaskSchema(this.db);
-        ensureTaskReferenceSchema(this.db);
-        ensurePlanningReferenceSchema(this.db);
-        ensureTaskAssetsSchema(this.db);
-        ensureWorkspaceAssetsSchema(this.db);
-        backfillPlanningAttachmentAssetIdentities(this.db, this.tenantId);
-        ensureDocumentReferenceSchema(this.db);
-        ensureDocumentReviewSessionsSchema(this.db);
-        ensureAnnotatedAttachmentSessionsSchema(this.db);
-        ensureTaskforceAgentsSchema(this.db);
-        ensureAgentRolesSchema(this.db);
-        ensureTaskforceAgentSkillsSchema(this.db);
-        ensureWorkflowSchema(this.db);
-        ensureBillingSchema(this.db);
-        ensureEntitlementsSchema(this.db);
-        ensureAuthIdentitySchema(this.db);
-        this.performMigrationIfNeeded();
-        repairTaskUpdatedAtOnlySyncDrift({
-            db: this.db,
-            tenantId: this.tenantId,
-            loadTask: (taskId, workspaceId) => this.getTask(taskId, workspaceId),
-        });
+        if (!isCloudReadWorker) {
+            this.initializeSchema();
+            ensureTaskApproachRemoved(this.db);
+            ensureTenantSchema(this.db);
+            ensureWorkspaceSchema(this.db);
+            ensureWorkspaceSyncDurabilitySchema(this.db);
+            if (this.runtimeMode === 'local') {
+                ensureLocalSyncCoordinatorSchema(this.db);
+            }
+            ensureScheduleTaskSchema(this.db);
+            ensureWorkstreamTaskOrderSchema(this.db);
+            ensureAssigneeTaskSchema(this.db);
+            ensureTaskReferenceSchema(this.db);
+            ensurePlanningReferenceSchema(this.db);
+            ensureTaskAssetsSchema(this.db);
+            ensureWorkspaceAssetsSchema(this.db);
+            backfillPlanningAttachmentAssetIdentities(this.db, this.tenantId);
+            ensureDocumentReferenceSchema(this.db);
+            ensureDocumentReviewSessionsSchema(this.db);
+            ensureAnnotatedAttachmentSessionsSchema(this.db);
+            ensureTaskforceAgentsSchema(this.db);
+            ensureAgentRolesSchema(this.db);
+            ensureTaskforceAgentSkillsSchema(this.db);
+            ensureWorkflowSchema(this.db);
+            ensureBillingSchema(this.db);
+            ensureEntitlementsSchema(this.db);
+            ensureAuthIdentitySchema(this.db);
+            this.performMigrationIfNeeded();
+            repairTaskUpdatedAtOnlySyncDrift({
+                db: this.db,
+                tenantId: this.tenantId,
+                loadTask: (taskId, workspaceId) => this.getTask(taskId, workspaceId),
+            });
+        }
         this.planEntitlementService = new PlanEntitlementService(this.db, this.tenantId, {
             getWorkspaceOwnerUserId: (wid) => this.getWorkspaceOwnerUserId(wid),
             readGlobalConfig: () => this.readGlobalConfig(),
             writeGlobalConfig: (config) => this.writeGlobalConfig(config),
         });
-        this.planEntitlementService.repairPlanCatalogDefaultsIfNeeded();
-        this.planEntitlementService.normalizeLegacyPlanDataIfNeeded();
-        this.planEntitlementService.backfillAccountEntitlements();
+        if (!isCloudReadWorker) {
+            this.planEntitlementService.repairPlanCatalogDefaultsIfNeeded();
+            this.planEntitlementService.normalizeLegacyPlanDataIfNeeded();
+            this.planEntitlementService.backfillAccountEntitlements();
+        }
         this.authTokenService = new AuthTokenService(this.db, this.tenantId);
         this.identityService = new AuthIdentityService(this.db, this.tenantId);
         this.authTokenService.setIdentityService(this.identityService);
         this.mcpTokenService = new McpTokenService(this.db, this.tenantId, {
             getAccountAccessStatus: (userId) => this.getAccountAccessStatus(userId),
         });
-        purgeExpiredDeletedTasksService(this.getDeletedTaskLifecycleServiceDeps());
+        if (!isCloudReadWorker) {
+            purgeExpiredDeletedTasksService(this.getDeletedTaskLifecycleServiceDeps());
+        }
     }
     close() {
         if (this.globalSettingsDb && this.globalSettingsDb.open) {
@@ -1751,6 +1765,7 @@ export class TaskforceCore {
                 order_in_day INTEGER,
                 workstream_order INTEGER,
                 workstream_id TEXT,
+                card_cover_asset_id TEXT,
                 FOREIGN KEY(workstream_id) REFERENCES workstreams(id) ON DELETE SET NULL
             );
 
@@ -1832,6 +1847,20 @@ export class TaskforceCore {
                 FOREIGN KEY(initiative_id) REFERENCES initiatives(id) ON DELETE SET NULL
             );
 
+            CREATE TABLE IF NOT EXISTS planning_entity_identities (
+                tenant_id TEXT NOT NULL DEFAULT 'default',
+                workspace_id TEXT NOT NULL DEFAULT 'default',
+                entity_type TEXT NOT NULL,
+                entity_id TEXT NOT NULL,
+                icon TEXT,
+                color TEXT,
+                updated_at TEXT NOT NULL,
+                PRIMARY KEY (tenant_id, workspace_id, entity_type, entity_id)
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_planning_entity_identities_updated
+            ON planning_entity_identities (tenant_id, workspace_id, updated_at, entity_type, entity_id);
+
             CREATE TABLE IF NOT EXISTS workspace_workstream_reference_sequences (
                 tenant_id TEXT NOT NULL DEFAULT 'default',
                 workspace_id TEXT NOT NULL DEFAULT 'default',
@@ -2222,6 +2251,9 @@ export class TaskforceCore {
             if (!taskColumns.some((c) => c.name === 'workstream_id')) {
                 this.db.exec(`ALTER TABLE tasks ADD COLUMN workstream_id TEXT`);
             }
+            if (!taskColumns.some((c) => c.name === 'card_cover_asset_id')) {
+                this.db.exec(`ALTER TABLE tasks ADD COLUMN card_cover_asset_id TEXT`);
+            }
             const initiativeColumns = this.db.prepare(`PRAGMA table_info(initiatives)`).all();
             if (!initiativeColumns.some((c) => c.name === 'comments_json')) {
                 this.db.exec(`ALTER TABLE initiatives ADD COLUMN comments_json TEXT`);
@@ -2258,6 +2290,12 @@ export class TaskforceCore {
             catch {
                 // Best-effort schema repair for existing deployments.
             }
+            try {
+                this.db.exec(`ALTER TABLE tasks ADD COLUMN IF NOT EXISTS card_cover_asset_id TEXT`);
+            }
+            catch {
+                // Best-effort schema repair for existing deployments.
+            }
             try {
                 this.db.exec(`ALTER TABLE initiatives ADD COLUMN IF NOT EXISTS comments_json TEXT`);
                 this.db.exec(`ALTER TABLE initiatives ADD COLUMN IF NOT EXISTS attachments_json TEXT`);
@@ -3679,7 +3717,7 @@ export class TaskforceCore {
                 const originalFilename = row.original_filename ? String(row.original_filename) : path.basename(storageKey);
                 const assetKind = String(canonicalAsset?.kind || row.kind || '').trim();
                 const isCanonicalDocument = Boolean(canonicalAsset && isValidCanonicalDocumentAsset(canonicalAsset));
-                const displayName = isCanonicalDocument
+                const caption = isCanonicalDocument
                     ? getCanonicalDocumentName({
                         logicalName: canonicalAsset?.logicalName || (row.logical_name ? String(row.logical_name) : null),
                         originalFilename,
@@ -3687,11 +3725,7 @@ export class TaskforceCore {
                         assetId: String(row.asset_id || '').trim() || null
                     })
                     : (canonicalAsset?.logicalName || (row.logical_name ? String(row.logical_name) : originalFilename));
-                const caption = isCanonicalDocument
-                    ? displayName
-                    : (row.display_name
-                        ? String(row.display_name)
-                        : displayName);
+                const displayName = row.display_name ? String(row.display_name) : originalFilename;
                 const referenceNumber = typeof canonicalAsset?.referenceNumber === 'number'
                     ? canonicalAsset.referenceNumber
                     : (Number.isFinite(Number(row.reference_number))
@@ -3825,6 +3859,9 @@ export class TaskforceCore {
             orderInDay: this.sanitizeOrderInDay(row.order_in_day),
             workstreamOrder: this.sanitizeOrderInDay(row.workstream_order),
             workstreamId: this.sanitizeWorkstreamId(row.workstream_id),
+            cardCoverAssetId: typeof row.card_cover_asset_id === 'string' && row.card_cover_asset_id.trim()
+                ? row.card_cover_asset_id.trim()
+                : null,
             taxonomies: JSON.parse(row.taxonomies || '{}'),
             createdBy: this.normalizeCreatedBy(row.created_by, workspaceId, { preserveGenericAi: true }),
             createdByActor: this.resolveWorkspaceActor(workspaceId, row.created_by),
@@ -3857,6 +3894,11 @@ export class TaskforceCore {
             title: String(row.title || '').trim() || 'Untitled Initiative',
             description: typeof row.description === 'string' ? row.description : null,
             ownerId: typeof row.owner_id === 'string' && row.owner_id.trim().length > 0 ? row.owner_id.trim() : null,
+            icon: typeof row.identity_icon === 'string' && row.identity_icon.trim().length > 0 ? row.identity_icon.trim() : null,
+            color: typeof row.identity_color === 'string' && row.identity_color.trim().length > 0 ? row.identity_color.trim() : null,
+            identityUpdatedAt: typeof row.identity_updated_at === 'string' && row.identity_updated_at.trim().length > 0
+                ? row.identity_updated_at.trim()
+                : null,
             createdAt: String(row.created_at || '').trim() || new Date().toISOString(),
             updatedAt: typeof row.updated_at === 'string' && row.updated_at.trim().length > 0 ? row.updated_at.trim() : undefined,
             order: row.sort_order == null ? null : Number(row.sort_order),
@@ -3890,6 +3932,11 @@ export class TaskforceCore {
             title: String(row.title || '').trim() || 'Untitled Workstream',
             description: typeof row.description === 'string' ? row.description : null,
             ownerId: typeof row.owner_id === 'string' && row.owner_id.trim().length > 0 ? row.owner_id.trim() : null,
+            icon: typeof row.identity_icon === 'string' && row.identity_icon.trim().length > 0 ? row.identity_icon.trim() : null,
+            color: typeof row.identity_color === 'string' && row.identity_color.trim().length > 0 ? row.identity_color.trim() : null,
+            identityUpdatedAt: typeof row.identity_updated_at === 'string' && row.identity_updated_at.trim().length > 0
+                ? row.identity_updated_at.trim()
+                : null,
             createdAt: String(row.created_at || '').trim() || new Date().toISOString(),
             updatedAt: typeof row.updated_at === 'string' && row.updated_at.trim().length > 0 ? row.updated_at.trim() : undefined,
             order: row.sort_order == null ? null : Number(row.sort_order),
@@ -3945,9 +3992,15 @@ export class TaskforceCore {
             return null;
         const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
         const row = this.db.prepare(`
-            SELECT *
-            FROM initiatives
-            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+            SELECT i.*, identity.icon AS identity_icon, identity.color AS identity_color,
+                   identity.updated_at AS identity_updated_at
+            FROM initiatives i
+            LEFT JOIN planning_entity_identities identity
+              ON identity.tenant_id = i.tenant_id
+             AND identity.workspace_id = i.workspace_id
+             AND identity.entity_type = 'initiative'
+             AND identity.entity_id = i.id
+            WHERE i.tenant_id = ? AND i.workspace_id = ? AND i.id = ?
             LIMIT 1
         `).get(this.tenantId, normalizedWorkspaceId, normalizedId);
         if (!row)
@@ -3957,10 +4010,16 @@ export class TaskforceCore {
     listInitiatives(workspaceId) {
         const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
         const rows = this.db.prepare(`
-            SELECT *
-            FROM initiatives
-            WHERE tenant_id = ? AND workspace_id = ?
-            ORDER BY COALESCE(sort_order, 2147483647), created_at ASC
+            SELECT i.*, identity.icon AS identity_icon, identity.color AS identity_color,
+                   identity.updated_at AS identity_updated_at
+            FROM initiatives i
+            LEFT JOIN planning_entity_identities identity
+              ON identity.tenant_id = i.tenant_id
+             AND identity.workspace_id = i.workspace_id
+             AND identity.entity_type = 'initiative'
+             AND identity.entity_id = i.id
+            WHERE i.tenant_id = ? AND i.workspace_id = ?
+            ORDER BY COALESCE(i.sort_order, 2147483647), i.created_at ASC
         `).all(this.tenantId, normalizedWorkspaceId);
         return rows.map((row) => this.rowToInitiative(row));
     }
@@ -3968,10 +4027,16 @@ export class TaskforceCore {
         const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
         const safeLimit = Math.max(1, Math.min(10000, Math.floor(limit)));
         const rows = this.db.prepare(`
-            SELECT *
-            FROM initiatives
-            WHERE tenant_id = ? AND workspace_id = ? AND id > ?
-            ORDER BY id ASC
+            SELECT i.*, identity.icon AS identity_icon, identity.color AS identity_color,
+                   identity.updated_at AS identity_updated_at
+            FROM initiatives i
+            LEFT JOIN planning_entity_identities identity
+              ON identity.tenant_id = i.tenant_id
+             AND identity.workspace_id = i.workspace_id
+             AND identity.entity_type = 'initiative'
+             AND identity.entity_id = i.id
+            WHERE i.tenant_id = ? AND i.workspace_id = ? AND i.id > ?
+            ORDER BY i.id ASC
             LIMIT ?
         `).all(this.tenantId, normalizedWorkspaceId, String(afterId || ''), safeLimit);
         return rows.map((row) => this.rowToInitiative(row));
@@ -4234,9 +4299,15 @@ export class TaskforceCore {
             return null;
         const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
         const row = this.db.prepare(`
-            SELECT *
-            FROM workstreams
-            WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+            SELECT w.*, identity.icon AS identity_icon, identity.color AS identity_color,
+                   identity.updated_at AS identity_updated_at
+            FROM workstreams w
+            LEFT JOIN planning_entity_identities identity
+              ON identity.tenant_id = w.tenant_id
+             AND identity.workspace_id = w.workspace_id
+             AND identity.entity_type = 'workstream'
+             AND identity.entity_id = w.id
+            WHERE w.tenant_id = ? AND w.workspace_id = ? AND w.id = ?
             LIMIT 1
         `).get(this.tenantId, normalizedWorkspaceId, normalizedId);
         if (!row)
@@ -4246,10 +4317,16 @@ export class TaskforceCore {
     listWorkstreams(workspaceId) {
         const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
         const rows = this.db.prepare(`
-            SELECT *
-            FROM workstreams
-            WHERE tenant_id = ? AND workspace_id = ?
-            ORDER BY COALESCE(sort_order, 2147483647), created_at ASC
+            SELECT w.*, identity.icon AS identity_icon, identity.color AS identity_color,
+                   identity.updated_at AS identity_updated_at
+            FROM workstreams w
+            LEFT JOIN planning_entity_identities identity
+              ON identity.tenant_id = w.tenant_id
+             AND identity.workspace_id = w.workspace_id
+             AND identity.entity_type = 'workstream'
+             AND identity.entity_id = w.id
+            WHERE w.tenant_id = ? AND w.workspace_id = ?
+            ORDER BY COALESCE(w.sort_order, 2147483647), w.created_at ASC
         `).all(this.tenantId, normalizedWorkspaceId);
         return rows.map((row) => this.rowToWorkstream(row));
     }
@@ -4257,14 +4334,157 @@ export class TaskforceCore {
         const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
         const safeLimit = Math.max(1, Math.min(10000, Math.floor(limit)));
         const rows = this.db.prepare(`
-            SELECT *
-            FROM workstreams
-            WHERE tenant_id = ? AND workspace_id = ? AND id > ?
-            ORDER BY id ASC
+            SELECT w.*, identity.icon AS identity_icon, identity.color AS identity_color,
+                   identity.updated_at AS identity_updated_at
+            FROM workstreams w
+            LEFT JOIN planning_entity_identities identity
+              ON identity.tenant_id = w.tenant_id
+             AND identity.workspace_id = w.workspace_id
+             AND identity.entity_type = 'workstream'
+             AND identity.entity_id = w.id
+            WHERE w.tenant_id = ? AND w.workspace_id = ? AND w.id > ?
+            ORDER BY w.id ASC
             LIMIT ?
         `).all(this.tenantId, normalizedWorkspaceId, String(afterId || ''), safeLimit);
         return rows.map((row) => this.rowToWorkstream(row));
     }
+    listPlanningEntityIdentities(workspaceId) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const rows = this.db.prepare(`
+            SELECT entity_type, entity_id, icon, color, updated_at
+            FROM planning_entity_identities
+            WHERE tenant_id = ? AND workspace_id = ?
+            ORDER BY updated_at ASC, entity_type ASC, entity_id ASC
+        `).all(this.tenantId, normalizedWorkspaceId);
+        return rows.map((row) => ({
+            entityType: row.entity_type === 'workstream' ? 'workstream' : 'initiative',
+            entityId: String(row.entity_id || '').trim(),
+            icon: assertPlanningIdentityIcon(row.icon),
+            color: assertPlanningIdentityColor(row.color),
+            updatedAt: String(row.updated_at || '').trim(),
+        }));
+    }
+    writePlanningEntityIdentity(identity, workspaceId) {
+        const existing = this.db.prepare(`
+            SELECT icon, color, updated_at
+            FROM planning_entity_identities
+            WHERE tenant_id = ? AND workspace_id = ? AND entity_type = ? AND entity_id = ?
+            LIMIT 1
+        `).get(this.tenantId, workspaceId, identity.entityType, identity.entityId);
+        if (existing) {
+            this.db.prepare(`
+                UPDATE planning_entity_identities
+                SET icon = ?, color = ?, updated_at = ?
+                WHERE tenant_id = ? AND workspace_id = ? AND entity_type = ? AND entity_id = ?
+            `).run(identity.icon, identity.color, identity.updatedAt, this.tenantId, workspaceId, identity.entityType, identity.entityId);
+        }
+        else {
+            this.db.prepare(`
+                INSERT INTO planning_entity_identities (
+                    tenant_id, workspace_id, entity_type, entity_id, icon, color, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?)
+            `).run(this.tenantId, workspaceId, identity.entityType, identity.entityId, identity.icon, identity.color, identity.updatedAt);
+        }
+        return identity;
+    }
+    updatePlanningEntityIdentity(entityType, entityId, patch, workspaceId) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const normalizedEntityId = String(entityId || '').trim();
+        const entity = entityType === 'initiative'
+            ? this.getInitiative(normalizedEntityId, normalizedWorkspaceId)
+            : this.getWorkstream(normalizedEntityId, normalizedWorkspaceId);
+        if (!entity) {
+            throw new TaskforceRuleError(`${entityType === 'initiative' ? 'Initiative' : 'Workstream'} not found: ${normalizedEntityId}`, 404, entityType === 'initiative' ? 'INITIATIVE_NOT_FOUND' : 'WORKSTREAM_NOT_FOUND');
+        }
+        if (entity.isArchived) {
+            throw new TaskforceRuleError('Restore the planning entity before changing its visual identity.', 409, 'PLANNING_IDENTITY_ARCHIVED');
+        }
+        if (!Object.prototype.hasOwnProperty.call(patch, 'icon')
+            && !Object.prototype.hasOwnProperty.call(patch, 'color')) {
+            throw new TaskforceRuleError('Planning identity update must include icon or color.', 400, 'PLANNING_IDENTITY_INVALID');
+        }
+        let icon;
+        let color;
+        try {
+            icon = Object.prototype.hasOwnProperty.call(patch, 'icon')
+                ? assertPlanningIdentityIcon(patch.icon)
+                : assertPlanningIdentityIcon(entity.icon);
+            color = Object.prototype.hasOwnProperty.call(patch, 'color')
+                ? assertPlanningIdentityColor(patch.color)
+                : assertPlanningIdentityColor(entity.color);
+        }
+        catch (error) {
+            throw new TaskforceRuleError(error instanceof Error ? error.message : 'Planning identity is invalid.', 400, 'PLANNING_IDENTITY_INVALID');
+        }
+        this.writePlanningEntityIdentity({
+            entityType,
+            entityId: normalizedEntityId,
+            icon,
+            color,
+            updatedAt: new Date().toISOString(),
+        }, normalizedWorkspaceId);
+        this.emitRealtimeMutation({
+            workspaceId: normalizedWorkspaceId,
+            entityType,
+            changeType: 'identity-updated',
+            entityIds: [normalizedEntityId],
+            affectedCollections: ['planning'],
+        });
+        return entityType === 'initiative'
+            ? this.getInitiative(normalizedEntityId, normalizedWorkspaceId)
+            : this.getWorkstream(normalizedEntityId, normalizedWorkspaceId);
+    }
+    applyPlanningEntityIdentityForSync(identity, workspaceId) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId || undefined);
+        const entityType = identity.entityType === 'workstream' ? 'workstream' : 'initiative';
+        const entityId = String(identity.entityId || '').trim();
+        const updatedAt = String(identity.updatedAt || '').trim();
+        if (!entityId || !Number.isFinite(Date.parse(updatedAt))) {
+            throw new TaskforceRuleError('Planning identity sync payload is invalid.', 400, 'PLANNING_IDENTITY_INVALID');
+        }
+        const entityExists = entityType === 'initiative'
+            ? this.initiativeExistsForSync(entityId, normalizedWorkspaceId)
+            : this.workstreamExistsForSync(entityId, normalizedWorkspaceId);
+        if (!entityExists)
+            return null;
+        const incoming = {
+            entityType,
+            entityId,
+            icon: assertPlanningIdentityIcon(identity.icon),
+            color: assertPlanningIdentityColor(identity.color),
+            updatedAt: new Date(Date.parse(updatedAt)).toISOString(),
+        };
+        const existing = this.db.prepare(`
+            SELECT icon, color, updated_at
+            FROM planning_entity_identities
+            WHERE tenant_id = ? AND workspace_id = ? AND entity_type = ? AND entity_id = ?
+            LIMIT 1
+        `).get(this.tenantId, normalizedWorkspaceId, entityType, entityId);
+        if (existing) {
+            const existingUpdatedAt = String(existing.updated_at || '').trim();
+            const timeComparison = incoming.updatedAt.localeCompare(existingUpdatedAt);
+            const incomingTieBreak = `${incoming.icon || ''}\u0000${incoming.color || ''}`;
+            const existingTieBreak = `${String(existing.icon || '')}\u0000${String(existing.color || '')}`;
+            if (timeComparison < 0 || (timeComparison === 0 && incomingTieBreak <= existingTieBreak)) {
+                return {
+                    entityType,
+                    entityId,
+                    icon: assertPlanningIdentityIcon(existing.icon),
+                    color: assertPlanningIdentityColor(existing.color),
+                    updatedAt: existingUpdatedAt,
+                };
+            }
+        }
+        const applied = this.writePlanningEntityIdentity(incoming, normalizedWorkspaceId);
+        this.emitRealtimeMutation({
+            workspaceId: normalizedWorkspaceId,
+            entityType,
+            changeType: 'identity-updated',
+            entityIds: [entityId],
+            affectedCollections: ['planning'],
+        });
+        return applied;
+    }
     listPlanningBootstrap(workspaceId, diagnostics) {
         const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
         const startedAt = Date.now();
@@ -5302,6 +5522,10 @@ export class TaskforceCore {
                 }
                 return apply(durableDeleteOwnedKeys);
             })(),
+            listDurableDeleteOwnedTaskIds: (workspaceId) => new Set(new WorkspaceSyncDurabilityStore(this.db)
+                .listTaskMetadataOwnership({ tenantId: this.tenantId, workspaceId })
+                .filter((ownership) => ownership.activeDeleteOperation || ownership.deleteOwned)
+                .map((ownership) => ownership.taskId)),
         };
     }
     getSyncReconciliationServiceDeps() {
@@ -5360,9 +5584,11 @@ export class TaskforceCore {
         const clauses = [
             'tenant_id = ?',
             'workspace_id = ?',
-            'is_archived = 0',
         ];
         const params = [this.tenantId, normalizedWorkspaceId];
+        if (!filters.includeArchived) {
+            clauses.push('is_archived = 0');
+        }
         if (filters.category) {
             clauses.push('category = ?');
             params.push(filters.category);
@@ -5467,6 +5693,114 @@ export class TaskforceCore {
             };
         });
     }
+    listTaskCountsByWorkstream(workspaceId, workstreamId) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const clauses = [
+            'tenant_id = ?',
+            'workspace_id = ?',
+            'workstream_id IS NOT NULL',
+            "TRIM(workstream_id) <> ''",
+        ];
+        const params = [this.tenantId, normalizedWorkspaceId];
+        const normalizedWorkstreamId = this.sanitizeWorkstreamId(workstreamId);
+        if (normalizedWorkstreamId) {
+            clauses.push('workstream_id = ?');
+            params.push(normalizedWorkstreamId);
+        }
+        const rows = this.db.prepare(`
+            SELECT
+                workstream_id,
+                COUNT(*) AS total,
+                SUM(CASE WHEN is_archived = 0 THEN 1 ELSE 0 END) AS active,
+                SUM(CASE WHEN is_archived = 1 THEN 1 ELSE 0 END) AS archived
+            FROM tasks
+            WHERE ${clauses.join(' AND ')}
+            GROUP BY workstream_id
+        `).all(...params);
+        return rows.map((row) => ({
+            workstreamId: String(row.workstream_id || '').trim(),
+            total: Number(row.total || 0),
+            active: Number(row.active || 0),
+            archived: Number(row.archived || 0),
+        }));
+    }
+    listTaskReferenceSummaries(taskIds, workspaceId) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const normalizedIds = Array.from(new Set(taskIds.map((id) => String(id || '').trim()).filter(Boolean)));
+        if (normalizedIds.length === 0)
+            return [];
+        const placeholders = normalizedIds.map(() => '?').join(', ');
+        const rows = this.db.prepare(`
+            SELECT id, reference_number, local_reference_number, title, status
+            FROM tasks
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND id IN (${placeholders})
+        `).all(this.tenantId, normalizedWorkspaceId, ...normalizedIds);
+        return rows.map((row) => {
+            const referenceNumber = this.sanitizeTaskReferenceNumber(row.reference_number);
+            const localReferenceNumber = this.sanitizeTaskReferenceNumber(row.local_reference_number);
+            return {
+                id: String(row.id || '').trim(),
+                referenceNumber,
+                localReferenceNumber,
+                referenceLabel: deriveTaskReferenceLabel({ referenceNumber, localReferenceNumber }),
+                title: String(row.title || ''),
+                status: this.normalizeStatusValue(row.status),
+            };
+        });
+    }
+    searchTaskSummaries(query, scope = 'all', workspaceId) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const normalizedQuery = String(query || '').trim();
+        if (!normalizedQuery)
+            return [];
+        const exactReferenceNumber = parseTaskReference(normalizedQuery);
+        const exactLocalReferenceNumber = parseLocalTaskReference(normalizedQuery);
+        const term = `%${normalizedQuery}%`;
+        const clauses = [
+            'tenant_id = ?',
+            'workspace_id = ?',
+            '(title LIKE ? OR description LIKE ? OR id LIKE ? OR reference_number = ? OR local_reference_number = ?)',
+        ];
+        const params = [
+            this.tenantId,
+            normalizedWorkspaceId,
+            term,
+            term,
+            term,
+            exactReferenceNumber || -1,
+            exactLocalReferenceNumber || -1,
+        ];
+        if (scope === 'active')
+            clauses.push('is_archived = 0');
+        if (scope === 'archive')
+            clauses.push('is_archived = 1');
+        const rows = this.db.prepare(`
+            SELECT id, reference_number, local_reference_number, title, status, assignee, category, priority
+            FROM tasks
+            WHERE ${clauses.join(' AND ')}
+            ORDER BY
+                CASE WHEN id = ? OR reference_number = ? OR local_reference_number = ? THEN 0 ELSE 1 END,
+                created_at DESC
+            LIMIT 50
+        `).all(...params, normalizedQuery, exactReferenceNumber || -1, exactLocalReferenceNumber || -1);
+        return rows.map((row) => {
+            const referenceNumber = this.sanitizeTaskReferenceNumber(row.reference_number);
+            const localReferenceNumber = this.sanitizeTaskReferenceNumber(row.local_reference_number);
+            return {
+                id: String(row.id || '').trim(),
+                referenceNumber,
+                localReferenceNumber,
+                referenceLabel: deriveTaskReferenceLabel({ referenceNumber, localReferenceNumber }),
+                title: String(row.title || ''),
+                status: this.normalizeStatusValue(row.status),
+                assignee: String(row.assignee || '').trim() || null,
+                category: String(row.category || ''),
+                priority: this.normalizePriorityValue(row.priority),
+            };
+        });
+    }
     getDataVersion() {
         if (this.db.provider === 'sqlite') {
             const version = this.db.pragma('data_version', { simple: true });
@@ -5511,6 +5845,9 @@ export class TaskforceCore {
     listDeletedTasks(workspaceId) {
         return listDeletedTasksService(this.getDeletedTaskLifecycleServiceDeps(), workspaceId);
     }
+    listDeletedTasksReadOnly(workspaceId) {
+        return listDeletedTasksReadOnlyService(this.getDeletedTaskLifecycleServiceDeps(), workspaceId);
+    }
     getDeletedTask(id, workspaceId) {
         return getDeletedTaskService(this.getDeletedTaskLifecycleServiceDeps(), id, workspaceId);
     }
@@ -5594,11 +5931,13 @@ export class TaskforceCore {
         const deletedStatsSql = this.db.provider === 'postgres'
             ? `SELECT count(*) as total,
                     sum(case when task_snapshot_json::jsonb ->> 'status' = 'done' then 1 else 0 end) as done_count,
-                    sum(case when task_snapshot_json::jsonb ->> 'status' = 'cancelled' then 1 else 0 end) as cancelled_count
+                    sum(case when task_snapshot_json::jsonb ->> 'status' = 'cancelled' then 1 else 0 end) as cancelled_count,
+                    sum(case when coalesce(task_snapshot_json::jsonb ->> 'status', '') not in ('done', 'cancelled') then 1 else 0 end) as other_count
                FROM deleted_tasks WHERE tenant_id = ? AND workspace_id = ?`
             : `SELECT count(*) as total,
                     sum(case when json_extract(task_snapshot_json, '$.status') = 'done' then 1 else 0 end) as done_count,
-                    sum(case when json_extract(task_snapshot_json, '$.status') = 'cancelled' then 1 else 0 end) as cancelled_count
+                    sum(case when json_extract(task_snapshot_json, '$.status') = 'cancelled' then 1 else 0 end) as cancelled_count,
+                    sum(case when coalesce(json_extract(task_snapshot_json, '$.status'), '') not in ('done', 'cancelled') then 1 else 0 end) as other_count
                FROM deleted_tasks WHERE tenant_id = ? AND workspace_id = ?`;
         const deletedStats = this.db.prepare(deletedStatsSql).get(this.tenantId, normalizedWorkspaceId);
         return {
@@ -5612,6 +5951,7 @@ export class TaskforceCore {
                 total: Number(deletedStats.total || 0),
                 doneCount: Number(deletedStats.done_count || 0),
                 cancelledCount: Number(deletedStats.cancelled_count || 0),
+                otherCount: Number(deletedStats.other_count || 0),
                 retentionDays: DELETED_TASK_RETENTION_DAYS
             }
         };
@@ -7835,6 +8175,9 @@ export class TaskforceCore {
     bindMcpOAuthConnectorGrantAiProfile(input) {
         return this.mcpTokenService.bindMcpOAuthConnectorGrantAiProfile(input);
     }
+    listMcpOAuthRestorableAiProfileIds(input) {
+        return this.mcpTokenService.listMcpOAuthRestorableAiProfileIds(input);
+    }
     recordMcpOAuthConnectorGrantUsage(input) {
         return this.mcpTokenService.recordMcpOAuthConnectorGrantUsage(input);
     }
@@ -8566,6 +8909,12 @@ export class TaskforceCore {
             return inferredAssignee || 'unassigned';
         })();
         const normalizedAttachments = normalizedInput.attachments ?? [];
+        const requestedCardCoverAssetId = typeof normalizedInput.cardCoverAssetId === 'string'
+            ? normalizedInput.cardCoverAssetId.trim()
+            : null;
+        if (requestedCardCoverAssetId && !normalizedAttachments.some((item) => (typeof item !== 'string' && item.assetId === requestedCardCoverAssetId && item.linkRole === 'image'))) {
+            throw new TaskforceRuleError('Task card cover must reference an image already attached to this task.', 400, 'TASK_CARD_COVER_INVALID');
+        }
         const normalizedComments = this.normalizeIncomingComments(normalizedInput.comments, normalizedWorkspaceId);
         const normalizedDescription = this.normalizeGeneratedDescription(normalizedInput.description, createdBySignal);
         const workstreamId = this.sanitizeWorkstreamId(normalizedInput.workstreamId);
@@ -8598,6 +8947,7 @@ export class TaskforceCore {
                     ? this.nextWorkstreamTaskOrder(workstreamId, normalizedWorkspaceId)
                     : null,
             workstreamId,
+            cardCoverAssetId: requestedCardCoverAssetId,
             checklistItems: Array.isArray(normalizedInput.checklistItems)
                 ? normalizedInput.checklistItems.map((item, index) => ({
                     id: String(item?.id || this.generateEntityId('checklist')),
@@ -8628,7 +8978,7 @@ export class TaskforceCore {
                 local_reference_number,
                 created_at, updated_at, is_archived, taxonomies, created_by, assignee,
                 scheduled_date, due_date, scheduled_week_key, order_in_day, workstream_order,
-                workstream_id
+                workstream_id, card_cover_asset_id
             ) VALUES (
                 @id, @tenantId, @title, @description, @status, @priority, @complexity, @type, @category,
                 @workspaceId,
@@ -8636,7 +8986,7 @@ export class TaskforceCore {
                 @localReferenceNumber,
                 @createdAt, @updatedAt, 0, @taxonomies, @createdBy, @assignee,
                 @scheduledDate, @dueDate, @scheduledWeekKey, @orderInDay, @workstreamOrder,
-                @workstreamId
+                @workstreamId, @cardCoverAssetId
             )
         `);
         stmt.run({
@@ -9422,6 +9772,23 @@ export class TaskforceCore {
             if (Object.prototype.hasOwnProperty.call(patch, 'workstreamOrder')) {
                 patch.workstreamOrder = this.sanitizeOrderInDay(patch.workstreamOrder);
             }
+            if (Object.prototype.hasOwnProperty.call(patch, 'cardCoverAssetId')) {
+                const requestedCoverAssetId = typeof patch.cardCoverAssetId === 'string'
+                    ? patch.cardCoverAssetId.trim()
+                    : null;
+                if (requestedCoverAssetId) {
+                    const attachment = (patch.attachments || existing.attachments || []).find((item) => (typeof item !== 'string' && item.assetId === requestedCoverAssetId && item.linkRole === 'image'));
+                    if (!attachment) {
+                        throw new TaskforceRuleError('Task card cover must reference an image already attached to this task.', 400, 'TASK_CARD_COVER_INVALID');
+                    }
+                }
+                patch.cardCoverAssetId = requestedCoverAssetId;
+            }
+            else if (Object.prototype.hasOwnProperty.call(patch, 'attachments') && existing.cardCoverAssetId) {
+                const coverStillAttached = (patch.attachments || []).some((item) => (typeof item !== 'string' && item.assetId === existing.cardCoverAssetId && item.linkRole === 'image'));
+                if (!coverStillAttached)
+                    patch.cardCoverAssetId = null;
+            }
             const hasScheduledDatePatch = Object.prototype.hasOwnProperty.call(patch, 'scheduledDate');
             const hasScheduledWeekKeyPatch = Object.prototype.hasOwnProperty.call(patch, 'scheduledWeekKey');
             const hasOrderInDayPatch = Object.prototype.hasOwnProperty.call(patch, 'orderInDay');
@@ -9486,7 +9853,7 @@ export class TaskforceCore {
             const mappableFields = [
                 'title', 'description', 'status', 'completedAt', 'priority', 'complexity', 'type', 'category',
                 'canceledReason', 'createdBy', 'assignee', 'scheduledDate', 'dueDate',
-                'scheduledWeekKey', 'orderInDay', 'workstreamOrder', 'workstreamId', 'referenceNumber', 'localReferenceNumber'
+                'scheduledWeekKey', 'orderInDay', 'workstreamOrder', 'workstreamId', 'cardCoverAssetId', 'referenceNumber', 'localReferenceNumber'
             ];
             const propertyToColumn = {
                 canceledReason: 'canceled_reason',
@@ -9500,6 +9867,7 @@ export class TaskforceCore {
                 orderInDay: 'order_in_day',
                 workstreamOrder: 'workstream_order',
                 workstreamId: 'workstream_id',
+                cardCoverAssetId: 'card_cover_asset_id',
             };
             mappableFields.forEach(f => {
                 if (patch[f] !== undefined) {
@@ -10398,6 +10766,123 @@ export class TaskforceCore {
     listTasksForSync(workspaceId, cursor, limit) {
         return listTasksForSyncService(this.getSyncReconciliationServiceDeps(), workspaceId, cursor, limit);
     }
+    /**
+     * Full task inventory for authoritative repair without the per-task UI
+     * hydration performed by rowToTask. Repair serializes task roots, comments,
+     * and checklist items separately; task activity, actor decoration, and
+     * resolved attachment bodies are not part of that canonical inventory.
+     */
+    listTasksForAuthoritativeRepair(workspaceId) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const rows = this.db.prepare(`
+            SELECT *
+            FROM tasks
+            WHERE tenant_id = ? AND workspace_id = ?
+            ORDER BY COALESCE(updated_at, created_at) ASC, id ASC
+        `).all(this.tenantId, normalizedWorkspaceId);
+        if (rows.length === 0)
+            return [];
+        const commentsByTaskId = new Map();
+        const checklistByTaskId = new Map();
+        const taskIds = rows.map((row) => String(row.id || '').trim()).filter(Boolean);
+        const batchSize = workspaceSyncV3RepairEntityReadBatchSize(this.db);
+        const normalizedCommentAuthor = new Map();
+        for (let offset = 0; offset < taskIds.length; offset += batchSize) {
+            const batch = taskIds.slice(offset, offset + batchSize);
+            const placeholders = batch.map(() => '?').join(', ');
+            const commentRows = this.db.prepare(`
+                SELECT id, task_id, author, submitted_author, text, timestamp
+                FROM comments
+                WHERE tenant_id = ? AND workspace_id = ? AND task_id IN (${placeholders})
+                ORDER BY task_id ASC, timestamp ASC
+            `).all(this.tenantId, normalizedWorkspaceId, ...batch);
+            for (const comment of commentRows) {
+                const taskId = String(comment.task_id || '').trim();
+                const rawAuthor = String(comment.author || 'user');
+                let author = normalizedCommentAuthor.get(rawAuthor);
+                if (!author) {
+                    author = this.normalizeCommentAuthor(rawAuthor, normalizedWorkspaceId);
+                    normalizedCommentAuthor.set(rawAuthor, author);
+                }
+                const items = commentsByTaskId.get(taskId) || [];
+                items.push({
+                    id: String(comment.id || '').trim(),
+                    author,
+                    submittedAuthor: String(comment.submitted_author || comment.author || 'user').trim() || 'user',
+                    text: String(comment.text || ''),
+                    timestamp: String(comment.timestamp || ''),
+                });
+                commentsByTaskId.set(taskId, items);
+            }
+            const checklistRows = this.db.prepare(`
+                SELECT id, task_id, title, is_completed, sort_order, created_at, updated_at
+                FROM checklist_items
+                WHERE tenant_id = ? AND workspace_id = ? AND task_id IN (${placeholders})
+                ORDER BY task_id ASC, sort_order ASC, created_at ASC
+            `).all(this.tenantId, normalizedWorkspaceId, ...batch);
+            for (const checklistRow of checklistRows) {
+                const item = this.rowToChecklistItem(checklistRow);
+                const items = checklistByTaskId.get(item.taskId) || [];
+                items.push(item);
+                checklistByTaskId.set(item.taskId, items);
+            }
+        }
+        const sanitizedAssigneeByValue = new Map();
+        const normalizedCreatedBy = new Map();
+        return rows.map((row) => {
+            const taskId = String(row.id || '').trim();
+            const rawAssignee = String(row.assignee || '');
+            let sanitizedAssignee = sanitizedAssigneeByValue.get(rawAssignee);
+            if (sanitizedAssignee === undefined) {
+                sanitizedAssignee = this.sanitizeAssignee(row.assignee, normalizedWorkspaceId);
+                sanitizedAssigneeByValue.set(rawAssignee, sanitizedAssignee);
+            }
+            const assignee = this.repairTaskAssignee(taskId, normalizedWorkspaceId, row.assignee, sanitizedAssignee) ? sanitizedAssignee : String(row.assignee || '').trim() || 'unassigned';
+            const rawCreatedBy = String(row.created_by || '');
+            if (!normalizedCreatedBy.has(rawCreatedBy)) {
+                normalizedCreatedBy.set(rawCreatedBy, this.normalizeCreatedBy(row.created_by, normalizedWorkspaceId, { preserveGenericAi: true }));
+            }
+            const scheduledDate = this.sanitizeDateOnly(row.scheduled_date);
+            const dueDate = this.sanitizeDateOnly(row.due_date);
+            const scheduledWeekKey = row.scheduled_week_key
+                || (scheduledDate ? this.dateOnlyToIsoWeekKey(scheduledDate) : null);
+            const referenceNumber = this.sanitizeTaskReferenceNumber(row.reference_number);
+            const localReferenceNumber = this.sanitizeTaskReferenceNumber(row.local_reference_number);
+            return {
+                id: taskId,
+                referenceNumber,
+                localReferenceNumber,
+                referenceLabel: deriveTaskReferenceLabel({ referenceNumber, localReferenceNumber }),
+                title: row.title,
+                description: row.description,
+                status: this.normalizeStatusValue(row.status),
+                priority: this.normalizePriorityValue(row.priority),
+                complexity: row.complexity,
+                type: row.type,
+                category: row.category,
+                createdAt: row.created_at,
+                updatedAt: row.updated_at,
+                completedAt: row.completed_at,
+                canceledReason: row.canceled_reason,
+                isArchived: row.is_archived === 1,
+                scheduledDate,
+                dueDate,
+                scheduledWeekKey,
+                orderInDay: this.sanitizeOrderInDay(row.order_in_day),
+                workstreamOrder: this.sanitizeOrderInDay(row.workstream_order),
+                workstreamId: this.sanitizeWorkstreamId(row.workstream_id),
+                cardCoverAssetId: typeof row.card_cover_asset_id === 'string' && row.card_cover_asset_id.trim()
+                    ? row.card_cover_asset_id.trim()
+                    : null,
+                taxonomies: JSON.parse(row.taxonomies || '{}'),
+                createdBy: normalizedCreatedBy.get(rawCreatedBy),
+                assignee,
+                comments: commentsByTaskId.get(taskId) || [],
+                attachments: [],
+                checklistItems: checklistByTaskId.get(taskId) || [],
+            };
+        });
+    }
     listWorkspaceSyncDeletesSince(workspaceId, cursor, limit) {
         return listWorkspaceSyncDeletesSinceService(this.getSyncReconciliationServiceDeps(), workspaceId, cursor, limit);
     }