@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/sync/workspaceSyncSnapshotProjection.js

@@ -0,0 +1,101 @@
+/**
+ * Projects the entity-event history embedded in the browser's hydrated task and
+ * planning collections into the legacy v2 snapshot contract.
+ *
+ * Keep this projection shared by browser and server-owned snapshot builders:
+ * reading the standalone entity-event feed instead would subtly change v2
+ * payload and signature behavior.
+ */
+export function flattenTaskEvents(tasks, archivedTasks, initiatives = [], workstreams = []) {
+    const deduped = new Map();
+    for (const task of [...(tasks || []), ...(archivedTasks || [])]) {
+        const taskEvents = Array.isArray(task?.taskEvents) ? task.taskEvents : [];
+        for (const event of taskEvents) {
+            const id = String(event?.id || '').trim();
+            const taskId = String(event?.taskId || task?.id || '').trim();
+            const workspaceId = String(event?.workspaceId || '').trim();
+            const createdAt = String(event?.createdAt || '').trim();
+            if (!id || !taskId || !workspaceId || !createdAt)
+                continue;
+            const nextEvent = {
+                id,
+                workspaceId,
+                entityType: 'task',
+                entityId: taskId,
+                taskId,
+                action: String(event?.action || '').trim(),
+                actor: String(event?.actor || 'system').trim() || 'system',
+                actorType: event?.actorType === 'ai' || event?.actorType === 'human' || event?.actorType === 'system'
+                    ? event.actorType
+                    : 'system',
+                details: event?.details,
+                createdAt,
+            };
+            const existing = deduped.get(id);
+            if (!existing || nextEvent.createdAt > existing.createdAt) {
+                deduped.set(id, nextEvent);
+            }
+        }
+    }
+    for (const initiative of initiatives || []) {
+        const entityEvents = Array.isArray(initiative?.entityEvents) ? initiative.entityEvents : [];
+        for (const event of entityEvents) {
+            const id = String(event?.id || '').trim();
+            const entityId = String(event?.entityId || initiative?.id || '').trim();
+            const workspaceId = String(event?.workspaceId || '').trim();
+            const createdAt = String(event?.createdAt || '').trim();
+            if (!id || !entityId || !workspaceId || !createdAt)
+                continue;
+            const nextEvent = {
+                id,
+                workspaceId,
+                entityType: 'initiative',
+                entityId,
+                action: String(event?.action || '').trim(),
+                actor: String(event?.actor || 'system').trim() || 'system',
+                actorType: event?.actorType === 'ai' || event?.actorType === 'human' || event?.actorType === 'system'
+                    ? event.actorType
+                    : 'system',
+                details: event?.details,
+                createdAt,
+            };
+            const existing = deduped.get(id);
+            if (!existing || nextEvent.createdAt > existing.createdAt) {
+                deduped.set(id, nextEvent);
+            }
+        }
+    }
+    for (const workstream of workstreams || []) {
+        const entityEvents = Array.isArray(workstream?.entityEvents) ? workstream.entityEvents : [];
+        for (const event of entityEvents) {
+            const id = String(event?.id || '').trim();
+            const entityId = String(event?.entityId || workstream?.id || '').trim();
+            const workspaceId = String(event?.workspaceId || '').trim();
+            const createdAt = String(event?.createdAt || '').trim();
+            if (!id || !entityId || !workspaceId || !createdAt)
+                continue;
+            const nextEvent = {
+                id,
+                workspaceId,
+                entityType: 'workstream',
+                entityId,
+                action: String(event?.action || '').trim(),
+                actor: String(event?.actor || 'system').trim() || 'system',
+                actorType: event?.actorType === 'ai' || event?.actorType === 'human' || event?.actorType === 'system'
+                    ? event.actorType
+                    : 'system',
+                details: event?.details,
+                createdAt,
+            };
+            const existing = deduped.get(id);
+            if (!existing || nextEvent.createdAt > existing.createdAt) {
+                deduped.set(id, nextEvent);
+            }
+        }
+    }
+    return Array.from(deduped.values()).sort((left, right) => {
+        if (left.createdAt !== right.createdAt)
+            return left.createdAt.localeCompare(right.createdAt);
+        return left.id.localeCompare(right.id);
+    });
+}

package/dist/sync/workspaceSyncState.d.ts

@@ -1,13 +1,21 @@
 export type WorkspaceSyncPhase = 'idle' | 'provision-local' | 'attach-cloud' | 'active' | 'error';
 export type WorkspaceSyncSetupIntent = 'attach-cloud-import' | null;
+export interface WorkspaceSyncStateRevision {
+    counter: number;
+    writerId: string;
+}
 export interface WorkspaceSyncPushBaselineSnapshot {
     taskIds?: string[];
     taskWatermarks: Array<[string, string]>;
     taskChangeKeys?: Array<[string, string]>;
+    taskRelationshipChangeKeys?: Array<[string, string]>;
     initiativeWatermarks: Array<[string, string]>;
     workstreamWatermarks: Array<[string, string]>;
     aiProfileWatermarks: Array<[string, string]>;
     aiProfileChangeKeys?: Array<[string, string]>;
+    taskforceAgentWatermarks?: Array<[string, string]>;
+    taskforceAgentSkillWatermarks?: Array<[string, string]>;
+    agentConversationWatermarks?: Array<[string, string]>;
     documentWatermarks: Array<[string, string]>;
     assetWatermarks: Array<[string, string]>;
     documentReviewSessionWatermarks: Array<[string, string]>;
@@ -15,9 +23,11 @@ export interface WorkspaceSyncPushBaselineSnapshot {
     annotatedAttachmentSessionWatermarks: Array<[string, string]>;
     taskEventWatermarks: Array<[string, string]>;
     taxonomyStateFingerprint: string;
+    taxonomyChangeKey?: string;
 }
 export interface WorkspaceSyncStateV2 {
     version: 2;
+    revision: WorkspaceSyncStateRevision | null;
     enabled: boolean;
     phase: WorkspaceSyncPhase;
     setupIntent?: WorkspaceSyncSetupIntent;
@@ -30,3 +40,6 @@ export interface WorkspaceSyncStateV2 {
     pushBaseline?: WorkspaceSyncPushBaselineSnapshot | null;
 }
 export declare function createDefaultWorkspaceSyncState(): WorkspaceSyncStateV2;
+export declare function normalizeWorkspaceSyncStateRevision(value: unknown): WorkspaceSyncStateRevision | null;
+export declare function compareWorkspaceSyncStateRevisions(left: WorkspaceSyncStateRevision | null, right: WorkspaceSyncStateRevision | null): number;
+export declare function createNextWorkspaceSyncStateRevision(current: WorkspaceSyncStateRevision | null, writerId: string): WorkspaceSyncStateRevision;

package/dist/sync/workspaceSyncState.js

@@ -1,6 +1,7 @@
 export function createDefaultWorkspaceSyncState() {
     return {
         version: 2,
+        revision: null,
         enabled: false,
         phase: 'idle',
         setupIntent: null,
@@ -13,3 +14,38 @@ export function createDefaultWorkspaceSyncState() {
         pushBaseline: null
     };
 }
+export function normalizeWorkspaceSyncStateRevision(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const candidate = value;
+    const counter = candidate.counter;
+    const writerId = typeof candidate.writerId === 'string' ? candidate.writerId.trim() : '';
+    if (!Number.isSafeInteger(counter) || Number(counter) < 1 || !writerId || writerId.length > 200)
+        return null;
+    return { counter: Number(counter), writerId };
+}
+export function compareWorkspaceSyncStateRevisions(left, right) {
+    if (!left)
+        return right ? -1 : 0;
+    if (!right)
+        return 1;
+    if (left.counter !== right.counter)
+        return left.counter < right.counter ? -1 : 1;
+    if (left.writerId === right.writerId)
+        return 0;
+    return left.writerId < right.writerId ? -1 : 1;
+}
+export function createNextWorkspaceSyncStateRevision(current, writerId) {
+    const normalizedWriterId = String(writerId || '').trim();
+    if (!normalizedWriterId)
+        throw new Error('Workspace sync state revision writer is required');
+    if (normalizedWriterId.length > 200)
+        throw new Error('Workspace sync state revision writer is too long');
+    if (current?.counter === Number.MAX_SAFE_INTEGER) {
+        throw new Error('Workspace sync state revision counter is exhausted');
+    }
+    return {
+        counter: (current?.counter || 0) + 1,
+        writerId: normalizedWriterId,
+    };
+}

package/dist/sync/workspaceSyncV2SnapshotBuilder.d.ts

@@ -0,0 +1,106 @@
+import type { TaskRelationshipRecord } from '../core/Taskforce.js';
+import type { WorkspaceTaxonomyState } from '../shared/taxonomyState.js';
+import type { DeletedTaskRecord, InitiativeItem, TaskItem, WorkstreamItem } from '../types.js';
+import { type WorkspaceSyncAiProfileSnapshot, type WorkspaceSyncAgentConversationSnapshot, type WorkspaceSyncAgentRoleSnapshot, type WorkspaceSyncAnnotatedAttachmentSessionSnapshot, type WorkspaceSyncAssetSnapshot, type WorkspaceSyncBaselineResetReason, type WorkspaceSyncDocumentReviewCommentSnapshot, type WorkspaceSyncDocumentReviewSessionSnapshot, type WorkspaceSyncDocumentSnapshot, type WorkspaceSyncEntityEventSnapshot, type WorkspaceSyncPayload, type WorkspaceSyncTaskforceAgentSkillSnapshot, type WorkspaceSyncTaskforceAgentSnapshot } from './workspaceSyncModel.js';
+export interface WorkspaceSyncV2SnapshotInput {
+    workspaceId: string;
+    tasks: readonly TaskItem[];
+    archivedTasks: readonly TaskItem[];
+    deletedTasks?: readonly DeletedTaskRecord[];
+    pendingDeletedTaskIds?: ReadonlySet<string>;
+    pendingDeletedTaskWatermarks?: ReadonlyMap<string, string>;
+    taskRelationships?: readonly TaskRelationshipRecord[];
+    initiatives?: readonly InitiativeItem[];
+    workstreams?: readonly WorkstreamItem[];
+    taxonomies?: readonly unknown[];
+    taxonomyState?: WorkspaceTaxonomyState;
+    aiProfiles?: readonly WorkspaceSyncAiProfileSnapshot[];
+    documents?: readonly WorkspaceSyncDocumentSnapshot[];
+    assets?: readonly WorkspaceSyncAssetSnapshot[];
+    currentDocumentPaths?: ReadonlySet<string>;
+    currentAssetPaths?: ReadonlySet<string>;
+    documentReviewSessions?: readonly WorkspaceSyncDocumentReviewSessionSnapshot[];
+    documentReviewComments?: readonly WorkspaceSyncDocumentReviewCommentSnapshot[];
+    annotatedAttachmentSessions?: readonly WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
+    taskforceAgents?: readonly WorkspaceSyncTaskforceAgentSnapshot[];
+    agentRoles?: readonly WorkspaceSyncAgentRoleSnapshot[];
+    taskforceAgentSkills?: readonly WorkspaceSyncTaskforceAgentSkillSnapshot[];
+    agentConversations?: readonly WorkspaceSyncAgentConversationSnapshot[];
+    taskEvents?: readonly WorkspaceSyncEntityEventSnapshot[];
+}
+export interface WorkspaceSyncV2FrozenSnapshot {
+    readonly workspaceId: string;
+    readonly tasks: readonly TaskItem[];
+    readonly archivedTasks: readonly TaskItem[];
+    readonly deletedTasks: readonly DeletedTaskRecord[];
+    readonly pendingDeletedTaskIds: ReadonlySet<string>;
+    readonly pendingDeletedTaskWatermarks: ReadonlyMap<string, string>;
+    readonly taskRelationships: readonly TaskRelationshipRecord[];
+    readonly initiatives: readonly InitiativeItem[];
+    readonly workstreams: readonly WorkstreamItem[];
+    readonly taxonomies: readonly unknown[];
+    readonly taxonomyState?: WorkspaceTaxonomyState;
+    readonly aiProfiles: readonly WorkspaceSyncAiProfileSnapshot[];
+    readonly documents: readonly WorkspaceSyncDocumentSnapshot[];
+    readonly assets: readonly WorkspaceSyncAssetSnapshot[];
+    readonly currentDocumentPaths: ReadonlySet<string>;
+    readonly currentAssetPaths: ReadonlySet<string>;
+    readonly documentReviewSessions: readonly WorkspaceSyncDocumentReviewSessionSnapshot[];
+    readonly documentReviewComments: readonly WorkspaceSyncDocumentReviewCommentSnapshot[];
+    readonly annotatedAttachmentSessions: readonly WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
+    readonly taskforceAgents: readonly WorkspaceSyncTaskforceAgentSnapshot[];
+    readonly agentRoles: readonly WorkspaceSyncAgentRoleSnapshot[];
+    readonly taskforceAgentSkills: readonly WorkspaceSyncTaskforceAgentSkillSnapshot[];
+    readonly agentConversations: readonly WorkspaceSyncAgentConversationSnapshot[];
+    readonly taskEvents: readonly WorkspaceSyncEntityEventSnapshot[];
+}
+export interface WorkspaceSyncV2PushBaseline {
+    readonly lastPushedTaskIds: ReadonlySet<string>;
+    readonly lastPushedWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedTaskChangeKeys: ReadonlyMap<string, string>;
+    readonly lastPushedTaskRelationshipChangeKeys: ReadonlyMap<string, string>;
+    readonly lastPushedTaxonomyChangeKey: string;
+    readonly lastPushedInitiativeIds: ReadonlySet<string>;
+    readonly lastPushedInitiativeWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedWorkstreamIds: ReadonlySet<string>;
+    readonly lastPushedWorkstreamWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedAiProfileIds: ReadonlySet<string>;
+    readonly lastPushedAiProfileWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedAiProfileChangeKeys: ReadonlyMap<string, string>;
+    readonly lastPushedDocumentPaths: ReadonlySet<string>;
+    readonly lastPushedDocumentWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedAssetPaths: ReadonlySet<string>;
+    readonly lastPushedAssetWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedDocumentReviewSessionIds: ReadonlySet<string>;
+    readonly lastPushedDocumentReviewSessionWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedDocumentReviewCommentIds: ReadonlySet<string>;
+    readonly lastPushedDocumentReviewCommentWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedAnnotatedAttachmentSessionIds: ReadonlySet<string>;
+    readonly lastPushedAnnotatedAttachmentSessionWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedTaskforceAgentIds: ReadonlySet<string>;
+    readonly lastPushedTaskforceAgentWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedTaskforceAgentSkillIds: ReadonlySet<string>;
+    readonly lastPushedTaskforceAgentSkillWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedAgentConversationIds: ReadonlySet<string>;
+    readonly lastPushedAgentConversationWatermarks: ReadonlyMap<string, string>;
+    readonly lastPushedTaskEventWatermarks: ReadonlyMap<string, string>;
+    readonly baselineResetReason: WorkspaceSyncBaselineResetReason | null;
+}
+export interface WorkspaceSyncV2Candidate {
+    readonly snapshot: WorkspaceSyncV2FrozenSnapshot;
+    readonly payload: WorkspaceSyncPayload;
+    readonly signature: string;
+}
+/**
+ * Captures all already-normalized browser snapshot collections once so payload
+ * and signature construction cannot observe different React ref revisions.
+ */
+export declare function createWorkspaceSyncV2FrozenSnapshot(input: WorkspaceSyncV2SnapshotInput): WorkspaceSyncV2FrozenSnapshot;
+export declare function buildWorkspaceSyncV2Candidate(input: {
+    snapshot: WorkspaceSyncV2FrozenSnapshot;
+    baseline: WorkspaceSyncV2PushBaseline;
+    forceAllAiProfiles?: boolean;
+    forceDocumentPaths?: ReadonlySet<string>;
+    forceAssetPaths?: ReadonlySet<string>;
+}): WorkspaceSyncV2Candidate;
+export declare function buildWorkspaceSyncV2Signature(snapshot: WorkspaceSyncV2FrozenSnapshot): string;

package/dist/sync/workspaceSyncV2SnapshotBuilder.js

@@ -0,0 +1,193 @@
+import { normalizeTaskDataRelativePath } from '../storage/taskDataPath.js';
+import { listReferencedAiProfileAvatarAssetPaths } from './aiProfileAvatarSyncPaths.js';
+import { buildWorkspaceSyncPayloadModel, buildWorkspaceSyncSignatureModel, } from './workspaceSyncModel.js';
+import { flattenTaskEvents } from './workspaceSyncSnapshotProjection.js';
+function frozenArray(value) {
+    return Object.freeze(structuredClone(Array.from(value || [])));
+}
+function stringSet(value, fallback) {
+    return new Set(value
+        ? Array.from(value)
+        : fallback);
+}
+/**
+ * Captures all already-normalized browser snapshot collections once so payload
+ * and signature construction cannot observe different React ref revisions.
+ */
+export function createWorkspaceSyncV2FrozenSnapshot(input) {
+    const tasks = frozenArray(input.tasks);
+    const archivedTasks = frozenArray(input.archivedTasks);
+    const deletedTasks = frozenArray(input.deletedTasks);
+    const initiatives = frozenArray(input.initiatives);
+    const workstreams = frozenArray(input.workstreams);
+    const documents = frozenArray(input.documents);
+    const assets = frozenArray(input.assets);
+    const pendingDeletedTaskIds = input.pendingDeletedTaskIds
+        ? new Set(input.pendingDeletedTaskIds)
+        : new Set();
+    const pendingDeletedTaskWatermarks = input.pendingDeletedTaskWatermarks
+        ? new Map(input.pendingDeletedTaskWatermarks)
+        : new Map();
+    if (!input.pendingDeletedTaskIds && !input.pendingDeletedTaskWatermarks) {
+        for (const deleted of deletedTasks) {
+            const taskId = String(deleted?.taskId || '').trim();
+            const deletedAt = String(deleted?.deletedAt || '').trim();
+            if (!taskId)
+                continue;
+            pendingDeletedTaskIds.add(taskId);
+            if (Number.isFinite(Date.parse(deletedAt))) {
+                pendingDeletedTaskWatermarks.set(taskId, deletedAt);
+            }
+        }
+    }
+    const taskEvents = input.taskEvents
+        ? frozenArray(input.taskEvents)
+        : Object.freeze(flattenTaskEvents(tasks, archivedTasks, initiatives, workstreams));
+    return Object.freeze({
+        workspaceId: String(input.workspaceId || '').trim(),
+        tasks,
+        archivedTasks,
+        deletedTasks,
+        pendingDeletedTaskIds,
+        pendingDeletedTaskWatermarks,
+        taskRelationships: frozenArray(input.taskRelationships),
+        initiatives,
+        workstreams,
+        taxonomies: frozenArray(input.taxonomies),
+        taxonomyState: input.taxonomyState
+            ? structuredClone(input.taxonomyState)
+            : undefined,
+        aiProfiles: frozenArray(input.aiProfiles),
+        documents,
+        assets,
+        currentDocumentPaths: stringSet(input.currentDocumentPaths, documents.map((entry) => entry.path)),
+        currentAssetPaths: stringSet(input.currentAssetPaths, assets.map((entry) => entry.path)),
+        documentReviewSessions: frozenArray(input.documentReviewSessions),
+        documentReviewComments: frozenArray(input.documentReviewComments),
+        annotatedAttachmentSessions: frozenArray(input.annotatedAttachmentSessions),
+        taskforceAgents: frozenArray(input.taskforceAgents),
+        agentRoles: frozenArray(input.agentRoles),
+        taskforceAgentSkills: frozenArray(input.taskforceAgentSkills),
+        agentConversations: frozenArray(input.agentConversations),
+        taskEvents,
+    });
+}
+function mutableSet(value) {
+    return new Set(value);
+}
+function mutableMap(value) {
+    return new Map(value);
+}
+function aiProfileAvatarPaths(profiles, workspaceId) {
+    return new Set(listReferencedAiProfileAvatarAssetPaths(Array.from(profiles), workspaceId, (rawPath) => normalizeTaskDataRelativePath(String(rawPath || '').trim())).keys());
+}
+export function buildWorkspaceSyncV2Candidate(input) {
+    const { snapshot, baseline } = input;
+    const forceAllAiProfiles = input.forceAllAiProfiles === true;
+    const forcedAvatarPaths = forceAllAiProfiles
+        ? aiProfileAvatarPaths(snapshot.aiProfiles, snapshot.workspaceId)
+        : new Set();
+    const lastPushedAssetPaths = mutableSet(baseline.lastPushedAssetPaths);
+    const lastPushedAssetWatermarks = mutableMap(baseline.lastPushedAssetWatermarks);
+    const lastPushedDocumentPaths = mutableSet(baseline.lastPushedDocumentPaths);
+    const lastPushedDocumentWatermarks = mutableMap(baseline.lastPushedDocumentWatermarks);
+    for (const forcedPath of [
+        ...forcedAvatarPaths,
+        ...(input.forceAssetPaths || []),
+    ]) {
+        lastPushedAssetPaths.delete(forcedPath);
+        lastPushedAssetWatermarks.delete(forcedPath);
+    }
+    for (const forcedPath of input.forceDocumentPaths || []) {
+        lastPushedDocumentPaths.delete(forcedPath);
+        lastPushedDocumentWatermarks.delete(forcedPath);
+    }
+    const payload = structuredClone(buildWorkspaceSyncPayloadModel({
+        tasks: Array.from(snapshot.tasks),
+        archivedTasks: Array.from(snapshot.archivedTasks),
+        taskRelationships: Array.from(snapshot.taskRelationships),
+        taskEvents: Array.from(snapshot.taskEvents),
+        lastPushedTaskIds: mutableSet(baseline.lastPushedTaskIds),
+        pendingDeletedTaskIds: mutableSet(snapshot.pendingDeletedTaskIds),
+        pendingDeletedTaskWatermarks: mutableMap(snapshot.pendingDeletedTaskWatermarks),
+        deletedTasks: Array.from(snapshot.deletedTasks),
+        initiatives: Array.from(snapshot.initiatives),
+        workstreams: Array.from(snapshot.workstreams),
+        taxonomies: Array.from(snapshot.taxonomies),
+        taxonomyState: snapshot.taxonomyState,
+        lastPushedInitiativeIds: mutableSet(baseline.lastPushedInitiativeIds),
+        lastPushedInitiativeWatermarks: mutableMap(baseline.lastPushedInitiativeWatermarks),
+        lastPushedWorkstreamIds: mutableSet(baseline.lastPushedWorkstreamIds),
+        lastPushedWorkstreamWatermarks: mutableMap(baseline.lastPushedWorkstreamWatermarks),
+        aiProfiles: Array.from(snapshot.aiProfiles),
+        lastPushedAiProfileIds: forceAllAiProfiles ? new Set() : mutableSet(baseline.lastPushedAiProfileIds),
+        lastPushedAiProfileWatermarks: forceAllAiProfiles ? new Map() : mutableMap(baseline.lastPushedAiProfileWatermarks),
+        lastPushedAiProfileChangeKeys: forceAllAiProfiles ? new Map() : mutableMap(baseline.lastPushedAiProfileChangeKeys),
+        documents: Array.from(snapshot.documents),
+        assets: Array.from(snapshot.assets),
+        currentDocumentPaths: snapshot.currentDocumentPaths,
+        currentAssetPaths: snapshot.currentAssetPaths,
+        documentReviewSessions: Array.from(snapshot.documentReviewSessions),
+        documentReviewComments: Array.from(snapshot.documentReviewComments),
+        annotatedAttachmentSessions: Array.from(snapshot.annotatedAttachmentSessions),
+        taskforceAgents: Array.from(snapshot.taskforceAgents),
+        agentRoles: Array.from(snapshot.agentRoles),
+        taskforceAgentSkills: Array.from(snapshot.taskforceAgentSkills),
+        agentConversations: Array.from(snapshot.agentConversations),
+        lastPushedDocumentPaths,
+        lastPushedDocumentWatermarks,
+        lastPushedAssetPaths,
+        lastPushedAssetWatermarks,
+        lastPushedDocumentReviewSessionIds: mutableSet(baseline.lastPushedDocumentReviewSessionIds),
+        lastPushedDocumentReviewSessionWatermarks: mutableMap(baseline.lastPushedDocumentReviewSessionWatermarks),
+        lastPushedDocumentReviewCommentIds: mutableSet(baseline.lastPushedDocumentReviewCommentIds),
+        lastPushedDocumentReviewCommentWatermarks: mutableMap(baseline.lastPushedDocumentReviewCommentWatermarks),
+        lastPushedAnnotatedAttachmentSessionIds: mutableSet(baseline.lastPushedAnnotatedAttachmentSessionIds),
+        lastPushedAnnotatedAttachmentSessionWatermarks: mutableMap(baseline.lastPushedAnnotatedAttachmentSessionWatermarks),
+        // A full AI-profile reassert follows a null-cursor reconciliation. Reassert
+        // the closely coupled Agent definitions, Roles, and Skills at the same
+        // boundary so a stale local acknowledgement cannot hide missing cloud rows.
+        lastPushedTaskforceAgentIds: forceAllAiProfiles ? new Set() : mutableSet(baseline.lastPushedTaskforceAgentIds),
+        lastPushedTaskforceAgentWatermarks: forceAllAiProfiles ? new Map() : mutableMap(baseline.lastPushedTaskforceAgentWatermarks),
+        lastPushedTaskforceAgentSkillIds: forceAllAiProfiles ? new Set() : mutableSet(baseline.lastPushedTaskforceAgentSkillIds),
+        lastPushedTaskforceAgentSkillWatermarks: forceAllAiProfiles ? new Map() : mutableMap(baseline.lastPushedTaskforceAgentSkillWatermarks),
+        lastPushedAgentConversationIds: mutableSet(baseline.lastPushedAgentConversationIds),
+        lastPushedAgentConversationWatermarks: mutableMap(baseline.lastPushedAgentConversationWatermarks),
+        lastPushedTaskEventWatermarks: mutableMap(baseline.lastPushedTaskEventWatermarks),
+        baselineResetReason: baseline.baselineResetReason,
+        lastPushedWatermarks: mutableMap(baseline.lastPushedWatermarks),
+        lastPushedTaskChangeKeys: mutableMap(baseline.lastPushedTaskChangeKeys),
+        lastPushedTaskRelationshipChangeKeys: mutableMap(baseline.lastPushedTaskRelationshipChangeKeys),
+        lastPushedTaxonomyChangeKey: baseline.lastPushedTaxonomyChangeKey,
+    }));
+    const signature = buildWorkspaceSyncV2Signature(snapshot);
+    return Object.freeze({
+        snapshot,
+        signature,
+        payload,
+    });
+}
+export function buildWorkspaceSyncV2Signature(snapshot) {
+    return buildWorkspaceSyncSignatureModel({
+        workspaceId: snapshot.workspaceId,
+        tasks: Array.from(snapshot.tasks),
+        archivedTasks: Array.from(snapshot.archivedTasks),
+        taskRelationships: Array.from(snapshot.taskRelationships),
+        taskEvents: Array.from(snapshot.taskEvents),
+        pendingDeletedTaskIds: mutableSet(snapshot.pendingDeletedTaskIds),
+        initiatives: Array.from(snapshot.initiatives),
+        workstreams: Array.from(snapshot.workstreams),
+        taxonomies: Array.from(snapshot.taxonomies),
+        taxonomyState: snapshot.taxonomyState,
+        aiProfiles: Array.from(snapshot.aiProfiles),
+        documents: Array.from(snapshot.documents),
+        assets: Array.from(snapshot.assets),
+        documentReviewSessions: Array.from(snapshot.documentReviewSessions),
+        documentReviewComments: Array.from(snapshot.documentReviewComments),
+        annotatedAttachmentSessions: Array.from(snapshot.annotatedAttachmentSessions),
+        taskforceAgents: Array.from(snapshot.taskforceAgents),
+        agentRoles: Array.from(snapshot.agentRoles),
+        taskforceAgentSkills: Array.from(snapshot.taskforceAgentSkills),
+        agentConversations: Array.from(snapshot.agentConversations),
+    });
+}

package/dist/types.d.ts

@@ -7,12 +7,6 @@ export type { TaskforceTheme } from './utils/theme';
 export type { TaskActor } from './shared/taskActor.js';
 import type { TaskforceTheme } from './utils/theme';
 import type { TaskActor } from './shared/taskActor.js';
-export interface Environment {
-    id: string;
-    name: string;
-    icon?: string;
-    directory: string;
-}
 export interface Comment {
     id: string;
     author: 'user' | 'ai' | string;
@@ -108,6 +102,7 @@ export interface AttachmentItem {
     referenceLabel?: string | null;
     taskId?: string | null;
     timestamp?: string;
+    linkRole?: 'attachment' | 'image' | 'reference';
 }
 export interface TaxonomyOption {
     value: string | number;
@@ -177,8 +172,16 @@ export interface WorkstreamItem {
 export interface PlanningBootstrapTaskPreview {
     id: string;
     referenceNumber?: number | null;
+    localReferenceNumber?: number | null;
+    referenceLabel?: string;
     title: string;
+    createdAt?: string | null;
     status?: string | null;
+    priority?: number | null;
+    workstreamOrder?: number | null;
+    assignee?: string | null;
+    attachmentCount: number;
+    isArchived?: boolean;
 }
 export interface PlanningBootstrapWorkstreamTaskSummary {
     workstreamId: string;
@@ -191,6 +194,16 @@ export interface PlanningBootstrapPayload {
     workstreams: WorkstreamItem[];
     workstreamTaskSummaries: PlanningBootstrapWorkstreamTaskSummary[];
 }
+export type PlanningCollectionLoadStatus = 'loading' | 'ready' | 'error';
+export interface PlanningLoadState {
+    status: 'loading' | 'ready' | 'empty' | 'partial' | 'error';
+    error: string | null;
+    isRefreshing: boolean;
+    collections: {
+        initiatives: PlanningCollectionLoadStatus;
+        workstreams: PlanningCollectionLoadStatus;
+    };
+}
 export interface ChecklistItem {
     id: string;
     taskId: string;
@@ -212,7 +225,6 @@ export interface TaskItem {
     priority: number | string;
     complexity?: number;
     status: TaskStatus;
-    approach?: string;
     createdAt: string;
     updatedAt?: string;
     completedAt?: string | null;
@@ -234,14 +246,17 @@ export interface TaskItem {
     assignee?: TaskAssignee;
     specialists?: string[];
     assigneeActor?: TaskActor | null;
-    canceledReason?: string;
+    canceledReason?: string | null;
     isArchived?: boolean;
     isDeleted?: boolean;
     deletedRecordId?: string | null;
+    deletedAt?: string | null;
+    deletedExpiresAt?: string | null;
     scheduledDate?: string | null;
     dueDate?: string | null;
     scheduledWeekKey?: string | null;
     orderInDay?: number | null;
+    workstreamOrder?: number | null;
     workstreamId?: string | null;
     checklistItems?: ChecklistItem[];
 }
@@ -275,13 +290,6 @@ export interface TaskforceConfig {
         color?: string;
         icon?: string;
     }>;
-    /** Approach labels */
-    approaches?: Array<{
-        value: string;
-        label: string;
-        color?: string;
-        icon?: string;
-    }>;
     /** Taxonomy configuration (Phase 1) */
     taxonomies?: TaxonomyDefinition[];
     /** Backend endpoint to POST tasks */

package/dist/types.js

@@ -4,12 +4,10 @@
  * A decoupled, reusable collaborative task manager.
  */
 import { cloneDefaultCategoryDefinitions, cloneDefaultPriorityDefinitions, cloneDefaultTypeDefinitions } from './shared/taxonomyDefaults.js';
-import { cloneDefaultWorkflowDefinitions } from './shared/workflowDefaults.js';
 export const DEFAULT_CONFIG = {
     categories: cloneDefaultCategoryDefinitions(),
     types: cloneDefaultTypeDefinitions(),
     priorities: cloneDefaultPriorityDefinitions(),
-    approaches: cloneDefaultWorkflowDefinitions(),
     taxonomies: [],
     apiEndpoint: '/api/taskforce/task',
     apiBaseUrl: undefined,
@@ -18,9 +16,9 @@ export const DEFAULT_CONFIG = {
     wsBaseUrl: undefined,
     position: 'bottom-right',
     offsetY: 70,
-    theme: 'dark',
+    theme: 'dawn',
     shortcut: 'Alt+T',
     manualComplexityEnabled: false,
     checklistDropdownEnabled: true,
-    showTaskCardStatusLabel: true,
+    showTaskCardStatusLabel: false,
 };

package/dist/ui/ai-profile-clients/amazon-nova.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 33 32" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Nova</title><g mask="url(#lobe-icons-nova-0-_R_0_)"><mask height="32" id="lobe-icons-nova-0-_R_0_" maskUnits="userSpaceOnUse" style="mask-type:luminance" width="32" x="0" y="0"><path d="M31.8 0H0v32h31.8z" fill="#fff"></path></mask><mask height="32" id="lobe-icons-nova-1-_R_0_" maskUnits="userSpaceOnUse" style="mask-type:alpha" width="32" x="0" y="0"><path d="m17.865 23.28 1.533 1.543c.07.07.092.175.055.267l-2.398 6.118A1.24 1.24 0 0 1 15.9 32c-.51 0-.969-.315-1.155-.793l-3.451-8.804-5.582 5.617a.246.246 0 0 1-.35 0l-1.407-1.415a.25.25 0 0 1 0-.352l6.89-6.932a1.3 1.3 0 0 1 .834-.398 1.25 1.25 0 0 1 1.232.79l2.992 7.63 1.557-3.977a.248.248 0 0 1 .408-.085zm8.224-19.3-5.583 5.617-3.45-8.805a1.24 1.24 0 0 0-1.43-.762c-.414.092-.744.407-.899.805l-2.38 6.072a.25.25 0 0 0 .055.267l1.533 1.543c.127.127.34.082.407-.085L15.9 4.655l2.991 7.629a1.24 1.24 0 0 0 2.035.425l6.922-6.965a.25.25 0 0 0 0-.352L26.44 3.977a.246.246 0 0 0-.35 0zM8.578 17.566l-3.953-1.567 7.582-3.01c.49-.195.815-.685.785-1.24a1.3 1.3 0 0 0-.395-.84l-6.886-6.93a.246.246 0 0 0-.35 0L3.954 5.395a.25.25 0 0 0 0 .353l5.583 5.617-8.75 3.472a1.25 1.25 0 0 0 0 2.325l6.079 2.412a.24.24 0 0 0 .266-.055l1.533-1.542a.25.25 0 0 0-.085-.41zm22.434-2.73-6.08-2.412a.24.24 0 0 0-.265.055l-1.533 1.542a.25.25 0 0 0 .084.41L27.172 16l-7.583 3.01a1.255 1.255 0 0 0-.785 1.24c.018.317.172.614.395.84l6.89 6.931a.246.246 0 0 0 .35 0l1.406-1.415a.25.25 0 0 0 0-.352l-5.582-5.617 8.75-3.472a1.25 1.25 0 0 0 0-2.325z" fill="#fff"></path></mask><g mask="url(#lobe-icons-nova-1-_R_0_)"><path d="M-2.915 34.125h37.448V-2.109H-2.915z" fill="url(#lobe-icons-nova-2-_R_0_)"></path></g></g><defs><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-nova-2-_R_0_" x1="33.663" x2="-2.086" y1="33.633" y2="-1.901"><stop stop-color="#ff6200"></stop><stop offset=".399" stop-color="#e433ff"></stop><stop offset=".96" stop-color="#6842ff"></stop></linearGradient></defs></svg>

package/dist/ui/ai-profile-clients/chatgpt.svg

@@ -0,0 +1,10 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 2406 2406">
+	<path d="M1 578.4C1 259.5 259.5 1 578.4 1h1249.1c319 0 577.5 258.5 577.5 577.4V2406H578.4C259.5 2406 1 2147.5 1 1828.6V578.4z" fill="#74aa9c"/>
+	<path id="a" d="M1107.3 299.1c-197.999 0-373.9 127.3-435.2 315.3L650 743.5v427.9c0 21.4 11 40.4 29.4 51.4l344.5 198.515V833.3h.1v-27.9L1372.7 604c33.715-19.52 70.44-32.857 108.47-39.828L1447.6 450.3C1361 353.5 1237.1 298.5 1107.3 299.1zm0 117.5-.6.6c79.699 0 156.3 27.5 217.6 78.4-2.5 1.2-7.4 4.3-11 6.1L952.8 709.3c-18.4 10.4-29.4 30-29.4 51.4V1248l-155.1-89.4V755.8c-.1-187.099 151.601-338.9 339-339.2z" fill="#fff"/>
+	<use xlink:href="#a" transform="rotate(60 1203 1203)"/>
+  	<use xlink:href="#a" transform="rotate(120 1203 1203)"/>
+	<use xlink:href="#a" transform="rotate(180 1203 1203)"/>
+	<use xlink:href="#a" transform="rotate(240 1203 1203)"/>
+	<use xlink:href="#a" transform="rotate(300 1203 1203)"/>
+
+</svg>

package/dist/ui/ai-profile-clients/claude-chat.svg

@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Claude</title><path d="M4.709 15.955l4.72-2.647.08-.23-.08-.128H9.2l-.79-.048-2.698-.073-2.339-.097-2.266-.122-.571-.121L0 11.784l.055-.352.48-.321.686.06 1.52.103 2.278.158 1.652.097 2.449.255h.389l.055-.157-.134-.098-.103-.097-2.358-1.596-2.552-1.688-1.336-.972-.724-.491-.364-.462-.158-1.008.656-.722.881.06.225.061.893.686 1.908 1.476 2.491 1.833.365.304.145-.103.019-.073-.164-.274-1.355-2.446-1.446-2.49-.644-1.032-.17-.619a2.97 2.97 0 01-.104-.729L6.283.134 6.696 0l.996.134.42.364.62 1.414 1.002 2.229 1.555 3.03.456.898.243.832.091.255h.158V9.01l.128-1.706.237-2.095.23-2.695.08-.76.376-.91.747-.492.584.28.48.685-.067.444-.286 1.851-.559 2.903-.364 1.942h.212l.243-.242.985-1.306 1.652-2.064.73-.82.85-.904.547-.431h1.033l.76 1.129-.34 1.166-1.064 1.347-.881 1.142-1.264 1.7-.79 1.36.073.11.188-.02 2.856-.606 1.543-.28 1.841-.315.833.388.091.395-.328.807-1.969.486-2.309.462-3.439.813-.042.03.049.061 1.549.146.662.036h1.622l3.02.225.79.522.474.638-.079.485-1.215.62-1.64-.389-3.829-.91-1.312-.329h-.182v.11l1.093 1.068 2.006 1.81 2.509 2.33.127.578-.322.455-.34-.049-2.205-1.657-.851-.747-1.926-1.62h-.128v.17l.444.649 2.345 3.521.122 1.08-.17.353-.608.213-.668-.122-1.374-1.925-1.415-2.167-1.143-1.943-.14.08-.674 7.254-.316.37-.729.28-.607-.461-.322-.747.322-1.476.389-1.924.315-1.53.286-1.9.17-.632-.012-.042-.14.018-1.434 1.967-2.18 2.945-1.726 1.845-.414.164-.717-.37.067-.662.401-.589 2.388-3.036 1.44-1.882.93-1.086-.006-.158h-.055L4.132 18.56l-1.13.146-.487-.456.061-.746.231-.243 1.908-1.312-.006.006z" fill="#D97757" fill-rule="nonzero"></path></svg>

package/dist/ui/ai-profile-clients/claude-code.svg

@@ -0,0 +1,15 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" role="img" aria-labelledby="title">
+  <title id="title">Claude Code Claw'd mascot</title>
+  <rect width="256" height="256" fill="#d97757"/>
+  <g
+    fill="#f7f3ee"
+    font-family="Menlo, Monaco, Consolas, 'Liberation Mono', monospace"
+    font-size="35"
+    font-weight="700"
+    text-anchor="middle"
+  >
+    <text x="128" y="102">&#x2590;&#x259B;&#x2588;&#x2588;&#x2588;&#x259C;&#x258C;</text>
+    <text x="128" y="137">&#x259D;&#x259C;&#x2588;&#x2588;&#x2588;&#x2588;&#x2588;&#x259B;&#x2598;</text>
+    <text x="128" y="172" xml:space="preserve">  &#x2598;&#x2598; &#x259D;&#x259D;  </text>
+  </g>
+</svg>