@taskforcehq/taskforce 0.3.170 → 0.3.300

package/dist/utils/assignees.js

@@ -0,0 +1,132 @@
+export const TASK_ASSIGNEE_UNASSIGNED = 'unassigned';
+export const TASK_ASSIGNEE_AGENT = 'agent';
+const LEGACY_TASK_ASSIGNEE_USER = 'user';
+const OPAQUE_AI_PROFILE_ID_PATTERN = /^[0-9a-f]{8,}$/i;
+export function isAgentAssignee(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    return normalized === TASK_ASSIGNEE_AGENT || normalized === 'ai' || normalized.startsWith('ai-profile-');
+}
+export function isUnassignedAssignee(value) {
+    const normalized = String(value || '').trim().toLowerCase();
+    return !normalized
+        || normalized === TASK_ASSIGNEE_UNASSIGNED
+        || normalized === 'none'
+        || normalized === 'null'
+        || normalized === LEGACY_TASK_ASSIGNEE_USER;
+}
+export function getAssigneeKind(value) {
+    if (isAgentAssignee(value))
+        return 'agent';
+    if (isUnassignedAssignee(value))
+        return 'unassigned';
+    return 'member';
+}
+export function formatWorkspaceAssigneeLabel(candidate) {
+    const displayName = String(candidate.displayName || '').trim();
+    const email = String(candidate.email || '').trim().toLowerCase();
+    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',
+        },
+    ];
+}
+export function createWorkspaceAssigneeOptions(candidates) {
+    const deduped = new Map();
+    for (const candidate of candidates) {
+        const userId = String(candidate.userId || '').trim();
+        if (!userId)
+            continue;
+        deduped.set(userId, {
+            value: userId,
+            label: formatWorkspaceAssigneeLabel(candidate),
+            icon: 'User',
+            color: '#22c55e',
+            kind: 'member',
+        });
+    }
+    return mergeAssigneeOptions(Array.from(deduped.values()));
+}
+export function mergeAssigneeOptions(options) {
+    const deduped = new Map();
+    for (const option of createDefaultAssigneeOptions()) {
+        deduped.set(option.value, option);
+    }
+    for (const option of Array.isArray(options) ? options : []) {
+        const value = String(option?.value || '').trim();
+        if (!value || value === TASK_ASSIGNEE_UNASSIGNED || value === TASK_ASSIGNEE_AGENT)
+            continue;
+        deduped.set(value, {
+            value,
+            label: String(option.label || value).trim() || value,
+            icon: String(option.icon || (option.kind === 'agent' ? 'Bot' : 'User')),
+            color: String(option.color || (option.kind === 'agent' ? '#8b5cf6' : '#22c55e')),
+            kind: option.kind === 'agent' ? 'agent' : 'member',
+        });
+    }
+    const defaults = [TASK_ASSIGNEE_UNASSIGNED];
+    return Array.from(deduped.values()).sort((a, b) => {
+        const aIndex = defaults.indexOf(a.value);
+        const bIndex = defaults.indexOf(b.value);
+        if (aIndex >= 0 || bIndex >= 0) {
+            if (aIndex < 0)
+                return 1;
+            if (bIndex < 0)
+                return -1;
+            return aIndex - bIndex;
+        }
+        return a.label.localeCompare(b.label, undefined, { sensitivity: 'base' });
+    });
+}
+export function ensureAssigneeOptionPresent(options, assignee) {
+    const value = String(assignee || '').trim();
+    if (!value)
+        return options;
+    if (options.some((option) => option.value === value))
+        return options;
+    const cleanedLabel = value
+        .replace(/^ai-profile-/i, '')
+        .replace(/[-_]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    const fallbackLabel = cleanedLabel
+        ? cleanedLabel.split(' ').map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(' ')
+        : value;
+    if (getAssigneeKind(value) === 'agent') {
+        const isOpaqueProfileId = String(value).toLowerCase().startsWith('ai-profile-')
+            && cleanedLabel.split(' ').every((part) => OPAQUE_AI_PROFILE_ID_PATTERN.test(part));
+        return mergeAssigneeOptions([
+            ...options,
+            { value, label: isOpaqueProfileId ? 'AI' : (fallbackLabel || 'AI'), icon: 'Bot', color: '#8b5cf6', kind: 'agent' },
+        ]);
+    }
+    if (getAssigneeKind(value) === 'member') {
+        return mergeAssigneeOptions([
+            ...options,
+            { value, label: fallbackLabel || value, icon: 'User', color: '#22c55e', kind: 'member' },
+        ]);
+    }
+    return options;
+}
+export function normalizeAssigneeOptions(options) {
+    const next = Array.isArray(options) ? options.filter(Boolean) : [];
+    return mergeAssigneeOptions(next);
+}
+export function getAssigneeLabel(assignee, options) {
+    const value = String(assignee || '').trim();
+    const resolvedOptions = normalizeAssigneeOptions(options);
+    const matching = resolvedOptions.find((option) => option.value === value);
+    if (matching)
+        return matching.label;
+    if (isAgentAssignee(value))
+        return 'AI';
+    if (isUnassignedAssignee(value))
+        return 'Unassigned';
+    return value || 'Unassigned';
+}

package/dist/utils/canonicalAssetKind.d.ts

@@ -0,0 +1,16 @@
+export type CanonicalAssetKind = 'document' | 'image' | 'file';
+export declare function isCanonicalDocumentExtension(filePathRaw: string | null | undefined): boolean;
+export declare function isCanonicalDocumentMimeType(mimeTypeRaw: string | null | undefined): boolean;
+export declare function inferCanonicalAssetKind(filePathRaw: string | null | undefined, mimeTypeRaw: string | null | undefined, fallback?: CanonicalAssetKind): CanonicalAssetKind;
+export declare function isValidCanonicalDocumentAsset(params: {
+    kind: CanonicalAssetKind;
+    storageKey?: string | null;
+    originalFilename?: string | null;
+    mimeType?: string | null;
+}): boolean;
+export declare function normalizeCanonicalAssetKind(params: {
+    kind: CanonicalAssetKind;
+    storageKey?: string | null;
+    originalFilename?: string | null;
+    mimeType?: string | null;
+}): CanonicalAssetKind;

package/dist/utils/canonicalAssetKind.js

@@ -0,0 +1,39 @@
+import * as path from 'path';
+const CANONICAL_DOCUMENT_EXTENSIONS = new Set(['.md', '.markdown']);
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif', '.svg']);
+export function isCanonicalDocumentExtension(filePathRaw) {
+    const ext = path.extname(String(filePathRaw || '').trim()).toLowerCase();
+    return CANONICAL_DOCUMENT_EXTENSIONS.has(ext);
+}
+export function isCanonicalDocumentMimeType(mimeTypeRaw) {
+    const mimeType = String(mimeTypeRaw || '').trim().toLowerCase();
+    return mimeType === 'text/markdown';
+}
+export function inferCanonicalAssetKind(filePathRaw, mimeTypeRaw, fallback = 'file') {
+    const filePath = String(filePathRaw || '').trim();
+    const mimeType = String(mimeTypeRaw || '').trim().toLowerCase();
+    const ext = path.extname(filePath).toLowerCase();
+    if (mimeType.startsWith('image/'))
+        return 'image';
+    if (IMAGE_EXTENSIONS.has(ext))
+        return 'image';
+    if (isCanonicalDocumentExtension(filePath) || isCanonicalDocumentMimeType(mimeType))
+        return 'document';
+    return fallback;
+}
+export function isValidCanonicalDocumentAsset(params) {
+    if (params.kind !== 'document')
+        return false;
+    const filePath = String(params.originalFilename || params.storageKey || '').trim();
+    return isCanonicalDocumentExtension(filePath) || isCanonicalDocumentMimeType(params.mimeType);
+}
+export function normalizeCanonicalAssetKind(params) {
+    if (params.kind === 'image')
+        return 'image';
+    if (isValidCanonicalDocumentAsset(params))
+        return 'document';
+    if (params.kind === 'document') {
+        return inferCanonicalAssetKind(params.originalFilename || params.storageKey || '', params.mimeType || '', 'file');
+    }
+    return 'file';
+}

package/dist/utils/canonicalAssetKind.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/canonicalAssetKind.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { inferCanonicalAssetKind, isValidCanonicalDocumentAsset, normalizeCanonicalAssetKind } from './canonicalAssetKind';
+describe('canonicalAssetKind', () => {
+    it('treats markdown as canonical documents', () => {
+        expect(inferCanonicalAssetKind('plan.md', 'text/markdown')).toBe('document');
+        expect(inferCanonicalAssetKind('plan.markdown', 'application/octet-stream')).toBe('document');
+        expect(isValidCanonicalDocumentAsset({ kind: 'document', originalFilename: 'plan.md', mimeType: 'text/plain' })).toBe(true);
+    });
+    it('does not treat non-markdown files in document folders as canonical documents', () => {
+        expect(inferCanonicalAssetKind('workspaces/default/assets/documents/asset-doc-inline-missing-2-spec.pdf', 'application/pdf')).toBe('file');
+        expect(normalizeCanonicalAssetKind({
+            kind: 'document',
+            storageKey: 'workspaces/default/assets/documents/asset-sync-hello.txt',
+            originalFilename: 'hello.txt',
+            mimeType: 'text/plain'
+        })).toBe('file');
+        expect(isValidCanonicalDocumentAsset({
+            kind: 'document',
+            storageKey: 'workspaces/default/assets/documents/asset-sync-hello.txt',
+            originalFilename: 'hello.txt',
+            mimeType: 'text/plain'
+        })).toBe(false);
+    });
+});

package/dist/utils/coalescedRefresh.d.ts

@@ -0,0 +1,5 @@
+export declare function runCoalescedRefresh(inFlightRef: {
+    current: boolean;
+}, pendingRef: {
+    current: boolean;
+}, refresh: () => Promise<void>): Promise<void>;

package/dist/utils/coalescedRefresh.js

@@ -0,0 +1,16 @@
+export async function runCoalescedRefresh(inFlightRef, pendingRef, refresh) {
+    if (inFlightRef.current) {
+        pendingRef.current = true;
+        return;
+    }
+    inFlightRef.current = true;
+    try {
+        do {
+            pendingRef.current = false;
+            await refresh();
+        } while (pendingRef.current);
+    }
+    finally {
+        inFlightRef.current = false;
+    }
+}

package/dist/utils/coalescedRefresh.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/coalescedRefresh.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { runCoalescedRefresh } from './coalescedRefresh';
+describe('runCoalescedRefresh', () => {
+    it('coalesces overlapping refresh triggers into one follow-up run', async () => {
+        const inFlightRef = { current: false };
+        const pendingRef = { current: false };
+        const releaseQueue = [];
+        let refreshCalls = 0;
+        const refresh = async () => {
+            refreshCalls += 1;
+            await new Promise((resolve) => {
+                releaseQueue.push(resolve);
+            });
+        };
+        const firstRun = runCoalescedRefresh(inFlightRef, pendingRef, refresh);
+        expect(refreshCalls).toBe(1);
+        await runCoalescedRefresh(inFlightRef, pendingRef, refresh);
+        expect(refreshCalls).toBe(1);
+        expect(pendingRef.current).toBe(true);
+        releaseQueue.shift()?.();
+        await Promise.resolve();
+        await Promise.resolve();
+        expect(refreshCalls).toBe(2);
+        releaseQueue.shift()?.();
+        await firstRun;
+        expect(refreshCalls).toBe(2);
+        expect(inFlightRef.current).toBe(false);
+        expect(pendingRef.current).toBe(false);
+    });
+});

package/dist/utils/constants.d.ts

@@ -1,12 +1,22 @@
+import type { TaxonomyDefinition, TaxonomyOption, TaskStatus } from '../types';
 export declare const STORAGE_KEY = "taskforce-settings";
+export type StatusDefinition = TaxonomyOption & {
+    value: TaskStatus;
+    shortLabel?: string;
+};
+export declare const STATUS_DEFINITIONS: StatusDefinition[];
+export declare const STATUS_SYSTEM_TAXONOMY: TaxonomyDefinition;
 export declare const STATUS_OPTIONS: {
-    value: string;
+    value: "task" | "review" | "on-hold" | "in-progress" | "done" | "cancelled";
     label: string;
+    icon: string | undefined;
+    color: string | undefined;
 }[];
-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", "Inbox", "HelpCircle", "Gauge", "FileCode", "ArrowDown", "Minus", "ArrowUp", "AlertTriangle", "CircleQuestionMark", "TriangleAlert"];
+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"];
 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", "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", "ScanSearch", "Inbox", "HelpCircle", "Gauge", "FileCode", "ArrowDown", "Minus", "ArrowUp", "AlertTriangle", "CircleQuestionMark", "TriangleAlert"];
 export declare const TypeMeta: Record<string, {
     icon: string;
     color: string;
@@ -18,4 +28,7 @@ export declare const PALETTE_ORDER: 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 {};

package/dist/utils/constants.icons.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { AVAILABLE_ICONS, IconMap, TypeMeta } from './constants';
+import { AVAILABLE_ICONS, IconMap, STATUS_DEFINITIONS, TypeMeta } from './constants';
 import { DEFAULT_CONFIG } from '../types';
 function collectIcons(items) {
     return items
@@ -14,6 +14,7 @@ describe('icon registry coverage', () => {
             ...collectIcons(DEFAULT_CONFIG.categories),
             ...collectIcons(DEFAULT_CONFIG.priorities),
             ...collectIcons(DEFAULT_CONFIG.approaches),
+            ...collectIcons(STATUS_DEFINITIONS),
             // Schedule/hierarchy/assignee columns and form defaults used in the app.
             'Calendar',
             'Gauge',

package/dist/utils/constants.js

@@ -1,13 +1,35 @@
 import * as Icons from 'lucide-react';
+import { listBuiltInTaxonomyLibraryPacks } from '../shared/taxonomyLibrary.js';
 export const STORAGE_KEY = 'taskforce-settings';
-export const STATUS_OPTIONS = [
-    { value: 'task', label: 'To Do' },
-    { value: 'on-hold', label: 'Blocked' },
-    { value: 'in-progress', label: 'In Progress' },
-    { value: 'review', label: 'Ready for Review' },
-    { value: 'done', label: 'Completed' },
-    { value: 'cancelled', label: 'Cancelled' }
+export const STATUS_DEFINITIONS = [
+    { value: 'task', label: 'To Do', shortLabel: 'To Do', icon: 'Square', color: 'blue-200' },
+    { value: 'on-hold', label: 'Blocked', shortLabel: 'Blocked', icon: 'Pause', color: 'amber-500' },
+    { value: 'in-progress', label: 'Working', shortLabel: 'Working', icon: 'Play', color: 'blue-500' },
+    { value: 'review', label: 'Review', shortLabel: 'Review', icon: 'ScanSearch', color: 'violet-500' },
+    { value: 'done', label: 'Done', shortLabel: 'Done', icon: 'SquareCheck', color: 'green-500' },
+    { value: 'cancelled', label: 'Cancelled', shortLabel: 'Cancelled', icon: 'Ban', color: 'red-500' }
 ];
+export const STATUS_SYSTEM_TAXONOMY = {
+    id: 'status',
+    label: 'Status',
+    options: STATUS_DEFINITIONS,
+    widgetType: 'select',
+    isSystem: true,
+    multiSelect: false
+};
+export const STATUS_OPTIONS = STATUS_DEFINITIONS.map(({ value, label, icon, color }) => ({
+    value,
+    label,
+    icon,
+    color
+}));
+export function getStatusDefinition(status) {
+    const normalized = String(status || 'task').trim().toLowerCase();
+    if (normalized === 'completed') {
+        return STATUS_DEFINITIONS.find((item) => item.value === 'done') || STATUS_DEFINITIONS[0];
+    }
+    return STATUS_DEFINITIONS.find((item) => item.value === normalized) || STATUS_DEFINITIONS[0];
+}
 // Curated list of icons for categories.
 // Adding a name here automatically imports it and adds it to the list of choices in settings.
 const curatedIcons = [
@@ -18,6 +40,8 @@ const curatedIcons = [
     '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',
     // Used by built-in columns/taxonomies/defaults.
     'Inbox', 'HelpCircle', 'Gauge', 'FileCode',
     'ArrowDown', 'Minus', 'ArrowUp', 'AlertTriangle',
@@ -30,12 +54,23 @@ export const IconMap = curatedIcons.reduce((acc, name) => {
     return acc;
 }, {});
 export const AVAILABLE_ICONS = curatedIcons;
-export const TypeMeta = {
-    bug: { icon: 'Bug', color: 'red-500' },
-    feature: { icon: 'Star', color: 'teal-500' },
-    chore: { icon: 'Zap', color: 'amber-500' },
-    refactor: { icon: 'Code', color: 'blue-500' },
-    documentation: { icon: 'Book', color: 'sky-500' }
+export const TypeMeta = Object.fromEntries(listBuiltInTaxonomyLibraryPacks()
+    .flatMap((pack) => pack.types)
+    .filter((type) => type.icon && type.color)
+    .reduce((acc, type) => {
+    if (acc.some(([value]) => value === type.value))
+        return acc;
+    acc.push([type.value, { icon: type.icon, color: type.color }]);
+    return acc;
+}, []));
+const FILE_TYPE_COLOR_TOKENS = {
+    PDF: 'red-500',
+    DOC: 'blue-500',
+    DOCX: 'blue-500',
+    CSV: 'teal-500',
+    JSON: 'amber-500',
+    TXT: 'violet-200',
+    MD: 'violet-200',
 };
 // ------------------------------------------------------------------
 // Color Palette System (Token-based)
@@ -98,3 +133,25 @@ export function resolveColor(colorValue) {
     // Return as-is (legacy hex or other format)
     return colorValue;
 }
+export function getTypeAccentColor(type) {
+    const normalized = String(type || '').trim().toLowerCase();
+    return resolveColor(TypeMeta[normalized]?.color) || resolveColor('violet-200') || '#9c7aeb';
+}
+export function getPriorityAccentColor(priority) {
+    switch (Number(priority)) {
+        case 1:
+            return 'var(--text-muted)';
+        case 2:
+            return 'var(--text-secondary)';
+        case 3:
+            return 'var(--priority-high)';
+        case 4:
+            return 'var(--priority-critical)';
+        default:
+            return 'var(--text-secondary)';
+    }
+}
+export function getFileTypeAccentColor(fileType) {
+    const normalized = String(fileType || '').trim().toUpperCase();
+    return resolveColor(FILE_TYPE_COLOR_TOKENS[normalized]) || 'var(--text-muted)';
+}

package/dist/utils/contextAssetEvents.d.ts

@@ -0,0 +1,7 @@
+export declare const TASKFORCE_CONTEXT_ASSETS_MUTATED_EVENT = "taskforce:context-assets-mutated";
+export interface TaskforceContextAssetsMutatedDetail {
+    workspaceId?: string | null;
+    taskId?: string | null;
+    reason?: 'upload' | 'delete' | 'update';
+}
+export declare function dispatchTaskforceContextAssetsMutated(detail: TaskforceContextAssetsMutatedDetail): void;

package/dist/utils/contextAssetEvents.js

@@ -0,0 +1,6 @@
+export const TASKFORCE_CONTEXT_ASSETS_MUTATED_EVENT = 'taskforce:context-assets-mutated';
+export function dispatchTaskforceContextAssetsMutated(detail) {
+    if (typeof window === 'undefined' || typeof window.dispatchEvent !== 'function')
+        return;
+    window.dispatchEvent(new CustomEvent(TASKFORCE_CONTEXT_ASSETS_MUTATED_EVENT, { detail }));
+}

package/dist/utils/contextFiles.d.ts

@@ -1,8 +1,19 @@
 export interface OpenMarkdownEditorDetail {
     path: string;
     fsPath: string;
+    assetId?: string;
 }
+type MarkdownOpenTarget = string | {
+    path: string;
+    fsPath?: string;
+    assetId?: string;
+    caption?: string;
+    displayName?: string;
+    originalFilename?: string;
+};
 export declare function extractContextLinkedPath(sourcePath: string): string | null;
-export declare function resolveContextFsPath(sourcePath: string, fsPath?: string): string | null;
-export declare function isMarkdownContextFile(sourcePath: string, fsPath?: string): boolean;
-export declare function dispatchOpenMarkdownDocument(sourcePath: string, fsPath?: string): boolean;
+export declare function resolveContextFsPath(target: MarkdownOpenTarget, fsPath?: string): string | null;
+export declare function resolveContextAssetId(target: MarkdownOpenTarget, assetId?: string): string | null;
+export declare function isMarkdownContextFile(target: MarkdownOpenTarget, fsPath?: string): boolean;
+export declare function dispatchOpenMarkdownDocument(target: MarkdownOpenTarget, fsPath?: string): boolean;
+export {};

package/dist/utils/contextFiles.js

@@ -4,6 +4,21 @@ function normalizeCandidate(value) {
 function stripQueryAndHash(value) {
     return value.split('?')[0].split('#')[0];
 }
+function resolveSourcePath(target) {
+    return typeof target === 'string' ? target : String(target.path || '').trim();
+}
+function extractDocumentAssetIdFromApiPath(sourcePath) {
+    const normalized = stripQueryAndHash(normalizeCandidate(sourcePath));
+    const match = normalized.match(/\/api\/taskforce\/documents\/([^/]+)\/content$/i);
+    if (!match?.[1])
+        return null;
+    try {
+        return decodeURIComponent(match[1]).trim() || null;
+    }
+    catch {
+        return match[1].trim() || null;
+    }
+}
 export function extractContextLinkedPath(sourcePath) {
     if (!sourcePath.includes('/api/taskforce/context-link?path='))
         return null;
@@ -16,16 +31,30 @@ export function extractContextLinkedPath(sourcePath) {
         return null;
     }
 }
-export function resolveContextFsPath(sourcePath, fsPath) {
-    const normalizedFsPath = (fsPath || '').trim();
+export function resolveContextFsPath(target, fsPath) {
+    const normalizedFsPath = (fsPath || (typeof target === 'string' ? '' : target.fsPath || '')).trim();
     if (normalizedFsPath)
         return normalizeCandidate(normalizedFsPath);
+    const sourcePath = resolveSourcePath(target);
     const linkedPath = extractContextLinkedPath(sourcePath);
     return linkedPath ? normalizeCandidate(linkedPath) : null;
 }
-export function isMarkdownContextFile(sourcePath, fsPath) {
+export function resolveContextAssetId(target, assetId) {
+    const explicitAssetId = String(assetId || (typeof target === 'string' ? '' : target.assetId || '')).trim();
+    if (explicitAssetId)
+        return explicitAssetId;
+    const sourcePath = resolveSourcePath(target);
+    return extractDocumentAssetIdFromApiPath(sourcePath);
+}
+export function isMarkdownContextFile(target, fsPath) {
+    const sourcePath = resolveSourcePath(target);
+    if (extractDocumentAssetIdFromApiPath(sourcePath))
+        return true;
     const candidates = [
-        (fsPath || '').trim(),
+        (fsPath || (typeof target === 'string' ? '' : target.fsPath || '')).trim(),
+        typeof target === 'string' ? '' : String(target.originalFilename || '').trim(),
+        typeof target === 'string' ? '' : String(target.displayName || '').trim(),
+        typeof target === 'string' ? '' : String(target.caption || '').trim(),
         extractContextLinkedPath(sourcePath) || '',
         sourcePath
     ];
@@ -36,16 +65,19 @@ export function isMarkdownContextFile(sourcePath, fsPath) {
         return normalized.endsWith('.md') || normalized.endsWith('.markdown');
     });
 }
-export function dispatchOpenMarkdownDocument(sourcePath, fsPath) {
-    const resolvedFsPath = resolveContextFsPath(sourcePath, fsPath);
+export function dispatchOpenMarkdownDocument(target, fsPath) {
+    const sourcePath = resolveSourcePath(target);
+    const resolvedFsPath = resolveContextFsPath(target, fsPath);
     if (!resolvedFsPath)
         return false;
-    if (!isMarkdownContextFile(sourcePath, resolvedFsPath))
+    if (!isMarkdownContextFile(target, resolvedFsPath))
         return false;
+    const assetId = resolveContextAssetId(target);
     const event = new CustomEvent('taskforce:open-markdown-document', {
         detail: {
             path: sourcePath,
-            fsPath: resolvedFsPath
+            fsPath: resolvedFsPath,
+            ...(assetId ? { assetId } : {})
         },
         cancelable: true
     });

package/dist/utils/documentManagerApi.d.ts

@@ -0,0 +1,6 @@
+export declare function resolveDocumentManagerApiBase(params: {
+    runtimeMode: 'local' | 'cloud';
+    apiBaseUrl?: string;
+    cloudAuthBaseUrl?: string;
+}): string;
+export declare function logDocumentManagerDebug(event: string, details: Record<string, unknown>): void;

package/dist/utils/documentManagerApi.js

@@ -0,0 +1,19 @@
+function normalizeBaseUrl(value) {
+    return typeof value === 'string' ? value.trim().replace(/\/+$/, '') : '';
+}
+export function resolveDocumentManagerApiBase(params) {
+    if (params.runtimeMode === 'local') {
+        return '';
+    }
+    return normalizeBaseUrl(params.apiBaseUrl) || normalizeBaseUrl(params.cloudAuthBaseUrl) || '';
+}
+export function logDocumentManagerDebug(event, details) {
+    if (!import.meta.env.DEV)
+        return;
+    try {
+        console.debug(`[DocumentManager] ${event}`, details);
+    }
+    catch {
+        // Best-effort diagnostics only.
+    }
+}

package/dist/utils/documentNames.d.ts

@@ -0,0 +1,24 @@
+export declare function isGeneratedDocumentName(value: string | null | undefined, assetId?: string | null): boolean;
+export declare function getCanonicalDocumentName(input: {
+    logicalName?: string | null;
+    displayName?: string | null;
+    title?: string | null;
+    originalFilename?: string | null;
+    fsPath?: string | null;
+    assetId?: string | null;
+}): string;
+export declare function getReadableDocumentName(doc: {
+    logicalName?: string | null;
+    displayName?: string | null;
+    title?: string | null;
+    originalFilename?: string | null;
+    fsPath?: string | null;
+    assetId?: string | null;
+}): string;
+export declare function getDocumentDownloadName(doc: {
+    displayName?: string | null;
+    title?: string | null;
+    originalFilename?: string | null;
+    fsPath?: string | null;
+    assetId?: string | null;
+}): string;