@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/compat/taskforceAgentDefinitionCompat.d.ts

@@ -0,0 +1,12 @@
+import { type LegacyTaskforceAgentDefinitionInput, type LegacyTaskforceAgentDefinitionMigration } from '../migrations/taskforceAgentDefinitionMigration.js';
+export declare function migrateLegacyTaskforceAgentWrite(input: LegacyTaskforceAgentDefinitionInput): LegacyTaskforceAgentDefinitionMigration;
+export interface LegacyTaskforceAgentResponseProjection {
+    name: string;
+    modelProvider: string;
+    providerKey: string;
+    modelKey: string;
+    modelTier: string;
+    systemPrompt: string;
+    enabled: boolean;
+}
+export declare function projectLegacyTaskforceAgentResponse(agent: LegacyTaskforceAgentResponseProjection): LegacyTaskforceAgentResponseProjection;

package/dist/compat/taskforceAgentDefinitionCompat.js

@@ -0,0 +1,25 @@
+import { MIGRATION_COMPAT_ENABLED } from '../runtime/migrationFlags.js';
+import { migrateLegacyTaskforceAgentDefinition, } from '../migrations/taskforceAgentDefinitionMigration.js';
+export function migrateLegacyTaskforceAgentWrite(input) {
+    // COMPAT_TRACK: taskforce-agent-definition-v1-legacy-flat-records
+    // COMPAT_REMOVE_AFTER: v0.4.0
+    if (!MIGRATION_COMPAT_ENABLED) {
+        const error = new Error('Legacy Taskforce Agent configuration writes are disabled.');
+        error.code = 'TASKFORCE_AGENT_LEGACY_WRITE_DISABLED';
+        throw error;
+    }
+    return migrateLegacyTaskforceAgentDefinition(input);
+}
+export function projectLegacyTaskforceAgentResponse(agent) {
+    // COMPAT_TRACK: taskforce-agent-definition-v1-legacy-flat-records
+    // COMPAT_REMOVE_AFTER: v0.4.0
+    return {
+        name: agent.name,
+        modelProvider: agent.modelProvider,
+        providerKey: agent.providerKey,
+        modelKey: agent.modelKey,
+        modelTier: agent.modelTier,
+        systemPrompt: agent.systemPrompt,
+        enabled: agent.enabled,
+    };
+}

package/dist/compat/workspaceSyncCompat.js

@@ -1,5 +1,5 @@
 import { MIGRATION_COMPAT_ENABLED } from '../runtime/migrationFlags.js';
-import { createDefaultWorkspaceSyncState } from '../sync/workspaceSyncState.js';
+import { createDefaultWorkspaceSyncState, normalizeWorkspaceSyncStateRevision } from '../sync/workspaceSyncState.js';
 function normalizeTimestamp(value) {
     const normalized = String(value || '').trim();
     return normalized.length > 0 ? normalized : null;
@@ -37,6 +37,7 @@ function normalizePushBaseline(value) {
         taskIds: normalizeIdEntries(raw.taskIds),
         taskWatermarks: normalizeEntries('taskWatermarks'),
         taskChangeKeys: normalizeEntries('taskChangeKeys'),
+        taskRelationshipChangeKeys: normalizeEntries('taskRelationshipChangeKeys'),
         initiativeWatermarks: normalizeEntries('initiativeWatermarks'),
         workstreamWatermarks: normalizeEntries('workstreamWatermarks'),
         aiProfileWatermarks: normalizeEntries('aiProfileWatermarks'),
@@ -47,7 +48,8 @@ function normalizePushBaseline(value) {
         documentReviewCommentWatermarks: normalizeEntries('documentReviewCommentWatermarks'),
         annotatedAttachmentSessionWatermarks: normalizeEntries('annotatedAttachmentSessionWatermarks'),
         taskEventWatermarks: normalizeEntries('taskEventWatermarks'),
-        taxonomyStateFingerprint: String(raw.taxonomyStateFingerprint || '').trim()
+        taxonomyStateFingerprint: String(raw.taxonomyStateFingerprint || '').trim(),
+        taxonomyChangeKey: String(raw.taxonomyChangeKey || '')
     };
 }
 function resolveLegacyPhase(input, base) {
@@ -90,6 +92,7 @@ export function normalizeWorkspaceSyncStateCompat(rawState) {
         : null;
     const normalized = {
         version: 2,
+        revision: normalizeWorkspaceSyncStateRevision(state.revision),
         enabled: Boolean(state.enabled ?? state.cloudSyncEnabled),
         phase: 'idle',
         setupIntent: normalizeSetupIntent(state.setupIntent),
@@ -114,6 +117,7 @@ export function normalizeWorkspaceSyncStateCompat(rawState) {
     }
     const currentVersion = Number(state.version || 0);
     const changed = currentVersion !== 2
+        || JSON.stringify(normalizeWorkspaceSyncStateRevision(state.revision)) !== JSON.stringify(normalized.revision)
         || Boolean(state.enabled ?? state.cloudSyncEnabled) !== normalized.enabled
         || String(state.phase || '').trim() !== normalized.phase
         || normalizeSetupIntent(state.setupIntent) !== normalized.setupIntent

package/dist/compat/workspaceSyncV3CombinedCoverageCompat.d.ts

@@ -0,0 +1,6 @@
+export type WorkspaceSyncV3CombinedCoverageCompatibility = 'upgrade-required' | 'invalid';
+export declare function classifyWorkspaceSyncV3CombinedCoverageCompat(input: {
+    coverageProfileId: unknown;
+    coverageVersion: unknown;
+    coverageDigest: unknown;
+}): WorkspaceSyncV3CombinedCoverageCompatibility;

package/dist/compat/workspaceSyncV3CombinedCoverageCompat.js

@@ -0,0 +1,22 @@
+import { MIGRATION_COMPAT_ENABLED } from '../runtime/migrationFlags.js';
+const LEGACY_COMBINED_COVERAGE = Object.freeze([
+    Object.freeze({
+        coverageProfileId: 'task-planning-metadata', coverageVersion: 1,
+        coverageDigest: 'ca7fcd57f50f0599f8ca8c21697d8c22ec46d0c2b07ce8e48c5efc9776863786',
+    }),
+    Object.freeze({
+        coverageProfileId: 'task-planning-metadata', coverageVersion: 2,
+        coverageDigest: 'ee36e72c8363db4be1ad750cc4ebb3e051274ad3c59c48a4e61cc401249ec63c',
+    }),
+]);
+export function classifyWorkspaceSyncV3CombinedCoverageCompat(input) {
+    if (!MIGRATION_COMPAT_ENABLED)
+        return 'invalid';
+    // COMPAT_TRACK: workspace-sync-v3-combined-coverage-v1-v2
+    // COMPAT_REMOVE_AFTER: v0.3.340
+    return LEGACY_COMBINED_COVERAGE.some((coverage) => input.coverageProfileId === coverage.coverageProfileId
+        && Number(input.coverageVersion) === coverage.coverageVersion
+        && input.coverageDigest === coverage.coverageDigest)
+        ? 'upgrade-required'
+        : 'invalid';
+}

package/dist/compat/workspaceSyncV3OperationCompat.d.ts

@@ -0,0 +1,7 @@
+export type WorkspaceSyncV3TaskMetadataRevisionCompat = {
+    authoritativeSequence: unknown;
+    operationHighWatermark: unknown;
+    activityRevision: unknown;
+    legacySingleEntry: boolean;
+};
+export declare function normalizeWorkspaceSyncV3TaskActivityRevisionCompat(response: Record<string, unknown>, authoritative: Record<string, unknown>): WorkspaceSyncV3TaskMetadataRevisionCompat;

package/dist/compat/workspaceSyncV3OperationCompat.js

@@ -0,0 +1,30 @@
+import { MIGRATION_COMPAT_ENABLED } from '../runtime/migrationFlags.js';
+export function normalizeWorkspaceSyncV3TaskActivityRevisionCompat(response, authoritative) {
+    const hasAuthoritativeSequence = Object.prototype.hasOwnProperty.call(authoritative, 'sequence');
+    const hasOperationHighWatermark = Object.prototype.hasOwnProperty.call(response, 'operationHighWatermark');
+    const hasActivityRevision = Object.prototype.hasOwnProperty.call(response, 'activityRevision');
+    if (hasAuthoritativeSequence || hasOperationHighWatermark || hasActivityRevision) {
+        return {
+            authoritativeSequence: authoritative.sequence,
+            operationHighWatermark: response.operationHighWatermark,
+            activityRevision: response.activityRevision,
+            legacySingleEntry: false,
+        };
+    }
+    if (!MIGRATION_COMPAT_ENABLED) {
+        return {
+            authoritativeSequence: undefined,
+            operationHighWatermark: undefined,
+            activityRevision: undefined,
+            legacySingleEntry: false,
+        };
+    }
+    // COMPAT_TRACK: workspace-sync-v3-task-activity-revision
+    // COMPAT_REMOVE_AFTER: v0.3.330
+    return {
+        authoritativeSequence: response.acceptedSequence,
+        operationHighWatermark: response.acceptedSequence,
+        activityRevision: null,
+        legacySingleEntry: true,
+    };
+}

package/dist/components/activity/EntityActivityTimeline.d.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import type { TaskReferenceContract } from '../../utils/taskReferences';
 import { type TaskEventValueFormatter } from '../../utils/taskActivity';
 import type { EntityActivityItem, TaskActor } from '../../types';
 export type ActivityActorPresentation = {
@@ -9,8 +10,10 @@ export type ActivityActorPresentation = {
         size?: number;
         strokeWidth?: number;
     }>;
+    isCurrentActorHint?: boolean;
+    description?: string;
 };
-export declare function EntityActivityTimeline({ activity, comments, formatFieldValue, resolveActorPresentation, onOpenTaskById, emptyMessage, listClassName, emptyClassName, endRef, }: {
+export declare function EntityActivityTimeline({ activity, comments, formatFieldValue, resolveActorPresentation, currentActorId, taskReferences, emptyMessage, listClassName, emptyClassName, listRef, endRef, onScroll, targetEntryId, targetEntryRef, }: {
     activity?: EntityActivityItem[];
     comments?: Array<{
         id: string;
@@ -26,9 +29,14 @@ export declare function EntityActivityTimeline({ activity, comments, formatField
         actorProfile?: TaskActor | null;
         fallbackKind?: 'member' | 'agent' | 'system';
     }) => ActivityActorPresentation;
-    onOpenTaskById?: (taskId: string) => void;
+    currentActorId?: string | null;
+    taskReferences?: TaskReferenceContract;
     emptyMessage?: string;
     listClassName?: string;
     emptyClassName?: string;
+    listRef?: React.Ref<HTMLDivElement>;
     endRef?: React.Ref<HTMLDivElement>;
+    onScroll?: React.UIEventHandler<HTMLDivElement>;
+    targetEntryId?: string | null;
+    targetEntryRef?: React.Ref<HTMLDivElement>;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/components/activity/EntityActivityTimeline.js

@@ -4,24 +4,31 @@ import { Markdown } from '../ui/Markdown';
 import { formatDate } from '../../utils/formatting';
 import { getEntityActivityItems, getEntityEventPrimaryChangeField, summarizeEntityEvent, summarizeTaskChange, } from '../../utils/taskActivity';
 import timelineStyles from './EntityActivityTimeline.module.css';
-function hexToRgba(hex, opacity) {
-    const normalized = hex.replace('#', '').trim();
-    if (normalized.length !== 3 && normalized.length !== 6)
-        return '';
-    const expanded = normalized.length === 3
-        ? normalized.split('').map((part) => part + part).join('')
-        : normalized;
-    const int = Number.parseInt(expanded, 16);
-    if (Number.isNaN(int))
-        return '';
-    const red = (int >> 16) & 255;
-    const green = (int >> 8) & 255;
-    const blue = int & 255;
-    return `rgba(${red}, ${green}, ${blue}, ${opacity})`;
-}
-export function EntityActivityTimeline({ activity, comments, formatFieldValue, resolveActorPresentation, onOpenTaskById, emptyMessage = 'No activity yet.', listClassName, emptyClassName, endRef, }) {
+export function EntityActivityTimeline({ activity, comments, formatFieldValue, resolveActorPresentation, currentActorId, taskReferences, emptyMessage = 'No activity yet.', listClassName, emptyClassName, listRef, endRef, onScroll, targetEntryId, targetEntryRef, }) {
     const items = React.useMemo(() => getEntityActivityItems({ activity, comments }), [activity, comments]);
-    return (_jsxs("div", { className: [timelineStyles.thread, listClassName].filter(Boolean).join(' '), children: [items.length === 0 ? (_jsx("div", { className: [timelineStyles.empty, emptyClassName].filter(Boolean).join(' '), children: emptyMessage })) : null, items.map((item) => {
+    const normalizedCurrentActorId = String(currentActorId || '').trim().toLowerCase();
+    const normalizedTargetEntryId = String(targetEntryId || '').trim();
+    const hasKnownCurrentActor = normalizedCurrentActorId !== '' && normalizedCurrentActorId !== 'anonymous';
+    const currentActorPresentation = React.useMemo(() => hasKnownCurrentActor
+        ? resolveActorPresentation({
+            actorId: currentActorId,
+            actorType: 'human',
+            fallbackKind: 'member',
+        })
+        : null, [currentActorId, hasKnownCurrentActor, resolveActorPresentation]);
+    const currentActorLabel = String(currentActorPresentation?.label || '').trim();
+    const normalizedCurrentActorLabel = currentActorLabel.toLowerCase();
+    const hasCanonicalCurrentActorLabel = Boolean(currentActorPresentation?.kind === 'member' &&
+        currentActorLabel &&
+        normalizedCurrentActorLabel !== 'you' &&
+        normalizedCurrentActorLabel !== 'user' &&
+        normalizedCurrentActorLabel !== 'human' &&
+        normalizedCurrentActorLabel !== normalizedCurrentActorId);
+    return (_jsxs("div", { ref: listRef, className: [timelineStyles.thread, listClassName].filter(Boolean).join(' '), onScroll: onScroll, children: [items.length === 0 ? (_jsx("div", { className: [timelineStyles.empty, emptyClassName].filter(Boolean).join(' '), children: emptyMessage })) : null, items.map((item) => {
+                const isTargetEntry = Boolean(normalizedTargetEntryId
+                    && (item.id === normalizedTargetEntryId
+                        || (item.type === 'comment' && item.comment.id === normalizedTargetEntryId)
+                        || (item.type === 'event' && item.event.id === normalizedTargetEntryId)));
                 if (item.type === 'comment') {
                     const actorPresentation = resolveActorPresentation({
                         actorId: item.comment.author,
@@ -32,25 +39,56 @@ export function EntityActivityTimeline({ activity, comments, formatFieldValue, r
                                 : null,
                         actorProfile: item.comment.actor || null,
                     });
-                    const commentKind = actorPresentation.kind === 'agent' ? 'agent' : 'member';
+                    const commentKind = actorPresentation.kind === 'agent'
+                        ? 'agent'
+                        : actorPresentation.kind === 'system'
+                            ? 'system'
+                            : 'member';
+                    const normalizedCommentAuthor = String(item.comment.author || '').trim().toLowerCase();
+                    const normalizedProfileId = String(item.comment.actor?.id || '').trim().toLowerCase();
+                    const commentActorIds = [normalizedCommentAuthor, normalizedProfileId]
+                        .map((value) => String(value || '').trim().toLowerCase())
+                        .filter(Boolean);
+                    const hasExplicitActorIdentity = Boolean((normalizedProfileId &&
+                        normalizedProfileId !== 'user' &&
+                        normalizedProfileId !== 'human') ||
+                        (normalizedCommentAuthor &&
+                            normalizedCommentAuthor !== 'user' &&
+                            normalizedCommentAuthor !== 'human'));
+                    const isCurrentActor = hasKnownCurrentActor
+                        ? hasExplicitActorIdentity
+                            ? commentActorIds.includes(normalizedCurrentActorId)
+                            : actorPresentation.isCurrentActorHint === true
+                        : commentKind === 'member';
+                    const authorLabel = isCurrentActor &&
+                        actorPresentation.label.trim().toLowerCase() === 'you' &&
+                        hasCanonicalCurrentActorLabel
+                        ? currentActorLabel
+                        : actorPresentation.label;
                     const { ActorIcon } = actorPresentation;
-                    const authorColor = actorPresentation.color;
-                    const commentAccentStyle = authorColor && hexToRgba(authorColor, 0.35)
-                        ? {
-                            background: `linear-gradient(135deg, ${hexToRgba(authorColor, 0.18)} 0%, ${hexToRgba(authorColor, 0.1)} 100%)`,
-                            borderColor: hexToRgba(authorColor, 0.35),
-                        }
+                    const authorColor = actorPresentation.kind === 'system'
+                        ? undefined
+                        : actorPresentation.color;
+                    const commentAccentStyle = authorColor
+                        ? { '--conversation-accent': authorColor }
                         : undefined;
-                    return (_jsxs("div", { className: [
+                    return (_jsxs("div", { ref: isTargetEntry ? targetEntryRef : undefined, tabIndex: isTargetEntry ? -1 : undefined, "data-activity-entry-id": item.id, "data-activity-targeted": isTargetEntry ? 'true' : undefined, "data-conversation-role": commentKind === 'agent'
+                            ? 'assistant'
+                            : commentKind === 'system'
+                                ? 'system'
+                                : 'user', "data-conversation-side": isCurrentActor ? 'outgoing' : 'incoming', style: commentAccentStyle, className: [
                             timelineStyles.item,
                             timelineStyles.comment,
-                            commentKind === 'agent' ? timelineStyles.commentAgent : timelineStyles.commentMember,
-                        ].join(' '), children: [_jsxs("div", { className: timelineStyles.header, children: [_jsxs("span", { className: timelineStyles.author, style: authorColor ? { color: authorColor } : undefined, children: [_jsx(ActorIcon, { size: 12, strokeWidth: 1.5 }), actorPresentation.label] }), _jsx("span", { className: timelineStyles.time, children: formatDate(item.comment.timestamp, {
+                            commentKind === 'system' ? timelineStyles.commentSystem : '',
+                            isCurrentActor ? timelineStyles.commentCurrentActor : timelineStyles.commentOtherActor,
+                        ].join(' '), children: [_jsxs("div", { className: timelineStyles.header, children: [_jsxs("span", { className: timelineStyles.author, style: authorColor ? { color: authorColor } : undefined, title: actorPresentation.description, "aria-label": actorPresentation.description
+                                            ? `${authorLabel}. ${actorPresentation.description}`
+                                            : undefined, children: [_jsx(ActorIcon, { size: 12, strokeWidth: 1.5 }), authorLabel] }), _jsx("time", { className: timelineStyles.time, dateTime: item.comment.timestamp, children: formatDate(item.comment.timestamp, {
                                             month: 'short',
                                             day: 'numeric',
                                             hour: '2-digit',
                                             minute: '2-digit',
-                                        }) })] }), _jsx("div", { className: timelineStyles.commentText, style: commentAccentStyle, children: _jsx(Markdown, { onTaskIdClick: onOpenTaskById, children: item.comment.text }) })] }, item.id));
+                                        }) })] }), _jsx("div", { className: timelineStyles.commentText, children: _jsx(Markdown, { variant: "conversation", taskReferences: taskReferences, children: item.comment.text }) })] }, item.id));
                 }
                 const actorPresentation = resolveActorPresentation({
                     actorId: item.event.actor,
@@ -67,15 +105,15 @@ export function EntityActivityTimeline({ activity, comments, formatFieldValue, r
                     : changeEntries.length > 1
                         ? changeEntries
                         : [];
-                return (_jsxs("div", { className: [
+                return (_jsx("div", { ref: isTargetEntry ? targetEntryRef : undefined, tabIndex: isTargetEntry ? -1 : undefined, "data-activity-entry-id": item.id, "data-activity-targeted": isTargetEntry ? 'true' : undefined, className: [
                         timelineStyles.item,
                         timelineStyles.event,
                         actorPresentation.kind === 'system' ? timelineStyles.eventSystem : '',
-                    ].filter(Boolean).join(' '), children: [_jsxs("div", { className: [timelineStyles.header, timelineStyles.eventHeader].join(' '), children: [_jsxs("span", { className: timelineStyles.author, style: authorColor ? { color: authorColor } : undefined, children: [_jsx(ActorIcon, { size: 12, strokeWidth: 1.5 }), actorPresentation.label] }), _jsx("span", { className: timelineStyles.time, children: formatDate(item.event.createdAt, {
-                                        month: 'short',
-                                        day: 'numeric',
-                                        hour: '2-digit',
-                                        minute: '2-digit',
-                                    }) })] }), _jsxs("div", { className: timelineStyles.eventText, children: [_jsx("div", { children: summarizeEntityEvent(item.event, formatFieldValue) }), displayedChangeEntries.length > 0 ? (_jsx("div", { className: timelineStyles.eventChanges, children: displayedChangeEntries.map(([field, change]) => (_jsx("div", { className: timelineStyles.eventChange, children: summarizeTaskChange(field, change, formatFieldValue) }, field))) })) : null] })] }, item.id));
+                    ].filter(Boolean).join(' '), children: _jsxs("div", { className: timelineStyles.eventMain, children: [_jsxs("span", { className: timelineStyles.author, style: authorColor ? { color: authorColor } : undefined, children: [_jsx(ActorIcon, { size: 12, strokeWidth: 1.5 }), actorPresentation.label] }), _jsxs("div", { className: timelineStyles.eventText, children: [_jsx("div", { children: summarizeEntityEvent(item.event, formatFieldValue) }), displayedChangeEntries.length > 0 ? (_jsx("div", { className: timelineStyles.eventChanges, children: displayedChangeEntries.map(([field, change]) => (_jsx("div", { className: timelineStyles.eventChange, children: summarizeTaskChange(field, change, formatFieldValue) }, field))) })) : null] }), _jsx("time", { className: timelineStyles.time, dateTime: item.event.createdAt, children: formatDate(item.event.createdAt, {
+                                    month: 'short',
+                                    day: 'numeric',
+                                    hour: '2-digit',
+                                    minute: '2-digit',
+                                }) })] }) }, item.id));
             }), _jsx("div", { ref: endRef })] }));
 }

package/dist/components/context/AttachmentPreviewHost.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface AttachmentPreviewHostProps {
+    theme?: string;
+}
+export declare function AttachmentPreviewHost({ theme }: AttachmentPreviewHostProps): React.ReactPortal | null;
+export {};

package/dist/components/context/AttachmentPreviewHost.js

@@ -0,0 +1,222 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useId, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { Download, ExternalLink, FileText, Image as ImageIcon, PencilLine, X } from 'lucide-react';
+import { CONTEXT_ATTACHMENT_PREVIEW_EVENT, } from '../../utils/contextAttachmentPreview';
+import { canOpenAnnotatedAttachment, dispatchOpenAnnotatedAttachment } from '../../utils/annotatedAttachments';
+import { dispatchOpenMarkdownDocument, isMarkdownContextFile } from '../../utils/contextFiles';
+import { getDocumentReferenceLabel } from '../../utils/documentReferences';
+import { getImageReferenceLabel } from '../../utils/imageReferences';
+import { Markdown } from '../ui/Markdown';
+import { ReferenceBadgeButton } from '../ui/ReferenceBadgeButton';
+import styles from './AttachmentPreviewHost.module.css';
+const TEXT_PREVIEW_PATTERN = /\.(?:md|markdown|txt|csv|json|js|ts|tsx|css|py|java|go|rs|sh)(?:[?#]|$)/i;
+const IMAGE_PREVIEW_PATTERN = /\.(?:png|jpe?g|webp|gif)(?:[?#]|$)/i;
+const PDF_PREVIEW_PATTERN = /\.pdf(?:[?#]|$)/i;
+function getAttachmentPath(attachment) {
+    return typeof attachment === 'string' ? attachment : attachment.path;
+}
+function getAttachmentName(attachment) {
+    if (typeof attachment === 'string')
+        return attachment.split('/').pop() || 'Context attachment';
+    return attachment.caption
+        || attachment.displayName
+        || attachment.originalFilename
+        || attachment.fsPath?.split('/').pop()
+        || attachment.path.split('/').pop()
+        || 'Context attachment';
+}
+function getAttachmentTypeCandidates(attachment) {
+    if (typeof attachment === 'string')
+        return [attachment];
+    return [
+        attachment.path,
+        attachment.fsPath,
+        attachment.originalFilename,
+        attachment.displayName,
+        attachment.caption,
+    ].filter((value) => Boolean(value));
+}
+function buildDownloadUrl(path, name) {
+    const separator = path.includes('?') ? '&' : '?';
+    return `${path}${separator}download=1&filename=${encodeURIComponent(name)}`;
+}
+function buildManagerTarget(detail) {
+    if (detail.ownerType !== 'task')
+        return detail.attachment;
+    if (typeof detail.attachment === 'string') {
+        return { path: detail.attachment, taskId: detail.ownerId || null };
+    }
+    return { ...detail.attachment, taskId: detail.ownerId || detail.attachment.taskId || null };
+}
+export function AttachmentPreviewHost({ theme }) {
+    const [preview, setPreview] = useState(null);
+    const [textContent, setTextContent] = useState('');
+    const [textLoading, setTextLoading] = useState(false);
+    const [textError, setTextError] = useState(null);
+    const [copiedReference, setCopiedReference] = useState(false);
+    const dialogRef = useRef(null);
+    const previousFocusRef = useRef(null);
+    const copyResetTimerRef = useRef(null);
+    const previewGenerationRef = useRef(0);
+    const titleId = useId();
+    useEffect(() => {
+        const handlePreview = (event) => {
+            const customEvent = event;
+            if (!customEvent.detail?.attachment)
+                return;
+            customEvent.preventDefault();
+            previewGenerationRef.current += 1;
+            if (copyResetTimerRef.current !== null) {
+                window.clearTimeout(copyResetTimerRef.current);
+                copyResetTimerRef.current = null;
+            }
+            setCopiedReference(false);
+            setPreview(customEvent.detail);
+        };
+        window.addEventListener(CONTEXT_ATTACHMENT_PREVIEW_EVENT, handlePreview);
+        return () => window.removeEventListener(CONTEXT_ATTACHMENT_PREVIEW_EVENT, handlePreview);
+    }, []);
+    useEffect(() => () => {
+        previewGenerationRef.current += 1;
+        if (copyResetTimerRef.current !== null)
+            window.clearTimeout(copyResetTimerRef.current);
+    }, []);
+    useEffect(() => {
+        if (!preview)
+            return;
+        previousFocusRef.current = document.activeElement instanceof HTMLElement
+            ? document.activeElement
+            : null;
+        const handleKeyDown = (event) => {
+            if (event.key === 'Escape') {
+                event.preventDefault();
+                event.stopPropagation();
+                setPreview(null);
+                return;
+            }
+            if (event.key !== 'Tab' || !dialogRef.current)
+                return;
+            const focusable = Array.from(dialogRef.current.querySelectorAll('button:not([disabled]), [href], iframe, [tabindex]:not([tabindex="-1"])'));
+            if (focusable.length === 0) {
+                event.preventDefault();
+                dialogRef.current.focus();
+                return;
+            }
+            const first = focusable[0];
+            const last = focusable[focusable.length - 1];
+            if (event.shiftKey && document.activeElement === first) {
+                event.preventDefault();
+                last.focus();
+            }
+            else if (!event.shiftKey && document.activeElement === last) {
+                event.preventDefault();
+                first.focus();
+            }
+        };
+        window.addEventListener('keydown', handleKeyDown, true);
+        window.requestAnimationFrame(() => dialogRef.current?.focus());
+        return () => {
+            window.removeEventListener('keydown', handleKeyDown, true);
+            previousFocusRef.current?.focus();
+        };
+    }, [preview]);
+    const path = preview ? getAttachmentPath(preview.attachment) : '';
+    const typeCandidates = preview ? getAttachmentTypeCandidates(preview.attachment) : [];
+    const isExternal = /^https?:\/\//i.test(path);
+    const isImage = typeCandidates.some((candidate) => IMAGE_PREVIEW_PATTERN.test(candidate));
+    const isPdf = typeCandidates.some((candidate) => PDF_PREVIEW_PATTERN.test(candidate));
+    const isText = typeCandidates.some((candidate) => TEXT_PREVIEW_PATTERN.test(candidate)) && !isExternal;
+    const isMarkdown = typeCandidates.some((candidate) => /\.(?:md|markdown)(?:[?#]|$)/i.test(candidate));
+    useEffect(() => {
+        setTextContent('');
+        setTextError(null);
+        if (!preview || !isText) {
+            setTextLoading(false);
+            return;
+        }
+        const controller = new AbortController();
+        setTextLoading(true);
+        void fetch(path, {
+            signal: controller.signal,
+            headers: preview.workspaceId
+                ? { 'x-taskforce-workspace-id': preview.workspaceId }
+                : undefined,
+        }).then(async (response) => {
+            if (!response.ok)
+                throw new Error('Preview unavailable');
+            setTextContent(await response.text());
+        }).catch((error) => {
+            if (error instanceof DOMException && error.name === 'AbortError')
+                return;
+            setTextError(error instanceof Error ? error.message : 'Preview unavailable');
+        }).finally(() => {
+            if (!controller.signal.aborted)
+                setTextLoading(false);
+        });
+        return () => controller.abort();
+    }, [isText, path, preview]);
+    if (!preview)
+        return null;
+    const attachmentName = getAttachmentName(preview.attachment);
+    const attachmentObject = typeof preview.attachment === 'string' ? null : preview.attachment;
+    const referenceLabel = isImage
+        ? getImageReferenceLabel(attachmentObject)
+        : getDocumentReferenceLabel(attachmentObject);
+    const managerTarget = buildManagerTarget(preview);
+    const canOpenImageNotes = isImage && canOpenAnnotatedAttachment(managerTarget, {
+        taskId: preview.ownerType === 'task' ? preview.ownerId : null,
+        taskReferenceLabel: preview.ownerReferenceLabel,
+    });
+    const canOpenDocumentManager = !isImage && isMarkdownContextFile(managerTarget, typeof managerTarget === 'string' ? undefined : managerTarget.fsPath);
+    const copyReference = async () => {
+        if (!referenceLabel)
+            return;
+        const copyGeneration = previewGenerationRef.current;
+        try {
+            await navigator.clipboard.writeText(referenceLabel);
+        }
+        catch {
+            if (previewGenerationRef.current !== copyGeneration)
+                return;
+            const textarea = document.createElement('textarea');
+            textarea.value = referenceLabel;
+            document.body.appendChild(textarea);
+            textarea.select();
+            document.execCommand('copy');
+            textarea.remove();
+        }
+        if (previewGenerationRef.current !== copyGeneration)
+            return;
+        setCopiedReference(true);
+        if (copyResetTimerRef.current !== null)
+            window.clearTimeout(copyResetTimerRef.current);
+        copyResetTimerRef.current = window.setTimeout(() => {
+            if (previewGenerationRef.current !== copyGeneration)
+                return;
+            setCopiedReference(false);
+            copyResetTimerRef.current = null;
+        }, 1200);
+    };
+    const openManager = () => {
+        const handled = canOpenImageNotes
+            ? dispatchOpenAnnotatedAttachment(managerTarget, {
+                taskId: preview.ownerType === 'task' ? preview.ownerId : null,
+                taskReferenceLabel: preview.ownerReferenceLabel,
+            })
+            : dispatchOpenMarkdownDocument(managerTarget, typeof managerTarget === 'string' ? undefined : managerTarget.fsPath);
+        if (handled) {
+            setPreview(null);
+            return;
+        }
+        window.open(path, '_blank', 'noopener,noreferrer');
+    };
+    return createPortal(_jsx("div", { className: styles.overlay, "data-theme": theme, onMouseDown: (event) => {
+            if (event.target === event.currentTarget)
+                setPreview(null);
+        }, children: _jsxs("div", { ref: dialogRef, className: styles.dialog, role: "dialog", "aria-modal": "true", "aria-labelledby": titleId, tabIndex: -1, children: [_jsxs("header", { className: styles.header, children: [_jsxs("div", { className: styles.titleGroup, children: [_jsx("span", { className: styles.typeIcon, "aria-hidden": "true", children: isImage ? _jsx(ImageIcon, { size: 16 }) : _jsx(FileText, { size: 16 }) }), _jsxs("div", { className: styles.titleText, children: [_jsx("div", { className: styles.title, id: titleId, children: attachmentName }), referenceLabel && (_jsx(ReferenceBadgeButton, { label: referenceLabel, copied: copiedReference, onClick: () => { void copyReference(); }, title: attachmentName, ariaLabel: copiedReference
+                                                ? `Copied ${referenceLabel}`
+                                                : `Copy ${referenceLabel}`, className: styles.referenceBadge }))] })] }), _jsx("button", { type: "button", className: "tf-control-icon", "aria-label": "Close preview", title: "Close preview", onClick: () => setPreview(null), children: _jsx(X, { size: 18 }) })] }), _jsxs("div", { className: styles.content, children: [isImage && _jsx("img", { className: styles.image, src: path, alt: attachmentName }), isPdf && (_jsx("iframe", { className: styles.pdf, src: path, title: `Preview ${attachmentName}` })), isText && textLoading && _jsx("div", { className: styles.message, children: "Loading preview\u2026" }), isText && textError && _jsx("div", { className: styles.message, children: textError }), isText && !textLoading && !textError && (isMarkdown
+                            ? _jsx("div", { className: styles.textPreview, children: _jsx(Markdown, { variant: "detail", children: textContent }) })
+                            : _jsx("pre", { className: styles.codePreview, children: textContent })), !isImage && !isPdf && !isText && (_jsxs("div", { className: styles.unavailable, children: [_jsx(FileText, { size: 34, "aria-hidden": "true" }), _jsx("strong", { children: "Preview unavailable" }), _jsx("span", { children: "This file type can be opened or downloaded instead." })] }))] }), _jsxs("footer", { className: styles.footer, children: [_jsxs("div", { className: styles.secondaryActions, children: [!isExternal && (_jsxs("a", { className: styles.secondaryLink, href: buildDownloadUrl(path, attachmentName), target: "_blank", rel: "noreferrer", children: [_jsx(Download, { size: 14 }), " Download"] })), (isExternal || (!canOpenImageNotes && !canOpenDocumentManager)) && (_jsxs("a", { className: styles.secondaryLink, href: path, target: "_blank", rel: "noreferrer", children: [_jsx(ExternalLink, { size: 14 }), " Open original"] }))] }), (canOpenImageNotes || canOpenDocumentManager) && (_jsxs("button", { type: "button", className: "tf-button-primary tf-button-compact", onClick: openManager, children: [canOpenImageNotes ? _jsx(PencilLine, { size: 14 }) : _jsx(ExternalLink, { size: 14 }), canOpenImageNotes ? 'Open in Image Notes' : 'Open in Documents'] }))] })] }) }), document.body);
+}

package/dist/components/context/ContextAttachmentManager.d.ts

@@ -1,3 +1,4 @@
+import React from 'react';
 import type { AttachmentItem } from '../../types';
 export type ContextAttachmentOwnerType = 'task' | 'initiative' | 'workstream';
 export interface ContextAttachmentManagerProps {
@@ -10,5 +11,8 @@ export interface ContextAttachmentManagerProps {
     onAddAttachment: (file: AttachmentItem) => void;
     onRemoveAttachment: (index: number) => void;
     onUpdateAttachmentCaption: (index: number, caption: string) => void;
+    readOnly?: boolean;
+    defaultExpanded?: boolean;
+    supplementalContent?: React.ReactNode;
 }
 export declare function ContextAttachmentManager(props: ContextAttachmentManagerProps): import("react/jsx-runtime").JSX.Element;