@compilr-dev/cli 0.5.17 → 0.6.1

package/dist/agent.js

@@ -1,45 +1,108 @@
 /**
  * Agent Configuration
  *
- * Creates and configures the Agent instance with
- * ClaudeProvider, OllamaProvider, OpenAIProvider, or GeminiProvider
- * and available tools.
+ * Thin wrapper around createCompilrAgent() from @compilr-dev/sdk.
+ * Handles CLI-specific concerns: credential resolution, system prompt
+ * assembly, subagent callbacks, and token estimates.
  */
 import { log } from './foundation/logger.js';
-import { Agent, ContextManager, DEFAULT_CONTEXT_CONFIG, createTaskTool, createSuggestTool, defaultAgentTypes, TOOL_SETS, BUILTIN_GUARDRAILS, createProviderFromType, CapabilityManager, CapabilityContext, CAPABILITY_PACKS, GIT_SAFETY_MODULE, PLATFORM_TOOL_HINTS_MODULE, FACTORY_TOOL_HINTS_MODULE, TOOL_USAGE_META_MODULE, createLoadCapabilityTool, createCapabilityHook, resolveProfileGroups, resolveUpfrontGroups, } from '@compilr-dev/sdk';
+import { createCompilrAgent, createTaskTool, defaultAgentTypes, TOOL_SETS, BUILTIN_GUARDRAILS, } 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, getFilteredToolIndexForSystemPrompt, getToolStats, setMetaToolFilter, createToolFallback, getRegisteredMetaTools, } from './tools.js';
-// TOOL_GROUPS no longer needed — profile resolution moved to SDK
-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';
+import { getDefaultModelForTier } from './models/index.js';
 import { PROVIDER_METADATA } from './models/providers.js';
 import { setStaticEstimates, estimateTokens, estimateJsonTokens, } from './utils/token-tracker.js';
 import { createFileLockCheckHook, createFileLockAcquireHook } from './multi-agent/file-lock-hook.js';
 import { getActiveProject } from './tools/project-db.js';
+import { allDbTools, allFactoryTools } from './tools/db-tools.js';
+import { createGuideTool } from '@compilr-dev/sdk';
+import { CLI_GUIDE_ENTRIES } from './guide/cli-guide-entries.js';
+const cliGuideTool = createGuideTool({
+    environment: 'cli',
+    additionalEntries: CLI_GUIDE_ENTRIES,
+});
+import { defineTool, createSuccessResult } from '@compilr-dev/agents';
+/** Create plan_submit and plan_mode_exit tools if callbacks are provided */
+function buildPlanModeTools(callbacks) {
+    if (!callbacks || !callbacks.onPlanSubmit || !callbacks.onPlanModeExit)
+        return [];
+    const onSubmit = callbacks.onPlanSubmit;
+    const onExit = callbacks.onPlanModeExit;
+    const planSubmitTool = defineTool({
+        name: 'plan_submit',
+        description: 'Submit a plan for user approval. Call when your plan is ready for review. ' +
+            'The user will choose to approve, revise, or reject. On approval, write tools are unlocked.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                plan_id: { type: 'number', description: 'ID of the plan to submit' },
+                summary: { type: 'string', description: 'One-line summary of the plan' },
+            },
+            required: ['plan_id'],
+        },
+        execute: async (input) => {
+            const result = await onSubmit({ planId: input.plan_id, summary: input.summary });
+            const messages = {
+                'approve-auto': 'Plan approved. Auto-accept mode enabled. Proceed with implementation.',
+                approve: 'Plan approved. Proceed with implementation.',
+                revise: `Plan needs revision. Feedback: ${result.feedback ?? 'No specific feedback.'}`,
+                reject: 'Plan rejected.',
+            };
+            return createSuccessResult({ action: result.action, message: messages[result.action] });
+        },
+    });
+    const planModeExitTool = defineTool({
+        name: 'plan_mode_exit',
+        description: 'Exit plan mode without a plan. Use when the task is simple enough to implement directly.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                reason: { type: 'string', description: 'Brief reason for exiting plan mode' },
+            },
+            required: ['reason'],
+        },
+        execute: async (input) => {
+            await onExit({ reason: input.reason });
+            return createSuccessResult({ message: `Exited plan mode: ${input.reason}. Full tools now available.` });
+        },
+    });
+    return [planSubmitTool, planModeExitTool];
+}
 /**
  * Default permission rules for potentially dangerous operations
- * Note: Tool names are lowercase (bash, write_file, edit, git_commit)
  */
 const DEFAULT_PERMISSION_RULES = [
-    // File writes need approval each time (user can see diff before approving)
     { toolName: 'write_file', level: 'once', description: 'Write/create files' },
     { toolName: 'edit', level: 'once', description: 'Edit file contents' },
-    // Git operations that modify state
     { toolName: 'git_commit', level: 'once', description: 'Create git commit' },
     { toolName: 'git_branch', level: 'once', description: 'Create/delete git branches' },
-    // Shell commands need approval each time
     { toolName: 'bash', level: 'once', description: 'Execute shell command' },
-    // Project runners (can have side effects)
     { toolName: 'run_tests', level: 'once', description: 'Run test suite' },
     { toolName: 'run_lint', level: 'once', description: 'Run linter (may auto-fix)' },
-    // Note: backlog_write removed - use workitem_* tools which modify database
 ];
+/** Delegation config for tool result auto-summarization */
+const CLI_DELEGATION_CONFIG = {
+    enabled: true,
+    delegationThreshold: 8000,
+    summaryMaxTokens: 800,
+    resultTTL: 600_000,
+    maxStoredResults: 50,
+    strategy: 'auto',
+    toolOverrides: {
+        bash: { threshold: 12000 },
+        grep: { threshold: 4000 },
+        git_diff: { threshold: 6000 },
+        get_tool_info: { enabled: false },
+        list_tools: { enabled: false },
+        ask_user: { enabled: false },
+        ask_user_simple: { enabled: false },
+        todo_read: { enabled: false },
+    },
+};
 /**
  * Get permission info for a tool by name.
- * Returns undefined if the tool doesn't require special permission (always allowed).
  */
 export function getToolPermissionInfo(toolName) {
     const rule = DEFAULT_PERMISSION_RULES.find(r => r.toolName === toolName);
@@ -53,7 +116,6 @@ export function getToolPermissionInfo(toolName) {
 }
 /**
  * Get information about built-in guardrails.
- * Used for displaying guardrail info in /help or status overlays.
  */
 export function getBuiltinGuardrailInfo() {
     return BUILTIN_GUARDRAILS.map((g) => ({
@@ -66,21 +128,16 @@ export function getBuiltinGuardrailInfo() {
 }
 /**
  * Merges built-in agent types with custom agents from registry.
- * Custom agents get safe read-only tools by default.
  */
 function getMergedAgentTypes() {
     const registry = getAgentRegistry();
     const customAgents = registry.getCustomAgents();
-    // Start with default agent types (library now has correct tool names)
     const mergedTypes = { ...defaultAgentTypes };
-    // Add custom agents from registry
     for (const agent of customAgents) {
         mergedTypes[agent.name] = {
             description: agent.description,
             systemPrompt: agent.systemPrompt,
             defaultModel: agent.model === 'inherit' ? undefined : agent.model,
-            // Safe read-only tools for custom agents (using library's TOOL_SETS)
-            // Type assertion needed because TOOL_SETS typing might not be exported correctly
             allowedTools: Array.isArray(TOOL_SETS.READ_ONLY) ? [...(TOOL_SETS.READ_ONLY)] : [],
             maxIterations: 10,
             contextMode: 'inherit-summary',
@@ -88,189 +145,52 @@ function getMergedAgentTypes() {
     }
     return mergedTypes;
 }
-/**
- * Creates the appropriate LLM provider based on configuration.
- * Resolves CLI-specific concerns (credentials, settings) then delegates
- * provider instantiation to the SDK's createProviderFromType().
- */
-function createProvider(options) {
+// ─── Provider Resolution (CLI-specific credentials) ─────────────────────────
+function resolveProviderConfig(options) {
     const providerType = options.provider ?? 'claude';
-    const quiet = options.quiet ?? false;
     const meta = PROVIDER_METADATA[providerType];
-    // 1. Resolve API key from CLI credential store
     const apiKey = meta.requiresKey ? getApiKey(meta.credentialKey) : undefined;
     if (!apiKey && meta.requiresKey) {
         throw new Error(`${meta.displayName} API key not found.\n` +
             `Run /keys to set it, or: export ${meta.envVar}=...` +
             (providerType === 'claude' ? '\nOr use --provider ollama for local models.' : ''));
     }
-    // 2. Resolve model (from options or registry default for balanced tier)
     const model = options.model ?? getDefaultModelForTier(providerType, 'balanced')?.id;
-    // 3. Resolve Ollama base URL from settings
     const baseUrl = providerType === 'ollama'
         ? ((typeof getSetting('ollamaBaseUrl') === 'string'
             ? getSetting('ollamaBaseUrl')
-            : undefined) ??
-            process.env.OLLAMA_BASE_URL ??
-            'http://localhost:11434')
-        : undefined;
-    // 4. Log (unless quiet)
-    if (!quiet)
-        console.log(`Using ${meta.displayName} with model: ${model ?? 'default'}`);
-    if (!quiet && providerType === 'ollama' && baseUrl !== 'http://localhost:11434') {
-        console.log(`  Ollama server: ${baseUrl ?? ''}`);
-    }
-    // 5. Delegate to SDK (with tiktoken-based token estimator for debug payload)
-    return createProviderFromType(providerType, {
-        model,
-        apiKey: apiKey ?? undefined,
-        baseUrl,
-        siteName: providerType === 'openrouter' ? 'compilr-cli' : undefined,
-        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.
- */
-// getProfileGroupsFromToolFilter → replaced by resolveProfileGroups from SDK
-// autoDetectCapabilities → replaced by autoDetectCapabilities from SDK
-// createCapabilityHook → replaced by createCapabilityHook + CapabilityContext from SDK
-/**
- * Creates an Agent instance configured with all tools.
- */
-export function createAgent(options = {}) {
-    const provider = createProvider(options);
-    // Create context manager with model-specific limits
-    // Uses library defaults: compact at 50%, summarize at 90%, emergency at 95%
-    // Auto-compact can be disabled via settings (requires restart)
-    const autoCompact = isAutoCompactEnabled();
-    const contextManager = new ContextManager({
-        provider,
-        config: {
-            maxContextTokens: getModelContextWindow(options.model ?? '', options.provider),
-            // If auto-compact disabled, set threshold to 100% (never triggers)
-            compaction: autoCompact
-                ? DEFAULT_CONTEXT_CONFIG.compaction
-                : {
-                    ...DEFAULT_CONTEXT_CONFIG.compaction,
-                    triggerThreshold: 1.0, // Never auto-trigger
-                    triggerInterval: Number.MAX_SAFE_INTEGER, // Never interval-trigger
-                },
-        },
-    });
-    // Create event handler for verbose mode
-    const onEvent = options.verbose
-        ? (event) => {
-            if (event.type === 'tool_start') {
-                log.debug({ component: 'agent', tool: event.name }, 'Tool starting');
-            }
-            else if (event.type === 'tool_end') {
-                log.debug({ component: 'agent', tool: event.name }, 'Tool done');
-            }
-        }
+            : undefined) ?? process.env.OLLAMA_BASE_URL ?? 'http://localhost:11434')
         : undefined;
-    // Build modular system prompt based on current context
-    // Note: Anchors are NOT added here - they're handled by library's AnchorManager
-    // 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)
-    const useMetaTools = options.enableMetaTools && !options.minimal;
-    if (useMetaTools) {
-        initializeMetaTools(true);
-    }
-    // ==========================================================================
-    // 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 capabilityContext;
-    let orphanToolNames = [];
-    if (useMetaTools) {
-        // Use SDK's profile resolver instead of local implementation
-        const profileGroups = options.toolFilter
-            ? resolveProfileGroups(options.toolFilter)
-            : Object.keys(CAPABILITY_PACKS);
-        const upfrontGroupIds = resolveUpfrontGroups(profileGroups);
-        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)
-        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));
-        // Create capability context (SDK) for filter sync + auto-load callback
-        capabilityContext = new CapabilityContext({
-            manager: capabilityManager,
-            orphanTools: orphanToolNames,
-            onFilterUpdate: (allowed) => { setMetaToolFilter(allowed); },
-        });
-        capabilityContext.syncFilter();
-        // 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`);
+    if (!options.quiet) {
+        log.info({ component: 'agent', provider: meta.displayName, model: model ?? 'default' }, 'Provider configured');
+        if (providerType === 'ollama' && baseUrl !== 'http://localhost:11434') {
+            log.info({ component: 'agent', baseUrl }, 'Ollama server');
         }
     }
-    // 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)
+    return { provider: providerType, model, apiKey: apiKey ?? undefined, baseUrl };
+}
+// ─── System Prompt Assembly ─────────────────────────────────────────────────
+function buildSystemPrompt(options) {
     if (options.useMinimalSystemPrompt && options.systemPromptAddition) {
-        // Skip all modules - just use the role prompt directly
-        systemPrompt = options.systemPromptAddition;
+        return options.systemPromptAddition;
     }
-    else {
-        // Use modular system prompt builder
-        // 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: capabilityManager ? false : useMetaTools,
-            hasGit: capabilityManager ? false : undefined, // false = skip git-safety; undefined = auto-detect
-            projectName: options.projectName,
-            projectSlug: options.projectSlug,
-            projectId: options.projectId,
-            projectContext: options.projectContext,
-            guidedModeContext: options.guidedModeContext,
-            planModeContext: options.planModeContext,
-            metaToolsIndex,
-            hasRoleIdentity: !!options.systemPromptAddition, // Skip default identity when role is specified
-        });
-        const buildResult = promptBuilder.build();
-        systemPrompt = buildResult.prompt;
-        // Prepend role-specific system prompt (for team agents)
-        // The default identity module is already excluded via hasRoleIdentity flag
-        if (options.systemPromptAddition) {
-            // Extract role name from the role prompt (format: "# ROLE: ROLE_NAME")
-            const roleMatch = options.systemPromptAddition.match(/^#\s*ROLE:\s*(.+)$/m);
-            const roleName = roleMatch ? roleMatch[1].trim() : 'specialized team member';
-            // Put FULL role prompt at the END (recency effect is stronger than primacy)
-            // LLMs weight the end of context more heavily
-            const roleEnding = `
+    const promptBuilder = new SystemPromptBuilder({
+        enableMetaTools: false, // SDK handles capability-based prompt assembly
+        hasGit: undefined, // Auto-detect (SDK capability hook will override if needed)
+        projectName: options.projectName,
+        projectSlug: options.projectSlug,
+        projectId: options.projectId,
+        projectContext: options.projectContext,
+        guidedModeContext: options.guidedModeContext,
+        planModeContext: options.planModeContext,
+        hasRoleIdentity: !!options.systemPromptAddition,
+    });
+    let systemPrompt = promptBuilder.build().prompt;
+    // Wrap role identity at beginning AND end for team agents
+    if (options.systemPromptAddition) {
+        const roleMatch = options.systemPromptAddition.match(/^#\s*ROLE:\s*(.+)$/m);
+        const roleName = roleMatch ? roleMatch[1].trim() : 'specialized team member';
+        const roleEnding = `
 
 ---
 
@@ -279,113 +199,130 @@ export function createAgent(options = {}) {
 ${options.systemPromptAddition}
 
 **CRITICAL**: When asked "what is your role?", "what are you?", or similar identity questions, your response should acknowledge your assigned role. For example: "In this team, I'm the ${roleName}" or "I'm operating as the ${roleName} in this session."`;
-            // Put role at BOTH beginning AND end, with full role prompt at the end
-            systemPrompt = options.systemPromptAddition + '\n\n' + systemPrompt + roleEnding;
-        }
+        systemPrompt = options.systemPromptAddition + '\n\n' + systemPrompt + roleEnding;
     }
-    // Store base prompt for capability-aware BeforeLLM hook
-    const baseSystemPrompt = capabilityManager ? systemPrompt : undefined;
-    const agent = new Agent({
+    return systemPrompt;
+}
+// ─── Context Pressure Hook ──────────────────────────────────────────────────
+function createContextPressureHook() {
+    return (ctx) => {
+        const msgCount = ctx.messages.length;
+        if (msgCount < 20)
+            return undefined;
+        let hint;
+        if (msgCount < 40) {
+            hint = `[Context: ~${String(msgCount)} messages] Consider task() for multi-file operations.`;
+        }
+        else if (msgCount < 60) {
+            hint = `[Context: ~${String(msgCount)} messages - HIGH] Prefer task() sub-agents for file reads and code search.`;
+        }
+        else {
+            hint = `[Context: ~${String(msgCount)} messages - CRITICAL] Use task() for ALL exploration. Do not read files directly.`;
+        }
+        const messages = [...ctx.messages];
+        messages.splice(1, 0, { role: 'user', content: hint });
+        return { messages };
+    };
+}
+// ─── Main Factory ───────────────────────────────────────────────────────────
+/**
+ * Creates an Agent instance configured with all tools.
+ *
+ * Delegates to createCompilrAgent() from @compilr-dev/sdk for:
+ * - Provider creation, context management, observation masking
+ * - Smart windowing, tool output guards
+ * - Capability loading (meta-tools, dynamic prompt assembly)
+ * - Permission handling, guardrails, delegation
+ *
+ * CLI adds on top:
+ * - Credential resolution from CLI keystore
+ * - System prompt with project context and role identity
+ * - Subagent callbacks for UI updates
+ * - Token estimate logging
+ */
+export function createAgent(options = {}) {
+    const { provider, model, apiKey } = resolveProviderConfig(options);
+    const systemPrompt = buildSystemPrompt(options);
+    log.info({
+        component: 'agent',
+        provider,
+        model: model ?? 'default',
+        quiet: options.quiet ?? false,
+        metaTools: options.enableMetaTools ?? false,
+        projectName: options.projectName,
+    }, 'Creating agent');
+    // ── Create agent via SDK ──────────────────────────────────────────────────
+    const compilrAgent = createCompilrAgent({
         provider,
+        model,
+        apiKey,
         systemPrompt,
         maxIterations: options.maxIterations ?? 50,
-        onEvent,
-        contextManager,
-        // Set tool timeout to 2 minutes (default is 30s which is too short for complex operations)
-        // Sub-agents inherit this timeout from the parent agent
         toolTimeoutMs: 120000,
-        // Enable file tracking for context restoration hints
         enableFileTracking: true,
-        // Enable permissions if handler is provided
+        logger: log,
+        // Permissions
         permissions: options.onPermissionRequest
-            ? {
-                enabled: true,
-                defaultLevel: 'always', // Allow tools by default, unless specified in rules
-                rules: DEFAULT_PERMISSION_RULES,
-                onPermissionRequest: options.onPermissionRequest,
-            }
-            : undefined,
-        // Iteration limit handler - asks user if they want to continue
+            ? options.onPermissionRequest
+            : 'auto',
+        permissionRules: DEFAULT_PERMISSION_RULES,
+        includeDefaultRules: true,
+        // Iteration limits
         onIterationLimitReached: options.onIterationLimitReached,
-        // Anchors - critical info that survives context compaction
-        // Library re-injects anchors on every LLM call
-        anchors: options.enableAnchors
-            ? {
-                maxAnchors: 50,
-                maxTokens: 4000,
-                includeDefaults: true,
-                // Note: We manage persistence ourselves via project-anchors.ts
-                // Don't set persistPath - we load anchors manually below
-            }
+        // Pins / anchors
+        pins: options.enableAnchors
+            ? { maxAnchors: 50, maxTokens: 4000, includeDefaults: true }
             : undefined,
-        // Guardrails - pattern-based safety checks for risky operations
-        // 15 built-in patterns: git destructive ops, rm -rf, DROP TABLE, secrets, etc.
+        // Guardrails
         guardrails: options.enableGuardrails
-            ? {
-                enabled: true,
-                includeDefaults: true,
-                onTriggered: options.onGuardrailTriggered,
+            ? { includeDefaults: true }
+            : false,
+        // Delegation
+        delegation: isDelegationEnabled() ? CLI_DELEGATION_CONFIG : undefined,
+        // Context management
+        context: {
+            compactionThreshold: isAutoCompactEnabled() ? undefined : 1.0,
+        },
+        // Suggest tool
+        onSuggest: options.onSuggest,
+        // Verbose event handler
+        onEvent: options.verbose
+            ? (event) => {
+                if (event.type === 'tool_start') {
+                    log.debug({ component: 'agent', tool: event.name }, 'Tool starting');
+                }
+                else if (event.type === 'tool_end') {
+                    log.debug({ component: 'agent', tool: event.name }, 'Tool done');
+                }
             }
             : undefined,
-        // Tool result delegation — auto-summarize large results to conserve context
-        delegation: isDelegationEnabled()
+        // Capability loading (replaces CLI's manual meta-tools wiring)
+        // Platform tools (DB, factory) + MCP + guide + plan mode tools
+        capabilities: (options.enableMetaTools && !options.minimal && !options.noTools)
             ? {
                 enabled: true,
-                delegationThreshold: 8000,
-                summaryMaxTokens: 800,
-                resultTTL: 600_000,
-                maxStoredResults: 50,
-                strategy: 'auto',
-                toolOverrides: {
-                    // Custom thresholds
-                    bash: { threshold: 12000 },
-                    grep: { threshold: 4000 },
-                    git_diff: { threshold: 6000 },
-                    // Never summarize — agent needs verbatim results
-                    get_tool_info: { enabled: false },
-                    list_tools: { enabled: false },
-                    ask_user: { enabled: false },
-                    ask_user_simple: { enabled: false },
-                    todo_read: { enabled: false },
-                },
+                profile: options.toolFilter ?? 'full',
+                additionalTools: [
+                    ...allDbTools,
+                    ...allFactoryTools,
+                    ...(options.mcpTools ?? []),
+                    cliGuideTool,
+                    ...buildPlanModeTools(options.planModeCallbacks),
+                ],
             }
-            : undefined,
-        // Hooks: context pressure, capability loading, file lock check/acquire
+            : {
+                enabled: false,
+                additionalTools: [
+                    ...allDbTools,
+                    ...allFactoryTools,
+                    ...(options.mcpTools ?? []),
+                    cliGuideTool,
+                    ...buildPlanModeTools(options.planModeCallbacks),
+                ],
+            },
+        // CLI-specific hooks
         hooks: {
-            beforeLLM: [
-                // Context pressure hook
-                (ctx) => {
-                    const utilization = contextManager.getUtilization();
-                    if (utilization < 0.3)
-                        return undefined;
-                    const pct = Math.round(utilization * 100);
-                    let hint;
-                    if (utilization < 0.6) {
-                        hint = `[Context: ${String(pct)}%] Consider task() for multi-file operations.`;
-                    }
-                    else if (utilization < 0.8) {
-                        hint = `[Context: ${String(pct)}% - HIGH] Prefer task() sub-agents for file reads and code search.`;
-                    }
-                    else {
-                        hint = `[Context: ${String(pct)}% - CRITICAL] Use task() for ALL exploration. Do not read files directly.`;
-                    }
-                    const messages = [...ctx.messages];
-                    messages.splice(1, 0, { role: 'user', content: hint });
-                    return { messages };
-                },
-                // Capability-aware system prompt assembly (SDK hook with auto-detection)
-                ...(capabilityContext && baseSystemPrompt
-                    ? [createCapabilityHook(capabilityContext, baseSystemPrompt, {
-                            staticSections: [TOOL_USAGE_META_MODULE.content],
-                            conditionalModules: [
-                                { content: GIT_SAFETY_MODULE.content, whenModuleActive: ['git-safety'] },
-                                { content: PLATFORM_TOOL_HINTS_MODULE.content, whenModuleActive: ['platform-tool-hints'] },
-                                { content: FACTORY_TOOL_HINTS_MODULE.content, whenModuleActive: ['factory-tool-hints'] },
-                            ],
-                            getToolIndex: (allowedNames) => getFilteredToolIndexForSystemPrompt(allowedNames),
-                        })]
-                    : []),
-            ],
+            beforeLLM: [createContextPressureHook()],
             beforeTool: [createFileLockCheckHook(getActiveProject)],
             afterTool: [
                 createFileLockAcquireHook(getActiveProject),
@@ -393,7 +330,8 @@ ${options.systemPromptAddition}
             ],
         },
     });
-    // Load persisted anchors into the agent's pin manager
+    const agent = compilrAgent.unwrap();
+    // ── Load persisted anchors ────────────────────────────────────────────────
     if (options.enableAnchors && options.persistedAnchors) {
         for (const anchor of options.persistedAnchors) {
             agent.addPin({
@@ -402,112 +340,44 @@ ${options.systemPromptAddition}
                 priority: anchor.priority,
                 scope: anchor.scope,
                 tags: anchor.tags,
-                // Note: projectId is for our tracking, not needed by library
             });
         }
     }
-    // Register tools using registerTools method (skip if noTools is set)
-    if (!options.noTools) {
-        // When meta-tools is enabled, use direct tools + meta-tools instead of all tools
-        let tools;
-        if (options.minimal) {
-            tools = createMinimalToolRegistry();
-        }
-        else if (options.enableMetaTools) {
-            // 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
-            // eslint-disable-next-line @typescript-eslint/no-deprecated -- Intentional for backward compatibility
-            tools = createToolRegistry();
-        }
-        // Apply tool filter if specified (filter direct tools)
-        if (options.toolFilter && options.toolFilter.length > 0) {
-            const allowedTools = new Set(options.toolFilter);
-            // 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));
-            // 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 if (!capabilityManager) {
-            // No filter and no capability loading - clear any previous filter
-            setMetaToolFilter(null);
-        }
-        // Type assertion needed for tool registry compatibility
-        agent.registerTools(tools);
-        // Register MCP tools (from external MCP servers)
-        // These are registered as direct tools since their schemas are unknown at build time
-        if (options.mcpTools && options.mcpTools.length > 0) {
-            agent.registerTools(options.mcpTools);
-        }
-        // Set up transparent fallback to meta-registry
-        // When the agent calls a tool not in direct tools (e.g., workitem_add),
-        // the fallback handler checks the meta-registry and executes it.
-        if (options.enableMetaTools && !options.minimal) {
-            agent.getToolRegistry().setFallbackHandler(createToolFallback());
-        }
-    }
-    // Register Task tool for sub-agent spawning (only in full mode)
+    // ── Register subagent task tool (CLI-specific callbacks) ──────────────────
     if (!options.minimal && !options.noTools) {
-        // Track active subagents to correlate spawn/complete/events
-        // Track active subagents by toolUseId for token counting
         const activeSubagents = new Map();
-        // Provide a way for caller to clear tracking state between runs
         if (options.onSubagentTrackingReady) {
-            options.onSubagentTrackingReady(() => {
-                activeSubagents.clear();
-            });
+            options.onSubagentTrackingReady(() => { activeSubagents.clear(); });
         }
         const taskTool = createTaskTool({
             parentAgent: agent,
             agentTypes: getMergedAgentTypes(),
             enableEventStreaming: true,
-            defaultTimeout: 120000, // 2 minutes for subagent operations
-            // Now uses toolUseId for direct correlation (no more FIFO matching!)
+            defaultTimeout: 120000,
             onSpawn: (agentType, description, toolUseId) => {
                 if (options.verbose) {
                     log.debug({ component: 'agent', agentType, toolUseId }, 'Spawning sub-agent: %s', description);
                 }
-                // Immediately notify with toolUseId - no more queuing/matching!
                 if (toolUseId) {
                     activeSubagents.set(toolUseId, { agentType, tokenCount: 0 });
-                    if (options.onSubagentStart) {
-                        options.onSubagentStart(toolUseId, agentType, description);
-                    }
+                    options.onSubagentStart?.(toolUseId, agentType, description);
                 }
             },
             onComplete: (agentType, result, toolUseId) => {
                 if (options.verbose) {
                     log.debug({ component: 'agent', agentType, iterations: result.iterations }, 'Sub-agent completed');
                 }
-                // Direct notification with toolUseId - no more searching!
-                if (toolUseId && options.onSubagentEnd) {
-                    options.onSubagentEnd(toolUseId, true, result.toolCalls);
+                if (toolUseId) {
+                    options.onSubagentEnd?.(toolUseId, true, result.toolCalls);
                     activeSubagents.delete(toolUseId);
                 }
             },
-            // Stream subagent events for live updates
             onSubAgentEvent: (eventInfo) => {
                 const { toolUseId, event } = eventInfo;
-                // Handle tool events for live updates
                 if (event.type === 'tool_start' && toolUseId && event.name && options.onSubagentToolUse) {
-                    // Extract tool name and input summary
-                    const toolName = event.name;
-                    let summary;
-                    // Try to get a meaningful summary from input
                     const input = event.input;
+                    let summary;
                     if (input) {
-                        // Common patterns for tool input summaries
                         const path = input.path;
                         const pattern = input.pattern;
                         const command = input.command;
@@ -521,64 +391,42 @@ ${options.systemPromptAddition}
                         else if (typeof filePath === 'string')
                             summary = filePath;
                     }
-                    options.onSubagentToolUse(toolUseId, toolName, summary);
+                    options.onSubagentToolUse(toolUseId, event.name, summary);
                 }
             },
         });
-        // Type assertion needed for task tool compatibility
         agent.registerTool(taskTool);
-        // Register Suggest tool for next action suggestions
-        const suggestTool = createSuggestTool({
-            onSuggest: options.onSuggest,
-        });
-        agent.registerTool(suggestTool);
+        // Note: suggest tool is already registered by createCompilrAgent via onSuggest config
     }
-    // ==========================================================================
-    // Calculate and store token estimates for debugging
-    // ==========================================================================
+    // ── Token estimate logging ────────────────────────────────────────────────
     if (!options.quiet) {
-        // Calculate tool tokens from the tools we registered
+        const toolDefs = agent.getToolRegistry().getDefinitions();
         let toolTokens = 0;
-        // Get the tools array based on options
-        let toolsForEstimate = [];
-        if (!options.noTools) {
-            if (options.minimal) {
-                toolsForEstimate = createMinimalToolRegistry();
-            }
-            else if (options.enableMetaTools) {
-                toolsForEstimate = [...getDirectTools(true), ...getMetaTools()];
-            }
-            else {
-                // eslint-disable-next-line @typescript-eslint/no-deprecated
-                toolsForEstimate = createToolRegistry();
-            }
-        }
-        for (const tool of toolsForEstimate) {
-            const def = tool.definition;
+        for (const def of toolDefs) {
             toolTokens += estimateJsonTokens({
                 name: def.name,
                 description: def.description,
                 input_schema: def.inputSchema,
             });
         }
-        // Add task tool and suggest tool estimates (if registered)
-        if (!options.minimal && !options.noTools) {
-            // Task tool has a large description with all agent types
-            toolTokens += 700; // Approximate for task tool
-            toolTokens += 200; // Approximate for suggest tool
-        }
-        // Calculate estimates
         const systemTokens = estimateTokens(systemPrompt);
         const roleTokens = options.systemPromptAddition
-            ? estimateTokens(options.systemPromptAddition) * 2 // Role appears at start and end
+            ? estimateTokens(options.systemPromptAddition) * 2
             : 0;
         const contextTokens = estimateTokens(options.projectContext);
         setStaticEstimates({
-            system: systemTokens - roleTokens, // Subtract role since it's counted separately
+            system: systemTokens - roleTokens,
             role: roleTokens,
             tools: toolTokens,
             context: contextTokens,
         });
+        log.info({
+            component: 'agent',
+            toolCount: toolDefs.length,
+            systemTokens,
+            toolTokens,
+            contextTokens,
+        }, 'Agent created');
     }
     return agent;
 }