@bbigbang/core 0.1.0

package/dist/web/contextBundleResolver.js

@@ -0,0 +1,488 @@
+import { buildThreadShortId, } from '@bbigbang/protocol';
+import { listRecentConversationHandoffs } from './conversationHandoffs.js';
+import { getConversationSummary, listConversationSummariesForAgent } from './conversationSummaries.js';
+import { compareRankedItems, scoreHandoffCandidate, scoreSurfaceCandidate, scoreTaskCandidate } from './contextBundleRanking.js';
+const DEFAULT_MAX_SURFACES = 4;
+const DEFAULT_MAX_TASKS = 3;
+const DEFAULT_MAX_HANDOFFS = 3;
+export function buildContextBundle(db, agent, conversationId, options) {
+    const currentConversation = getConversationSummary(db, agent, conversationId);
+    if (!currentConversation)
+        return null;
+    const maxSurfaces = clampCount(options?.maxSurfaces, DEFAULT_MAX_SURFACES, 8);
+    const maxTasks = clampCount(options?.maxTasks, DEFAULT_MAX_TASKS, 8);
+    const maxHandoffs = clampCount(options?.maxHandoffs, DEFAULT_MAX_HANDOFFS, 8);
+    const nowMs = Date.now();
+    const currentTargetFamily = getTargetFamily(currentConversation.replyTarget);
+    const currentThreadRootId = normalizeText(currentConversation.threadRootId);
+    const currentOwnerName = normalizeText(currentConversation.summary.ownerName);
+    const currentParticipants = new Set(currentConversation.summary.participants.map((name) => name.trim().toLowerCase()).filter(Boolean));
+    const currentTaskRefs = collectCurrentTaskRefs(currentConversation);
+    const currentTaskIds = collectCurrentTaskIds(currentConversation);
+    const currentBoundTaskId = currentConversation.summary.boundTask?.taskId ?? null;
+    const handoffs = listRecentConversationHandoffs(db, agent.agentId, Math.max(12, maxHandoffs * 4));
+    const surfaces = listConversationSummariesForAgent(db, agent)
+        .filter((conversation) => conversation.conversationId !== conversationId);
+    const tasks = listAgentTaskCandidates(db, agent.agentId)
+        .filter((task) => task.taskId !== currentBoundTaskId);
+    const rankedSurfaces = surfaces
+        .map((conversation) => buildSurfaceItem({
+        conversation,
+        currentConversation,
+        currentTargetFamily,
+        currentThreadRootId,
+        currentOwnerName,
+        currentParticipants,
+        currentTaskRefs,
+        currentTaskIds,
+        handoffs,
+        nowMs,
+    }))
+        .filter((item) => Boolean(item))
+        .sort(compareRankedItems);
+    const rankedTasks = tasks
+        .map((task) => buildTaskItem({
+        task,
+        currentTargetFamily,
+        currentTaskRefs,
+        currentTaskIds,
+        handoffs,
+        nowMs,
+    }))
+        .filter((item) => Boolean(item))
+        .sort(compareRankedItems);
+    const rankedHandoffs = handoffs
+        .map((handoff) => buildHandoffItem({
+        handoff,
+        currentConversationId: conversationId,
+        currentTargetFamily,
+        currentTaskRefs,
+        currentTaskIds,
+        nowMs,
+    }))
+        .filter((item) => Boolean(item))
+        .sort(compareRankedItems);
+    const selectedItems = [
+        ...rankedSurfaces.slice(0, maxSurfaces),
+        ...rankedTasks.slice(0, maxTasks),
+        ...rankedHandoffs.slice(0, maxHandoffs),
+    ].sort(compareRankedItems);
+    const omittedItems = [
+        ...rankedSurfaces.slice(maxSurfaces),
+        ...rankedTasks.slice(maxTasks),
+        ...rankedHandoffs.slice(maxHandoffs),
+    ];
+    const recommended = recommendRelevantContextNextAction(selectedItems);
+    return {
+        generatedAt: new Date(nowMs).toISOString(),
+        currentConversation: {
+            conversationId: currentConversation.conversationId,
+            replyTarget: currentConversation.replyTarget,
+            status: currentConversation.status,
+            surfaceKind: currentConversation.surfaceKind,
+            boundTaskRef: currentConversation.summary.boundTask?.agentTaskRef ?? null,
+            linkedTaskRefs: currentConversation.summary.linkedTaskRefs,
+        },
+        recommendedNextAction: recommended.action,
+        recommendedNextActionReason: recommended.reason,
+        suggestedHistoryReads: buildContextBundleHistorySuggestions(selectedItems),
+        items: selectedItems,
+        totalCount: rankedSurfaces.length + rankedTasks.length + rankedHandoffs.length,
+        truncated: omittedItems.length > 0,
+        overflowByStatus: summarizeContextBundleOverflowByStatus(omittedItems),
+    };
+}
+export function buildRelevantContextHintSection(bundle) {
+    const top = bundle?.items[0];
+    if (!top || !hasStrongRelevantContextHintSignal(top))
+        return '';
+    return [
+        '[Relevant context hint]',
+        'Treat this as a narrowing hint, not a mandatory route.',
+        `Top related item: ${formatRelevantContextHintItem(top)}`,
+        `Context signal: ${bundle.recommendedNextActionReason}`,
+        'If you need the full ranked bundle before deciding what to inspect or whether to hand off, run bigbang context bundle --format json.',
+    ].join('\n');
+}
+function buildSurfaceItem(params) {
+    const candidateTaskRefs = new Set(params.conversation.summary.linkedTaskRefs.map(normalizeTaskRef).filter(Boolean));
+    const candidateTaskIds = new Set(params.conversation.summary.linkedTasks.map((task) => task.taskId).filter(Boolean));
+    if (params.conversation.summary.boundTask?.taskId)
+        candidateTaskIds.add(params.conversation.summary.boundTask.taskId);
+    if (params.conversation.summary.boundTask?.agentTaskRef) {
+        candidateTaskRefs.add(normalizeTaskRef(params.conversation.summary.boundTask.agentTaskRef));
+    }
+    const relatedHandoffs = params.handoffs.filter((handoff) => (handoff.sourceConversationId === params.conversation.conversationId
+        || handoff.targetConversationId === params.conversation.conversationId));
+    const participantOverlapCount = params.conversation.summary.participants.reduce((count, participant) => (params.currentParticipants.has(participant.trim().toLowerCase()) ? count + 1 : count), 0);
+    const linkedTaskMatches = intersectSets(params.currentTaskRefs, candidateTaskRefs);
+    const hasBoundTaskMatch = hasSetOverlap(params.currentTaskIds, candidateTaskIds);
+    const hasActiveHandoff = relatedHandoffs.some((handoff) => isOpenHandoff(handoff) && relatesToCurrent(handoff, params.currentConversation, params.currentTaskRefs, params.currentTaskIds));
+    const hasRecentHandoff = relatedHandoffs.some((handoff) => !isOpenHandoff(handoff) && relatesToCurrent(handoff, params.currentConversation, params.currentTaskRefs, params.currentTaskIds));
+    const ranked = scoreSurfaceCandidate({
+        hasBoundTaskMatch,
+        linkedTaskMatches,
+        hasActiveHandoff,
+        hasRecentHandoff,
+        isSameThreadRoot: Boolean(params.currentThreadRootId) && params.currentThreadRootId === normalizeText(params.conversation.threadRootId),
+        isSameTargetFamily: getTargetFamily(params.conversation.replyTarget) === params.currentTargetFamily,
+        participantOverlapCount,
+        ownerMatch: Boolean(params.currentOwnerName) && params.currentOwnerName === normalizeText(params.conversation.summary.ownerName),
+        hasRole: Boolean(params.conversation.summary.myRole),
+        unreadCount: params.conversation.unreadCount,
+        queuedPromptCount: params.conversation.queuedPromptCount,
+        updatedAt: params.conversation.updatedAt,
+        nowMs: params.nowMs,
+    });
+    if (ranked.score <= 0)
+        return null;
+    return {
+        kind: 'surface',
+        score: ranked.score,
+        reasons: ranked.reasons,
+        updatedAt: params.conversation.updatedAt,
+        conversationId: params.conversation.conversationId,
+        replyTarget: params.conversation.replyTarget,
+        status: params.conversation.status,
+        surfaceKind: params.conversation.surfaceKind,
+        threadKind: params.conversation.threadKind,
+        threadRootId: params.conversation.threadRootId ?? null,
+        unreadCount: params.conversation.unreadCount,
+        queuedPromptCount: params.conversation.queuedPromptCount,
+        goal: params.conversation.summary.goal,
+        nextStep: params.conversation.summary.nextStep,
+        myRole: params.conversation.summary.myRole,
+        ownerName: params.conversation.summary.ownerName,
+        linkedTaskRefs: params.conversation.summary.linkedTaskRefs,
+        boundTask: params.conversation.summary.boundTask,
+        activeHandoff: params.conversation.summary.activeHandoff,
+        lastMessage: params.conversation.summary.lastMessage,
+        summaryText: params.conversation.summaryText,
+    };
+}
+function buildTaskItem(params) {
+    const normalizedTaskRef = normalizeTaskRef(params.task.agentTaskRef);
+    const linkedTaskMatches = [
+        ...(normalizedTaskRef && params.currentTaskRefs.has(normalizedTaskRef) ? [normalizedTaskRef] : []),
+        ...(params.currentTaskIds.has(params.task.taskId) ? [params.task.taskId] : []),
+    ];
+    const hasBoundTaskMatch = params.currentTaskIds.has(params.task.taskId);
+    const relatedHandoffs = params.handoffs.filter((handoff) => (handoffMatchesTaskIdentity(handoff, {
+        taskId: params.task.taskId,
+        normalizedTaskRef,
+    })));
+    const threadTarget = buildTaskThreadTarget(params.task.sourceTarget, params.task.messageId);
+    const ranked = scoreTaskCandidate({
+        hasBoundTaskMatch,
+        linkedTaskMatches,
+        hasActiveHandoff: relatedHandoffs.some(isOpenHandoff),
+        hasRecentHandoff: relatedHandoffs.some((handoff) => !isOpenHandoff(handoff)),
+        isSameTargetFamily: getTargetFamily(threadTarget ?? params.task.sourceTarget ?? '') === params.currentTargetFamily,
+        status: params.task.status,
+        updatedAt: new Date(params.task.updatedAt).toISOString(),
+        nowMs: params.nowMs,
+    });
+    if (ranked.score <= 0)
+        return null;
+    return {
+        kind: 'task',
+        score: ranked.score,
+        reasons: ranked.reasons,
+        updatedAt: new Date(params.task.updatedAt).toISOString(),
+        taskId: params.task.taskId,
+        agentTaskRef: params.task.agentTaskRef,
+        taskNumber: params.task.taskNumber,
+        title: params.task.title,
+        status: params.task.status,
+        sourceTarget: params.task.sourceTarget,
+        sourceLabel: buildTaskSourceLabel(params.task.channelId, params.task.sourceTarget, params.task.channelName),
+        threadTarget,
+    };
+}
+function buildHandoffItem(params) {
+    const ranked = scoreHandoffCandidate({
+        matchesCurrentConversation: params.handoff.sourceConversationId === params.currentConversationId || params.handoff.targetConversationId === params.currentConversationId,
+        hasRelatedTaskMatch: handoffMatchesCurrentTaskContext(params.handoff, params.currentTaskIds, params.currentTaskRefs),
+        isSameTargetFamily: getTargetFamily(params.handoff.targetReplyTarget) === params.currentTargetFamily
+            || getTargetFamily(params.handoff.payload.sourceTarget ?? '') === params.currentTargetFamily,
+        status: params.handoff.status,
+        updatedAt: params.handoff.updatedAt,
+        nowMs: params.nowMs,
+    });
+    if (ranked.score <= 0)
+        return null;
+    return {
+        kind: 'handoff',
+        score: ranked.score,
+        reasons: ranked.reasons,
+        updatedAt: params.handoff.updatedAt,
+        handoffId: params.handoff.handoffId,
+        mode: params.handoff.mode,
+        status: params.handoff.status,
+        workflowKind: params.handoff.workflowKind,
+        sourceDisposition: params.handoff.sourceDisposition,
+        sourceConversationId: params.handoff.sourceConversationId,
+        sourceTarget: params.handoff.payload.sourceTarget,
+        targetConversationId: params.handoff.targetConversationId,
+        targetReplyTarget: params.handoff.targetReplyTarget,
+        goal: params.handoff.payload.goal,
+        relatedTaskRef: params.handoff.payload.relatedTaskRef,
+        taskId: params.handoff.taskId,
+        taskNumber: params.handoff.taskNumber,
+    };
+}
+export function recommendRelevantContextNextAction(items) {
+    const top = items[0];
+    if (!top) {
+        return {
+            action: 'stay_on_current_surface',
+            reason: 'No higher-signal related surface, task, or handoff was found.',
+        };
+    }
+    if (top.kind === 'handoff') {
+        if (top.status === 'started' || top.status === 'accepted') {
+            return {
+                action: 'check_handoff',
+                reason: `Open handoff ${top.handoffId} is the highest-signal related context.`,
+            };
+        }
+        return {
+            action: 'inspect_surface',
+            reason: `Recent handoff ${top.handoffId} is the highest-signal related context.`,
+        };
+    }
+    if (top.kind === 'task') {
+        return {
+            action: 'read_task_history',
+            reason: `Task ${formatTaskIdentity(top.agentTaskRef, top.taskNumber)} is the highest-signal related context.`,
+        };
+    }
+    const reasonCodes = new Set(top.reasons.map((reason) => reason.code));
+    if (reasonCodes.has('active_handoff')) {
+        return {
+            action: 'check_handoff',
+            reason: `${top.replyTarget} has an open handoff relationship with the current work.`,
+        };
+    }
+    if (reasonCodes.has('bound_task_match') || reasonCodes.has('linked_task_match')) {
+        if ((reasonCodes.has('queued_activity') || reasonCodes.has('unread_activity')) && isRunnableSurfaceStatus(top.status)) {
+            return {
+                action: 'handoff_candidate',
+                reason: `${top.replyTarget} shares the current task context and already has waiting activity.`,
+            };
+        }
+        return {
+            action: 'inspect_surface',
+            reason: `${top.replyTarget} shares the current task context.`,
+        };
+    }
+    if (reasonCodes.has('unread_activity') || reasonCodes.has('queued_activity')) {
+        return {
+            action: 'read_history',
+            reason: `${top.replyTarget} has waiting activity to inspect.`,
+        };
+    }
+    return {
+        action: 'inspect_surface',
+        reason: `${top.replyTarget} is the highest-signal neighboring surface.`,
+    };
+}
+export function buildContextBundleHistorySuggestions(items) {
+    const suggestions = [];
+    const seenTargets = new Set();
+    for (const item of items) {
+        if (suggestions.length >= 3)
+            break;
+        if (item.kind === 'surface') {
+            if (seenTargets.has(item.replyTarget))
+                continue;
+            seenTargets.add(item.replyTarget);
+            suggestions.push({
+                target: item.replyTarget,
+                around: item.lastMessage?.messageId ?? null,
+                includeRoot: item.surfaceKind === 'dm_thread' || item.surfaceKind === 'channel_thread',
+                reason: item.reasons[0]?.label ?? 'Top-ranked related surface',
+            });
+            continue;
+        }
+        if (item.kind === 'handoff') {
+            if (seenTargets.has(item.targetReplyTarget))
+                continue;
+            seenTargets.add(item.targetReplyTarget);
+            suggestions.push({
+                target: item.targetReplyTarget,
+                includeRoot: isThreadTarget(item.targetReplyTarget),
+                reason: item.reasons[0]?.label ?? 'Top-ranked related handoff target',
+            });
+        }
+    }
+    return suggestions;
+}
+export function summarizeContextBundleOverflowByStatus(items) {
+    return items.reduce((counts, item) => {
+        const statusKey = `${item.kind}:${item.status}`;
+        counts[statusKey] = (counts[statusKey] ?? 0) + 1;
+        return counts;
+    }, {});
+}
+function isRunnableSurfaceStatus(status) {
+    return status === 'active' || status === 'queued' || status === 'recovering';
+}
+function isThreadTarget(target) {
+    const trimmed = target.trim();
+    if (trimmed.startsWith('dm:@'))
+        return trimmed.split(':').length >= 3;
+    if (trimmed.startsWith('#'))
+        return trimmed.includes(':');
+    return false;
+}
+function collectCurrentTaskRefs(conversation) {
+    const refs = new Set();
+    for (const taskRef of conversation.summary.linkedTaskRefs) {
+        const normalized = normalizeTaskRef(taskRef);
+        if (normalized)
+            refs.add(normalized);
+    }
+    const boundTaskRef = normalizeTaskRef(conversation.summary.boundTask?.agentTaskRef);
+    if (boundTaskRef)
+        refs.add(boundTaskRef);
+    return refs;
+}
+function collectCurrentTaskIds(conversation) {
+    const ids = new Set();
+    for (const task of conversation.summary.linkedTasks) {
+        if (task.taskId)
+            ids.add(task.taskId);
+    }
+    if (conversation.summary.boundTask?.taskId)
+        ids.add(conversation.summary.boundTask.taskId);
+    return ids;
+}
+function listAgentTaskCandidates(db, agentId) {
+    return db.prepare(`SELECT t.task_id as taskId,
+            t.agent_task_ref as agentTaskRef,
+            t.channel_id as channelId,
+            t.task_number as taskNumber,
+            t.title,
+            t.status,
+            t.updated_at as updatedAt,
+            t.message_id as messageId,
+            COALESCE(t.dm_target, cm.target) as sourceTarget,
+            ch.name as channelName
+       FROM tasks t
+       LEFT JOIN task_participants tp ON tp.task_id = t.task_id AND tp.agent_id = ?
+       LEFT JOIN channel_messages cm ON cm.message_id = t.message_id
+       LEFT JOIN channels ch ON ch.channel_id = t.channel_id
+      WHERE t.claimed_by_agent_id = ? OR tp.agent_id = ?
+      ORDER BY t.updated_at DESC, t.created_at DESC
+      LIMIT 24`).all(agentId, agentId, agentId);
+}
+function relatesToCurrent(handoff, currentConversation, currentTaskRefs, currentTaskIds) {
+    if (handoff.sourceConversationId === currentConversation.conversationId || handoff.targetConversationId === currentConversation.conversationId) {
+        return true;
+    }
+    if (handoffMatchesCurrentTaskContext(handoff, currentTaskIds, currentTaskRefs))
+        return true;
+    const currentTargetFamily = getTargetFamily(currentConversation.replyTarget);
+    return getTargetFamily(handoff.targetReplyTarget) === currentTargetFamily
+        || getTargetFamily(handoff.payload.sourceTarget ?? '') === currentTargetFamily;
+}
+function handoffMatchesCurrentTaskContext(handoff, currentTaskIds, currentTaskRefs) {
+    if (handoff.taskId)
+        return currentTaskIds.has(handoff.taskId);
+    const relatedTaskRef = normalizeTaskRef(handoff.payload.relatedTaskRef);
+    return relatedTaskRef ? currentTaskRefs.has(relatedTaskRef) : false;
+}
+function handoffMatchesTaskIdentity(handoff, params) {
+    if (handoff.taskId)
+        return handoff.taskId === params.taskId;
+    return Boolean(params.normalizedTaskRef) && normalizeTaskRef(handoff.payload.relatedTaskRef) === params.normalizedTaskRef;
+}
+function buildTaskSourceLabel(channelId, sourceTarget, channelName) {
+    if (sourceTarget)
+        return sourceTarget;
+    if (channelId.startsWith('dm:'))
+        return channelId;
+    return `#${channelName ?? channelId}`;
+}
+export function buildTaskThreadTarget(sourceTarget, messageId) {
+    if (!sourceTarget || !messageId)
+        return null;
+    const normalizedTarget = sourceTarget.trim();
+    if (!(normalizedTarget.startsWith('dm:@') || normalizedTarget.startsWith('#')))
+        return null;
+    if (isThreadTarget(normalizedTarget))
+        return normalizedTarget;
+    return `${normalizedTarget}:${buildThreadShortId(messageId)}`;
+}
+function hasStrongRelevantContextHintSignal(item) {
+    return item.reasons.some((reason) => (reason.code === 'active_handoff'
+        || reason.code === 'bound_task_match'
+        || reason.code === 'current_conversation_handoff'));
+}
+function formatRelevantContextHintItem(item) {
+    if (item.kind === 'surface') {
+        return `surface ${item.replyTarget} [${item.status}]`;
+    }
+    if (item.kind === 'task') {
+        const target = item.threadTarget ?? item.sourceTarget;
+        return target
+            ? `task ${formatTaskIdentity(item.agentTaskRef, item.taskNumber)} [${item.status}] -> ${target}`
+            : `task ${formatTaskIdentity(item.agentTaskRef, item.taskNumber)} [${item.status}]`;
+    }
+    const source = item.sourceTarget ?? item.sourceConversationId;
+    return `handoff ${item.mode} [${item.status}] ${source} -> ${item.targetReplyTarget}`;
+}
+function formatTaskIdentity(agentTaskRef, taskNumber) {
+    if (agentTaskRef && taskNumber != null)
+        return `${agentTaskRef} · #t${taskNumber}`;
+    if (agentTaskRef)
+        return agentTaskRef;
+    if (taskNumber != null)
+        return `#t${taskNumber}`;
+    return 'task';
+}
+function clampCount(value, defaultValue, maxValue) {
+    if (!Number.isFinite(value))
+        return defaultValue;
+    return Math.max(1, Math.min(Math.floor(value), maxValue));
+}
+function normalizeTaskRef(taskRef) {
+    return taskRef?.trim().toLowerCase() ?? '';
+}
+function normalizeText(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed.toLowerCase() : null;
+}
+function getTargetFamily(target) {
+    const trimmed = target.trim().toLowerCase();
+    if (!trimmed)
+        return '';
+    if (trimmed.startsWith('dm:@')) {
+        const parts = trimmed.split(':');
+        return parts.length >= 2 ? `${parts[0]}:${parts[1]}` : trimmed;
+    }
+    if (trimmed.startsWith('#')) {
+        const index = trimmed.indexOf(':');
+        return index >= 0 ? trimmed.slice(0, index) : trimmed;
+    }
+    return trimmed;
+}
+function isOpenHandoff(handoff) {
+    return handoff.status === 'started' || handoff.status === 'accepted';
+}
+function hasSetOverlap(left, right) {
+    for (const value of left) {
+        if (right.has(value))
+            return true;
+    }
+    return false;
+}
+function intersectSets(left, right) {
+    const values = [];
+    for (const value of left) {
+        if (right.has(value))
+            values.push(value);
+    }
+    return values;
+}

package/dist/web/conversationBuiltinSkillRoots.js

@@ -0,0 +1,50 @@
+import { BUILTIN_LIBRARY_DOCUMENTS_SKILL_ROOT_SENTINEL, BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL, BUILTIN_WORKSPACE_TOOL_SKILL_ROOT_SENTINEL, } from '@bbigbang/protocol';
+export const CONVERSATION_BUILTIN_SKILL_ROOTS = [
+    BUILTIN_WORKSPACE_TOOL_SKILL_ROOT_SENTINEL,
+    BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL,
+    BUILTIN_LIBRARY_DOCUMENTS_SKILL_ROOT_SENTINEL,
+];
+const BUILTIN_SKILL_ROOT_SET = new Set(CONVERSATION_BUILTIN_SKILL_ROOTS);
+export function isConversationBuiltinSkillRoot(value) {
+    return BUILTIN_SKILL_ROOT_SET.has(value);
+}
+export function normalizeConversationBuiltinSkillRoots(values) {
+    const enabled = new Set();
+    for (const rawValue of values) {
+        const value = rawValue?.trim();
+        if (!value || !isConversationBuiltinSkillRoot(value))
+            continue;
+        enabled.add(value);
+    }
+    return CONVERSATION_BUILTIN_SKILL_ROOTS.filter((value) => enabled.has(value));
+}
+export function parseConversationBuiltinSkillRoots(raw) {
+    if (!raw?.trim())
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return normalizeConversationBuiltinSkillRoots(parsed.map((value) => (typeof value === 'string' ? value : null)));
+    }
+    catch {
+        return [];
+    }
+}
+export function serializeConversationBuiltinSkillRoots(values) {
+    return JSON.stringify(normalizeConversationBuiltinSkillRoots(values));
+}
+export function conversationBuiltinSkillRootsForSlashCommand(slashCommandName) {
+    const normalized = slashCommandName?.trim().toLowerCase();
+    if (normalized === 'tool' || normalized === 'tool:plan') {
+        return [
+            BUILTIN_WORKSPACE_TOOL_SKILL_ROOT_SENTINEL,
+            BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL,
+        ];
+    }
+    if (normalized === 'panel' || normalized === 'panel:plan')
+        return [BUILTIN_UI_PANEL_SKILL_ROOT_SENTINEL];
+    if (normalized === 'document')
+        return [BUILTIN_LIBRARY_DOCUMENTS_SKILL_ROOT_SENTINEL];
+    return [];
+}