@compilr-dev/cli 0.5.4 → 0.5.6

package/dist/agent.js

@@ -5,10 +5,12 @@
  * ClaudeProvider, OllamaProvider, OpenAIProvider, or GeminiProvider
  * and available tools.
  */
-import { Agent, ContextManager, DEFAULT_CONTEXT_CONFIG, createTaskTool, createSuggestTool, defaultAgentTypes, TOOL_SETS, BUILTIN_GUARDRAILS, createProviderFromType, } from '@compilr-dev/sdk';
+import { Agent, ContextManager, DEFAULT_CONTEXT_CONFIG, createTaskTool, createSuggestTool, defaultAgentTypes, TOOL_SETS, BUILTIN_GUARDRAILS, createProviderFromType, CapabilityManager, CAPABILITY_PACKS, GIT_SAFETY_MODULE, PLATFORM_TOOL_HINTS_MODULE, FACTORY_TOOL_HINTS_MODULE, TOOL_USAGE_META_MODULE, createLoadCapabilityTool, generateCapabilityCatalog, } from '@compilr-dev/sdk';
 import { isAutoCompactEnabled, isDelegationEnabled, getSetting } from './settings/index.js';
 import { getApiKey } from './utils/credentials.js';
-import { createToolRegistry, createMinimalToolRegistry, getDirectTools, getMetaTools, initializeMetaTools, getToolIndexForSystemPrompt, getToolStats, setMetaToolFilter, createToolFallback, } from './tools.js';
+import { createToolRegistry, createMinimalToolRegistry, getDirectTools, getMetaTools, initializeMetaTools, getToolIndexForSystemPrompt, getFilteredToolIndexForSystemPrompt, getToolStats, setMetaToolFilter, createToolFallback, getRegisteredMetaTools, } from './tools.js';
+import { TOOL_GROUPS } from './multi-agent/tool-config.js';
+import { setCapabilityManager } from './multi-agent/capability-loader.js';
 import { getAgentRegistry } from './agents/registry.js';
 import { SystemPromptBuilder } from './system-prompt/index.js';
 import { getDefaultModelForTier, getModelContextWindow } from './models/index.js';
@@ -126,6 +128,151 @@ function createProvider(options) {
         estimateTokens,
     });
 }
+// =============================================================================
+// Dynamic Capability Loading Helpers
+// =============================================================================
+/**
+ * Derive profile group IDs from a tool filter (array of tool names).
+ * A group is included if any of its tools are in the filter.
+ */
+function getProfileGroupsFromToolFilter(toolFilter) {
+    const toolSet = new Set(toolFilter);
+    const groups = [];
+    for (const [groupId, group] of Object.entries(TOOL_GROUPS)) {
+        if (group.tools.some((t) => toolSet.has(t))) {
+            groups.push(groupId);
+        }
+    }
+    return groups;
+}
+/**
+ * Scan recent messages for "Tool not found: X" errors and auto-load
+ * the corresponding capability packs (max 2 per turn, loadable only).
+ * Also detects forbidden tool access for handoff suggestions.
+ */
+function autoDetectCapabilities(manager, messages) {
+    const MAX_AUTO_LOADS = 2;
+    const result = { loaded: [], forbidden: [] };
+    const toolNotFoundPattern = /Tool not found: (\w+)/;
+    // Find the most recent user message (contains the last turn's tool results)
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role !== 'user' || typeof msg.content === 'string')
+            continue;
+        // Scan this message's tool_result blocks for "Tool not found" errors
+        for (const block of msg.content) {
+            if (block.type !== 'tool_result' || !block.isError || !block.content)
+                continue;
+            const match = toolNotFoundPattern.exec(block.content);
+            if (!match)
+                continue;
+            const toolName = match[1];
+            const packId = manager.findPackForTool(toolName);
+            if (!packId || manager.isLoaded(packId))
+                continue;
+            const tier = manager.getTier(packId);
+            if (tier === 'loadable' && result.loaded.length < MAX_AUTO_LOADS) {
+                manager.load(packId, 'auto-detect');
+                result.loaded.push(packId);
+            }
+            else if (tier === 'forbidden') {
+                result.forbidden.push({
+                    toolName,
+                    packId,
+                    suggestedAgent: manager.getSuggestedAgent(packId),
+                });
+            }
+        }
+        // Only scan the most recent user message
+        break;
+    }
+    return result;
+}
+function createCapabilityHook(manager, basePrompt, orphanTools) {
+    return (ctx) => {
+        // Auto-detect capability needs from tool failures (safety net)
+        let forbiddenHints = [];
+        if (manager.hasLoadablePacks() || ctx.messages.length > 1) {
+            const detected = autoDetectCapabilities(manager, ctx.messages);
+            // Generate handoff suggestions for forbidden tool access
+            if (detected.forbidden.length > 0) {
+                forbiddenHints = detected.forbidden.map((f) => {
+                    const agentHint = f.suggestedAgent
+                        ? ` Consider using handoff("${f.suggestedAgent}", "Need ${f.packId} access for ${f.toolName}").`
+                        : '';
+                    return `[System] Tool "${f.toolName}" requires ${f.packId} capability which is outside your tool profile.${agentHint}`;
+                });
+            }
+        }
+        const activeToolNames = manager.getActiveToolNames();
+        const activeModuleIds = manager.getActivePromptModuleIds();
+        // Include orphan tools (not in any capability pack) — always visible
+        const allActiveTools = [...activeToolNames, ...orphanTools];
+        // Update meta-tool filter for this turn
+        setMetaToolFilter(allActiveTools);
+        // Build dynamic system prompt sections
+        const dynamicSections = [];
+        // Meta-tools protocol (how to use get_tool_info/use_tool)
+        dynamicSections.push(TOOL_USAGE_META_MODULE.content);
+        // Conditional modules based on loaded capability packs
+        if (activeModuleIds.has('git-safety')) {
+            dynamicSections.push(GIT_SAFETY_MODULE.content);
+        }
+        if (activeModuleIds.has('platform-tool-hints')) {
+            dynamicSections.push(PLATFORM_TOOL_HINTS_MODULE.content);
+        }
+        if (activeModuleIds.has('factory-tool-hints')) {
+            dynamicSections.push(FACTORY_TOOL_HINTS_MODULE.content);
+        }
+        // Prompt snippets from loaded packs
+        const snippets = manager.getActivePromptSnippets();
+        if (snippets.length > 0) {
+            dynamicSections.push('## Active Tool Capabilities\n' + snippets.join('\n'));
+        }
+        // Filtered tool index (only loaded tools)
+        const filteredIndex = getFilteredToolIndexForSystemPrompt(allActiveTools);
+        dynamicSections.push(filteredIndex);
+        // Capability catalog (if loadable packs remain)
+        if (manager.hasLoadablePacks()) {
+            const catalog = manager.getCatalog();
+            const catalogSection = generateCapabilityCatalog(catalog, manager.getLoadedPackIds());
+            if (catalogSection) {
+                dynamicSections.push(catalogSection);
+            }
+        }
+        // Preserve anchors from the current system prompt.
+        // The agents library injects anchors into systemContent BEFORE this hook runs.
+        // We must extract and re-append them, since we rebuild the prompt from basePrompt.
+        let anchorsBlock = '';
+        const anchorMarker = '## Active Anchors (Critical Information)';
+        const anchorIdx = ctx.systemPrompt.indexOf(anchorMarker);
+        if (anchorIdx > 0) {
+            // Find the preceding "---\n\n" separator
+            const separatorBefore = ctx.systemPrompt.lastIndexOf('---', anchorIdx);
+            const startIdx = separatorBefore > 0 ? separatorBefore : anchorIdx;
+            // Find the end: either the next "---" after the anchor block, or end of string
+            const afterAnchor = ctx.systemPrompt.indexOf('\n\n---\n\n', anchorIdx);
+            if (afterAnchor > 0) {
+                // Anchors are followed by more content (e.g., role ending) — extract just the anchor block
+                anchorsBlock = '\n\n' + ctx.systemPrompt.substring(startIdx, afterAnchor + 7); // include trailing "---\n\n"
+            }
+            else {
+                // Anchors are at the end of the prompt
+                anchorsBlock = '\n\n' + ctx.systemPrompt.substring(startIdx);
+            }
+        }
+        const hookResult = {
+            systemPrompt: basePrompt + '\n\n' + dynamicSections.join('\n\n') + anchorsBlock,
+        };
+        // Inject forbidden boundary messages (handoff suggestions)
+        if (forbiddenHints.length > 0) {
+            const hintContent = forbiddenHints.join('\n');
+            const hintMessage = { role: 'user', content: hintContent };
+            hookResult.messages = [...ctx.messages, hintMessage];
+        }
+        return hookResult;
+    };
+}
 /**
  * Creates an Agent instance configured with all tools.
  */
@@ -165,18 +312,64 @@ export function createAgent(options = {}) {
     // which re-injects them on every LLM call (survives compaction)
     // Initialize meta-tools if enabled (needed for tool index)
     // includeWarmTools=true moves 11 warm tools into meta-registry (hot-tools mode)
-    let metaToolsIndex;
-    if (options.enableMetaTools && !options.minimal) {
+    const useMetaTools = options.enableMetaTools && !options.minimal;
+    if (useMetaTools) {
         initializeMetaTools(true);
-        metaToolsIndex = getToolIndexForSystemPrompt();
-        // Log tool stats (unless quiet mode)
+    }
+    // ==========================================================================
+    // Dynamic Capability Loading
+    // When meta-tools are enabled, create a CapabilityManager to control which
+    // tools and prompt modules are active per-turn.
+    // ==========================================================================
+    let capabilityManager;
+    let orphanToolNames = [];
+    if (useMetaTools) {
+        // Determine profile groups from toolFilter
+        const profileGroups = options.toolFilter
+            ? getProfileGroupsFromToolFilter(options.toolFilter)
+            : Object.keys(CAPABILITY_PACKS);
+        // Upfront groups: all direct-tier groups that are in the profile
+        const upfrontGroupIds = Object.entries(TOOL_GROUPS)
+            .filter(([, group]) => group.tier === 'direct')
+            .map(([id]) => id)
+            .filter((id) => profileGroups.includes(id));
+        capabilityManager = new CapabilityManager({
+            profileGroups,
+            packs: CAPABILITY_PACKS,
+            upfrontGroups: upfrontGroupIds,
+        });
+        // Expose the capability manager for slash command handlers (Phase 3)
+        setCapabilityManager(capabilityManager);
+        // Compute orphan tools (meta-registry tools not in any capability pack)
+        // These are always visible regardless of which packs are loaded.
+        const packedTools = new Set();
+        for (const pack of Object.values(CAPABILITY_PACKS)) {
+            for (const tool of pack.tools) {
+                packedTools.add(tool);
+            }
+        }
+        const registered = getRegisteredMetaTools();
+        orphanToolNames = registered
+            .map((t) => t.definition.name)
+            .filter((name) => !packedTools.has(name));
+        // Set initial meta-tool filter
+        setMetaToolFilter([...capabilityManager.getActiveToolNames(), ...orphanToolNames]);
+        // Log stats (unless quiet mode)
         if (!options.quiet) {
             const stats = getToolStats();
+            const loadedPacks = capabilityManager.getLoadedPackIds();
+            const loadableCount = capabilityManager.getCatalog().length;
             console.log(`[Meta-tools] Direct: ${String(stats.directTools)}, ` +
                 `Meta: ${String(stats.metaRegistryTools)}, ` +
                 `Est. savings: ~${String(stats.tokenSavings)} tokens`);
+            console.log(`[Capabilities] Upfront: ${String(loadedPacks.length)} packs, ` +
+                `Loadable: ${String(loadableCount)} packs`);
         }
     }
+    // Generate tool index for static system prompt (only when NOT using capability loading)
+    const metaToolsIndex = useMetaTools && !capabilityManager
+        ? getToolIndexForSystemPrompt()
+        : undefined;
     let systemPrompt;
     // Check if we should use minimal system prompt (for testing role identity)
     if (options.useMinimalSystemPrompt && options.systemPromptAddition) {
@@ -185,16 +378,18 @@ export function createAgent(options = {}) {
     }
     else {
         // Use modular system prompt builder
-        // When a role-specific identity is provided (systemPromptAddition), skip the default identity module
+        // When capability loading is active, exclude conditional modules:
+        // git-safety, platform-tool-hints, factory-tool-hints, tool-usage-meta
+        // These are dynamically added by the BeforeLLM hook based on loaded capabilities.
         const promptBuilder = new SystemPromptBuilder({
-            enableMetaTools: options.enableMetaTools && !options.minimal,
+            enableMetaTools: capabilityManager ? false : useMetaTools,
+            hasGit: capabilityManager ? false : undefined, // false = skip git-safety; undefined = auto-detect
             projectName: options.projectName,
             projectContext: options.projectContext,
             guidedModeContext: options.guidedModeContext,
             planModeContext: options.planModeContext,
             metaToolsIndex,
             hasRoleIdentity: !!options.systemPromptAddition, // Skip default identity when role is specified
-            // hasGit is auto-detected by builder
         });
         const buildResult = promptBuilder.build();
         systemPrompt = buildResult.prompt;
@@ -219,6 +414,8 @@ ${options.systemPromptAddition}
             systemPrompt = options.systemPromptAddition + '\n\n' + systemPrompt + roleEnding;
         }
     }
+    // Store base prompt for capability-aware BeforeLLM hook
+    const baseSystemPrompt = capabilityManager ? systemPrompt : undefined;
     const agent = new Agent({
         provider,
         systemPrompt,
@@ -284,9 +481,10 @@ ${options.systemPromptAddition}
                 },
             }
             : undefined,
-        // Hooks: context pressure, file lock check/acquire
+        // Hooks: context pressure, capability loading, file lock check/acquire
         hooks: {
             beforeLLM: [
+                // Context pressure hook
                 (ctx) => {
                     const utilization = contextManager.getUtilization();
                     if (utilization < 0.3)
@@ -306,6 +504,10 @@ ${options.systemPromptAddition}
                     messages.splice(1, 0, { role: 'user', content: hint });
                     return { messages };
                 },
+                // Capability-aware system prompt assembly (with auto-detection safety net)
+                ...(capabilityManager && baseSystemPrompt
+                    ? [createCapabilityHook(capabilityManager, baseSystemPrompt, orphanToolNames)]
+                    : []),
             ],
             beforeTool: [createFileLockCheckHook(getActiveProject)],
             afterTool: [
@@ -338,6 +540,10 @@ ${options.systemPromptAddition}
             // Hot-tools mode: only hot tools + get_tool_info (for schema introspection)
             // Warm tools + meta-registry tools are accessed transparently via fallback handler
             tools = [...getDirectTools(true), ...getMetaTools()];
+            // Add load_capability tool when the agent has loadable packs
+            if (capabilityManager?.hasLoadablePacks()) {
+                tools.push(createLoadCapabilityTool(capabilityManager));
+            }
         }
         else {
             // Legacy mode: all tools declared directly
@@ -347,14 +553,17 @@ ${options.systemPromptAddition}
         // Apply tool filter if specified (filter direct tools)
         if (options.toolFilter && options.toolFilter.length > 0) {
             const allowedTools = new Set(options.toolFilter);
-            // get_tool_info is always allowed for schema introspection
-            const alwaysAllowed = new Set(['get_tool_info']);
+            // get_tool_info and load_capability are always allowed
+            const alwaysAllowed = new Set(['get_tool_info', 'load_capability']);
             tools = tools.filter((tool) => allowedTools.has(tool.definition.name) || alwaysAllowed.has(tool.definition.name));
-            // Also set the meta-tool filter for use_tool/list_tools filtering
-            setMetaToolFilter(options.toolFilter);
+            // When capability loading is active, the BeforeLLM hook manages the meta-tool filter.
+            // Otherwise, set it to the full tool filter.
+            if (!capabilityManager) {
+                setMetaToolFilter(options.toolFilter);
+            }
         }
-        else {
-            // No filter - clear any previous filter
+        else if (!capabilityManager) {
+            // No filter and no capability loading - clear any previous filter
             setMetaToolFilter(null);
         }
         // Type assertion needed for tool registry compatibility

package/dist/commands-v2/handlers/project.js

@@ -10,6 +10,25 @@ import { setCurrentProject, getCurrentProject } from '../../tools/project-db.js'
 import { getSkillPrompt } from '../../repl-helpers.js';
 import { getModelTier, modelMeetsTier } from '../../utils/model-tiers.js';
 import { getCurrentProjectIdForTracking, handleProjectSwitch } from './session.js';
+import { loadCapabilitiesForSkill } from '../../multi-agent/capability-loader.js';
+/**
+ * Load capabilities for a skill and warn about forbidden packs.
+ * Called before queuing a skill-driven agent message.
+ */
+function loadSkillCapabilities(skillName, ctx) {
+    const result = loadCapabilitiesForSkill(skillName);
+    if (!result)
+        return; // No capability loading active or no requirements
+    if (result.forbidden.length > 0) {
+        const suggestions = result.forbidden
+            .map((f) => `${f.packId}${f.suggestedAgent ? ` (try ${f.suggestedAgent})` : ''}`)
+            .join(', ');
+        ctx.ui.print({
+            type: 'warning',
+            message: `Some capabilities are restricted: ${suggestions}`,
+        });
+    }
+}
 // =============================================================================
 // Helper Functions
 // =============================================================================
@@ -335,6 +354,8 @@ export const designCommand = {
                     break;
             }
         }
+        // Load capabilities for the design skill
+        loadSkillCapabilities('design', ctx);
         // Get design skill prompt
         const designPrompt = getSkillPrompt('design');
         if (!designPrompt) {
@@ -384,6 +405,8 @@ export const sketchCommand = {
             ctx.ui.print({ type: 'error', message: 'No project selected. Run /new or /projects first.' });
             return Promise.resolve(true);
         }
+        // Load capabilities for the sketch skill
+        loadSkillCapabilities('sketch', ctx);
         // Get sketch skill prompt
         const sketchPrompt = getSkillPrompt('sketch');
         if (!sketchPrompt) {
@@ -474,8 +497,9 @@ export const refineCommand = {
                 }
             }
         }
-        // Get appropriate skill prompt
+        // Get appropriate skill prompt and load capabilities
         const skillName = isFocusedRefine ? 'refine-item' : 'refine';
+        loadSkillCapabilities(skillName, ctx);
         const refinePrompt = getSkillPrompt(skillName);
         if (!refinePrompt) {
             ctx.ui.print({ type: 'error', message: `${skillName} skill not found.` });
@@ -605,7 +629,8 @@ export const buildCommand = {
                 }
             }
         }
-        // Get build skill prompt and replace placeholders
+        // Load capabilities and get build skill prompt
+        loadSkillCapabilities('build', ctx);
         let buildPrompt = getSkillPrompt('build');
         if (!buildPrompt) {
             ctx.ui.print({ type: 'error', message: 'Build skill not found.' });
@@ -683,7 +708,8 @@ export const noteCommand = {
             ctx.ui.print({ type: 'error', message: 'No project selected. Run /new or /projects first.' });
             return Promise.resolve(true);
         }
-        // Get session-notes skill prompt
+        // Load capabilities and get session-notes skill prompt
+        loadSkillCapabilities('session-notes', ctx);
         const notePrompt = getSkillPrompt('session-notes');
         if (!notePrompt) {
             ctx.ui.print({ type: 'error', message: 'Session-notes skill not found.' });
@@ -741,7 +767,8 @@ export const prdCommand = {
             ctx.ui.print({ type: 'error', message: 'No project selected. Run /new or /projects first.' });
             return Promise.resolve(true);
         }
-        // Get PRD skill prompt
+        // Load capabilities and get PRD skill prompt
+        loadSkillCapabilities('prd', ctx);
         const prdPrompt = getSkillPrompt('prd');
         if (!prdPrompt) {
             ctx.ui.print({ type: 'error', message: 'PRD skill not found.' });
@@ -866,6 +893,8 @@ export const scaffoldCommand = {
         else {
             skillName = 'scaffold';
         }
+        // Load capability packs for this skill
+        loadSkillCapabilities(skillName, ctx);
         // Get skill prompt and replace path placeholder
         let scaffoldPrompt = getSkillPrompt(skillName);
         if (!scaffoldPrompt) {
@@ -946,7 +975,8 @@ export const archCommand = {
             // User cancelled
             return true;
         }
-        // Get architecture skill prompt
+        // Load capabilities and get architecture skill prompt
+        loadSkillCapabilities('architecture', ctx);
         const archPrompt = getSkillPrompt('architecture');
         if (!archPrompt) {
             ctx.ui.print({ type: 'error', message: 'Architecture skill not found.' });

package/dist/commands-v2/handlers/settings.js

@@ -4,7 +4,7 @@
  * Commands for configuration: theme, config, verbose, model, tools, agents
  */
 import { ThemeOverlayV2, ModelOverlayV2, ToolsOverlayV2, KeysOverlayV2, MascotOverlayV2, AgentsOverlayV2, ConfigOverlayV2, PermissionsOverlayV2 } from '../../ui/overlay/index.js';
-import { getSetting, getSettings, recordUpdateCheck, permissionModeToAgentMode } from '../../settings/index.js';
+import { getSetting, getSettings, setSetting, recordUpdateCheck, permissionModeToAgentMode, getVerbosity } from '../../settings/index.js';
 import { getToolPermissionInfo } from '../../agent.js';
 import { checkForUpdates, performUpdate } from '../../utils/update-checker.js';
 import { getRegisteredMetaTools, TOOL_NAMES, getToolStats } from '../../tools.js';
@@ -84,6 +84,9 @@ export const configCommand = {
         });
         const result = await ctx.ui.showOverlay(configOverlay);
         if (result?.settingsChanged) {
+            // Sync TerminalUI config with persisted settings
+            const updated = getSettings();
+            ctx.ui.setConfig({ verbosity: updated.verbosity });
             ctx.ui.print({ type: 'info', message: 'Settings updated' });
         }
         return true;
@@ -94,16 +97,19 @@ export const configCommand = {
 // =============================================================================
 export const verboseCommand = {
     name: 'verbose',
-    description: 'Toggle verbose mode',
-    details: 'Toggles verbose mode on or off. When enabled, shows additional debug information during agent execution.',
+    description: 'Cycle verbosity level',
+    details: 'Cycles verbosity through Normal → Focused → Verbose. Normal shows compact output. Focused hides read-only tools (spinner only). Verbose shows thinking and full output.',
     examples: [{ code: '/verbose' }],
     execute(_args, ctx) {
-        const config = ctx.ui.getConfig();
-        const newVerbose = !config.verbose;
-        ctx.ui.setConfig({ verbose: newVerbose });
+        const current = getVerbosity();
+        const cycle = { normal: 'focused', focused: 'verbose', verbose: 'normal' };
+        const next = cycle[current];
+        setSetting('verbosity', next);
+        ctx.ui.setConfig({ verbosity: next });
+        const labels = { normal: 'Normal', focused: 'Focused', verbose: 'Verbose' };
         ctx.ui.print({
             type: 'info',
-            message: `Verbose mode: ${newVerbose ? 'ON' : 'OFF'}`,
+            message: `Verbosity: ${labels[next]}`,
         });
         return Promise.resolve(true);
     },

package/dist/multi-agent/capability-loader.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Capability Loader — Bridge between slash commands and the CapabilityManager.
+ *
+ * Stores a module-level reference to the current CapabilityManager
+ * (set by agent.ts during createAgent()). Provides a high-level function
+ * for slash command handlers to load capability packs required by a skill.
+ */
+import type { CapabilityManager, CapabilityLoadResult } from '@compilr-dev/sdk';
+/**
+ * Set the current CapabilityManager instance.
+ * Called by createAgent() after constructing the manager.
+ */
+export declare function setCapabilityManager(manager: CapabilityManager | null): void;
+/**
+ * Get the current CapabilityManager instance.
+ * Returns null if capability loading is not active.
+ */
+export declare function getCapabilityManager(): CapabilityManager | null;
+/**
+ * Load capability packs required by a skill invocation.
+ *
+ * Maps the skill's required + optional tool names to capability pack IDs,
+ * then loads each loadable pack. Returns a result indicating what was loaded,
+ * what was already loaded, and what is forbidden.
+ *
+ * @param skillName - Skill name (e.g., 'design', 'build', 'refactor')
+ * @returns Load result, or null if capability loading is not active or skill has no requirements
+ */
+export declare function loadCapabilitiesForSkill(skillName: string): CapabilityLoadResult | null;

package/dist/multi-agent/capability-loader.js

@@ -0,0 +1,54 @@
+/**
+ * Capability Loader — Bridge between slash commands and the CapabilityManager.
+ *
+ * Stores a module-level reference to the current CapabilityManager
+ * (set by agent.ts during createAgent()). Provides a high-level function
+ * for slash command handlers to load capability packs required by a skill.
+ */
+import { SKILL_REQUIREMENTS } from './skill-requirements.js';
+// =============================================================================
+// Module-level state
+// =============================================================================
+let currentManager = null;
+/**
+ * Set the current CapabilityManager instance.
+ * Called by createAgent() after constructing the manager.
+ */
+export function setCapabilityManager(manager) {
+    currentManager = manager;
+}
+/**
+ * Get the current CapabilityManager instance.
+ * Returns null if capability loading is not active.
+ */
+export function getCapabilityManager() {
+    return currentManager;
+}
+// =============================================================================
+// Skill-based capability loading
+// =============================================================================
+/**
+ * Load capability packs required by a skill invocation.
+ *
+ * Maps the skill's required + optional tool names to capability pack IDs,
+ * then loads each loadable pack. Returns a result indicating what was loaded,
+ * what was already loaded, and what is forbidden.
+ *
+ * @param skillName - Skill name (e.g., 'design', 'build', 'refactor')
+ * @returns Load result, or null if capability loading is not active or skill has no requirements
+ */
+export function loadCapabilitiesForSkill(skillName) {
+    if (!currentManager) {
+        return null;
+    }
+    if (!(skillName in SKILL_REQUIREMENTS)) {
+        return null;
+    }
+    const requirements = SKILL_REQUIREMENTS[skillName];
+    // Combine required + optional tools
+    const allTools = [
+        ...requirements.required,
+        ...(requirements.optional ?? []),
+    ];
+    return currentManager.loadForSkill(allTools, 'slash-command');
+}

package/dist/repl-v2.js

@@ -24,7 +24,8 @@ import { getCurrentProject } from './tools/project-db.js';
 import { TerminalUI } from './ui/terminal-ui.js';
 import * as terminal from './ui/terminal.js';
 import { getStyles } from './themes/index.js';
-import { getSettings, getStartupMode, syncPermissionModeFromUI, getPermissionMode, permissionModeToAgentMode, getProjectSessionMode, isFirstRunComplete, getSessionRetentionDays, updateSettings } from './settings/index.js';
+import { getSettings, getStartupMode, syncPermissionModeFromUI, getPermissionMode, permissionModeToAgentMode, getProjectSessionMode, isFirstRunComplete, getSessionRetentionDays, updateSettings, getVerbosity } from './settings/index.js';
+import { isReadOnlyTool } from './utils/readonly-tools.js';
 import { renderMascotWithLogo } from './ui/mascot/renderer.js';
 import { getStartupHighlights } from './changelog/index.js';
 import { registerCommands, executeCommand, allCommands, getAutocompleteCommands, saveCurrentSession, saveCurrentTeam, loadProjectSession, archiveCurrentSession, convertMessagesToItems, } from './commands-v2/index.js';
@@ -801,6 +802,7 @@ export class ReplV2 {
         const initialUiMode = permissionModeToAgentMode(savedPermissionMode);
         this.ui = new TerminalUI({
             initialMode: initialUiMode,
+            config: { verbosity: getVerbosity() },
         });
         // Print welcome screen
         // Skip if: login overlay shows its own branded welcome,
@@ -2483,6 +2485,7 @@ export class ReplV2 {
                                     params: categoryParam,
                                     summary: `${String(count)} tools available`,
                                     success: result.success,
+                                    readOnly: isReadOnlyTool('list_tools'),
                                     agentId: activeAgentId,
                                 });
                                 this.ui.setCurrentTool(null);
@@ -2517,6 +2520,7 @@ export class ReplV2 {
                                     content: content || undefined,
                                     diffLines: innerDiffLines,
                                     success,
+                                    readOnly: isReadOnlyTool(innerToolName),
                                     agentId: activeAgentId,
                                 });
                                 this.ui.setCurrentTool(null);
@@ -2545,6 +2549,7 @@ export class ReplV2 {
                                     params: name,
                                     summary: `Schema: ${name}`,
                                     success: result.success,
+                                    readOnly: isReadOnlyTool('get_tool_info'),
                                     agentId: activeAgentId,
                                 });
                                 this.ui.setCurrentTool(null);
@@ -2590,6 +2595,7 @@ export class ReplV2 {
                                 content: content || undefined,
                                 diffLines,
                                 success,
+                                readOnly: isReadOnlyTool(toolName),
                                 agentId: activeAgentId,
                             });
                             this.ui.setCurrentTool(null);
@@ -3154,6 +3160,7 @@ export class ReplV2 {
                         params: '**/*.ts',
                         summary: 'Found 42 files',
                         content: 'src/index.ts\nsrc/config.ts\nsrc/utils/helpers.ts\n... and 39 more',
+                        readOnly: true,
                     });
                     this.ui.setTodos([
                         { content: 'Analyze the request', status: 'completed' },

package/dist/settings/index.d.ts

@@ -13,6 +13,7 @@ export type ProjectStartupMode = 'last' | 'off';
 export type MascotSetting = 'none' | 'random' | 'neutral' | 'thinking' | 'looking_left' | 'looking_right' | 'sleeping' | 'alert' | 'error' | 'success' | 'success_minimal' | 'searching' | 'skeptical';
 export type ProjectSessionMode = 'auto' | 'ask' | 'fresh';
 export type CompactMode = 'active' | 'all' | 'auto';
+export type Verbosity = 'normal' | 'focused' | 'verbose';
 /**
  * Permission rule for a tool or pattern.
  * Supports wildcards: git_* matches git_commit, git_branch, etc.
@@ -34,6 +35,7 @@ export interface Settings {
     showTips: boolean;
     reviseCode: boolean;
     verbose: boolean;
+    verbosity: Verbosity;
     progressBar: boolean;
     checkUpdates: boolean;
     lastUpdateCheck: number | null;
@@ -82,6 +84,7 @@ export declare const getDefaultModel: () => string | null;
 export declare const isAutoCompactEnabled: () => boolean;
 export declare const isShowTipsEnabled: () => boolean;
 export declare const isReviseCodeEnabled: () => boolean;
+export declare const getVerbosity: () => Verbosity;
 export declare const isVerboseEnabled: () => boolean;
 export declare const isProgressBarEnabled: () => boolean;
 export declare const isTelemetryEnabled: () => boolean;
@@ -166,6 +169,14 @@ export declare function sessionRetentionToDisplay(days: number): string;
  * Map display value to session retention days
  */
 export declare function displayToSessionRetention(display: string): number;
+/**
+ * Map internal verbosity to display value
+ */
+export declare function verbosityToDisplay(v: Verbosity): string;
+/**
+ * Map display value to internal verbosity
+ */
+export declare function displayToVerbosity(d: string): Verbosity;
 /**
  * Map internal compact mode to display value
  */