@taskforcehq/taskforce 0.3.326 → 0.3.328

package/dist/components/features/agentSkills/SkillManagerPanel.js

@@ -0,0 +1,355 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState, } from 'react';
+import { ArrowDown, ArrowUp, Plus, Sparkles, X, } from 'lucide-react';
+import { compileTaskforceAgentSkillPrompt, inspectTaskforceAgentSkillDefinition, } from '../../../shared/taskforceAgentSkill.js';
+import { dispatchTaskforceAgentSkillsMutated, TASKFORCE_AGENT_SKILLS_MUTATED_EVENT, } from '../../../utils/taskforceAgentSkillEvents.js';
+import { fetchTaskforceApi } from '../../../utils/taskforceApiClient.js';
+import { Markdown } from '../../ui/Markdown.js';
+import { AgentBehaviorEditorHeader, AgentBehaviorEmptyState, AgentBehaviorFieldError, AgentBehaviorFeedback, AgentBehaviorLibrary, AgentBehaviorRetirementConfirmation, AgentBehaviorRuntimePreview, agentBehaviorManagerStyles as managerStyles, createAgentBehaviorIssueMap, focusFirstAgentBehaviorIssue, } from '../agentBehavior/AgentBehaviorManagerShared.js';
+import { ToolAccessSelector } from '../agentCapabilities/AgentCapabilitiesPrototype.js';
+import styles from './SkillManagerPanel.module.css';
+const EMPTY_DRAFT = {
+    name: '',
+    shortDescription: '',
+    purpose: '',
+    instructions: '',
+    expectedInputs: [],
+    expectedOutputs: [],
+    qualityChecks: [],
+    exampleUseCases: [],
+    recommendedCapabilityGroups: [],
+};
+function draftFromSkill(skill) {
+    const { schemaVersion: _schemaVersion, ...draft } = skill.definition;
+    return {
+        ...draft,
+        expectedInputs: [...draft.expectedInputs],
+        expectedOutputs: [...draft.expectedOutputs],
+        qualityChecks: [...draft.qualityChecks],
+        exampleUseCases: [...draft.exampleUseCases],
+        recommendedCapabilityGroups: [...draft.recommendedCapabilityGroups],
+    };
+}
+function draftFingerprint(draft) {
+    return JSON.stringify(draft);
+}
+function parseError(payload, fallback) {
+    const issues = Array.isArray(payload.issues) ? payload.issues : [];
+    const firstIssue = issues[0];
+    if (firstIssue?.message) {
+        return `${firstIssue.path ? `${firstIssue.path}: ` : ''}${firstIssue.message}`;
+    }
+    return String(payload.error || fallback);
+}
+function OrderedListEditor({ fieldPath, label, helper, values, onChange, placeholder, disabled = false, issues, fieldRefs, }) {
+    const addItem = () => onChange([...values, '']);
+    const updateItem = (index, value) => {
+        const next = [...values];
+        next[index] = value;
+        onChange(next);
+    };
+    const moveItem = (index, direction) => {
+        const destination = index + direction;
+        if (destination < 0 || destination >= values.length)
+            return;
+        const next = [...values];
+        [next[index], next[destination]] = [next[destination], next[index]];
+        onChange(next);
+    };
+    const groupIssue = issues.get(fieldPath);
+    return (_jsxs("div", { className: "tf-field-stack", children: [_jsxs("div", { className: "tf-field-label-row", children: [_jsx("span", { className: "tf-field-label", children: label }), _jsxs("button", { type: "button", className: "tf-button-ghost tf-button-compact", disabled: disabled, onClick: addItem, children: [_jsx(Plus, { size: 13 }), " Add"] })] }), _jsx("span", { className: "tf-field-hint", children: helper }), _jsx(AgentBehaviorFieldError, { id: `skill-field-${fieldPath}-error`, message: groupIssue }), values.length === 0 ? (_jsx("div", { className: styles.listEmpty, children: "No items added." })) : (_jsx("div", { className: styles.orderedList, children: values.map((value, index) => {
+                    const itemIssue = issues.get(`${fieldPath}.${index}`);
+                    const fieldIssue = itemIssue || (index === 0 ? groupIssue : undefined);
+                    const errorId = itemIssue
+                        ? `skill-field-${fieldPath}-${index}-error`
+                        : `skill-field-${fieldPath}-error`;
+                    return (_jsxs("div", { className: styles.orderedRow, children: [_jsx("span", { className: styles.orderNumber, children: index + 1 }), _jsxs("div", { className: styles.orderedInput, children: [_jsx("input", { ref: (element) => {
+                                            fieldRefs.current[`${fieldPath}.${index}`] = element || undefined;
+                                            if (index === 0) {
+                                                fieldRefs.current[fieldPath] = element || undefined;
+                                            }
+                                        }, id: `skill-field-${fieldPath}-${index}`, className: "tf-field-shell", "aria-label": `${label} item ${index + 1}`, "aria-invalid": Boolean(fieldIssue), "aria-errormessage": fieldIssue
+                                            ? errorId
+                                            : undefined, value: value, placeholder: placeholder, disabled: disabled, onChange: (event) => updateItem(index, event.target.value) }), _jsx(AgentBehaviorFieldError, { id: `skill-field-${fieldPath}-${index}-error`, message: itemIssue })] }), _jsxs("div", { className: styles.orderActions, children: [_jsx("button", { type: "button", className: "tf-control-icon tf-control-icon-compact tf-control-icon-quiet", "aria-label": `Move ${label.toLowerCase()} item up`, disabled: disabled || index === 0, onClick: () => {
+                                            if (!disabled)
+                                                moveItem(index, -1);
+                                        }, children: _jsx(ArrowUp, { size: 13 }) }), _jsx("button", { type: "button", className: "tf-control-icon tf-control-icon-compact tf-control-icon-quiet", "aria-label": `Move ${label.toLowerCase()} item down`, disabled: disabled || index === values.length - 1, onClick: () => {
+                                            if (!disabled)
+                                                moveItem(index, 1);
+                                        }, children: _jsx(ArrowDown, { size: 13 }) }), _jsx("button", { type: "button", className: "tf-control-icon tf-control-icon-compact tf-control-icon-quiet", "aria-label": `Remove ${label.toLowerCase()} item`, disabled: disabled, onClick: () => onChange(values.filter((_item, itemIndex) => itemIndex !== index)), children: _jsx(X, { size: 13 }) })] })] }, `${fieldPath}-${index}`));
+                }) }))] }));
+}
+export function SkillManagerPanel({ workspaceId, active = true, libraryPortalTarget, }) {
+    const [skills, setSkills] = useState([]);
+    const [selectedSkillId, setSelectedSkillId] = useState(null);
+    const [draft, setDraft] = useState(EMPTY_DRAFT);
+    const [savedFingerprint, setSavedFingerprint] = useState(draftFingerprint(EMPTY_DRAFT));
+    const [creating, setCreating] = useState(false);
+    const [loading, setLoading] = useState(true);
+    const [saving, setSaving] = useState(false);
+    const [error, setError] = useState(null);
+    const [notice, setNotice] = useState(null);
+    const [search, setSearch] = useState('');
+    const [showRetired, setShowRetired] = useState(false);
+    const [retireConfirmationOpen, setRetireConfirmationOpen] = useState(false);
+    const [validationVisible, setValidationVisible] = useState(false);
+    const [loaded, setLoaded] = useState(false);
+    const fieldRefs = useRef({});
+    const selectedSkill = skills.find((skill) => skill.id === selectedSkillId) || null;
+    const dirty = draftFingerprint(draft) !== savedFingerprint;
+    const selectSkill = useCallback((skill) => {
+        if (dirty && !window.confirm('Discard unsaved Skill changes?'))
+            return;
+        const nextDraft = draftFromSkill(skill);
+        setSelectedSkillId(skill.id);
+        setDraft(nextDraft);
+        setSavedFingerprint(draftFingerprint(nextDraft));
+        setCreating(false);
+        setRetireConfirmationOpen(false);
+        setValidationVisible(false);
+        setError(null);
+        setNotice(null);
+    }, [dirty]);
+    const loadSkills = useCallback(async (options) => {
+        if (!options?.quiet)
+            setLoading(true);
+        try {
+            const response = await fetchTaskforceApi(`/api/taskforce/agent-skills?workspaceId=${encodeURIComponent(workspaceId)}&includeRetired=true`, { credentials: 'include' });
+            const payload = await response.json().catch(() => ({}));
+            if (!response.ok || payload?.success === false || !Array.isArray(payload?.skills)) {
+                throw new Error(parseError(payload, 'Unable to load Skills.'));
+            }
+            const nextSkills = payload.skills;
+            setSkills(nextSkills);
+            setSelectedSkillId((currentId) => {
+                if (creating)
+                    return currentId;
+                const nextSelected = nextSkills.find((skill) => skill.id === currentId)
+                    || nextSkills.find((skill) => skill.lifecycleStatus === 'active')
+                    || nextSkills[0]
+                    || null;
+                if (nextSelected && (!dirty || nextSelected.id === currentId)) {
+                    const nextDraft = draftFromSkill(nextSelected);
+                    setDraft(nextDraft);
+                    setSavedFingerprint(draftFingerprint(nextDraft));
+                }
+                return nextSelected?.id || null;
+            });
+            setError(null);
+        }
+        catch (loadError) {
+            setError(String(loadError?.message || loadError || 'Unable to load Skills.'));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [creating, dirty, workspaceId]);
+    useEffect(() => {
+        if (!active || loaded)
+            return;
+        setLoaded(true);
+        void loadSkills();
+    }, [active, loadSkills, loaded]);
+    useEffect(() => {
+        const handleMutation = (event) => {
+            const detail = event.detail;
+            if (String(detail?.workspaceId || '').trim() !== workspaceId)
+                return;
+            void loadSkills({ quiet: true });
+        };
+        window.addEventListener(TASKFORCE_AGENT_SKILLS_MUTATED_EVENT, handleMutation);
+        return () => window.removeEventListener(TASKFORCE_AGENT_SKILLS_MUTATED_EVENT, handleMutation);
+    }, [loadSkills, workspaceId]);
+    useEffect(() => {
+        if (!dirty)
+            return;
+        const warn = (event) => {
+            event.preventDefault();
+            event.returnValue = '';
+        };
+        window.addEventListener('beforeunload', warn);
+        return () => window.removeEventListener('beforeunload', warn);
+    }, [dirty]);
+    const visibleSkills = useMemo(() => {
+        const normalizedSearch = search.trim().toLocaleLowerCase();
+        return skills.filter((skill) => {
+            if (!showRetired && skill.lifecycleStatus === 'retired')
+                return false;
+            if (!normalizedSearch)
+                return true;
+            return [
+                skill.definition.name,
+                skill.definition.shortDescription,
+                skill.definition.purpose,
+            ].some((value) => value.toLocaleLowerCase().includes(normalizedSearch));
+        });
+    }, [search, showRetired, skills]);
+    const previewDefinition = useMemo(() => ({
+        schemaVersion: 1,
+        ...draft,
+    }), [draft]);
+    const inspection = useMemo(() => inspectTaskforceAgentSkillDefinition(previewDefinition), [previewDefinition]);
+    const promptPreview = useMemo(() => compileTaskforceAgentSkillPrompt(previewDefinition), [previewDefinition]);
+    const firstIssueByPath = useMemo(() => createAgentBehaviorIssueMap(inspection.issues, validationVisible), [inspection.issues, validationVisible]);
+    const startCreating = () => {
+        if (dirty && !window.confirm('Discard unsaved Skill changes?'))
+            return;
+        setSelectedSkillId(null);
+        setDraft(EMPTY_DRAFT);
+        setSavedFingerprint(draftFingerprint(EMPTY_DRAFT));
+        setCreating(true);
+        setRetireConfirmationOpen(false);
+        setValidationVisible(false);
+        setError(null);
+        setNotice(null);
+    };
+    const resetDraft = () => {
+        const nextDraft = selectedSkill ? draftFromSkill(selectedSkill) : EMPTY_DRAFT;
+        setDraft(nextDraft);
+        setSavedFingerprint(draftFingerprint(nextDraft));
+        setRetireConfirmationOpen(false);
+        setValidationVisible(false);
+        setError(null);
+        setNotice(null);
+    };
+    const saveSkill = async () => {
+        if (saving)
+            return;
+        if (!inspection.definition) {
+            setValidationVisible(true);
+            setError(inspection.issues[0]?.message || 'Complete the required Skill fields.');
+            focusFirstAgentBehaviorIssue(inspection.issues, fieldRefs.current);
+            return;
+        }
+        setSaving(true);
+        setError(null);
+        setNotice(null);
+        try {
+            const url = selectedSkill
+                ? `/api/taskforce/agent-skills/${encodeURIComponent(selectedSkill.id)}`
+                : '/api/taskforce/agent-skills';
+            const response = await fetchTaskforceApi(url, {
+                method: selectedSkill ? 'PATCH' : 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({
+                    workspaceId,
+                    definition: inspection.definition,
+                    ...(selectedSkill ? { expectedContentHash: selectedSkill.contentHash } : {}),
+                }),
+            });
+            const payload = await response.json().catch(() => ({}));
+            if (!response.ok || payload?.success === false || !payload?.skill) {
+                throw new Error(parseError(payload, 'Unable to save Skill.'));
+            }
+            const saved = payload.skill;
+            const nextDraft = draftFromSkill(saved);
+            setSkills((current) => {
+                const exists = current.some((skill) => skill.id === saved.id);
+                return exists
+                    ? current.map((skill) => skill.id === saved.id ? saved : skill)
+                    : [...current, saved].sort((left, right) => (left.definition.name.localeCompare(right.definition.name)));
+            });
+            setSelectedSkillId(saved.id);
+            setDraft(nextDraft);
+            setSavedFingerprint(draftFingerprint(nextDraft));
+            setCreating(false);
+            setValidationVisible(false);
+            setNotice(`Saved ${saved.definition.name}.`);
+            dispatchTaskforceAgentSkillsMutated({
+                workspaceId,
+                skillId: saved.id,
+                reason: selectedSkill ? 'update' : 'create',
+            });
+        }
+        catch (saveError) {
+            setError(String(saveError?.message || saveError || 'Unable to save Skill.'));
+        }
+        finally {
+            setSaving(false);
+        }
+    };
+    const changeLifecycle = async (action) => {
+        if (!selectedSkill || saving)
+            return;
+        setSaving(true);
+        setError(null);
+        setNotice(null);
+        try {
+            const response = await fetchTaskforceApi(`/api/taskforce/agent-skills/${encodeURIComponent(selectedSkill.id)}/${action}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ workspaceId }),
+            });
+            const payload = await response.json().catch(() => ({}));
+            if (!response.ok || payload?.success === false || !payload?.skill) {
+                throw new Error(parseError(payload, `Unable to ${action} Skill.`));
+            }
+            const saved = payload.skill;
+            setSkills((current) => current.map((skill) => skill.id === saved.id ? saved : skill));
+            if (action === 'retire')
+                setShowRetired(true);
+            setRetireConfirmationOpen(false);
+            setNotice(`${action === 'retire' ? 'Retired' : 'Restored'} ${saved.definition.name}.`);
+            dispatchTaskforceAgentSkillsMutated({
+                workspaceId,
+                skillId: saved.id,
+                reason: action,
+            });
+        }
+        catch (lifecycleError) {
+            setError(String(lifecycleError?.message
+                || lifecycleError
+                || `Unable to ${action} Skill.`));
+        }
+        finally {
+            setSaving(false);
+        }
+    };
+    const workflowCount = selectedSkill?.usage.workflowCount;
+    const knownUsageCount = selectedSkill
+        ? selectedSkill.usage.agentCount + (workflowCount || 0)
+        : 0;
+    const retirementMessage = [
+        knownUsageCount > 0
+            ? `${knownUsageCount} known Agent or Workflow configuration${knownUsageCount === 1 ? ' references' : 's reference'} this Skill and will require repair before running.`
+            : 'No known Agent or Workflow configurations currently reference this Skill.',
+        workflowCount === null
+            ? 'Workflow reference counts are unavailable in this version, so review attached Workflows before retiring it.'
+            : '',
+    ].filter(Boolean).join(' ');
+    return (_jsxs("div", { className: `${managerStyles.root} ${libraryPortalTarget ? managerStyles.rootExternalLibrary : ''}`.trim(), children: [_jsx(AgentBehaviorLibrary, { singularLabel: "Skill", pluralLabel: "Skills", description: "Reusable capabilities that define how an Agent performs a class of work.", icon: _jsx(Sparkles, { size: 15 }), items: visibleSkills.map((skill) => ({
+                    id: skill.id,
+                    name: skill.definition.name,
+                    description: skill.definition.shortDescription,
+                    lifecycleStatus: skill.lifecycleStatus,
+                })), selectedId: selectedSkillId, searchValue: search, onSearchChange: setSearch, showRetired: showRetired, onShowRetiredChange: setShowRetired, loading: loading, error: null, emptyMessage: skills.length === 0 ? 'No Skills configured yet.' : 'No Skills match this view.', onCreate: startCreating, onSelect: (skillId) => {
+                    const skill = skills.find((candidate) => candidate.id === skillId);
+                    if (skill)
+                        selectSkill(skill);
+                }, libraryPortalTarget: libraryPortalTarget }), _jsxs("main", { className: managerStyles.editor, children: [_jsx(AgentBehaviorEditorHeader, { icon: _jsx(Sparkles, { size: 18 }), title: creating ? 'New Skill' : selectedSkill?.definition.name || 'Skill Manager', description: "Define bounded, reusable guidance for how an Agent performs a class of work.", revision: selectedSkill?.revision, retired: selectedSkill?.lifecycleStatus === 'retired', showActions: creating || Boolean(selectedSkill), dirty: dirty, saving: saving, onReset: resetDraft, onSave: () => void saveSkill() }), retireConfirmationOpen && selectedSkill ? (_jsx(AgentBehaviorRetirementConfirmation, { title: `Retire ${selectedSkill.definition.name}?`, message: retirementMessage, entityLabel: "Skill", saving: saving, onConfirm: () => void changeLifecycle('retire'), onCancel: () => setRetireConfirmationOpen(false) })) : null, error ? _jsx(AgentBehaviorFeedback, { type: "error", message: error }) : null, notice ? _jsx(AgentBehaviorFeedback, { type: "success", message: notice }) : null, !creating && !selectedSkill ? (_jsx(AgentBehaviorEmptyState, { icon: _jsx(Sparkles, { size: 24 }), title: "Create your first Skill", description: "Skills package reusable instructions, inputs, outputs, and quality checks without granting tools or permissions.", actionLabel: "New Skill", onCreate: startCreating })) : (_jsxs("div", { className: managerStyles.editorGrid, children: [_jsxs("div", { className: managerStyles.formColumn, children: [_jsxs("section", { className: styles.section, children: [_jsx("div", { className: styles.sectionHeading, children: _jsxs("div", { children: [_jsx("h3", { className: "tf-heading-section", children: "Identity and discovery" }), _jsx("p", { className: "tf-text-helper", children: "These fields help people find and understand the Skill. They are not added to normal prompts." })] }) }), _jsxs("div", { className: styles.twoColumn, children: [_jsxs("label", { className: "tf-field-stack", children: [_jsx("span", { className: "tf-field-label", children: "Name" }), _jsx("input", { ref: (element) => {
+                                                                    fieldRefs.current.name = element || undefined;
+                                                                }, id: "skill-field-name", className: "tf-field-shell", "aria-label": "Name", "aria-invalid": Boolean(firstIssueByPath.get('name')), "aria-errormessage": firstIssueByPath.get('name')
+                                                                    ? 'skill-field-name-error'
+                                                                    : undefined, value: draft.name, maxLength: 80, disabled: selectedSkill?.lifecycleStatus === 'retired', onChange: (event) => setDraft((current) => ({ ...current, name: event.target.value })) }), _jsx(AgentBehaviorFieldError, { id: "skill-field-name-error", message: firstIssueByPath.get('name') })] }), _jsxs("label", { className: "tf-field-stack", children: [_jsx("span", { className: "tf-field-label", children: "Short description" }), _jsx("input", { ref: (element) => {
+                                                                    fieldRefs.current.shortDescription = element || undefined;
+                                                                }, id: "skill-field-short-description", className: "tf-field-shell", "aria-label": "Short description", "aria-invalid": Boolean(firstIssueByPath.get('shortDescription')), "aria-errormessage": firstIssueByPath.get('shortDescription')
+                                                                    ? 'skill-field-short-description-error'
+                                                                    : undefined, value: draft.shortDescription, maxLength: 280, disabled: selectedSkill?.lifecycleStatus === 'retired', onChange: (event) => setDraft((current) => ({ ...current, shortDescription: event.target.value })) }), _jsx(AgentBehaviorFieldError, { id: "skill-field-short-description-error", message: firstIssueByPath.get('shortDescription') })] })] }), _jsxs("label", { className: "tf-field-stack", children: [_jsx("span", { className: "tf-field-label", children: "Purpose" }), _jsx("textarea", { ref: (element) => {
+                                                            fieldRefs.current.purpose = element || undefined;
+                                                        }, id: "skill-field-purpose", className: "tf-field-shell", "aria-label": "Purpose", "aria-invalid": Boolean(firstIssueByPath.get('purpose')), "aria-errormessage": firstIssueByPath.get('purpose')
+                                                            ? 'skill-field-purpose-error'
+                                                            : undefined, rows: 3, value: draft.purpose, maxLength: 1_000, disabled: selectedSkill?.lifecycleStatus === 'retired', onChange: (event) => setDraft((current) => ({ ...current, purpose: event.target.value })) }), _jsx(AgentBehaviorFieldError, { id: "skill-field-purpose-error", message: firstIssueByPath.get('purpose') })] })] }), _jsxs("section", { className: styles.section, children: [_jsx("div", { className: styles.sectionHeading, children: _jsxs("div", { children: [_jsx("h3", { className: "tf-heading-section", children: "Runtime behavior" }), _jsx("p", { className: "tf-text-helper", children: "Only this bounded content is compiled into the Agent prompt." })] }) }), _jsxs("label", { className: "tf-field-stack", children: [_jsx("span", { className: "tf-field-label", children: "Instructions" }), _jsx("textarea", { ref: (element) => {
+                                                            fieldRefs.current.instructions = element || undefined;
+                                                        }, id: "skill-field-instructions", className: `tf-field-shell ${styles.instructions}`, "aria-label": "Instructions", "aria-describedby": `skill-field-instructions-hint${firstIssueByPath.get('instructions')
+                                                            ? ' skill-field-instructions-error'
+                                                            : ''}`, "aria-invalid": Boolean(firstIssueByPath.get('instructions')), "aria-errormessage": firstIssueByPath.get('instructions')
+                                                            ? 'skill-field-instructions-error'
+                                                            : undefined, rows: 9, value: draft.instructions, maxLength: 12_000, disabled: selectedSkill?.lifecycleStatus === 'retired', placeholder: "Describe how the Agent should perform this capability.", onChange: (event) => setDraft((current) => ({ ...current, instructions: event.target.value })) }), _jsx("span", { id: "skill-field-instructions-hint", className: "tf-field-hint", children: "Markdown is supported as text. Scripts and executable bundles are not supported." }), _jsx(AgentBehaviorFieldError, { id: "skill-field-instructions-error", message: firstIssueByPath.get('instructions') })] }), _jsx(OrderedListEditor, { fieldPath: "expectedInputs", label: "Expected inputs", helper: "What information or artifacts should be available?", values: draft.expectedInputs, placeholder: "e.g. Complete diff", onChange: (expectedInputs) => setDraft((current) => ({ ...current, expectedInputs })), disabled: selectedSkill?.lifecycleStatus === 'retired', issues: firstIssueByPath, fieldRefs: fieldRefs }), _jsx(OrderedListEditor, { fieldPath: "expectedOutputs", label: "Expected outputs", helper: "What should this Skill produce?", values: draft.expectedOutputs, placeholder: "e.g. Prioritized findings", onChange: (expectedOutputs) => setDraft((current) => ({ ...current, expectedOutputs })), disabled: selectedSkill?.lifecycleStatus === 'retired', issues: firstIssueByPath, fieldRefs: fieldRefs }), _jsx(OrderedListEditor, { fieldPath: "qualityChecks", label: "Quality checks", helper: "What must be true before the work is considered ready?", values: draft.qualityChecks, placeholder: "e.g. Every finding cites evidence", onChange: (qualityChecks) => setDraft((current) => ({ ...current, qualityChecks })), disabled: selectedSkill?.lifecycleStatus === 'retired', issues: firstIssueByPath, fieldRefs: fieldRefs })] }), _jsxs("section", { className: styles.section, children: [_jsx("div", { className: styles.sectionHeading, children: _jsxs("div", { children: [_jsx("h3", { className: "tf-heading-section", children: "Authoring metadata" }), _jsx("p", { className: "tf-text-helper", children: "Useful for discovery and recommendations; excluded from runtime prompts and permissions." })] }) }), _jsx(OrderedListEditor, { fieldPath: "exampleUseCases", label: "Example use cases", helper: "Situations where this Skill is useful.", values: draft.exampleUseCases, placeholder: "e.g. Review a pull request", onChange: (exampleUseCases) => setDraft((current) => ({ ...current, exampleUseCases })), disabled: selectedSkill?.lifecycleStatus === 'retired', issues: firstIssueByPath, fieldRefs: fieldRefs }), _jsx(ToolAccessSelector, { selectedKeys: draft.recommendedCapabilityGroups, title: "Required Tool Access", description: "Select the Taskforce modules this Skill expects. Requirements are saved for discovery but are not enforced or granted yet.", mode: "requirement", showFutureTools: false, disabled: selectedSkill?.lifecycleStatus === 'retired', onChange: (recommendedCapabilityGroups) => setDraft((current) => ({ ...current, recommendedCapabilityGroups })) })] })] }), _jsx(AgentBehaviorRuntimePreview, { entityLabel: "Skill", note: "This is the exact bounded Skill content supplied to the Agent runtime. Discovery and recommendation metadata are excluded.", meta: _jsxs("span", { className: "tf-chip-count", children: [promptPreview.length.toLocaleString(), " chars"] }), metrics: selectedSkill ? [
+                                    { label: 'Revision', value: selectedSkill.revision },
+                                    { label: 'Agent references', value: selectedSkill.usage.agentCount },
+                                    { label: 'Workflow references', value: selectedSkill.usage.workflowCount ?? 'Unavailable' },
+                                    { label: 'Status', value: selectedSkill.lifecycleStatus === 'retired' ? 'Retired' : 'Active' },
+                                ] : [], revisions: selectedSkill?.revisions || [], lifecycleStatus: selectedSkill?.lifecycleStatus, saving: saving, retireDescription: "Remove it from new selection while preserving immutable history.", restoreDescription: "Allow this Skill to resolve for new Agent runs again.", onRetire: () => setRetireConfirmationOpen(true), onRestore: () => void changeLifecycle('restore'), children: promptPreview ? (_jsx("div", { className: managerStyles.preview, children: _jsx(Markdown, { variant: "detail", children: promptPreview }) })) : (_jsx("div", { className: managerStyles.previewEmpty, children: "Add runtime instructions to preview this Skill." })) })] }))] })] }));
+}

package/dist/components/features/documentWorkspaceModel.d.ts

@@ -1,24 +1,36 @@
 import type { DocumentAttachmentFilter, DocumentTypeFilter } from './documentWorkspaceFilters';
+export type DocumentTargetType = 'task' | 'initiative' | 'workstream';
+export type DocumentLinkRole = 'attachment' | 'image' | 'reference';
+export interface DocumentTargetSummary {
+    targetType: DocumentTargetType;
+    targetId: string;
+    referenceLabel: string | null;
+    title: string;
+    role: DocumentLinkRole;
+}
 export interface DocMeta {
-    id: string;
-    assetId?: string;
+    assetId: string;
     referenceNumber?: number | null;
     referenceLabel?: string | null;
+    version?: number | null;
     fsPath: string;
     apiUrl: string;
     taskId: string | null;
-    displayName: string;
     originalFilename?: string | null;
     title: string;
     docType: 'implementation-plan' | 'review' | 'walkthrough' | 'planning' | 'other';
     sizeBytes: number;
     updatedAt: string | null;
+    createdAt?: string | null;
     editable?: boolean;
+    targets?: DocumentTargetSummary[];
     attachmentCount?: number;
     attachmentState?: 'attached' | 'unattached';
 }
 export declare function normalizeDocPath(value: string): string;
+export declare function withWorkspaceQuery(path: string, workspaceId?: string | null): string;
 export declare function docPathMatches(candidate: string, requested: string): boolean;
 export declare function extractAssetIdFromPath(value: string | null | undefined): string | null;
-export declare function getEffectiveAttachmentState(doc: Pick<DocMeta, 'attachmentState' | 'attachmentCount' | 'taskId'>): 'attached' | 'unattached';
+export declare function getDocumentAttachmentCount(doc: Pick<DocMeta, 'targets' | 'attachmentCount' | 'taskId'>): number;
+export declare function getEffectiveAttachmentState(doc: Pick<DocMeta, 'attachmentState' | 'targets' | 'attachmentCount' | 'taskId'>): 'attached' | 'unattached';
 export declare function filterDocuments(documents: DocMeta[], searchQuery: string, typeFilters: DocumentTypeFilter[], attachmentFilters: DocumentAttachmentFilter[]): DocMeta[];

package/dist/components/features/documentWorkspaceModel.js

@@ -15,6 +15,13 @@ export function normalizeDocPath(value) {
         .replace(/^\.taskforce\//, '');
     return normalized;
 }
+export function withWorkspaceQuery(path, workspaceId) {
+    const normalizedWorkspaceId = String(workspaceId || '').trim();
+    if (!normalizedWorkspaceId)
+        return path;
+    const separator = path.includes('?') ? '&' : '?';
+    return `${path}${separator}workspaceId=${encodeURIComponent(normalizedWorkspaceId)}`;
+}
 export function docPathMatches(candidate, requested) {
     if (candidate === requested)
         return true;
@@ -31,14 +38,23 @@ export function extractAssetIdFromPath(value) {
     const match = normalized.match(/(^|\/)(asset-[a-f0-9]{32})(?=[^/]*$)/i);
     return match?.[2] ? match[2].toLowerCase() : null;
 }
+export function getDocumentAttachmentCount(doc) {
+    if (Array.isArray(doc.targets)) {
+        return doc.targets.length;
+    }
+    if (typeof doc.attachmentCount === 'number' && Number.isFinite(doc.attachmentCount)) {
+        return Math.max(0, Math.floor(doc.attachmentCount));
+    }
+    return doc.taskId ? 1 : 0;
+}
 export function getEffectiveAttachmentState(doc) {
+    if (Array.isArray(doc.targets)) {
+        return doc.targets.length > 0 ? 'attached' : 'unattached';
+    }
     if (doc.attachmentState === 'attached' || doc.attachmentState === 'unattached') {
         return doc.attachmentState;
     }
-    const attachmentCount = typeof doc.attachmentCount === 'number' && Number.isFinite(doc.attachmentCount)
-        ? doc.attachmentCount
-        : 0;
-    if (attachmentCount > 0 || !!doc.taskId) {
+    if (getDocumentAttachmentCount(doc) > 0) {
         return 'attached';
     }
     return 'unattached';
@@ -47,7 +63,16 @@ export function filterDocuments(documents, searchQuery, typeFilters, attachmentF
     const normalizedQuery = searchQuery.trim().toLowerCase();
     return documents.filter((doc) => {
         const readableName = getReadableDocumentName(doc);
-        const haystack = `${readableName} ${doc.originalFilename || ''}`.toLowerCase();
+        const haystack = [
+            readableName,
+            doc.title,
+            doc.originalFilename,
+            doc.referenceLabel,
+            doc.referenceNumber,
+        ]
+            .filter((value) => value !== null && value !== undefined)
+            .join(' ')
+            .toLowerCase();
         const matchesSearch = normalizedQuery.length === 0 || haystack.includes(normalizedQuery);
         const matchesType = typeFilters.length === 0 || typeFilters.includes(doc.docType);
         const attachmentState = getEffectiveAttachmentState(doc);

package/dist/components/features/planning/PlanningArchiveConfirmation.d.ts

@@ -0,0 +1,9 @@
+export declare function PlanningArchiveConfirmation({ entityType, title, activeTaskCount, activeWorkstreamCount, busy, onCancel, onConfirm, }: {
+    entityType: 'initiative' | 'workstream';
+    title: string;
+    activeTaskCount?: number;
+    activeWorkstreamCount?: number;
+    busy: boolean;
+    onCancel: () => void;
+    onConfirm: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/features/planning/PlanningArchiveConfirmation.js

@@ -0,0 +1,19 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Check, X } from 'lucide-react';
+import styles from './PlanningArchiveConfirmation.module.css';
+export function PlanningArchiveConfirmation({ entityType, title, activeTaskCount = 0, activeWorkstreamCount = 0, busy, onCancel, onConfirm, }) {
+    const affectedItems = [
+        activeTaskCount > 0
+            ? `${activeTaskCount} completed/cancelled ${activeTaskCount === 1 ? 'task' : 'tasks'}`
+            : '',
+        entityType === 'initiative' && activeWorkstreamCount > 0
+            ? `${activeWorkstreamCount} ${activeWorkstreamCount === 1 ? 'workstream' : 'workstreams'}`
+            : '',
+    ].filter(Boolean);
+    const affectedPrefix = affectedItems.length === 0
+        ? ''
+        : affectedItems.length === 1
+            ? `${affectedItems[0]} and `
+            : `${affectedItems.join(', ')}, and `;
+    return (_jsxs("div", { className: `${styles.prompt} tf-surface-inset`, role: "group", "aria-label": `Confirm archive ${entityType} ${title}`, children: [_jsxs("span", { children: ["Archive ", affectedPrefix, "this ", entityType, "?"] }), _jsxs("div", { className: styles.actions, children: [_jsx("button", { type: "button", className: "tf-control-icon tf-control-icon-compact", disabled: busy, onClick: onCancel, title: "Cancel archive", "aria-label": "Cancel archive", children: _jsx(X, { size: 14, "aria-hidden": "true" }) }), _jsx("button", { type: "button", className: "tf-control-icon tf-control-icon-compact", disabled: busy, onClick: onConfirm, title: "Confirm archive", "aria-label": busy ? 'Archiving' : 'Confirm archive', children: _jsx(Check, { size: 14, "aria-hidden": "true" }) })] })] }));
+}

package/dist/components/features/planning/PlanningCardIdentity.d.ts

@@ -0,0 +1,12 @@
+import { type TaskAssigneeOption } from '../../../utils/assignees';
+type PlanningCardIdentityProps = {
+    role: 'owner' | 'assignee';
+    option?: TaskAssigneeOption | null;
+    label?: string | null;
+    value?: string | null;
+    options?: TaskAssigneeOption[];
+    onChange?: (value: string) => void | Promise<void>;
+    disabled?: boolean;
+};
+export declare function PlanningCardIdentity({ role, option, label, value, options, onChange, disabled, }: PlanningCardIdentityProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/features/planning/PlanningCardIdentity.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from 'react';
+import { mergeAssigneeOptions, UNASSIGNED_ASSIGNEE_OPTION, } from '../../../utils/assignees';
+import { AssigneeAvatar, AssigneeIdentity } from '../../ui/AssigneeIdentity';
+import { TaxonomyDropdown } from '../../ui/TaxonomyDropdown';
+import styles from './PlanningCardIdentity.module.css';
+export function PlanningCardIdentity({ role, option, label, value, options = [], onChange, disabled = false, }) {
+    const [saving, setSaving] = React.useState(false);
+    const normalizedLabel = String(option?.label || label || '').trim();
+    const identity = option || (normalizedLabel ? {
+        ...UNASSIGNED_ASSIGNEE_OPTION,
+        value: normalizedLabel,
+        label: normalizedLabel,
+        icon: 'User',
+        kind: 'member',
+    } : UNASSIGNED_ASSIGNEE_OPTION);
+    const accessibleLabel = role === 'owner'
+        ? `Owner: ${identity.label}`
+        : `Assigned to ${identity.label}`;
+    const changeLabel = role === 'owner'
+        ? `Change owner currently set to ${identity.label}`
+        : `Reassign task currently assigned to ${identity.label}`;
+    const resolvedOptions = React.useMemo(() => mergeAssigneeOptions(options), [options]);
+    const identityByValue = React.useMemo(() => new Map(resolvedOptions.map((candidate) => [candidate.value, candidate])), [resolvedOptions]);
+    const avatar = (_jsx("span", { className: styles.identity, title: onChange && !disabled ? changeLabel : accessibleLabel, "aria-label": accessibleLabel, children: _jsx("span", { className: styles.avatar, children: _jsx(AssigneeAvatar, { option: identity, size: 22, variant: "card" }) }) }));
+    if (!onChange || disabled)
+        return avatar;
+    const selectedValue = String(value || option?.value || UNASSIGNED_ASSIGNEE_OPTION.value);
+    return (_jsx("span", { className: styles.picker, onClick: (event) => event.stopPropagation(), onPointerDown: (event) => event.stopPropagation(), onKeyDown: (event) => event.stopPropagation(), children: _jsx(TaxonomyDropdown, { value: selectedValue, options: resolvedOptions, onChange: async (nextValue) => {
+                setSaving(true);
+                try {
+                    await onChange(String(nextValue));
+                }
+                catch {
+                    // The mutation boundary owns user-facing error reporting and rollback.
+                }
+                finally {
+                    setSaving(false);
+                }
+            }, disabled: saving, ariaLabel: changeLabel, className: styles.identityDropdown, hideChevron: true, portalPanel: true, panelAlign: "end", panelMinWidth: 240, searchable: true, searchPlaceholder: role === 'owner' ? 'Search owners...' : 'Search assignees...', noResultsText: role === 'owner' ? 'No owners found.' : 'No assignees found.', renderOptionContent: (candidate) => {
+                const assignee = identityByValue.get(String(candidate.value));
+                return assignee ? _jsx(AssigneeIdentity, { option: assignee }) : candidate.label;
+            }, triggerContent: avatar }) }));
+}

package/dist/components/features/planning/PlanningEntityDetails.d.ts

@@ -0,0 +1,36 @@
+import type { AttachmentItem } from '../../../types';
+import type { TaskReferenceContract } from '../../../utils/taskReferences';
+import type { TaskAssigneeOption } from '../../../utils/assignees';
+import type { PlanningEntityHydrationState, PlanningInitiativeSummary, PlanningNodeSummary } from './planningWorkspaceModel';
+export declare function PlanningEntityDescription({ description, label, taskReferences, className, markdownClassName, }: {
+    description?: string | null;
+    label: string;
+    taskReferences?: TaskReferenceContract;
+    className?: string;
+    markdownClassName?: string;
+}): import("react/jsx-runtime").JSX.Element | null;
+export declare function PlanningEntityContext({ entityType, entityId, referenceLabel, workspaceId, attachments, onAddAttachment, onRemoveAttachment, onUpdateAttachmentCaption, readOnly, defaultExpanded, }: {
+    entityType: 'initiative' | 'workstream';
+    entityId: string;
+    referenceLabel: string;
+    workspaceId?: string | null;
+    attachments?: PlanningNodeSummary['attachments'];
+    onAddAttachment?: (file: AttachmentItem) => void;
+    onRemoveAttachment?: (index: number) => void;
+    onUpdateAttachmentCaption?: (index: number, caption: string) => void;
+    readOnly?: boolean;
+    defaultExpanded?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function PlanningEntityActivity({ entityType, item, assigneeOptions, currentActorId, taskReferences, parentInitiative, defaultExpanded, listClassName, emptyClassName, hydrationState, onRetryHydration, }: {
+    entityType: 'initiative' | 'workstream';
+    item: PlanningNodeSummary;
+    assigneeOptions: TaskAssigneeOption[];
+    currentActorId?: string | null;
+    taskReferences?: TaskReferenceContract;
+    parentInitiative?: PlanningInitiativeSummary | null;
+    defaultExpanded?: boolean;
+    listClassName?: string;
+    emptyClassName?: string;
+    hydrationState?: PlanningEntityHydrationState;
+    onRetryHydration?: () => void;
+}): import("react/jsx-runtime").JSX.Element;