@taskforcehq/taskforce 0.3.324 → 0.3.327

package/dist/utils/aiProfileAvatarPaths.d.ts

@@ -0,0 +1,14 @@
+export type AiProfileAvatarSlot = 'display' | 'source';
+export declare function buildAiProfileAvatarStorageKey(input: {
+    workspaceId: string;
+    profileId: string;
+    slot: AiProfileAvatarSlot;
+    mimeType: string;
+    generationId?: string | null;
+}): string;
+export declare function buildAiProfileAvatarStoragePrefixes(input: {
+    workspaceId: string;
+    profileId: string;
+}): string[];
+export declare function storageKeyBelongsToAiProfileAvatar(workspaceId: string, profileId: string, storageKey: string): boolean;
+export declare function isAiProfileAvatarStorageKey(storageKey: unknown, workspaceId: string): boolean;

package/dist/utils/aiProfileAvatarPaths.js

@@ -0,0 +1,52 @@
+function normalizeId(value) {
+    return String(value || '').trim();
+}
+function sanitizeStorageSegment(value, fallback) {
+    const normalized = normalizeId(value)
+        .replace(/[^a-zA-Z0-9._-]/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return normalized || fallback;
+}
+function extensionForMimeType(mimeType) {
+    if (mimeType === 'image/gif')
+        return 'gif';
+    if (mimeType === 'image/jpeg')
+        return 'jpg';
+    if (mimeType === 'image/png')
+        return 'png';
+    return 'webp';
+}
+function buildAiProfileAvatarPrefix(input) {
+    const workspaceId = sanitizeStorageSegment(input.workspaceId, 'default');
+    const profileId = sanitizeStorageSegment(input.profileId, 'ai-profile');
+    return `workspaces/${workspaceId}/assets/ai-profiles/${profileId}/avatar/`;
+}
+function buildLegacyAiProfileAvatarPrefix(input) {
+    const workspaceId = sanitizeStorageSegment(input.workspaceId, 'default');
+    const profileId = sanitizeStorageSegment(input.profileId, 'ai-profile');
+    return `workspaces/${workspaceId}/assets/images/ai-profiles/${profileId}/avatar/`;
+}
+export function buildAiProfileAvatarStorageKey(input) {
+    const ext = extensionForMimeType(input.mimeType);
+    const generationId = sanitizeStorageSegment(input.generationId, '');
+    const filename = generationId ? `${input.slot}-${generationId}.${ext}` : `${input.slot}.${ext}`;
+    return `${buildAiProfileAvatarPrefix(input)}${filename}`;
+}
+export function buildAiProfileAvatarStoragePrefixes(input) {
+    return [
+        buildAiProfileAvatarPrefix(input),
+        buildLegacyAiProfileAvatarPrefix(input),
+    ];
+}
+export function storageKeyBelongsToAiProfileAvatar(workspaceId, profileId, storageKey) {
+    const normalized = String(storageKey || '').replace(/\\/g, '/');
+    return buildAiProfileAvatarStoragePrefixes({ workspaceId, profileId })
+        .some((prefix) => normalized.startsWith(prefix));
+}
+export function isAiProfileAvatarStorageKey(storageKey, workspaceId) {
+    const workspaceIdSafe = sanitizeStorageSegment(workspaceId, 'default');
+    const normalized = String(storageKey || '').replace(/\\/g, '/');
+    return (normalized.startsWith(`workspaces/${workspaceIdSafe}/assets/ai-profiles/`)
+        || normalized.startsWith(`workspaces/${workspaceIdSafe}/assets/images/ai-profiles/`)) && normalized.includes('/avatar/');
+}

package/dist/utils/aiProfileDefaultLogo.d.ts

@@ -0,0 +1,7 @@
+export interface AiProfileDefaultLogoIdentity {
+    name?: string | null;
+    username?: string | null;
+    surfaceType?: string | null;
+    providerMetadata?: Record<string, unknown> | null;
+}
+export declare function getAiProfileDefaultLogoUrl(profile: AiProfileDefaultLogoIdentity | null | undefined): string;

package/dist/utils/aiProfileDefaultLogo.js

@@ -0,0 +1,84 @@
+import antigravityLogo from '../assets/ai-profile-clients/antigravity.png';
+import chatgptLogo from '../assets/ai-profile-clients/chatgpt.svg';
+import claudeChatLogo from '../assets/ai-profile-clients/claude-chat.svg';
+import claudeCodeLogo from '../assets/ai-profile-clients/claude-code.svg';
+import clineLogo from '../assets/ai-profile-clients/cline.svg';
+import codexLogo from '../assets/ai-profile-clients/codex.svg';
+import cursorLogo from '../assets/ai-profile-clients/cursor.svg';
+import geminiLogo from '../assets/ai-profile-clients/gemini-cli-icon.png';
+import geminiChatLogo from '../assets/ai-profile-clients/gemini.svg';
+import grokLogo from '../assets/ai-profile-clients/grok.svg';
+import kiroLogo from '../assets/ai-profile-clients/kiro.svg';
+import mistralLogo from '../assets/ai-profile-clients/mistral.svg';
+import perplexityLogo from '../assets/ai-profile-clients/perplexity.svg';
+import vscodeLogo from '../assets/ai-profile-clients/vscode.svg';
+import windsurfLogo from '../assets/ai-profile-clients/windsurf.svg';
+import { getMcpClientRegistryEntry } from '../mcp/clientRegistry.js';
+import { isTaskforceManagedAiProfile } from '../shared/aiProfileAvatarEligibility.js';
+const LOGO_URLS = {
+    antigravity: antigravityLogo,
+    'chatgpt-desktop': chatgptLogo,
+    'claude-code': claudeCodeLogo,
+    'claude-chat': claudeChatLogo,
+    'grok-chat': grokLogo,
+    'gemini-chat': geminiChatLogo,
+    'mistral-chat': mistralLogo,
+    'perplexity-chat': perplexityLogo,
+    cline: clineLogo,
+    codex: codexLogo,
+    cursor: cursorLogo,
+    'gemini-cli': geminiLogo,
+    grok: grokLogo,
+    kiro: kiroLogo,
+    vscode: vscodeLogo,
+    windsurf: windsurfLogo,
+};
+export function getAiProfileDefaultLogoUrl(profile) {
+    if (!profile || isTaskforceManagedAiProfile(profile))
+        return '';
+    const connection = profile.providerMetadata?.connection;
+    const clientId = connection && typeof connection === 'object' && !Array.isArray(connection)
+        ? connection.clientId
+        : null;
+    const registryEntry = getMcpClientRegistryEntry(clientId);
+    if (registryEntry?.logoKey)
+        return LOGO_URLS[registryEntry.logoKey];
+    if (!['chat_app', 'ide', 'cli', 'coding_tool'].includes(String(profile.surfaceType || '')))
+        return '';
+    const identity = [profile.username, profile.name]
+        .map((value) => String(value || '').toLowerCase())
+        .join(' ');
+    if (!identity.trim())
+        return '';
+    if (identity.includes('openclaw') || identity.includes('hermes agent'))
+        return '';
+    if (identity.includes('chatgpt'))
+        return chatgptLogo;
+    if (identity.includes('claude code'))
+        return claudeCodeLogo;
+    if (identity.includes('claude desktop'))
+        return claudeChatLogo;
+    if (identity.includes('cline'))
+        return clineLogo;
+    if (identity.includes('codex'))
+        return codexLogo;
+    if (identity.includes('cursor'))
+        return cursorLogo;
+    if (identity.includes('cascade') || identity.includes('windsurf'))
+        return windsurfLogo;
+    if (identity.includes('antigravity'))
+        return antigravityLogo;
+    if (identity.includes('gemini'))
+        return geminiLogo;
+    if (identity.includes('grok'))
+        return grokLogo;
+    if (identity.includes('mistral') || identity.includes('le chat'))
+        return mistralLogo;
+    if (identity.includes('perplexity'))
+        return perplexityLogo;
+    if (identity.includes('kiro'))
+        return kiroLogo;
+    if (identity.includes('visual studio code') || identity.includes('vs code') || identity.includes('vscode'))
+        return vscodeLogo;
+    return '';
+}

package/dist/utils/aiProfileEvents.d.ts

@@ -2,6 +2,14 @@ export declare const TASKFORCE_AI_PROFILES_MUTATED_EVENT = "taskforce:ai-profile
 export interface TaskforceAiProfilesMutatedDetail {
     workspaceId?: string | null;
     profileId?: string | null;
-    reason?: 'avatar' | 'merge' | 'archive' | 'update';
+    reason?: 'avatar' | 'merge' | 'archive' | 'update' | 'sync-apply';
+    origin?: 'ai-profiles-module' | 'taskforce-agents-module' | 'sync-orchestrator';
+    taskforceAgentAvatar?: {
+        agentId: string;
+        avatarUrl: string | null;
+        avatarSourceUrl: string | null;
+        avatarRevision: number;
+        avatarUpdatedAt: string | null;
+    };
 }
 export declare function dispatchTaskforceAiProfilesMutated(detail: TaskforceAiProfilesMutatedDetail): void;

package/dist/utils/annotatedAttachments.d.ts

@@ -6,7 +6,14 @@ export interface OpenAnnotatedAttachmentDetail {
     imageReferenceLabel?: string;
     path: string;
     displayName: string;
+    sessionId?: string;
 }
+export declare function getAnnotatedAttachmentContextIdentity(target: OpenAnnotatedAttachmentDetail | null, sessionId: string | null): string;
+export declare function shouldApplyPersistedAnnotatedAttachmentContext(input: {
+    currentTarget: OpenAnnotatedAttachmentDetail | null;
+    currentSessionId: string | null;
+    lastHydratedIdentity: string | null;
+}): boolean;
 type AnnotatedAttachmentTarget = string | AttachmentItem;
 export declare function canOpenAnnotatedAttachment(target: AnnotatedAttachmentTarget, options?: {
     taskId?: string | null;
@@ -15,6 +22,7 @@ export declare function canOpenAnnotatedAttachment(target: AnnotatedAttachmentTa
 export declare function dispatchOpenAnnotatedAttachment(target: AnnotatedAttachmentTarget, options?: {
     taskId?: string | null;
     taskReferenceLabel?: string | null;
+    sessionId?: string | null;
 }): boolean;
 export declare function resolveAnnotatedAttachmentDetail(detail: OpenAnnotatedAttachmentDetail | null | undefined, tasks: Array<Pick<TaskItem, 'id' | 'referenceNumber' | 'referenceLabel'>>): OpenAnnotatedAttachmentDetail | null;
 export {};

package/dist/utils/annotatedAttachments.js

@@ -1,5 +1,18 @@
 import { getImageReferenceLabel } from './imageReferences';
 import { getTaskReferenceLabel } from './taskReferences';
+export function getAnnotatedAttachmentContextIdentity(target, sessionId) {
+    if (!target)
+        return '';
+    return JSON.stringify([
+        String(target.taskId || '').trim(),
+        String(target.assetId || '').trim(),
+        String(sessionId || '').trim(),
+    ]);
+}
+export function shouldApplyPersistedAnnotatedAttachmentContext(input) {
+    const currentIdentity = getAnnotatedAttachmentContextIdentity(input.currentTarget, input.currentSessionId);
+    return !currentIdentity || currentIdentity === input.lastHydratedIdentity;
+}
 function normalizeCandidate(value) {
     return value.trim().replace(/\\/g, '/');
 }
@@ -7,7 +20,7 @@ function resolvePath(target) {
     return typeof target === 'string' ? target : String(target.path || '').trim();
 }
 function isImagePath(pathValue) {
-    return /\.(png|jpe?g|webp)(\?|#|$)/i.test(pathValue);
+    return /\.(png|jpe?g|webp|gif)(\?|#|$)/i.test(pathValue);
 }
 function resolveDisplayName(target) {
     if (typeof target === 'string') {
@@ -35,6 +48,7 @@ export function dispatchOpenAnnotatedAttachment(target, options) {
     const taskReferenceLabel = String(options?.taskReferenceLabel || '').trim();
     const assetId = String(attachment.assetId || '').trim();
     const imageReferenceLabel = getImageReferenceLabel(attachment);
+    const sessionId = String(options?.sessionId || '').trim();
     const path = resolvePath(target);
     const event = new CustomEvent('taskforce:open-annotated-attachment', {
         detail: {
@@ -42,6 +56,7 @@ export function dispatchOpenAnnotatedAttachment(target, options) {
             ...(taskReferenceLabel ? { taskReferenceLabel } : {}),
             assetId,
             ...(imageReferenceLabel ? { imageReferenceLabel } : {}),
+            ...(sessionId ? { sessionId } : {}),
             path,
             displayName: resolveDisplayName(target),
         },
@@ -68,6 +83,7 @@ export function resolveAnnotatedAttachmentDetail(detail, tasks) {
         ...(taskReferenceLabel ? { taskReferenceLabel } : {}),
         assetId,
         imageReferenceLabel: String(detail.imageReferenceLabel || '').trim() || undefined,
+        sessionId: String(detail.sessionId || '').trim() || undefined,
         path,
         displayName,
     };

package/dist/utils/assetTraySorting.d.ts

@@ -0,0 +1,25 @@
+export type TraySortField = 'reference' | 'name' | 'size' | 'updated' | 'created';
+export type TraySortOrder = 'asc' | 'desc';
+type TraySortNameResolver<T> = (item: T) => string;
+interface TraySortableItem {
+    referenceNumber?: number | null;
+    referenceLabel?: string | null;
+    imageReferenceLabel?: string | null;
+    displayName?: string | null;
+    title?: string | null;
+    originalFilename?: string | null;
+    fsPath?: string | null;
+    path?: string | null;
+    storageKey?: string | null;
+    sizeBytes?: number | null;
+    updatedAt?: string | null;
+    createdAt?: string | null;
+}
+export declare const TRAY_SORT_OPTIONS: Array<{
+    value: TraySortField;
+    label: string;
+}>;
+export declare function compareTrayItems<T extends TraySortableItem>(a: T, b: T, field: TraySortField, order: TraySortOrder, resolveName?: TraySortNameResolver<T>): number;
+export declare function sortTrayItems<T extends TraySortableItem>(items: readonly T[], field: TraySortField, order: TraySortOrder, resolveName?: TraySortNameResolver<T>): T[];
+export declare function sortDocuments<T extends TraySortableItem>(docs: readonly T[], field: TraySortField, order: TraySortOrder): T[];
+export {};

package/dist/utils/assetTraySorting.js

@@ -0,0 +1,83 @@
+import { getReadableDocumentName } from './documentNames';
+export const TRAY_SORT_OPTIONS = [
+    { value: 'updated', label: 'Updated' },
+    { value: 'reference', label: 'Reference' },
+    { value: 'name', label: 'Name' },
+    { value: 'size', label: 'Size' },
+    { value: 'created', label: 'Created' },
+];
+function getRefSortValue(item) {
+    if (typeof item?.referenceNumber === 'number' && Number.isFinite(item.referenceNumber)) {
+        return item.referenceNumber;
+    }
+    const label = String(item?.referenceLabel || item?.imageReferenceLabel || '');
+    const match = label.match(/(\d+)/);
+    return match ? parseInt(match[1], 10) : 0;
+}
+function getFallbackNameForSort(item) {
+    if (!item)
+        return '';
+    const name = item.displayName
+        || item.title
+        || item.originalFilename
+        || item.fsPath
+        || item.path
+        || item.storageKey
+        || '';
+    return String(name).toLowerCase();
+}
+function getDocumentNameForSort(item) {
+    return getReadableDocumentName(item).toLowerCase();
+}
+function getNameForSort(item, resolveName) {
+    return String(resolveName(item) || '').toLowerCase();
+}
+function getSize(item) {
+    const s = item?.sizeBytes;
+    return typeof s === 'number' && Number.isFinite(s) ? s : 0;
+}
+function getDateValue(item, preferCreated) {
+    const c = item?.createdAt;
+    const u = item?.updatedAt;
+    const primary = preferCreated ? (c || u) : (u || c);
+    if (!primary)
+        return 0;
+    const t = Date.parse(String(primary));
+    return Number.isNaN(t) ? 0 : t;
+}
+export function compareTrayItems(a, b, field, order, resolveName = getFallbackNameForSort) {
+    let cmp = 0;
+    if (field === 'reference') {
+        const ra = getRefSortValue(a);
+        const rb = getRefSortValue(b);
+        cmp = ra - rb;
+        if (cmp === 0)
+            cmp = getNameForSort(a, resolveName).localeCompare(getNameForSort(b, resolveName));
+    }
+    else if (field === 'name') {
+        cmp = getNameForSort(a, resolveName).localeCompare(getNameForSort(b, resolveName));
+    }
+    else if (field === 'size') {
+        cmp = getSize(a) - getSize(b);
+    }
+    else if (field === 'created') {
+        cmp = getDateValue(a, true) - getDateValue(b, true);
+    }
+    else {
+        // updated (default)
+        cmp = getDateValue(a, false) - getDateValue(b, false);
+    }
+    if (cmp !== 0) {
+        return order === 'desc' ? -cmp : cmp;
+    }
+    cmp = getRefSortValue(b) - getRefSortValue(a);
+    if (cmp !== 0)
+        return cmp;
+    return getNameForSort(a, resolveName).localeCompare(getNameForSort(b, resolveName));
+}
+export function sortTrayItems(items, field, order, resolveName) {
+    return [...items].sort((a, b) => compareTrayItems(a, b, field, order, resolveName));
+}
+export function sortDocuments(docs, field, order) {
+    return sortTrayItems(docs, field, order, getDocumentNameForSort);
+}

package/dist/utils/assignees.d.ts

@@ -1,6 +1,8 @@
 import type { TaskAssignee } from '../types';
 export declare const TASK_ASSIGNEE_UNASSIGNED: "unassigned";
 export declare const TASK_ASSIGNEE_AGENT: "agent";
+export declare const TASK_ASSIGNEE_UNASSIGNED_ICON: "UserRound";
+export declare const TASK_ASSIGNEE_UNASSIGNED_COLOR: "color-mix(in srgb, var(--text-helper) 68%, transparent)";
 export type AssigneeKind = 'unassigned' | 'agent' | 'member';
 export interface WorkspaceAssigneeCandidate {
     userId: string;
@@ -18,10 +20,13 @@ export interface TaskAssigneeOption {
     avatarRevision?: number | null;
     avatarUpdatedAt?: string | null;
     username?: string | null;
+    surfaceType?: string | null;
+    providerMetadata?: Record<string, unknown> | null;
     archivedAt?: string | null;
     createdAt?: string | null;
     updatedAt?: string | null;
 }
+export declare const UNASSIGNED_ASSIGNEE_OPTION: TaskAssigneeOption;
 export declare function isAgentAssignee(value: unknown): boolean;
 export declare function isUnassignedAssignee(value: unknown): boolean;
 export declare function getAssigneeKind(value: unknown): AssigneeKind;

package/dist/utils/assignees.js

@@ -1,7 +1,16 @@
 export const TASK_ASSIGNEE_UNASSIGNED = 'unassigned';
 export const TASK_ASSIGNEE_AGENT = 'agent';
+export const TASK_ASSIGNEE_UNASSIGNED_ICON = 'UserRound';
+export const TASK_ASSIGNEE_UNASSIGNED_COLOR = 'color-mix(in srgb, var(--text-helper) 68%, transparent)';
 const LEGACY_TASK_ASSIGNEE_USER = 'user';
 const OPAQUE_AI_PROFILE_ID_PATTERN = /^[0-9a-f]{8,}$/i;
+export const UNASSIGNED_ASSIGNEE_OPTION = {
+    value: TASK_ASSIGNEE_UNASSIGNED,
+    label: 'Unassigned',
+    icon: TASK_ASSIGNEE_UNASSIGNED_ICON,
+    color: TASK_ASSIGNEE_UNASSIGNED_COLOR,
+    kind: 'unassigned',
+};
 export function isAgentAssignee(value) {
     const normalized = String(value || '').trim().toLowerCase();
     return normalized === TASK_ASSIGNEE_AGENT || normalized === 'ai' || normalized.startsWith('ai-profile-');
@@ -27,15 +36,7 @@ export function formatWorkspaceAssigneeLabel(candidate) {
     return displayName || email || String(candidate.userId || '').trim() || 'Workspace member';
 }
 export function createDefaultAssigneeOptions() {
-    return [
-        {
-            value: TASK_ASSIGNEE_UNASSIGNED,
-            label: 'Unassigned',
-            icon: 'HelpCircle',
-            color: 'var(--text-secondary)',
-            kind: 'unassigned',
-        },
-    ];
+    return [{ ...UNASSIGNED_ASSIGNEE_OPTION }];
 }
 export function createWorkspaceAssigneeOptions(candidates) {
     const deduped = new Map();
@@ -74,6 +75,10 @@ export function mergeAssigneeOptions(options) {
             avatarRevision: Number.isFinite(Number(option.avatarRevision)) ? Math.max(0, Math.floor(Number(option.avatarRevision))) : null,
             avatarUpdatedAt: typeof option.avatarUpdatedAt === 'string' && option.avatarUpdatedAt.trim().length > 0 ? option.avatarUpdatedAt.trim() : null,
             username: typeof option.username === 'string' && option.username.trim().length > 0 ? option.username.trim() : null,
+            surfaceType: typeof option.surfaceType === 'string' && option.surfaceType.trim().length > 0 ? option.surfaceType.trim() : null,
+            providerMetadata: option.providerMetadata && typeof option.providerMetadata === 'object' && !Array.isArray(option.providerMetadata)
+                ? option.providerMetadata
+                : null,
             archivedAt: null,
             createdAt: typeof option.createdAt === 'string' && option.createdAt.trim().length > 0 ? option.createdAt.trim() : null,
             updatedAt: typeof option.updatedAt === 'string' && option.updatedAt.trim().length > 0 ? option.updatedAt.trim() : null,

package/dist/utils/authLogin.d.ts

@@ -0,0 +1,10 @@
+export interface TaskforceCredentialLoginPayload {
+    email: string;
+    password: string;
+    workspaceId?: string;
+}
+export declare function buildTaskforceCredentialLoginPayload(input: {
+    email: string;
+    password: string;
+    activeWorkspaceId: string | null | undefined;
+}): TaskforceCredentialLoginPayload;

package/dist/utils/authLogin.js

@@ -0,0 +1,8 @@
+export function buildTaskforceCredentialLoginPayload(input) {
+    const workspaceId = String(input.activeWorkspaceId || '').trim();
+    return {
+        email: input.email,
+        password: input.password,
+        ...(workspaceId && workspaceId !== 'default' ? { workspaceId } : {}),
+    };
+}

package/dist/utils/authSessionEvents.d.ts

@@ -0,0 +1,2 @@
+export declare const TASKFORCE_AUTH_SESSION_CHANGED_EVENT = "taskforce:auth-session-changed";
+export declare function dispatchTaskforceAuthSessionChanged(): void;

package/dist/utils/authSessionEvents.js

@@ -0,0 +1,6 @@
+export const TASKFORCE_AUTH_SESSION_CHANGED_EVENT = 'taskforce:auth-session-changed';
+export function dispatchTaskforceAuthSessionChanged() {
+    if (typeof window === 'undefined' || typeof window.dispatchEvent !== 'function')
+        return;
+    window.dispatchEvent(new Event(TASKFORCE_AUTH_SESSION_CHANGED_EVENT));
+}

package/dist/utils/avatarUpload.js

@@ -1,4 +1,4 @@
-const DEFAULT_MAX_DIMENSION = 1024;
+const DEFAULT_MAX_DIMENSION = 512;
 const DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
 const WEBP_QUALITY_STEPS = [0.9, 0.82, 0.74, 0.66, 0.58];
 const JPEG_QUALITY_STEPS = [0.9, 0.82, 0.74, 0.66, 0.58];
@@ -87,14 +87,14 @@ export async function prepareAvatarUploadFile(file, options, deps = defaultDeps)
     const maxDimension = Number.isFinite(options?.maxDimension) && (options?.maxDimension || 0) > 0
         ? Math.floor(options?.maxDimension)
         : DEFAULT_MAX_DIMENSION;
-    if (file.size <= maxBytes) {
-        return { file, optimized: false, exceededLimit: false };
-    }
     if (!RESIZABLE_AVATAR_MIME_TYPES.has(file.type)) {
-        return { file, optimized: false, exceededLimit: true };
+        return { file, optimized: false, exceededLimit: file.size > maxBytes };
     }
     const image = await deps.loadImage(file);
     const longestEdge = Math.max(image.width, image.height, 1);
+    if (file.size <= maxBytes && longestEdge <= maxDimension) {
+        return { file, optimized: false, exceededLimit: false };
+    }
     const baseScale = Math.min(1, maxDimension / longestEdge);
     let bestBlob = null;
     for (const scaleStep of SCALE_STEPS) {

package/dist/utils/canonicalReferenceAttachments.d.ts

@@ -0,0 +1,12 @@
+import type { AttachmentItem } from '../types';
+import type { CanonicalEntityReference } from './entityReferences';
+type AttachmentReference = CanonicalEntityReference & {
+    kind: 'document' | 'image';
+};
+interface ResolveCanonicalAttachmentOptions {
+    workspaceId: string;
+    headers?: HeadersInit;
+    fetcher?: typeof fetch;
+}
+export declare function resolveCanonicalAttachmentReference(reference: AttachmentReference, options: ResolveCanonicalAttachmentOptions): Promise<AttachmentItem>;
+export {};

package/dist/utils/canonicalReferenceAttachments.js

@@ -0,0 +1,42 @@
+export async function resolveCanonicalAttachmentReference(reference, options) {
+    const fetcher = options.fetcher || fetch;
+    const query = new URLSearchParams({ workspaceId: options.workspaceId });
+    if (reference.kind === 'image') {
+        const response = await fetcher(`/api/taskforce/annotated-attachments/images/${encodeURIComponent(reference.token)}?${query.toString()}`, { credentials: 'include', headers: options.headers });
+        if (!response.ok)
+            throw new Error('Image not found');
+        const payload = await response.json();
+        const target = payload.target;
+        if (!target?.assetId || !target.path)
+            throw new Error('Image target is unavailable');
+        return {
+            path: target.path,
+            assetId: target.assetId,
+            displayName: target.displayName,
+            referenceNumber: reference.referenceNumber,
+            referenceLabel: target.imageReferenceLabel || reference.token,
+            linkRole: 'image',
+        };
+    }
+    const response = await fetcher(`/api/taskforce/documents?${query.toString()}`, {
+        credentials: 'include',
+        headers: options.headers,
+    });
+    if (!response.ok)
+        throw new Error('Document list unavailable');
+    const payload = await response.json();
+    const document = payload.documents?.find((entry) => (entry.referenceNumber === reference.referenceNumber
+        || String(entry.referenceLabel || '').toUpperCase() === reference.token));
+    if (!document?.apiUrl)
+        throw new Error('Document not found');
+    return {
+        path: document.apiUrl,
+        fsPath: document.fsPath,
+        assetId: document.assetId,
+        displayName: document.title,
+        originalFilename: document.originalFilename || undefined,
+        referenceNumber: reference.referenceNumber,
+        referenceLabel: document.referenceLabel || reference.token,
+        linkRole: 'reference',
+    };
+}

package/dist/utils/cloudAssetDisplay.d.ts

@@ -0,0 +1,2 @@
+export declare function withTaskforceCloudHint(url: string): string;
+export declare function resolveCloudAssetDisplayUrl(path: string): string;

package/dist/utils/cloudAssetDisplay.js

@@ -0,0 +1,8 @@
+export function withTaskforceCloudHint(url) {
+    const [base, hash = ''] = url.split('#');
+    const separator = base.includes('?') ? '&' : '?';
+    return `${base}${separator}taskforceCloud=1${hash ? `#${hash}` : ''}`;
+}
+export function resolveCloudAssetDisplayUrl(path) {
+    return /^https?:\/\//i.test(path) ? path : withTaskforceCloudHint(path);
+}

package/dist/utils/constants.d.ts

@@ -1,4 +1,5 @@
 import type { TaxonomyDefinition, TaxonomyOption, TaskStatus } from '../types';
+export { COLOR_PALETTE, PALETTE_ORDER, resolveColor } from '../shared/colorPalette.js';
 export declare const STORAGE_KEY = "taskforce-settings";
 export type StatusDefinition = TaxonomyOption & {
     value: TaskStatus;
@@ -7,28 +8,20 @@ export type StatusDefinition = TaxonomyOption & {
 export declare const STATUS_DEFINITIONS: StatusDefinition[];
 export declare const STATUS_SYSTEM_TAXONOMY: TaxonomyDefinition;
 export declare const STATUS_OPTIONS: {
-    value: "task" | "review" | "on-hold" | "in-progress" | "done" | "cancelled";
+    value: "task" | "on-hold" | "in-progress" | "review" | "done" | "cancelled";
     label: string;
     icon: string | undefined;
     color: string | undefined;
 }[];
 export declare function getStatusDefinition(status?: string | null): StatusDefinition;
-declare const curatedIcons: readonly ["Folder", "Code", "FileText", "Terminal", "Database", "Cpu", "Globe", "Layout", "Server", "Search", "Settings", "Zap", "Shield", "Star", "Layers", "Bug", "Box", "Book", "MessageSquare", "Image", "Music", "Video", "Map", "Mail", "Camera", "Heart", "Anchor", "Rocket", "Target", "Flag", "Bookmark", "Briefcase", "Puzzle", "SquareUserRound", "Users", "User", "Unplug", "Clock", "Lock", "Pencil", "TrafficCone", "CircleDollarSign", "Activity", "Wrench", "Microscope", "Palette", "Webhook", "FlaskConical", "Bot", "Cloud", "Kanban", "Infinity", "Monitor", "Smartphone", "History", "Brain", "Calendar", "Play", "Pause", "Sparkles", "Check", "Ban", "Circle", "CheckCircle", "Wind", "Github", "Square", "SquareCheck", "CheckSquare", "Package", "AlertCircle", "Lightbulb", "ScanSearch", "Inbox", "HelpCircle", "Gauge", "FileCode", "ArrowDown", "Minus", "ArrowUp", "AlertTriangle", "CircleQuestionMark", "TriangleAlert"];
+declare const curatedIcons: readonly ["Folder", "Code", "FileText", "Terminal", "Database", "Cpu", "Globe", "Layout", "Server", "Search", "Settings", "Zap", "Shield", "Star", "Layers", "Bug", "Box", "Book", "MessageSquare", "Image", "Music", "Video", "Map", "Mail", "Camera", "Heart", "Anchor", "Rocket", "Target", "Flag", "Bookmark", "Briefcase", "Puzzle", "SquareUserRound", "Users", "User", "Unplug", "Clock", "Lock", "Pencil", "TrafficCone", "CircleDollarSign", "Activity", "Wrench", "Microscope", "Palette", "Webhook", "FlaskConical", "Bot", "Cloud", "Kanban", "Infinity", "Monitor", "Smartphone", "History", "Brain", "Calendar", "Play", "Pause", "Sparkles", "Check", "Ban", "Circle", "CheckCircle", "Wind", "Github", "Square", "SquareCheck", "CheckSquare", "Package", "AlertCircle", "Lightbulb", "ClipboardCheck", "ScanSearch", "Inbox", "HelpCircle", "Gauge", "FileCode", "ArrowDown", "Minus", "ArrowUp", "AlertTriangle", "CircleQuestionMark", "TriangleAlert"];
 export type IconName = typeof curatedIcons[number];
 export declare const IconMap: Record<string, any>;
-export declare const AVAILABLE_ICONS: readonly ["Folder", "Code", "FileText", "Terminal", "Database", "Cpu", "Globe", "Layout", "Server", "Search", "Settings", "Zap", "Shield", "Star", "Layers", "Bug", "Box", "Book", "MessageSquare", "Image", "Music", "Video", "Map", "Mail", "Camera", "Heart", "Anchor", "Rocket", "Target", "Flag", "Bookmark", "Briefcase", "Puzzle", "SquareUserRound", "Users", "User", "Unplug", "Clock", "Lock", "Pencil", "TrafficCone", "CircleDollarSign", "Activity", "Wrench", "Microscope", "Palette", "Webhook", "FlaskConical", "Bot", "Cloud", "Kanban", "Infinity", "Monitor", "Smartphone", "History", "Brain", "Calendar", "Play", "Pause", "Sparkles", "Check", "Ban", "Circle", "CheckCircle", "Wind", "Github", "Square", "SquareCheck", "CheckSquare", "Package", "AlertCircle", "Lightbulb", "ScanSearch", "Inbox", "HelpCircle", "Gauge", "FileCode", "ArrowDown", "Minus", "ArrowUp", "AlertTriangle", "CircleQuestionMark", "TriangleAlert"];
+export declare const AVAILABLE_ICONS: readonly ["Folder", "Code", "FileText", "Terminal", "Database", "Cpu", "Globe", "Layout", "Server", "Search", "Settings", "Zap", "Shield", "Star", "Layers", "Bug", "Box", "Book", "MessageSquare", "Image", "Music", "Video", "Map", "Mail", "Camera", "Heart", "Anchor", "Rocket", "Target", "Flag", "Bookmark", "Briefcase", "Puzzle", "SquareUserRound", "Users", "User", "Unplug", "Clock", "Lock", "Pencil", "TrafficCone", "CircleDollarSign", "Activity", "Wrench", "Microscope", "Palette", "Webhook", "FlaskConical", "Bot", "Cloud", "Kanban", "Infinity", "Monitor", "Smartphone", "History", "Brain", "Calendar", "Play", "Pause", "Sparkles", "Check", "Ban", "Circle", "CheckCircle", "Wind", "Github", "Square", "SquareCheck", "CheckSquare", "Package", "AlertCircle", "Lightbulb", "ClipboardCheck", "ScanSearch", "Inbox", "HelpCircle", "Gauge", "FileCode", "ArrowDown", "Minus", "ArrowUp", "AlertTriangle", "CircleQuestionMark", "TriangleAlert"];
 export declare const TypeMeta: Record<string, {
     icon: string;
     color: string;
 }>;
-export declare const COLOR_PALETTE: Record<string, string>;
-export declare const PALETTE_ORDER: string[];
-/**
- * Resolves a color value to a valid CSS hex string.
- * Supports token IDs (e.g. 'red-500') and raw hex codes.
- */
-export declare function resolveColor(colorValue?: string): string | undefined;
 export declare function getTypeAccentColor(type?: string): string;
 export declare function getPriorityAccentColor(priority?: number | string): string;
 export declare function getFileTypeAccentColor(fileType?: string): string;
-export {};