@taskforcehq/taskforce 0.3.327 → 0.3.329

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';
@@ -59,6 +61,7 @@ import { getImageReferenceLabel } from '../utils/imageReferences.js';
 import { getCanonicalDocumentName } from '../utils/documentNames.js';
 import { isPathInsideRoot, resolveStorageKeyPathInsideRoot } from '../utils/pathSafety.js';
 import { DEFAULT_TASKFORCE_THEME } from '../utils/theme.js';
+import { normalizeTaskSearchQuery } from '../utils/taskSearch.js';
 import { ensureAssigneeTaskSchema, ensureAnnotatedAttachmentSessionsSchema, ensureAuthIdentitySchema, backfillPlanningAttachmentAssetIdentities, ensureBillingSchema, ensureDocumentReviewSessionsSchema, ensureDocumentReferenceSchema, ensureEntitlementsSchema, ensurePlanningReferenceSchema, ensureScheduleTaskSchema, ensureWorkstreamTaskOrderSchema, ensureTaskAssetsSchema, ensureTaskApproachRemoved, ensureAgentRolesSchema, ensureTaskforceAgentsSchema, ensureTaskforceAgentSkillsSchema, ensureTaskReferenceSchema, ensureTenantSchema, ensureWorkflowSchema, ensureWorkspaceAssetsSchema, ensureWorkspaceSchema, ensureLocalSyncCoordinatorSchema, ensureWorkspaceSyncDurabilitySchema } from '../migrations/taskSchemaMigrations.js';
 import { repairTaskUpdatedAtOnlySyncDrift } from '../migrations/taskUpdatedAtSyncDriftMigration.js';
 export class TaskforceRuleError extends Error {
@@ -1375,9 +1378,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 +1398,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 +1437,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 +1766,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 +1848,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 +2252,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 +2291,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`);
@@ -3120,7 +3159,17 @@ export class TaskforceCore {
         return ['manualComplexityEnabled'];
     }
     getUserBackedProjectConfigKeys() {
-        return ['theme', 'jsonBackupEnabled', 'checklistDropdownEnabled', 'showTaskCardStatusLabel'];
+        return [
+            'theme',
+            'jsonBackupEnabled',
+            'checklistDropdownEnabled',
+            'showTaskCardStatusLabel',
+            'showTaskCardDescription',
+            'showTaskCardAttachments',
+            'showTaskCardChecklistProgress',
+            'showTaskCardLatestActivity',
+            'tintTaskCardActivityBackground',
+        ];
     }
     isWorkspaceBackedProjectConfigKey(key) {
         return this.getWorkspaceBackedProjectConfigKeys().includes(key);
@@ -3163,6 +3212,21 @@ export class TaskforceCore {
         if (typeof source.showTaskCardStatusLabel === 'boolean') {
             next.showTaskCardStatusLabel = source.showTaskCardStatusLabel;
         }
+        if (typeof source.showTaskCardDescription === 'boolean') {
+            next.showTaskCardDescription = source.showTaskCardDescription;
+        }
+        if (typeof source.showTaskCardAttachments === 'boolean') {
+            next.showTaskCardAttachments = source.showTaskCardAttachments;
+        }
+        if (typeof source.showTaskCardChecklistProgress === 'boolean') {
+            next.showTaskCardChecklistProgress = source.showTaskCardChecklistProgress;
+        }
+        if (typeof source.showTaskCardLatestActivity === 'boolean') {
+            next.showTaskCardLatestActivity = source.showTaskCardLatestActivity;
+        }
+        if (typeof source.tintTaskCardActivityBackground === 'boolean') {
+            next.tintTaskCardActivityBackground = source.tintTaskCardActivityBackground;
+        }
         return next;
     }
     stripPersistedProjectConfigKeys(config) {
@@ -3679,7 +3743,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 +3751,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 +3885,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 +3920,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 +3958,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 +4018,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 +4036,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, i.id ASC
         `).all(this.tenantId, normalizedWorkspaceId);
         return rows.map((row) => this.rowToInitiative(row));
     }
@@ -3968,10 +4053,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 +4325,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 +4343,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, w.id ASC
         `).all(this.tenantId, normalizedWorkspaceId);
         return rows.map((row) => this.rowToWorkstream(row));
     }
@@ -4257,14 +4360,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();
@@ -5273,6 +5519,7 @@ export class TaskforceCore {
             generateEntityId: (prefix) => this.generateEntityId(prefix),
             normalizeWorkspaceId: (workspaceId) => this.normalizeWorkspaceId(workspaceId),
             resolveWorkspaceActor: (workspaceId, actorRef) => this.resolveWorkspaceActor(workspaceId, actorRef),
+            resolveWorkspaceActors: (workspaceId, actorRefs) => this.resolveWorkspaceActors(workspaceId, actorRefs),
             sanitizeOrderInDay: (value) => this.sanitizeOrderInDay(value),
             sanitizeDateOnly: (value) => this.sanitizeDateOnly(value),
             normalizeTaskEventActor: (actorRef, workspaceId) => this.normalizeTaskEventActor(actorRef, workspaceId),
@@ -5302,6 +5549,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() {
@@ -5348,6 +5599,489 @@ export class TaskforceCore {
             config: this.readConfig()
         };
     }
+    listTaskSummaries(workspaceId, archived) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const rows = this.db.prepare(`
+            WITH ranked_events AS (
+                SELECT e.entity_id,
+                       e.id,
+                       e.action,
+                       e.actor,
+                       e.actor_type,
+                       e.details_json,
+                       e.created_at,
+                       ROW_NUMBER() OVER (
+                           PARTITION BY e.entity_id
+                           ORDER BY e.created_at DESC, e.id DESC
+                       ) AS event_rank
+                FROM entity_events e
+                JOIN tasks scoped_task
+                  ON scoped_task.tenant_id = e.tenant_id
+                 AND scoped_task.workspace_id = e.workspace_id
+                 AND scoped_task.id = e.entity_id
+                WHERE e.tenant_id = ? AND e.workspace_id = ?
+                  AND e.entity_type = 'task'
+                  AND scoped_task.is_archived = ?
+                  -- Comment activity is represented by the comment itself; the
+                  -- paired audit event is intentionally hidden by taskActivity.
+                  AND e.action <> 'task-comment-added'
+                  -- Durable text-only autosaves retain an empty task-updated event
+                  -- for stable replay identity, but full task activity hides it.
+                  -- Match that visibility rule before ranking so an internal event
+                  -- cannot displace the latest meaningful card activity. REPLACE is
+                  -- intentionally used instead of dialect-specific JSON operators.
+                  AND NOT (
+                      e.action = 'task-updated'
+                      AND REPLACE(COALESCE(e.details_json, ''), ' ', '') LIKE '%"saveSource":"autosave"%'
+                      AND REPLACE(COALESCE(e.details_json, ''), ' ', '') LIKE '%"changes":{}%'
+                  )
+            )
+            SELECT t.id, t.reference_number, t.local_reference_number, t.title, t.status, t.priority,
+                   t.complexity, t.type, t.category, t.created_at, t.updated_at, t.completed_at,
+                   t.canceled_reason, t.is_archived, t.scheduled_date, t.due_date,
+                   t.scheduled_week_key, t.order_in_day, t.workstream_order, t.workstream_id,
+                   t.card_cover_asset_id, t.taxonomies, t.created_by, t.assignee,
+                   event.id AS latest_event_id,
+                   event.action AS latest_event_action,
+                   event.actor AS latest_event_actor,
+                   event.actor_type AS latest_event_actor_type,
+                   event.details_json AS latest_event_details_json,
+                   event.created_at AS latest_event_at
+            FROM tasks t
+            LEFT JOIN ranked_events event
+              ON event.entity_id = t.id AND event.event_rank = 1
+            WHERE t.tenant_id = ? AND t.workspace_id = ? AND t.is_archived = ?
+            ORDER BY ${archived ? 't.completed_at DESC, t.created_at DESC' : 't.created_at DESC'}
+        `).all(this.tenantId, normalizedWorkspaceId, archived ? 1 : 0, this.tenantId, normalizedWorkspaceId, archived ? 1 : 0);
+        const comments = this.db.prepare(`
+            WITH ranked_comments AS (
+                SELECT c.task_id,
+                       c.id,
+                       c.text,
+                       c.author,
+                       c.timestamp,
+                       COUNT(*) OVER (PARTITION BY c.task_id) AS count,
+                       MAX(c.timestamp) OVER (PARTITION BY c.task_id) AS revision,
+                       ROW_NUMBER() OVER (
+                           PARTITION BY c.task_id
+                           ORDER BY c.timestamp DESC, c.id DESC
+                       ) AS comment_rank
+                FROM comments c
+                JOIN tasks t
+                  ON t.tenant_id = c.tenant_id
+                 AND t.workspace_id = c.workspace_id
+                 AND t.id = c.task_id
+                WHERE c.tenant_id = ? AND c.workspace_id = ? AND t.is_archived = ?
+            )
+            SELECT task_id, id, text, author, timestamp, count, revision
+            FROM ranked_comments
+            WHERE comment_rank = 1
+        `).all(this.tenantId, normalizedWorkspaceId, archived ? 1 : 0);
+        const checklist = this.db.prepare(`
+            SELECT c.task_id, COUNT(*) AS count,
+                   SUM(CASE WHEN c.is_completed = 1 THEN 1 ELSE 0 END) AS completed_count,
+                   MAX(COALESCE(c.updated_at, c.created_at)) AS revision
+            FROM checklist_items c
+            JOIN tasks t ON t.tenant_id = c.tenant_id AND t.workspace_id = c.workspace_id AND t.id = c.task_id
+            WHERE c.tenant_id = ? AND c.workspace_id = ? AND t.is_archived = ?
+            GROUP BY c.task_id
+        `).all(this.tenantId, normalizedWorkspaceId, archived ? 1 : 0);
+        const attachments = this.db.prepare(`
+            SELECT l.task_id, COUNT(a.asset_id) AS count,
+                   MAX(CASE WHEN l.asset_id = t.card_cover_asset_id THEN l.asset_id ELSE NULL END) AS cover_asset_id,
+                   MAX(CASE WHEN l.asset_id = t.card_cover_asset_id THEN a.storage_provider ELSE NULL END) AS cover_storage_provider,
+                   MAX(CASE WHEN l.asset_id = t.card_cover_asset_id THEN a.storage_key ELSE NULL END) AS cover_storage_key,
+                   MAX(CASE WHEN l.asset_id = t.card_cover_asset_id THEN a.original_filename ELSE NULL END) AS cover_original_filename,
+                   MAX(CASE WHEN l.asset_id = t.card_cover_asset_id THEN COALESCE(l.display_name, a.logical_name) ELSE NULL END) AS cover_display_name,
+                   MAX(CASE
+                       WHEN COALESCE(a.updated_at, '') > COALESCE(l.updated_at, '') THEN a.updated_at
+                       ELSE l.updated_at
+                   END) AS revision
+            FROM workspace_asset_links l
+            JOIN tasks t ON t.tenant_id = l.tenant_id AND t.workspace_id = l.workspace_id AND t.id = l.task_id
+            JOIN workspace_assets a ON a.tenant_id = l.tenant_id AND a.workspace_id = l.workspace_id AND a.asset_id = l.asset_id AND a.deleted_at IS NULL
+            WHERE l.tenant_id = ? AND l.workspace_id = ? AND t.is_archived = ? AND l.target_type = 'task' AND l.deleted_at IS NULL
+            GROUP BY l.task_id
+        `).all(this.tenantId, normalizedWorkspaceId, archived ? 1 : 0);
+        const relationships = this.db.prepare(`
+            SELECT task_id, COUNT(*) AS count, MAX(updated_at) AS revision
+            FROM (
+                SELECT r.source_task_id AS task_id, r.updated_at
+                FROM task_relationships r
+                JOIN tasks t ON t.tenant_id = r.tenant_id AND t.workspace_id = r.workspace_id AND t.id = r.source_task_id
+                WHERE r.tenant_id = ? AND r.workspace_id = ? AND r.deleted_at IS NULL AND t.is_archived = ?
+                UNION ALL
+                SELECT r.target_task_id AS task_id, r.updated_at
+                FROM task_relationships r
+                JOIN tasks t ON t.tenant_id = r.tenant_id AND t.workspace_id = r.workspace_id AND t.id = r.target_task_id
+                WHERE r.tenant_id = ? AND r.workspace_id = ? AND r.deleted_at IS NULL
+                  AND r.target_task_id <> r.source_task_id AND t.is_archived = ?
+            ) scoped_relationships
+            GROUP BY task_id
+        `).all(this.tenantId, normalizedWorkspaceId, archived ? 1 : 0, this.tenantId, normalizedWorkspaceId, archived ? 1 : 0);
+        const countByTask = (entries) => new Map(entries.map((entry) => [String(entry.task_id || ''), Number(entry.count || 0)]));
+        const commentCountByTask = countByTask(comments);
+        const attachmentCountByTask = countByTask(attachments);
+        const commentRevisionByTask = new Map(comments.map((entry) => [String(entry.task_id || ''), String(entry.revision || '')]));
+        const attachmentRevisionByTask = new Map(attachments.map((entry) => [String(entry.task_id || ''), String(entry.revision || '')]));
+        const coverAttachmentByTask = new Map(attachments.flatMap((entry) => {
+            const taskId = String(entry.task_id || '');
+            const assetId = String(entry.cover_asset_id || '').trim();
+            const storageKey = String(entry.cover_storage_key || '').trim();
+            const storageProvider = String(entry.cover_storage_provider || 'local').trim();
+            if (!taskId || !assetId || !storageKey)
+                return [];
+            const isExternalHttpReference = storageProvider === 'external' && /^https?:\/\//i.test(storageKey);
+            return [[taskId, {
+                        assetId,
+                        path: isExternalHttpReference
+                            ? storageKey
+                            : storageProvider === 'external'
+                                ? `/api/taskforce/context-link?path=${encodeURIComponent(storageKey)}`
+                                : `/api/taskforce/context/${encodeURIComponent(storageKey)}`,
+                        ...(isExternalHttpReference ? {} : { fsPath: storageKey }),
+                        displayName: entry.cover_display_name ? String(entry.cover_display_name) : undefined,
+                        originalFilename: entry.cover_original_filename ? String(entry.cover_original_filename) : undefined,
+                        linkRole: 'image',
+                        taskId,
+                    }]];
+        }));
+        const checklistByTask = new Map(checklist.map((entry) => [String(entry.task_id || ''), {
+                total: Number(entry.count || 0),
+                completed: Number(entry.completed_count || 0),
+                revision: String(entry.revision || ''),
+            }]));
+        const relationshipCountByTask = countByTask(relationships);
+        const relationshipRevisionByTask = new Map(relationships.map((entry) => [
+            String(entry.task_id || ''),
+            String(entry.revision || ''),
+        ]));
+        const latestActivityByTask = new Map();
+        const latestActivityRevisionByTask = new Map();
+        const considerLatestActivity = (taskId, item) => {
+            const existing = latestActivityByTask.get(taskId);
+            const nextTimestamp = Date.parse(String(item.timestamp || ''));
+            const existingTimestamp = existing ? Date.parse(String(existing.timestamp || '')) : Number.NaN;
+            const isNewer = !existing
+                || (Number.isFinite(nextTimestamp) && !Number.isFinite(existingTimestamp))
+                || (Number.isFinite(nextTimestamp) && Number.isFinite(existingTimestamp) && nextTimestamp > existingTimestamp)
+                || (nextTimestamp === existingTimestamp && item.id.localeCompare(existing.id) > 0);
+            if (!isNewer)
+                return;
+            latestActivityByTask.set(taskId, item);
+            latestActivityRevisionByTask.set(taskId, `${item.timestamp}:${item.id}`);
+        };
+        for (const entry of comments) {
+            const taskId = String(entry.task_id || '').trim();
+            const commentId = String(entry.id || '').trim();
+            const timestamp = String(entry.timestamp || '');
+            if (!taskId || !commentId)
+                continue;
+            considerLatestActivity(taskId, {
+                id: `comment:${commentId}`,
+                type: 'comment',
+                timestamp,
+                comment: {
+                    text: String(entry.text || ''),
+                    author: String(entry.author || 'user').trim() || 'user',
+                },
+            });
+        }
+        for (const row of rows) {
+            const taskId = String(row.id || '').trim();
+            const eventId = String(row.latest_event_id || '').trim();
+            const timestamp = String(row.latest_event_at || '');
+            if (!taskId || !eventId)
+                continue;
+            let details = {};
+            try {
+                const parsed = row.latest_event_details_json ? JSON.parse(String(row.latest_event_details_json)) : {};
+                details = parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+            }
+            catch {
+                details = {};
+            }
+            considerLatestActivity(taskId, {
+                id: `event:${eventId}`,
+                type: 'event',
+                timestamp,
+                event: {
+                    action: String(row.latest_event_action || ''),
+                    actor: String(row.latest_event_actor || 'system').trim() || 'system',
+                    actorType: row.latest_event_actor_type === 'human' || row.latest_event_actor_type === 'ai'
+                        ? row.latest_event_actor_type
+                        : 'system',
+                    details,
+                },
+            });
+        }
+        return rows.map((row) => {
+            const id = String(row.id || '').trim();
+            const scheduledDate = this.sanitizeDateOnly(row.scheduled_date);
+            const dueDate = this.sanitizeDateOnly(row.due_date);
+            const referenceNumber = this.sanitizeTaskReferenceNumber(row.reference_number);
+            const localReferenceNumber = this.sanitizeTaskReferenceNumber(row.local_reference_number);
+            let taxonomies = {};
+            try {
+                taxonomies = JSON.parse(row.taxonomies || '{}');
+            }
+            catch {
+                taxonomies = {};
+            }
+            const checklistCounts = checklistByTask.get(id) || { total: 0, completed: 0, revision: '' };
+            const commentCount = commentCountByTask.get(id) || 0;
+            const attachmentCount = attachmentCountByTask.get(id) || 0;
+            const relationshipCount = relationshipCountByTask.get(id) || 0;
+            const detailRevision = JSON.stringify([
+                String(row.updated_at || row.created_at || ''),
+                commentCount,
+                commentRevisionByTask.get(id) || '',
+                checklistCounts.total,
+                checklistCounts.completed,
+                checklistCounts.revision,
+                attachmentCount,
+                attachmentRevisionByTask.get(id) || '',
+                relationshipCount,
+                relationshipRevisionByTask.get(id) || '',
+                latestActivityRevisionByTask.get(id) || '',
+            ]);
+            return {
+                id,
+                referenceNumber,
+                localReferenceNumber,
+                referenceLabel: deriveTaskReferenceLabel({ referenceNumber, localReferenceNumber }),
+                title: String(row.title || ''),
+                status: this.normalizeStatusValue(row.status),
+                priority: this.normalizePriorityValue(row.priority),
+                complexity: Number(row.complexity || 3),
+                type: String(row.type || 'task'),
+                category: String(row.category || 'default'),
+                createdAt: String(row.created_at || ''),
+                updatedAt: row.updated_at ? String(row.updated_at) : undefined,
+                completedAt: row.completed_at ? String(row.completed_at) : null,
+                canceledReason: row.canceled_reason ? String(row.canceled_reason) : null,
+                isArchived: row.is_archived === 1 || row.is_archived === true,
+                scheduledDate,
+                dueDate,
+                scheduledWeekKey: row.scheduled_week_key || (scheduledDate ? this.dateOnlyToIsoWeekKey(scheduledDate) : null),
+                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,
+                cardCoverAttachment: coverAttachmentByTask.get(id) || null,
+                taxonomies,
+                createdBy: this.normalizeCreatedBy(row.created_by, normalizedWorkspaceId, { preserveGenericAi: true }),
+                assignee: this.sanitizeAssignee(row.assignee, normalizedWorkspaceId),
+                isSummary: true,
+                commentCount,
+                checklistCount: checklistCounts.total,
+                completedChecklistCount: checklistCounts.completed,
+                attachmentCount,
+                relationshipCount,
+                latestActivity: latestActivityByTask.get(id) || null,
+                detailRevision,
+            };
+        });
+    }
+    listActiveTaskSummaries(workspaceId) {
+        return { tasks: this.listTaskSummaries(workspaceId, false) };
+    }
+    listArchiveSummaries(workspaceId) {
+        return { archived: this.listTaskSummaries(workspaceId, true) };
+    }
+    getTaskDetailRevision(id, workspaceId) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const taskId = String(id || '').trim();
+        if (!taskId)
+            return null;
+        const row = this.db.prepare(`
+            WITH target_task AS (
+                SELECT id, created_at, updated_at
+                FROM tasks
+                WHERE tenant_id = ? AND workspace_id = ? AND id = ?
+            ),
+            comment_stats AS (
+                SELECT COUNT(*) AS count, MAX(c.timestamp) AS revision
+                FROM comments c
+                JOIN target_task t ON t.id = c.task_id
+                WHERE c.tenant_id = ? AND c.workspace_id = ?
+            ),
+            latest_comment AS (
+                SELECT c.id, c.timestamp
+                FROM comments c
+                JOIN target_task t ON t.id = c.task_id
+                WHERE c.tenant_id = ? AND c.workspace_id = ?
+                ORDER BY c.timestamp DESC, c.id DESC
+                LIMIT 1
+            ),
+            checklist_stats AS (
+                SELECT COUNT(*) AS count,
+                       SUM(CASE WHEN c.is_completed = 1 THEN 1 ELSE 0 END) AS completed_count,
+                       MAX(COALESCE(c.updated_at, c.created_at)) AS revision
+                FROM checklist_items c
+                JOIN target_task t ON t.id = c.task_id
+                WHERE c.tenant_id = ? AND c.workspace_id = ?
+            ),
+            attachment_stats AS (
+                SELECT COUNT(a.asset_id) AS count,
+                       MAX(CASE
+                           WHEN COALESCE(a.updated_at, '') > COALESCE(l.updated_at, '') THEN a.updated_at
+                           ELSE l.updated_at
+                       END) AS revision
+                FROM workspace_asset_links l
+                JOIN target_task t ON t.id = l.task_id
+                JOIN workspace_assets a
+                  ON a.tenant_id = l.tenant_id
+                 AND a.workspace_id = l.workspace_id
+                 AND a.asset_id = l.asset_id
+                 AND a.deleted_at IS NULL
+                WHERE l.tenant_id = ? AND l.workspace_id = ?
+                  AND l.target_type = 'task' AND l.deleted_at IS NULL
+            ),
+            relationship_rows AS (
+                SELECT r.updated_at
+                FROM task_relationships r
+                JOIN target_task t ON t.id = r.source_task_id
+                WHERE r.tenant_id = ? AND r.workspace_id = ? AND r.deleted_at IS NULL
+                UNION ALL
+                SELECT r.updated_at
+                FROM task_relationships r
+                JOIN target_task t ON t.id = r.target_task_id
+                WHERE r.tenant_id = ? AND r.workspace_id = ? AND r.deleted_at IS NULL
+                  AND r.target_task_id <> r.source_task_id
+            ),
+            relationship_stats AS (
+                SELECT COUNT(*) AS count, MAX(updated_at) AS revision
+                FROM relationship_rows
+            ),
+            latest_event AS (
+                SELECT e.id, e.created_at
+                FROM entity_events e
+                JOIN target_task t ON t.id = e.entity_id
+                WHERE e.tenant_id = ? AND e.workspace_id = ?
+                  AND e.entity_type = 'task'
+                  AND e.action <> 'task-comment-added'
+                  AND NOT (
+                      e.action = 'task-updated'
+                      AND REPLACE(COALESCE(e.details_json, ''), ' ', '') LIKE '%"saveSource":"autosave"%'
+                      AND REPLACE(COALESCE(e.details_json, ''), ' ', '') LIKE '%"changes":{}%'
+                  )
+                ORDER BY e.created_at DESC, e.id DESC
+                LIMIT 1
+            )
+            SELECT t.created_at, t.updated_at,
+                   comments.count AS comment_count, comments.revision AS comment_revision,
+                   latest_comment.id AS latest_comment_id,
+                   latest_comment.timestamp AS latest_comment_at,
+                   checklist.count AS checklist_count,
+                   checklist.completed_count AS completed_checklist_count,
+                   checklist.revision AS checklist_revision,
+                   attachments.count AS attachment_count,
+                   attachments.revision AS attachment_revision,
+                   relationships.count AS relationship_count,
+                   relationships.revision AS relationship_revision,
+                   latest_event.id AS latest_event_id,
+                   latest_event.created_at AS latest_event_at
+            FROM target_task t
+            CROSS JOIN comment_stats comments
+            CROSS JOIN checklist_stats checklist
+            CROSS JOIN attachment_stats attachments
+            CROSS JOIN relationship_stats relationships
+            LEFT JOIN latest_comment ON 1 = 1
+            LEFT JOIN latest_event ON 1 = 1
+        `).get(this.tenantId, normalizedWorkspaceId, taskId, this.tenantId, normalizedWorkspaceId, this.tenantId, normalizedWorkspaceId, this.tenantId, normalizedWorkspaceId, this.tenantId, normalizedWorkspaceId, this.tenantId, normalizedWorkspaceId, this.tenantId, normalizedWorkspaceId, this.tenantId, normalizedWorkspaceId);
+        if (!row)
+            return null;
+        const latestCommentId = String(row.latest_comment_id || '').trim();
+        const latestCommentAt = String(row.latest_comment_at || '');
+        const latestEventId = String(row.latest_event_id || '').trim();
+        const latestEventAt = String(row.latest_event_at || '');
+        const commentTimestamp = Date.parse(latestCommentAt);
+        const eventTimestamp = Date.parse(latestEventAt);
+        const commentActivityId = latestCommentId ? `comment:${latestCommentId}` : '';
+        const eventActivityId = latestEventId ? `event:${latestEventId}` : '';
+        const latestActivityRevision = !latestEventId
+            || (latestCommentId && ((Number.isFinite(commentTimestamp) && !Number.isFinite(eventTimestamp))
+                || commentTimestamp > eventTimestamp
+                || (commentTimestamp === eventTimestamp && commentActivityId.localeCompare(eventActivityId) > 0)))
+            ? (latestCommentId ? `${latestCommentAt}:${commentActivityId}` : '')
+            : `${latestEventAt}:${eventActivityId}`;
+        return JSON.stringify([
+            String(row.updated_at || row.created_at || ''),
+            Number(row.comment_count || 0),
+            String(row.comment_revision || ''),
+            Number(row.checklist_count || 0),
+            Number(row.completed_checklist_count || 0),
+            String(row.checklist_revision || ''),
+            Number(row.attachment_count || 0),
+            String(row.attachment_revision || ''),
+            Number(row.relationship_count || 0),
+            String(row.relationship_revision || ''),
+            latestActivityRevision,
+        ]);
+    }
+    getTaskDetailSnapshot(id, workspaceId) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        return this.db.transaction(() => {
+            if (this.db.provider === 'postgres') {
+                this.db.exec('SET TRANSACTION ISOLATION LEVEL REPEATABLE READ');
+            }
+            const task = this.getTask(id, normalizedWorkspaceId);
+            if (!task)
+                return null;
+            const detailRevision = this.getTaskDetailRevision(id, normalizedWorkspaceId);
+            return detailRevision ? { ...task, detailRevision } : null;
+        })();
+    }
+    updateTaskIfDetailRevisionMatches(id, expectedDetailRevision, updates, workspaceId, options) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const updated = this.db.transaction(() => {
+            if (this.db.provider === 'postgres') {
+                this.db.exec('SET TRANSACTION ISOLATION LEVEL SERIALIZABLE');
+            }
+            const currentDetailRevision = this.getTaskDetailRevision(id, normalizedWorkspaceId);
+            if (currentDetailRevision === null)
+                return null;
+            if (currentDetailRevision !== expectedDetailRevision) {
+                throw new TaskforceRuleError('Task changed after this editor was loaded. Reload the latest task before saving.', 409, 'TASK_DETAIL_REVISION_CONFLICT', { currentDetailRevision });
+            }
+            const task = this.updateTask(id, updates, normalizedWorkspaceId, {
+                actorRef: options?.actorRef,
+                saveSource: options?.saveSource,
+                persistBackup: false,
+                emitRealtime: false,
+            });
+            if (!task)
+                return null;
+            const detailRevision = this.getTaskDetailRevision(id, normalizedWorkspaceId);
+            return detailRevision ? { ...task, detailRevision } : null;
+        })();
+        if (updated) {
+            this.persistBackup();
+            this.emitRealtimeMutation({
+                workspaceId: normalizedWorkspaceId,
+                entityType: 'task',
+                changeType: 'upsert',
+                entityIds: [updated.id],
+            });
+        }
+        return updated;
+    }
+    assertTaskDetailRevisionForUpdate(id, expectedDetailRevision, workspaceId) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const lockSql = this.db.provider === 'postgres'
+            ? `SELECT id FROM tasks WHERE tenant_id = ? AND workspace_id = ? AND id = ? FOR UPDATE`
+            : `SELECT id FROM tasks WHERE tenant_id = ? AND workspace_id = ? AND id = ?`;
+        const task = this.db.prepare(lockSql).get(this.tenantId, normalizedWorkspaceId, id);
+        if (!task)
+            throw new TaskforceRuleError('Task not found.', 404, 'TASK_NOT_FOUND');
+        const currentDetailRevision = this.getTaskDetailRevision(id, normalizedWorkspaceId);
+        if (currentDetailRevision !== expectedDetailRevision) {
+            throw new TaskforceRuleError('Task changed after this editor was loaded. Reload the latest task before saving.', 409, 'TASK_DETAIL_REVISION_CONFLICT', { currentDetailRevision });
+        }
+    }
     /**
      * Filter-pushdown listing used by read-only surfaces that don't need the
      * full task graph (MCP list_tasks, CLI summaries). Avoids the per-task
@@ -5360,9 +6094,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 +6203,127 @@ 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, options) {
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const normalizedQuery = normalizeTaskSearchQuery(String(query || ''));
+        if (!normalizedQuery.raw)
+            return [];
+        const exactReferenceNumber = parseTaskReference(normalizedQuery.raw);
+        const exactLocalReferenceNumber = parseLocalTaskReference(normalizedQuery.raw);
+        const searchableText = `
+            COALESCE(title, '') || ' ' ||
+            COALESCE(description, '') || ' ' ||
+            COALESCE(id, '') || ' ' ||
+            CASE WHEN reference_number IS NULL THEN '' ELSE 'T-' || CAST(reference_number AS TEXT) END || ' ' ||
+            CASE WHEN local_reference_number IS NULL THEN '' ELSE 'LT-' || CAST(local_reference_number AS TEXT) END || ' ' ||
+            COALESCE(category, '') || ' ' ||
+            COALESCE(type, '') || ' ' ||
+            COALESCE(CAST(priority AS TEXT), '') || ' ' ||
+            COALESCE(status, '') || ' ' ||
+            COALESCE(assignee, '') || ' ' ||
+            COALESCE(canceled_reason, '')
+        `;
+        const escapedTerms = normalizedQuery.tokens.map((token) => (`%${token.replace(/[\\%_]/g, '\\$&')}%`));
+        const clauses = [
+            'tenant_id = ?',
+            'workspace_id = ?',
+            ...escapedTerms.map(() => `LOWER(${searchableText}) LIKE ? ESCAPE '\\'`),
+        ];
+        const params = [
+            this.tenantId,
+            normalizedWorkspaceId,
+            ...escapedTerms,
+        ];
+        if (scope === 'active')
+            clauses.push('is_archived = 0');
+        if (scope === 'archive')
+            clauses.push('is_archived = 1');
+        const limit = Math.max(1, Math.min(51, Math.trunc(options?.limit ?? 50)));
+        const offset = Math.max(0, Math.trunc(options?.offset ?? 0));
+        const rows = this.db.prepare(`
+            SELECT id, reference_number, local_reference_number, title, status, assignee, category, priority, is_archived
+            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,
+                id DESC
+            LIMIT ? OFFSET ?
+        `).all(...params, normalizedQuery.raw, exactReferenceNumber || -1, exactLocalReferenceNumber || -1, limit, offset);
+        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),
+                isArchived: row.is_archived === 1 || row.is_archived === true,
+            };
+        });
+    }
     getDataVersion() {
         if (this.db.provider === 'sqlite') {
             const version = this.db.pragma('data_version', { simple: true });
@@ -5511,6 +6368,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 +6454,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 +6474,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
             }
         };
@@ -6889,6 +7752,20 @@ export class TaskforceCore {
             runTaskMetadataOwnershipTransaction: (input) => this.runTaskMetadataOwnershipTransaction(input),
         };
     }
+    buildUnresolvedWorkspaceActor(raw) {
+        const normalized = raw.toLowerCase();
+        const unresolvedKind = (normalized.startsWith('ai-profile-') || this.isKnownAiModelName(normalized)) ? 'ai' : 'human';
+        return {
+            id: raw,
+            kind: unresolvedKind,
+            label: this.formatActorLabel(raw),
+            username: this.normalizeAiProfileUsername(raw, raw),
+            icon: unresolvedKind === 'ai' ? GENERIC_AI_ACTOR_ICON : 'User',
+            color: unresolvedKind === 'ai' ? GENERIC_AI_ACTOR_COLOR : '#22c55e',
+            isNamed: true,
+            meta: { unresolved: true }
+        };
+    }
     resolveWorkspaceActor(workspaceId, actorRef) {
         const raw = String(actorRef || '').trim();
         const normalized = raw.toLowerCase();
@@ -6918,17 +7795,81 @@ export class TaskforceCore {
         if (workspaceUser) {
             return this.workspaceUserToActor(workspaceUser);
         }
-        const unresolvedKind = (normalized.startsWith('ai-profile-') || this.isKnownAiModelName(normalized)) ? 'ai' : 'human';
-        return {
-            id: raw,
-            kind: unresolvedKind,
-            label: this.formatActorLabel(raw),
-            username: this.normalizeAiProfileUsername(raw, raw),
-            icon: unresolvedKind === 'ai' ? GENERIC_AI_ACTOR_ICON : 'User',
-            color: unresolvedKind === 'ai' ? GENERIC_AI_ACTOR_COLOR : '#22c55e',
-            isNamed: true,
-            meta: { unresolved: true }
-        };
+        return this.buildUnresolvedWorkspaceActor(raw);
+    }
+    resolveWorkspaceActors(workspaceId, actorRefs) {
+        const rawActorRefs = [...new Set(actorRefs
+                .map((actorRef) => String(actorRef || '').trim())
+                .filter(Boolean))];
+        const resolvedActors = new Map();
+        const lookupActorRefs = [];
+        for (const raw of rawActorRefs) {
+            const normalized = raw.toLowerCase();
+            if (normalized === 'unassigned' || normalized === 'none' || normalized === 'null') {
+                resolvedActors.set(raw, null);
+            }
+            else if (this.isHumanActorReference(raw)) {
+                resolvedActors.set(raw, this.buildHumanActorFallback());
+            }
+            else if (this.isGenericAiActorReference(raw)) {
+                resolvedActors.set(raw, this.buildGenericAiActor());
+            }
+            else {
+                lookupActorRefs.push(raw);
+            }
+        }
+        if (lookupActorRefs.length === 0)
+            return resolvedActors;
+        const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
+        const aiProfileRows = this.db.prepare(`
+            SELECT *
+            FROM ai_profiles
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+            ORDER BY COALESCE(last_active_at, updated_at, created_at) DESC, id ASC
+        `).all(this.tenantId, normalizedWorkspaceId);
+        const aiProfileRowsById = new Map(aiProfileRows
+            .map((row) => [String(row.id || '').trim(), row])
+            .filter(([id]) => Boolean(id)));
+        const aiProfileRowsByAlias = new Map();
+        for (const row of aiProfileRows) {
+            const aliases = new Set([String(row.name || '').trim().toLowerCase(), String(row.username || '').trim().toLowerCase()]);
+            for (const alias of aliases) {
+                if (!alias)
+                    continue;
+                const matches = aiProfileRowsByAlias.get(alias) ?? [];
+                matches.push(row);
+                aiProfileRowsByAlias.set(alias, matches);
+            }
+        }
+        const workspaceUsersById = new Map(this.listWorkspaceUsers(normalizedWorkspaceId)
+            .map((user) => [user.userId, user]));
+        for (const raw of lookupActorRefs) {
+            const directAiProfileRow = aiProfileRowsById.get(raw);
+            if (directAiProfileRow) {
+                resolvedActors.set(raw, this.aiProfileToActor(this.aiProfileRowToRecord(directAiProfileRow)));
+                continue;
+            }
+            const aliasMatches = aiProfileRowsByAlias.get(raw.toLowerCase()) ?? [];
+            const aliasRowsById = new Map(aliasMatches
+                .map((row) => [String(row.id || '').trim(), row])
+                .filter(([id]) => Boolean(id)));
+            const canonicalAliasIds = [...new Set(aliasMatches
+                    .map((row) => this.resolveCanonicalAiProfileId(aliasRowsById, String(row.id || '').trim()))
+                    .filter(Boolean))];
+            if (canonicalAliasIds.length === 1) {
+                const canonicalAiProfileRow = aiProfileRowsById.get(canonicalAliasIds[0]);
+                if (canonicalAiProfileRow) {
+                    resolvedActors.set(raw, this.aiProfileToActor(this.aiProfileRowToRecord(canonicalAiProfileRow)));
+                    continue;
+                }
+            }
+            const workspaceUser = workspaceUsersById.get(raw);
+            resolvedActors.set(raw, workspaceUser
+                ? this.workspaceUserToActor(workspaceUser)
+                : this.buildUnresolvedWorkspaceActor(raw));
+        }
+        return resolvedActors;
     }
     listAssignableActors(workspaceId) {
         const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
@@ -7835,6 +8776,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 +9510,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 +9548,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 +9579,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 +9587,7 @@ export class TaskforceCore {
                 @localReferenceNumber,
                 @createdAt, @updatedAt, 0, @taxonomies, @createdBy, @assignee,
                 @scheduledDate, @dueDate, @scheduledWeekKey, @orderInDay, @workstreamOrder,
-                @workstreamId
+                @workstreamId, @cardCoverAssetId
             )
         `);
         stmt.run({
@@ -9366,9 +10317,11 @@ export class TaskforceCore {
                 return null;
             const patchFields = Object.keys(patch);
             const archivedNestedContentWrite = options?.allowArchivedNestedContentSyncWrite === true
-                && patchFields.some((field) => ['comments', 'attachments', 'checklistItems'].includes(field))
+                && patchFields.some((field) => [
+                    'comments', 'attachments', 'checklistItems', 'cardCoverAssetId',
+                ].includes(field))
                 && patchFields.every((field) => [
-                    'id', 'comments', 'attachments', 'checklistItems',
+                    'id', 'comments', 'attachments', 'checklistItems', 'cardCoverAssetId',
                 ].includes(field));
             if (existing.isArchived && !archivedNestedContentWrite) {
                 throw new TaskforceRuleError('Archived tasks are read-only. Unarchive first to make changes.', 409, 'TASK_ARCHIVED_READ_ONLY');
@@ -9422,6 +10375,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 +10456,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 +10470,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 +11369,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);
     }