@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/sync/collaborationSyncPayload.js

@@ -1,3 +1,4 @@
+import { normalizePersistedModelGatewayMessages } from '../services/modelGateway.js';
 import { hasOwnSyncField, normalizeSyncNullableString, normalizeSyncOptionalString, readSyncNullableIdField, readSyncNullableIsoStringField, readSyncNullableStringField, readSyncSameOriginAssetUrlField, } from './syncFieldSemantics.js';
 function toOptionalTrimmedString(value) {
     return normalizeSyncOptionalString(value);
@@ -21,6 +22,14 @@ function toOptionalNonNegativeInteger(value) {
         return 0;
     return Math.max(0, Math.floor(normalized));
 }
+function toOptionalNonNegativeNumber(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const normalized = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(normalized))
+        return null;
+    return Math.max(0, normalized);
+}
 export function normalizeAiProfileSyncPayload(raw, workspaceId, normalizeSurfaceType, normalizeSeatScope, source) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
         return null;
@@ -37,6 +46,8 @@ export function normalizeAiProfileSyncPayload(raw, workspaceId, normalizeSurface
         username: String(profile.username || '').trim(),
         icon: String(profile.icon || 'Bot').trim() || 'Bot',
         color: String(profile.color || '#8b5cf6').trim() || '#8b5cf6',
+        colorSource: readSyncNullableStringField(profile, 'colorSource') ?? null,
+        colorUpdatedAt: readSyncNullableIsoStringField(profile, 'colorUpdatedAt') ?? null,
         ...(hasOwnSyncField(profile, 'avatarUrl') ? { avatarUrl: readSyncSameOriginAssetUrlField(profile, 'avatarUrl') ?? null } : {}),
         ...(hasOwnSyncField(profile, 'avatarSourceUrl') ? { avatarSourceUrl: readSyncSameOriginAssetUrlField(profile, 'avatarSourceUrl') ?? null } : {}),
         ...(hasOwnSyncField(profile, 'avatarRevision') ? { avatarRevision: toOptionalNonNegativeInteger(profile.avatarRevision) } : {}),
@@ -91,17 +102,39 @@ export function normalizeDocumentReviewCommentSyncPayload(raw, options) {
     const sessionId = String(options?.sessionId || comment.sessionId || '').trim();
     if (!id || !sessionId)
         return null;
-    return {
+    const normalized = {
         id,
         sessionId,
         body: typeof comment.body === 'string' ? comment.body : '',
         anchor: (comment.anchor ?? null),
         order: toOptionalNonNegativeInteger(comment.order),
         authorActorId: toNullableTrimmedString(comment.authorActorId),
+        updatedByActorId: toNullableTrimmedString(comment.updatedByActorId),
+        deletedByActorId: toNullableTrimmedString(comment.deletedByActorId),
         createdAt: String(comment.createdAt || options?.sourceWatermark || '').trim(),
         updatedAt: String(comment.updatedAt || options?.sourceWatermark || comment.createdAt || '').trim(),
         deletedAt: toNullableTrimmedString(comment.deletedAt),
     };
+    if (Object.prototype.hasOwnProperty.call(comment, 'parentCommentId')) {
+        normalized.parentCommentId = toNullableTrimmedString(comment.parentCommentId);
+    }
+    if (Object.prototype.hasOwnProperty.call(comment, 'threadStatus')) {
+        normalized.threadStatus = comment.threadStatus === 'resolved'
+            ? 'resolved'
+            : comment.threadStatus === 'open'
+                ? 'open'
+                : null;
+    }
+    if (Object.prototype.hasOwnProperty.call(comment, 'threadStatusUpdatedAt')) {
+        normalized.threadStatusUpdatedAt = toNullableTrimmedString(comment.threadStatusUpdatedAt);
+    }
+    if (Object.prototype.hasOwnProperty.call(comment, 'resolvedAt')) {
+        normalized.resolvedAt = toNullableTrimmedString(comment.resolvedAt);
+    }
+    if (Object.prototype.hasOwnProperty.call(comment, 'resolvedByActorId')) {
+        normalized.resolvedByActorId = toNullableTrimmedString(comment.resolvedByActorId);
+    }
+    return normalized;
 }
 export function normalizeAnnotatedAttachmentSessionSyncPayload(raw, expectedWorkspaceId, sourceWatermark) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
@@ -129,6 +162,185 @@ export function normalizeAnnotatedAttachmentSessionSyncPayload(raw, expectedWork
         deletedAt: toNullableTrimmedString(session.deletedAt),
     };
 }
+export function normalizeTaskforceAgentSyncPayload(raw, expectedWorkspaceId, sourceWatermark) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const agent = raw;
+    const id = String(agent.id || '').trim();
+    const workspaceId = String(agent.workspaceId || expectedWorkspaceId || '').trim();
+    if (!id || !workspaceId)
+        return null;
+    if (expectedWorkspaceId && workspaceId !== expectedWorkspaceId)
+        return null;
+    const hasCanonicalDefinition = hasOwnSyncField(agent, 'definition');
+    const lifecycleStatus = String(agent.lifecycleStatus || '').trim();
+    const configurationState = String(agent.configurationState || '').trim();
+    return {
+        id,
+        tenantId: toOptionalTrimmedString(agent.tenantId),
+        workspaceId,
+        ...(hasCanonicalDefinition ? {
+            definition: agent.definition,
+            definitionRevision: toOptionalPositiveInteger(agent.definitionRevision) ?? 0,
+            definitionHash: String(agent.definitionHash || '').trim(),
+            lifecycleStatus,
+            managedProfileId: toNullableTrimmedString(agent.managedProfileId),
+            ...((configurationState === 'valid'
+                || configurationState === 'unresolved-references'
+                || configurationState === 'needs-migration'
+                || configurationState === 'unsupported-version'
+                || configurationState === 'invalid') ? {
+                configurationState,
+                configurationIssues: Array.isArray(agent.configurationIssues)
+                    ? agent.configurationIssues
+                    : [],
+            } : {}),
+        } : {}),
+        name: String(agent.name || 'Agent').trim() || 'Agent',
+        modelProvider: 'taskforce_hq',
+        providerKey: String(agent.providerKey || '').trim(),
+        modelKey: String(agent.modelKey || '').trim(),
+        modelTier: String(agent.modelTier || '').trim(),
+        systemPrompt: typeof agent.systemPrompt === 'string' ? agent.systemPrompt : '',
+        enabled: agent.enabled !== false,
+        createdByUserId: toNullableTrimmedString(agent.createdByUserId),
+        updatedByUserId: toNullableTrimmedString(agent.updatedByUserId),
+        createdAt: String(agent.createdAt || sourceWatermark || '').trim(),
+        updatedAt: String(agent.updatedAt || sourceWatermark || agent.createdAt || '').trim(),
+        deletedAt: toNullableTrimmedString(agent.deletedAt),
+    };
+}
+export function normalizeAgentRoleSyncPayload(raw, expectedWorkspaceId, sourceWatermark) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const role = raw;
+    const id = String(role.id || '').trim();
+    const workspaceId = String(role.workspaceId || expectedWorkspaceId || '').trim();
+    const rawCurrentRevision = Number(role.currentRevision);
+    const currentRevision = Number.isInteger(rawCurrentRevision) && rawCurrentRevision > 0
+        ? rawCurrentRevision
+        : 0;
+    const currentContentHash = String(role.currentContentHash || '').trim();
+    const lifecycleStatus = role.lifecycleStatus;
+    if (!id
+        || !workspaceId
+        || !currentRevision
+        || !currentContentHash
+        || (lifecycleStatus !== 'active' && lifecycleStatus !== 'retired'))
+        return null;
+    if (expectedWorkspaceId && workspaceId !== expectedWorkspaceId)
+        return null;
+    return {
+        id,
+        tenantId: toOptionalTrimmedString(role.tenantId),
+        workspaceId,
+        lifecycleStatus,
+        currentRevision,
+        currentContentHash,
+        definition: role.definition,
+        revisions: Array.isArray(role.revisions)
+            ? role.revisions.map((revision) => ({
+                roleId: String(revision?.roleId || id).trim() || id,
+                revision: Number.isInteger(Number(revision?.revision)) && Number(revision?.revision) > 0
+                    ? Number(revision.revision)
+                    : 0,
+                definition: revision?.definition,
+                contentHash: String(revision?.contentHash || '').trim(),
+                createdByActorId: toNullableTrimmedString(revision?.createdByActorId),
+                createdAt: String(revision?.createdAt || sourceWatermark || '').trim(),
+            }))
+            : [],
+        createdByActorId: toNullableTrimmedString(role.createdByActorId),
+        updatedByActorId: toNullableTrimmedString(role.updatedByActorId),
+        createdAt: String(role.createdAt || sourceWatermark || '').trim(),
+        updatedAt: String(role.updatedAt || sourceWatermark || role.createdAt || '').trim(),
+        retiredAt: toNullableTrimmedString(role.retiredAt),
+        deletedAt: toNullableTrimmedString(role.deletedAt),
+    };
+}
+export function normalizeTaskforceAgentSkillSyncPayload(raw, expectedWorkspaceId, sourceWatermark) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const skill = raw;
+    const id = String(skill.id || '').trim();
+    const workspaceId = String(skill.workspaceId || expectedWorkspaceId || '').trim();
+    const lifecycleStatus = String(skill.lifecycleStatus || '').trim();
+    const revision = Number(skill.revision);
+    if (!id || !workspaceId || !Number.isInteger(revision) || revision < 1)
+        return null;
+    if (expectedWorkspaceId && workspaceId !== expectedWorkspaceId)
+        return null;
+    if (lifecycleStatus !== 'active' && lifecycleStatus !== 'retired')
+        return null;
+    if (!Array.isArray(skill.revisions))
+        return null;
+    return {
+        id,
+        tenantId: toOptionalTrimmedString(skill.tenantId),
+        workspaceId,
+        lifecycleStatus,
+        definition: skill.definition,
+        revision,
+        contentHash: String(skill.contentHash || '').trim(),
+        revisions: skill.revisions
+            .map((rawRevision) => {
+            if (!rawRevision || typeof rawRevision !== 'object' || Array.isArray(rawRevision))
+                return null;
+            const candidate = rawRevision;
+            const revisionNumber = Number(candidate.revision);
+            if (!Number.isInteger(revisionNumber) || revisionNumber < 1)
+                return null;
+            return {
+                revision: revisionNumber,
+                contentHash: String(candidate.contentHash || '').trim(),
+                definition: candidate.definition,
+                createdByActorId: toNullableTrimmedString(candidate.createdByActorId),
+                createdAt: String(candidate.createdAt || sourceWatermark || '').trim(),
+            };
+        })
+            .filter((candidate) => candidate !== null),
+        createdByActorId: toNullableTrimmedString(skill.createdByActorId),
+        updatedByActorId: toNullableTrimmedString(skill.updatedByActorId),
+        createdAt: String(skill.createdAt || sourceWatermark || '').trim(),
+        updatedAt: String(skill.updatedAt || sourceWatermark || skill.createdAt || '').trim(),
+        retiredAt: toNullableTrimmedString(skill.retiredAt),
+        retiredByActorId: toNullableTrimmedString(skill.retiredByActorId),
+    };
+}
+export function normalizeAgentConversationSyncPayload(raw, expectedWorkspaceId, sourceWatermark) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const conversation = raw;
+    const id = String(conversation.id || '').trim();
+    const workspaceId = String(conversation.workspaceId || expectedWorkspaceId || '').trim();
+    const agentId = String(conversation.agentId || '').trim();
+    if (!id || !workspaceId || !agentId)
+        return null;
+    if (expectedWorkspaceId && workspaceId !== expectedWorkspaceId)
+        return null;
+    const messages = normalizePersistedModelGatewayMessages(conversation.messages);
+    const usage = conversation.usage && typeof conversation.usage === 'object' && !Array.isArray(conversation.usage)
+        ? conversation.usage
+        : null;
+    return {
+        id,
+        tenantId: toOptionalTrimmedString(conversation.tenantId),
+        workspaceId,
+        agentId,
+        taskId: toNullableTrimmedString(conversation.taskId),
+        title: String(conversation.title || 'Agent chat').trim() || 'Agent chat',
+        messages,
+        modelProvider: toNullableTrimmedString(conversation.modelProvider),
+        modelId: toNullableTrimmedString(conversation.modelId),
+        usage,
+        latencyMs: toOptionalNonNegativeNumber(conversation.latencyMs),
+        createdByUserId: toNullableTrimmedString(conversation.createdByUserId),
+        updatedByUserId: toNullableTrimmedString(conversation.updatedByUserId),
+        createdAt: String(conversation.createdAt || sourceWatermark || '').trim(),
+        updatedAt: String(conversation.updatedAt || sourceWatermark || conversation.createdAt || '').trim(),
+        deletedAt: toNullableTrimmedString(conversation.deletedAt),
+    };
+}
 export function normalizeDeleteSyncPayload(raw, idKey) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
         return null;

package/dist/sync/collaborationSyncState.d.ts

@@ -1,5 +1,5 @@
 import type { TaskforceCore, TaskforceSyncCapable } from '../core/Taskforce.js';
-import type { WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncEntityEventSnapshot } from './workspaceSyncModel.js';
+import type { WorkspaceSyncAgentConversationSnapshot, WorkspaceSyncAgentRoleSnapshot, WorkspaceSyncAnnotatedAttachmentSessionSnapshot, WorkspaceSyncDocumentReviewCommentSnapshot, WorkspaceSyncDocumentReviewSessionSnapshot, WorkspaceSyncEntityEventSnapshot, WorkspaceSyncTaskforceAgentSnapshot, WorkspaceSyncTaskforceAgentSkillSnapshot } from './workspaceSyncModel.js';
 type SyncCore = TaskforceCore & TaskforceSyncCapable;
 interface CollaborationSyncStateDeps {
     core: SyncCore;
@@ -7,11 +7,31 @@ interface CollaborationSyncStateDeps {
 export declare function listWorkspaceSyncDocumentReviewSessionsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncDocumentReviewSessionSnapshot[];
 export declare function listWorkspaceSyncDocumentReviewCommentsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncDocumentReviewCommentSnapshot[];
 export declare function listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
-export declare function listWorkspaceSyncTaskEventsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncEntityEventSnapshot[];
+export declare function listWorkspaceSyncTaskEventsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string, options?: {
+    cursor?: {
+        watermark: string;
+        id: string;
+    } | null;
+    limit?: number;
+}): WorkspaceSyncEntityEventSnapshot[];
+export declare function listWorkspaceSyncTaskforceAgentsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncTaskforceAgentSnapshot[];
+export declare function listWorkspaceSyncAgentRolesSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncAgentRoleSnapshot[];
+export declare function listWorkspaceSyncTaskforceAgentSkillsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncTaskforceAgentSkillSnapshot[];
+export declare function listWorkspaceSyncAgentConversationsSnapshot(deps: CollaborationSyncStateDeps, workspaceId?: string): WorkspaceSyncAgentConversationSnapshot[];
 export declare function createCollaborationSyncState(deps: CollaborationSyncStateDeps): {
     listWorkspaceSyncDocumentReviewSessionsSnapshot: (workspaceId?: string) => WorkspaceSyncDocumentReviewSessionSnapshot[];
     listWorkspaceSyncDocumentReviewCommentsSnapshot: (workspaceId?: string) => WorkspaceSyncDocumentReviewCommentSnapshot[];
     listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot: (workspaceId?: string) => WorkspaceSyncAnnotatedAttachmentSessionSnapshot[];
-    listWorkspaceSyncTaskEventsSnapshot: (workspaceId?: string) => WorkspaceSyncEntityEventSnapshot[];
+    listWorkspaceSyncTaskEventsSnapshot: (workspaceId?: string, options?: {
+        cursor?: {
+            watermark: string;
+            id: string;
+        } | null;
+        limit?: number;
+    }) => WorkspaceSyncEntityEventSnapshot[];
+    listWorkspaceSyncTaskforceAgentsSnapshot: (workspaceId?: string) => WorkspaceSyncTaskforceAgentSnapshot[];
+    listWorkspaceSyncAgentRolesSnapshot: (workspaceId?: string) => WorkspaceSyncAgentRoleSnapshot[];
+    listWorkspaceSyncTaskforceAgentSkillsSnapshot: (workspaceId?: string) => WorkspaceSyncTaskforceAgentSkillSnapshot[];
+    listWorkspaceSyncAgentConversationsSnapshot: (workspaceId?: string) => WorkspaceSyncAgentConversationSnapshot[];
 };
 export {};

package/dist/sync/collaborationSyncState.js

@@ -1,3 +1,8 @@
+import { TaskforceAgentStore } from '../storage/taskforceAgentStore.js';
+import { TaskforceAgentSkillStore } from '../storage/taskforceAgentSkillStore.js';
+import { TaskforceAgentConversationStore } from '../storage/taskforceAgentConversationStore.js';
+import { AgentRoleStore } from '../storage/agentRoleStore.js';
+import { projectLegacyTaskforceAgentResponse } from '../compat/taskforceAgentDefinitionCompat.js';
 export function listWorkspaceSyncDocumentReviewSessionsSnapshot(deps, workspaceId = 'default') {
     return deps.core.listDocumentReviewSessionsForSync({ workspaceId, includeDeleted: true })
         .map((session) => ({
@@ -25,6 +30,8 @@ export function listWorkspaceSyncDocumentReviewCommentsSnapshot(deps, workspaceI
         anchor: comment.anchor,
         order: comment.order,
         authorActorId: comment.authorActorId,
+        updatedByActorId: comment.updatedByActorId,
+        deletedByActorId: comment.deletedByActorId,
         createdAt: comment.createdAt,
         updatedAt: comment.updatedAt,
         deletedAt: comment.deletedAt,
@@ -51,8 +58,12 @@ export function listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(deps, works
         && session.workspaceId.length > 0
         && session.baseImageAssetId.length > 0));
 }
-export function listWorkspaceSyncTaskEventsSnapshot(deps, workspaceId = 'default') {
-    return deps.core.listEntityEventsForSync({ workspaceId })
+export function listWorkspaceSyncTaskEventsSnapshot(deps, workspaceId = 'default', options) {
+    return deps.core.listEntityEventsForSync({
+        workspaceId,
+        cursor: options?.cursor || null,
+        limit: options?.limit,
+    })
         .map((event) => {
         const entityType = event.entityType === 'initiative' || event.entityType === 'workstream'
             ? event.entityType
@@ -76,11 +87,89 @@ export function listWorkspaceSyncTaskEventsSnapshot(deps, workspaceId = 'default
         && event.action.length > 0
         && event.createdAt.length > 0));
 }
+export function listWorkspaceSyncTaskforceAgentsSnapshot(deps, workspaceId = 'default') {
+    const store = new TaskforceAgentStore(deps.core.getDatabaseAdapter(), deps.core.getTenantId());
+    return store.listForSync(workspaceId, { includeDeleted: true })
+        .map((agent) => ({
+        id: agent.id,
+        tenantId: agent.tenantId,
+        workspaceId: agent.workspaceId,
+        definition: agent.definitionValue,
+        definitionRevision: agent.definitionRevision,
+        definitionHash: agent.definitionHash,
+        lifecycleStatus: agent.lifecycleStatus,
+        managedProfileId: agent.managedProfileId,
+        configurationState: agent.configurationState,
+        configurationIssues: agent.configurationIssues,
+        ...projectLegacyTaskforceAgentResponse(agent),
+        modelProvider: agent.modelProvider,
+        createdByUserId: agent.createdByUserId,
+        updatedByUserId: agent.updatedByUserId,
+        createdAt: agent.createdAt,
+        updatedAt: agent.updatedAt,
+        deletedAt: agent.deletedAt ?? null,
+    }))
+        .filter((agent) => agent.id.length > 0 && agent.workspaceId.length > 0);
+}
+export function listWorkspaceSyncAgentRolesSnapshot(deps, workspaceId = 'default') {
+    const store = new AgentRoleStore(deps.core.getDatabaseAdapter(), deps.core.getTenantId());
+    return store.listForSync(workspaceId);
+}
+export function listWorkspaceSyncTaskforceAgentSkillsSnapshot(deps, workspaceId = 'default') {
+    const store = new TaskforceAgentSkillStore(deps.core.getDatabaseAdapter(), deps.core.getTenantId());
+    return store.listForSync(workspaceId)
+        .map((skill) => ({
+        id: skill.id,
+        tenantId: skill.tenantId,
+        workspaceId: skill.workspaceId,
+        lifecycleStatus: skill.lifecycleStatus,
+        definition: skill.definition,
+        revision: skill.revision,
+        contentHash: skill.contentHash,
+        revisions: skill.revisions || [],
+        createdByActorId: skill.createdByActorId,
+        updatedByActorId: skill.updatedByActorId,
+        createdAt: skill.createdAt,
+        updatedAt: skill.updatedAt,
+        retiredAt: skill.retiredAt,
+        retiredByActorId: skill.retiredByActorId,
+    }))
+        .filter((skill) => skill.id.length > 0 && skill.workspaceId.length > 0);
+}
+export function listWorkspaceSyncAgentConversationsSnapshot(deps, workspaceId = 'default') {
+    const store = new TaskforceAgentConversationStore(deps.core.getDatabaseAdapter(), deps.core.getTenantId());
+    return store.listForSync(workspaceId, { includeDeleted: true })
+        .map((conversation) => ({
+        id: conversation.id,
+        tenantId: conversation.tenantId,
+        workspaceId: conversation.workspaceId,
+        agentId: conversation.agentId,
+        taskId: conversation.taskId,
+        title: conversation.title,
+        messages: conversation.messages,
+        modelProvider: conversation.modelProvider,
+        modelId: conversation.modelId,
+        usage: conversation.usage,
+        latencyMs: conversation.latencyMs,
+        createdByUserId: conversation.createdByUserId,
+        updatedByUserId: conversation.updatedByUserId,
+        createdAt: conversation.createdAt,
+        updatedAt: conversation.updatedAt,
+        deletedAt: conversation.deletedAt ?? null,
+    }))
+        .filter((conversation) => (conversation.id.length > 0
+        && conversation.workspaceId.length > 0
+        && conversation.agentId.length > 0));
+}
 export function createCollaborationSyncState(deps) {
     return {
         listWorkspaceSyncDocumentReviewSessionsSnapshot: (workspaceId = 'default') => listWorkspaceSyncDocumentReviewSessionsSnapshot(deps, workspaceId),
         listWorkspaceSyncDocumentReviewCommentsSnapshot: (workspaceId = 'default') => listWorkspaceSyncDocumentReviewCommentsSnapshot(deps, workspaceId),
         listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot: (workspaceId = 'default') => listWorkspaceSyncAnnotatedAttachmentSessionsSnapshot(deps, workspaceId),
-        listWorkspaceSyncTaskEventsSnapshot: (workspaceId = 'default') => listWorkspaceSyncTaskEventsSnapshot(deps, workspaceId),
+        listWorkspaceSyncTaskEventsSnapshot: (workspaceId = 'default', options) => listWorkspaceSyncTaskEventsSnapshot(deps, workspaceId, options),
+        listWorkspaceSyncTaskforceAgentsSnapshot: (workspaceId = 'default') => listWorkspaceSyncTaskforceAgentsSnapshot(deps, workspaceId),
+        listWorkspaceSyncAgentRolesSnapshot: (workspaceId = 'default') => listWorkspaceSyncAgentRolesSnapshot(deps, workspaceId),
+        listWorkspaceSyncTaskforceAgentSkillsSnapshot: (workspaceId = 'default') => listWorkspaceSyncTaskforceAgentSkillsSnapshot(deps, workspaceId),
+        listWorkspaceSyncAgentConversationsSnapshot: (workspaceId = 'default') => listWorkspaceSyncAgentConversationsSnapshot(deps, workspaceId),
     };
 }

package/dist/sync/contentSyncPayload.d.ts

@@ -1,4 +1,11 @@
 import type { WorkspaceAssetLinkRole, WorkspaceAssetLinkTargetType } from '../storage/workspaceAssetStore.js';
+export interface WorkspaceAssetSyncLinkPayload {
+    targetType: WorkspaceAssetLinkTargetType;
+    targetId: string;
+    role: WorkspaceAssetLinkRole;
+    displayName?: string | null;
+    updatedAt?: string | null;
+}
 export interface DocumentSyncPayload {
     path: string;
     updatedAt: string;
@@ -14,6 +21,7 @@ export interface DocumentSyncPayload {
     caption?: string | null;
     originalFilename?: string | null;
     linkRole?: WorkspaceAssetLinkRole;
+    links?: WorkspaceAssetSyncLinkPayload[];
 }
 export interface DocumentDeleteSyncPayload {
     path: string;
@@ -35,6 +43,7 @@ export interface BinaryAssetSyncPayload {
     caption?: string | null;
     originalFilename?: string | null;
     linkRole?: WorkspaceAssetLinkRole;
+    links?: WorkspaceAssetSyncLinkPayload[];
 }
 export interface BinaryAssetDeleteSyncPayload {
     path: string;

package/dist/sync/contentSyncPayload.js

@@ -3,6 +3,31 @@ function toOptionalLinkTargetType(value) {
         ? value
         : undefined;
 }
+function normalizeSyncLinks(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.flatMap((entry) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return [];
+        const source = entry;
+        const targetType = toOptionalLinkTargetType(source.targetType);
+        const targetId = toOptionalTrimmedString(source.targetId);
+        if (!targetType || !targetId)
+            return [];
+        const role = source.role === 'reference'
+            ? 'reference'
+            : source.role === 'image'
+                ? 'image'
+                : 'attachment';
+        return [{
+                targetType,
+                targetId,
+                role,
+                displayName: toNullableTrimmedString(source.displayName),
+                updatedAt: toNullableTrimmedString(source.updatedAt),
+            }];
+    });
+}
 function toOptionalTrimmedString(value) {
     if (typeof value !== 'string')
         return undefined;
@@ -28,6 +53,7 @@ export function normalizeDocumentSyncPayload(raw, normalizePath) {
     const path = normalizePath(source.path);
     if (!path)
         return null;
+    const links = normalizeSyncLinks(source.links);
     return {
         path,
         updatedAt: String(source.updatedAt || source.watermark || '').trim(),
@@ -43,6 +69,7 @@ export function normalizeDocumentSyncPayload(raw, normalizePath) {
         caption: toNullableTrimmedString(source.caption),
         originalFilename: toNullableTrimmedString(source.originalFilename),
         linkRole: source.linkRole === 'reference' ? 'reference' : 'attachment',
+        ...(links ? { links } : {}),
     };
 }
 export function normalizeDocumentDeleteSyncPayload(raw, normalizePath, defaultDeletedAt) {
@@ -65,6 +92,7 @@ export function normalizeBinaryAssetSyncPayload(raw, normalizePath) {
     const path = normalizePath(source.path);
     if (!path)
         return null;
+    const links = normalizeSyncLinks(source.links);
     return {
         path,
         updatedAt: String(source.updatedAt || source.watermark || '').trim(),
@@ -84,6 +112,7 @@ export function normalizeBinaryAssetSyncPayload(raw, normalizePath) {
             : source.kind === 'image'
                 ? 'image'
                 : 'attachment',
+        ...(links ? { links } : {}),
     };
 }
 export function normalizeBinaryAssetDeleteSyncPayload(raw, normalizePath, defaultDeletedAt) {

package/dist/sync/contentSyncState.d.ts

@@ -1,11 +1,14 @@
 import type { TaskforceCore, TaskforceSyncCapable } from '../core/Taskforce.js';
 import type { ObjectStorageClient } from '../storage/objectStorageClient.js';
-import type { WorkspaceAssetEntry, WorkspaceAssetLinkEntry, WorkspaceAssetLinkRole, WorkspaceAssetLinkTargetType, WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
-import type { BinaryAssetDeleteSyncPayload, BinaryAssetSyncPayload, DocumentDeleteSyncPayload, DocumentSyncPayload } from './contentSyncPayload.js';
+import { type WorkspaceAssetEntry, type WorkspaceAssetLinkEntry, type WorkspaceAssetLinkRole, type WorkspaceAssetLinkTargetType, type WorkspaceAssetStore } from '../storage/workspaceAssetStore.js';
+import type { BinaryAssetDeleteSyncPayload, BinaryAssetSyncPayload, DocumentDeleteSyncPayload, DocumentSyncPayload, WorkspaceAssetSyncLinkPayload } from './contentSyncPayload.js';
+import type { WorkspaceSyncContentStorageProvider } from './engine/workspaceSyncContentVersionStore.js';
+import { WorkspaceSyncPublishedContentResolver } from './engine/workspaceSyncPublishedContentResolver.js';
 type SyncCore = TaskforceCore & TaskforceSyncCapable;
 type RecordSyncDiagnostic = (workspaceId: string, eventType: 'pull' | 'push' | 'apply', errorMessage: string, details?: Record<string, unknown>) => void;
 export interface CachedWorkspaceSyncDocument {
     path: string;
+    contentIdentity: string;
     mtimeMs: number;
     ctimeMs: number;
     size: number;
@@ -20,11 +23,68 @@ interface ContentSyncStateDeps {
     normalizeTaskDataRelativePath: (rawPath: string) => string | null;
     recordSyncDiagnostic: RecordSyncDiagnostic;
     workspaceDocumentSnapshotCache: Map<string, Map<string, CachedWorkspaceSyncDocument>>;
+    publishedContentResolver?: Pick<WorkspaceSyncPublishedContentResolver, 'resolve'>;
+}
+export type DocumentSyncIndexEntry = Omit<DocumentSyncPayload, 'content'> & {
+    contentSha256: string;
+    sizeBytes: number;
+    contentAvailable: boolean;
+};
+export type BinaryAssetSyncIndexEntry = Omit<BinaryAssetSyncPayload, 'contentBase64'> & {
+    contentSha256: string;
+    sizeBytes: number;
+    contentAvailable: boolean;
+};
+export interface WorkspaceSyncContentCursor {
+    u: string;
+    id: string;
+}
+export declare function readWorkspaceSyncContentFrontier(deps: ContentSyncStateDeps, workspaceId?: string): WorkspaceSyncContentCursor | null;
+export declare function hasWorkspaceSyncContentAfter(deps: ContentSyncStateDeps, workspaceId: string, cursor: WorkspaceSyncContentCursor | null): boolean;
+export interface PersistWorkspaceSyncDocumentMetadataInput {
+    document: DocumentSyncPayload | Omit<DocumentSyncPayload, 'content'>;
+    normalizedPath: string;
+    contentSha256: string;
+    sizeBytes: number;
+    storageProvider: WorkspaceSyncContentStorageProvider;
+    workspaceId?: string;
+    options?: {
+        allowReferenceNumberReassignment?: boolean;
+        strictWatermark?: boolean;
+        strictOrdering?: boolean;
+    };
+}
+export interface PersistWorkspaceSyncBinaryAssetMetadataInput {
+    asset: BinaryAssetSyncPayload | Omit<BinaryAssetSyncPayload, 'contentBase64'>;
+    normalizedPath: string;
+    contentSha256: string;
+    sizeBytes: number;
+    storageProvider: WorkspaceSyncContentStorageProvider;
+    workspaceId?: string;
+    options?: {
+        allowReferenceNumberReassignment?: boolean;
+        strictWatermark?: boolean;
+        strictOrdering?: boolean;
+    };
+}
+export interface DeleteWorkspaceSyncContentMetadataInput {
+    normalizedPath: string;
+    deletedAt: string;
+    workspaceId?: string;
+    strictWatermark?: boolean;
+    strictOrdering?: boolean;
+}
+export interface PersistWorkspaceSyncPreparedContentMetadataOptions {
+    contentSha256: string;
+    sizeBytes: number;
+    storageProvider: WorkspaceSyncContentStorageProvider;
+    allowReferenceNumberReassignment?: boolean;
+    strictWatermark?: boolean;
+    strictOrdering?: boolean;
 }
-export type DocumentSyncIndexEntry = Omit<DocumentSyncPayload, 'content'>;
-export type BinaryAssetSyncIndexEntry = Omit<BinaryAssetSyncPayload, 'contentBase64'>;
 export declare function resolveCanonicalAssetSyncLinkState(deps: ContentSyncStateDeps, asset: WorkspaceAssetEntry, workspaceId: string): {
     primaryLink: WorkspaceAssetLinkEntry | null;
+    activeLinks: WorkspaceAssetLinkEntry[];
     effectiveUpdatedAt: string;
 };
 export declare function getCanonicalSyncDocumentMetadata(deps: ContentSyncStateDeps, relativePath: string, workspaceId: string): Omit<DocumentSyncPayload, 'path' | 'updatedAt' | 'content'>;
@@ -39,6 +99,7 @@ export declare function reconcileWorkspaceSyncLinks(deps: ContentSyncStateDeps,
     role?: WorkspaceAssetLinkRole | null;
     displayName?: string | null;
     updatedAt?: string | null;
+    links?: WorkspaceAssetSyncLinkPayload[];
 }): void;
 export declare function listWorkspaceSyncDocumentDeletesSnapshot(deps: ContentSyncStateDeps, workspaceId?: string): DocumentDeleteSyncPayload[];
 export declare function listWorkspaceSyncDocumentsSnapshot(deps: ContentSyncStateDeps, basePath: string, workspaceId?: string): Promise<DocumentSyncPayload[]>;
@@ -48,17 +109,25 @@ export declare function listWorkspaceSyncBinaryAssetIndex(deps: ContentSyncState
 export declare function loadWorkspaceSyncDocumentPayload(deps: ContentSyncStateDeps, basePath: string, workspaceId: string, relativePath: string): Promise<DocumentSyncPayload | null>;
 export declare function loadWorkspaceSyncBinaryAssetPayload(deps: ContentSyncStateDeps, basePath: string, workspaceId: string, assetPath: string): Promise<BinaryAssetSyncPayload | null>;
 export declare function listWorkspaceSyncBinaryAssetDeletesSnapshot(deps: ContentSyncStateDeps, workspaceId?: string): BinaryAssetDeleteSyncPayload[];
+export declare function persistWorkspaceSyncDocumentMetadata(deps: ContentSyncStateDeps, input: PersistWorkspaceSyncDocumentMetadataInput): void;
+export declare function persistWorkspaceSyncBinaryAssetMetadata(deps: ContentSyncStateDeps, input: PersistWorkspaceSyncBinaryAssetMetadataInput): void;
 export declare function writeWorkspaceSyncDocument(deps: ContentSyncStateDeps, basePath: string, doc: DocumentSyncPayload, workspaceId?: string, options?: {
     allowReferenceNumberReassignment?: boolean;
 }): Promise<void>;
 export declare function writeWorkspaceSyncBinaryAsset(deps: ContentSyncStateDeps, basePath: string, asset: BinaryAssetSyncPayload, workspaceId?: string, options?: {
     allowReferenceNumberReassignment?: boolean;
 }): Promise<void>;
+export declare function canDeleteWorkspaceSyncBinaryAssetMetadata(deps: ContentSyncStateDeps, normalizedPath: string, workspaceId?: string): boolean;
+export declare function deleteWorkspaceSyncBinaryAssetMetadata(deps: ContentSyncStateDeps, input: DeleteWorkspaceSyncContentMetadataInput): boolean;
 export declare function deleteWorkspaceSyncBinaryAsset(deps: ContentSyncStateDeps, basePath: string, assetPath: string, workspaceId?: string): void;
+export declare function deleteWorkspaceSyncDocumentMetadata(deps: ContentSyncStateDeps, input: DeleteWorkspaceSyncContentMetadataInput): void;
 export declare function deleteWorkspaceSyncDocument(deps: ContentSyncStateDeps, basePath: string, docPath: string, workspaceId?: string): void;
 export declare function createContentSyncState(deps: ContentSyncStateDeps): {
+    readWorkspaceSyncContentFrontier: (workspaceId?: string) => WorkspaceSyncContentCursor | null;
+    hasWorkspaceSyncContentAfter: (workspaceId: string, cursor: WorkspaceSyncContentCursor | null) => boolean;
     resolveCanonicalAssetSyncLinkState: (asset: WorkspaceAssetEntry, workspaceId: string) => {
         primaryLink: WorkspaceAssetLinkEntry | null;
+        activeLinks: WorkspaceAssetLinkEntry[];
         effectiveUpdatedAt: string;
     };
     getCanonicalSyncDocumentMetadata: (relativePath: string, workspaceId: string) => Omit<DocumentSyncPayload, "path" | "updatedAt" | "content">;
@@ -77,6 +146,7 @@ export declare function createContentSyncState(deps: ContentSyncStateDeps): {
         role?: WorkspaceAssetLinkRole | null;
         displayName?: string | null;
         updatedAt?: string | null;
+        links?: WorkspaceAssetSyncLinkPayload[];
     }) => void;
     listWorkspaceSyncDocumentDeletesSnapshot: (workspaceId?: string) => DocumentDeleteSyncPayload[];
     listWorkspaceSyncDocumentIndex: (basePath: string, workspaceId?: string) => Promise<DocumentSyncIndexEntry[]>;
@@ -92,6 +162,11 @@ export declare function createContentSyncState(deps: ContentSyncStateDeps): {
     writeWorkspaceSyncBinaryAsset: (basePath: string, asset: BinaryAssetSyncPayload, workspaceId?: string, options?: {
         allowReferenceNumberReassignment?: boolean;
     }) => Promise<void>;
+    persistWorkspaceSyncDocumentMetadata: (document: DocumentSyncPayload | Omit<DocumentSyncPayload, "content">, workspaceId: string, metadata: PersistWorkspaceSyncPreparedContentMetadataOptions) => void;
+    persistWorkspaceSyncBinaryAssetMetadata: (asset: BinaryAssetSyncPayload | Omit<BinaryAssetSyncPayload, "contentBase64">, workspaceId: string, metadata: PersistWorkspaceSyncPreparedContentMetadataOptions) => void;
+    deleteWorkspaceSyncBinaryAssetMetadata: (normalizedPath: string, workspaceId: string, deletedAt: string) => boolean;
+    canDeleteWorkspaceSyncBinaryAssetMetadata: (normalizedPath: string, workspaceId: string) => boolean;
+    deleteWorkspaceSyncDocumentMetadata: (normalizedPath: string, workspaceId: string, deletedAt: string) => void;
     deleteWorkspaceSyncBinaryAsset: (basePath: string, assetPath: string, workspaceId?: string) => void;
     deleteWorkspaceSyncDocument: (basePath: string, docPath: string, workspaceId?: string) => void;
 };