@compilr-dev/cli 0.4.0 → 0.5.1

package/dist/agent.js

@@ -5,96 +5,17 @@
  * ClaudeProvider, OllamaProvider, OpenAIProvider, or GeminiProvider
  * and available tools.
  */
-import { Agent, ClaudeProvider, OllamaProvider, OpenAIProvider, GeminiProvider, ContextManager, DEFAULT_CONTEXT_CONFIG, createTaskTool, createSuggestTool, defaultAgentTypes, TOOL_SETS, } from '@compilr-dev/agents';
-import { isAutoCompactEnabled } from './settings/index.js';
+import { Agent, ContextManager, DEFAULT_CONTEXT_CONFIG, createTaskTool, createSuggestTool, defaultAgentTypes, TOOL_SETS, BUILTIN_GUARDRAILS, createProviderFromType, } from '@compilr-dev/sdk';
+import { isAutoCompactEnabled, isDelegationEnabled, getSetting } from './settings/index.js';
 import { getApiKey } from './utils/credentials.js';
-import { createToolRegistry, createMinimalToolRegistry } from './tools.js';
+import { createToolRegistry, createMinimalToolRegistry, getDirectTools, getMetaTools, initializeMetaTools, getToolIndexForSystemPrompt, getToolStats, setMetaToolFilter, createToolFallback, } from './tools.js';
 import { getAgentRegistry } from './agents/registry.js';
-const SYSTEM_PROMPT = `You are a helpful coding assistant running in a terminal.
-
-AVAILABLE TOOLS (use these exact names - lowercase with underscores):
-
-File Operations:
-- read_file: Read contents of a file (parameter: path)
-- write_file: Create or overwrite a file (parameters: path, content)
-- edit: Replace text in a file (parameters: path, old_text, new_text)
-- glob: Find files matching a pattern (parameters: pattern, path)
-- grep: Search file contents with regex (parameters: pattern, path)
-
-Shell:
-- bash: Run shell commands (parameter: command)
-  For long-running commands (dev servers, watch modes), use run_in_background=true
-- bash_output: Get output from a background shell (parameter: shell_id)
-- kill_shell: Terminate a background shell (parameter: shell_id)
-
-BACKGROUND PROCESSES:
-When running commands that don't exit (like npm run dev, npm start, watch commands):
-1. Use bash with run_in_background=true to start the process
-2. The tool returns a shell_id you can use to monitor or kill the process
-3. Use bash_output with the shell_id to check output/status
-4. Use kill_shell with the shell_id to stop the process when done
-
-Example: Starting a dev server
-  bash(command="npm run dev", run_in_background=true) → returns shell_id
-  bash_output(shell_id="...") → check if server started
-  kill_shell(shell_id="...") → stop when done
-
-Git:
-- git_status: Show working tree status
-- git_diff: Show file differences
-- git_log: Show commit history (parameter: limit)
-- git_commit: Create a commit (parameters: message, files)
-- git_branch: List or manage branches
-
-Project Analysis:
-- detect_project: Detect project type and framework
-- find_project_root: Find the root directory of the project
-- run_tests: Run project test suite
-- run_lint: Run project linter
-
-Task Management:
-- todo_write: Add/update todo items (parameters: todos array)
-- todo_read: View current todo list
-
-Next Action Suggestions:
-- suggest: Suggest a next action to the user (parameters: action, reason)
-  The suggestion appears as ghost text in the input prompt (user presses Tab to accept).
-
-  IMPORTANT: Always use 'suggest' after completing a task or answering a question.
-  This is a mandatory part of your response workflow, not optional.
-
-  When to suggest:
-    - After ANY tool-based task → suggest verifying, testing, or next logical step
-    - After answering a question → suggest a follow-up to explore
-    - After explaining something → suggest trying it out or diving deeper
-    - When your reply ends with a question → suggest an answer option
-
-  Good suggestions are short commands or actions: "run npm test", "commit the changes",
-  "show me the API endpoints", "explain the error in more detail"
-
-Sub-agents (via task tool):
-- task: Spawn a specialized sub-agent for complex, multi-step tasks
-  Parameters: description (3-5 words), prompt (detailed task), subagent_type
-  Built-in types:
-    - explore: Fast codebase search and navigation
-    - code-review: Review code for bugs and best practices
-    - plan: Break down complex tasks into steps
-    - debug: Investigate and fix issues
-    - test-runner: Run and analyze tests
-    - refactor: Safe code refactoring
-    - security-audit: Scan for vulnerabilities
-    - doc-lookup: Search documentation
-    - general: General-purpose multi-step tasks
-  Custom agents may also be available (check /agents command).
-
-IMPORTANT RULES:
-1. Tool names are lowercase with underscores - use them exactly as shown
-2. If unsure which tool to use, pick the closest match from the list
-3. For simple questions (math, facts), answer directly without tools
-4. After calling a tool, you MUST respond with the result to the user - never end silently
-5. Use the task tool to delegate complex tasks to specialized sub-agents
-
-Current working directory: ${process.cwd()}`;
+import { SystemPromptBuilder } from './system-prompt/index.js';
+import { getDefaultModelForTier, getModelContextWindow } 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';
 /**
  * Default permission rules for potentially dangerous operations
  * Note: Tool names are lowercase (bash, write_file, edit, git_commit)
@@ -111,8 +32,7 @@ const DEFAULT_PERMISSION_RULES = [
     // 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)' },
-    // Local file modifications
-    { toolName: 'backlog_write', level: 'once', description: 'Modify backlog file' },
+    // Note: backlog_write removed - use workitem_* tools which modify database
 ];
 /**
  * Get permission info for a tool by name.
@@ -128,6 +48,19 @@ export function getToolPermissionInfo(toolName) {
     }
     return undefined;
 }
+/**
+ * Get information about built-in guardrails.
+ * Used for displaying guardrail info in /help or status overlays.
+ */
+export function getBuiltinGuardrailInfo() {
+    return BUILTIN_GUARDRAILS.map((g) => ({
+        id: g.id,
+        name: g.name,
+        description: g.description,
+        action: g.action,
+        category: g.tags?.[0] ?? 'general',
+    }));
+}
 /**
  * Merges built-in agent types with custom agents from registry.
  * Custom agents get safe read-only tools by default.
@@ -154,85 +87,57 @@ function getMergedAgentTypes() {
 }
 /**
  * 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) {
     const providerType = options.provider ?? 'claude';
-    switch (providerType) {
-        case 'ollama': {
-            const model = options.model ?? 'llama3.1';
-            console.log(`Using Ollama provider with model: ${model}`);
-            const provider = new OllamaProvider({
-                model,
-                baseUrl: process.env.OLLAMA_BASE_URL ?? 'http://localhost:11434',
-            });
-            return provider;
-        }
-        case 'openai': {
-            const apiKey = getApiKey('openai');
-            if (!apiKey) {
-                throw new Error('OpenAI API key not found.\n' +
-                    'Run /keys to set it, or: export OPENAI_API_KEY=sk-...');
-            }
-            const model = options.model ?? 'gpt-4o';
-            console.log(`Using OpenAI provider with model: ${model}`);
-            const provider = new OpenAIProvider({ apiKey, model });
-            return provider;
-        }
-        case 'gemini': {
-            const apiKey = getApiKey('google');
-            if (!apiKey) {
-                throw new Error('Google AI API key not found.\n' +
-                    'Run /keys to set it, or: export GOOGLE_API_KEY=AI...');
-            }
-            const model = options.model ?? 'gemini-2.0-flash';
-            console.log(`Using Gemini provider with model: ${model}`);
-            const provider = new GeminiProvider({ apiKey, model });
-            return provider;
-        }
-        case 'claude':
-        default: {
-            const apiKey = getApiKey('anthropic');
-            if (!apiKey) {
-                throw new Error('Anthropic API key not found.\n' +
-                    'Run /keys to set it, or: export ANTHROPIC_API_KEY=sk-ant-...\n' +
-                    'Or use --provider ollama for local models.');
-            }
-            const model = options.model ?? 'claude-sonnet-4-20250514';
-            console.log(`Using Claude provider with model: ${model}`);
-            return new ClaudeProvider({ apiKey, model });
-        }
+    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.' : ''));
     }
-}
-/**
- * Returns the context window limit for each provider.
- */
-function getProviderContextLimit(provider) {
-    switch (provider) {
-        case 'gemini':
-            return 1000000; // 1M tokens
-        case 'claude':
-            return 200000; // 200K tokens
-        case 'openai':
-            return 128000; // 128K tokens
-        case 'ollama':
-            return 32000; // Conservative default for local models
-        default:
-            return 200000;
+    // 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
+    return createProviderFromType(providerType, {
+        model,
+        apiKey: apiKey ?? undefined,
+        baseUrl,
+        siteName: providerType === 'openrouter' ? 'compilr-cli' : undefined,
+    });
 }
 /**
  * Creates an Agent instance configured with all tools.
  */
 export function createAgent(options = {}) {
     const provider = createProvider(options);
-    // Create context manager with provider-appropriate limits
+    // 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: getProviderContextLimit(options.provider),
+            maxContextTokens: getModelContextWindow(options.model ?? '', options.provider),
             // If auto-compact disabled, set threshold to 100% (never triggers)
             compaction: autoCompact
                 ? DEFAULT_CONTEXT_CONFIG.compaction
@@ -254,10 +159,64 @@ export function createAgent(options = {}) {
             }
         }
         : undefined;
-    // Build system prompt with optional project context
-    const systemPrompt = options.projectContext
-        ? `${SYSTEM_PROMPT}\n\n---\n\n## Project Context\n\nThe following is project-specific context loaded from COMPILR.md:\n\n${options.projectContext}`
-        : SYSTEM_PROMPT;
+    // 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)
+    let metaToolsIndex;
+    if (options.enableMetaTools && !options.minimal) {
+        initializeMetaTools();
+        metaToolsIndex = getToolIndexForSystemPrompt();
+        // Log tool stats (unless quiet mode)
+        if (!options.quiet) {
+            const stats = getToolStats();
+            console.log(`[Meta-tools] Direct: ${String(stats.directTools)}, ` +
+                `Meta: ${String(stats.metaRegistryTools)}, ` +
+                `Est. savings: ~${String(stats.tokenSavings)} tokens`);
+        }
+    }
+    let systemPrompt;
+    // Check if we should use minimal system prompt (for testing role identity)
+    if (options.useMinimalSystemPrompt && options.systemPromptAddition) {
+        // Skip all modules - just use the role prompt directly
+        systemPrompt = options.systemPromptAddition;
+    }
+    else {
+        // Use modular system prompt builder
+        // When a role-specific identity is provided (systemPromptAddition), skip the default identity module
+        const promptBuilder = new SystemPromptBuilder({
+            enableMetaTools: options.enableMetaTools && !options.minimal,
+            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;
+        // 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 = `
+
+---
+
+## YOUR ASSIGNED ROLE: ${roleName}
+
+${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;
+        }
+    }
     const agent = new Agent({
         provider,
         systemPrompt,
@@ -280,29 +239,202 @@ export function createAgent(options = {}) {
             : undefined,
         // Iteration limit handler - asks user if they want to continue
         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
+            }
+            : undefined,
+        // Guardrails - pattern-based safety checks for risky operations
+        // 15 built-in patterns: git destructive ops, rm -rf, DROP TABLE, secrets, etc.
+        guardrails: options.enableGuardrails
+            ? {
+                enabled: true,
+                includeDefaults: true,
+                onTriggered: options.onGuardrailTriggered,
+            }
+            : undefined,
+        // Tool result delegation — auto-summarize large results to conserve context
+        delegation: isDelegationEnabled()
+            ? {
+                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 },
+                },
+            }
+            : undefined,
+        // Hooks: context pressure, file lock check/acquire
+        hooks: {
+            beforeLLM: [
+                (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 };
+                },
+            ],
+            beforeTool: [createFileLockCheckHook(getActiveProject)],
+            afterTool: [
+                createFileLockAcquireHook(getActiveProject),
+                ...(options.episodeRecorder ? [options.episodeRecorder.createHook()] : []),
+            ],
+        },
     });
-    // Register tools using registerTools method
-    const tools = options.minimal
-        ? createMinimalToolRegistry()
-        : createToolRegistry();
-    // Type assertion needed for tool registry compatibility
-    agent.registerTools(tools);
+    // Load persisted anchors into the agent's AnchorManager
+    if (options.enableAnchors && options.persistedAnchors) {
+        for (const anchor of options.persistedAnchors) {
+            agent.addAnchor({
+                id: anchor.id,
+                content: anchor.content,
+                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) {
+            // Meta-tools mode: direct tools + get_tool_info (for schema introspection)
+            // Meta-registry tools are accessed transparently via fallback handler
+            tools = [...getDirectTools(), ...getMetaTools()];
+        }
+        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 is always allowed for schema introspection
+            const alwaysAllowed = new Set(['get_tool_info']);
+            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);
+        }
+        else {
+            // No filter - 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)
-    if (!options.minimal) {
+    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();
+            });
+        }
         const taskTool = createTaskTool({
             parentAgent: agent,
             agentTypes: getMergedAgentTypes(),
             enableEventStreaming: true,
             defaultTimeout: 120000, // 2 minutes for subagent operations
-            onSpawn: (agentType, description) => {
+            // Now uses toolUseId for direct correlation (no more FIFO matching!)
+            onSpawn: (agentType, description, toolUseId) => {
                 if (options.verbose) {
-                    console.log(`\n[Sub-agent] Spawning ${agentType}: ${description}`);
+                    console.log(`\n[Sub-agent] Spawning ${agentType}: ${description} (${toolUseId ?? 'no-id'})`);
+                }
+                // Immediately notify with toolUseId - no more queuing/matching!
+                if (toolUseId) {
+                    activeSubagents.set(toolUseId, { agentType, tokenCount: 0 });
+                    if (options.onSubagentStart) {
+                        options.onSubagentStart(toolUseId, agentType, description);
+                    }
                 }
             },
-            onComplete: (agentType, result) => {
+            onComplete: (agentType, result, toolUseId) => {
                 if (options.verbose) {
                     console.log(`[Sub-agent] ${agentType} completed (${String(result.iterations)} iterations)`);
                 }
+                // Direct notification with toolUseId - no more searching!
+                if (toolUseId && options.onSubagentEnd) {
+                    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;
+                    if (input) {
+                        // Common patterns for tool input summaries
+                        const path = input.path;
+                        const pattern = input.pattern;
+                        const command = input.command;
+                        const filePath = input.file_path;
+                        if (typeof path === 'string')
+                            summary = path;
+                        else if (typeof pattern === 'string')
+                            summary = pattern;
+                        else if (typeof command === 'string')
+                            summary = command.slice(0, 40);
+                        else if (typeof filePath === 'string')
+                            summary = filePath;
+                    }
+                    options.onSubagentToolUse(toolUseId, toolName, summary);
+                }
             },
         });
         // Type assertion needed for task tool compatibility
@@ -313,5 +445,52 @@ export function createAgent(options = {}) {
         });
         agent.registerTool(suggestTool);
     }
+    // ==========================================================================
+    // Calculate and store token estimates for debugging
+    // ==========================================================================
+    if (!options.quiet) {
+        // Calculate tool tokens from the tools we registered
+        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(), ...getMetaTools()];
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-deprecated
+                toolsForEstimate = createToolRegistry();
+            }
+        }
+        for (const tool of toolsForEstimate) {
+            const def = tool.definition;
+            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
+            : 0;
+        const contextTokens = estimateTokens(options.projectContext);
+        setStaticEstimates({
+            system: systemTokens - roleTokens, // Subtract role since it's counted separately
+            role: roleTokens,
+            tools: toolTokens,
+            context: contextTokens,
+        });
+    }
     return agent;
 }

package/dist/anchors/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Anchors Module
+ *
+ * Re-exports the project-anchors API for managing persistent
+ * critical information that survives context compaction.
+ */
+export { getAnchorManager, getGlobalAnchorManager, clearProjectAnchors, getFormattedAnchors, addAnchor, getAllAnchors, getProjectsWithAnchors, getAnchorStats, clearManagerCache, } from './project-anchors.js';
+export type { Anchor, AnchorInput, AnchorQueryOptions } from './project-anchors.js';
+export { AnchorManager } from '@compilr-dev/sdk';

package/dist/anchors/index.js

@@ -0,0 +1,9 @@
+/**
+ * Anchors Module
+ *
+ * Re-exports the project-anchors API for managing persistent
+ * critical information that survives context compaction.
+ */
+export { getAnchorManager, getGlobalAnchorManager, clearProjectAnchors, getFormattedAnchors, addAnchor, getAllAnchors, getProjectsWithAnchors, getAnchorStats, clearManagerCache, } from './project-anchors.js';
+// Re-export the AnchorManager type from agents for consumers
+export { AnchorManager } from '@compilr-dev/sdk';