@compilr-dev/cli 0.5.1 → 0.5.3

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

@@ -90,16 +90,29 @@ export const resetCommand = {
                 ctx.ui.print({ type: 'info', message: `${String(clearedCount)} queued message${clearedCount !== 1 ? 's' : ''} cleared` });
             }
         }
+        // Recreate the default agent with fresh system prompt
+        // (reset-reload reloads COMPILR.md from disk; reset-only keeps current context but still
+        // needs a fresh agent so the empty history is reflected in a clean system prompt)
+        if (ctx.agentFactory && ctx.restoreAgent) {
+            try {
+                if (result.option === 'reset-reload' && ctx.updateProjectState) {
+                    // Reload project context (COMPILR.md, guided mode) from disk
+                    await ctx.updateProjectState(projectId);
+                }
+                const freshAgent = await ctx.agentFactory({});
+                ctx.restoreAgent(freshAgent);
+                if (ctx.team) {
+                    ctx.team.setDefaultAgent(freshAgent);
+                }
+            }
+            catch {
+                // Best effort — continue with old agent (history already cleared above)
+            }
+        }
         if (result.option === 'reset-reload') {
-            // Reset & reload context - need to refresh project context
-            // This is handled by creating a new agent with fresh context
-            // For now, we just clear history. Full context refresh requires
-            // recreating the agent (to be implemented in Phase 2 integration)
             ctx.ui.print({ type: 'success', message: 'Conversation cleared. Project context refreshed.' });
-            ctx.ui.print({ type: 'info', message: 'Note: Full context reload requires CLI restart for now.' });
         }
         else {
-            // Reset only - just clear messages
             ctx.ui.print({ type: 'success', message: 'Conversation cleared. Context preserved.' });
         }
         // Save the fresh session state

package/dist/commands-v2/handlers/session.d.ts

@@ -5,7 +5,7 @@
  * Sessions are now bound to projects - each project has its own session.
  */
 import type { CommandHandlerV2 } from '../types.js';
-import type { AgentState, SessionInfo, AnchorScope, AnchorClearOptions, AnchorPriority, Message } from '@compilr-dev/sdk';
+import type { Agent, AgentState, SessionInfo, AnchorScope, AnchorClearOptions, AnchorPriority, Message } from '@compilr-dev/sdk';
 import type { PrintableItem } from '../../ui/terminal-ui.js';
 import { type ProjectSession } from '../../session/index.js';
 import type { AgentTeam, AgentTeamConfig } from '../../multi-agent/index.js';
@@ -105,6 +105,9 @@ export declare function handleProjectSwitch(oldProjectId: number | null, agent:
     team: AgentTeam | null;
     agentFactory: AgentTeamConfig['agentFactory'];
     onEvent?: AgentTeamConfig['onEvent'];
+}, agentOptions?: {
+    agentFactory: AgentTeamConfig['agentFactory'];
+    updateProjectState?: (projectId: number | null) => Promise<void>;
 }): Promise<{
     switched: boolean;
     oldProjectId: number | null;
@@ -115,6 +118,7 @@ export declare function handleProjectSwitch(oldProjectId: number | null, agent:
     contextRefreshed: boolean;
     contextMessage?: string;
     newTeam?: AgentTeam;
+    newAgent?: Agent;
 } | null>;
 /**
  * Get the current project ID for tracking before overlay.

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

@@ -356,7 +356,7 @@ export async function loadAndRestoreSession(projectId, agent, mode = 'auto') {
  * @param teamOptions - Optional team switching options
  * @returns Object with switch info, or null if no switch occurred
  */
-export async function handleProjectSwitch(oldProjectId, agent, teamOptions) {
+export async function handleProjectSwitch(oldProjectId, agent, teamOptions, agentOptions) {
     const newProject = getCurrentProject();
     const newProjectId = newProject?.id ?? null;
     // No switch occurred
@@ -427,14 +427,24 @@ export async function handleProjectSwitch(oldProjectId, agent, teamOptions) {
                 messageCount = messages.length;
             }
         }
-        // Update agent's anchors for the new project
-        if (agent?.clearAnchors && agent.addAnchor) {
-            // Clear existing persistent anchors
-            agent.clearAnchors({ scope: 'persistent' });
-            // Add new project's anchors
+    }
+    catch {
+        // Context refresh is best-effort
+    }
+    // Recreate default agent if agentOptions provided — the new agent gets
+    // the fresh system prompt (project name, COMPILR.md, guided context).
+    let newAgent;
+    if (agentOptions) {
+        try {
+            // 1. Update liveProjectState in index.ts so agentFactory reads fresh values
+            await agentOptions.updateProjectState?.(newProjectId);
+            // 2. Create fresh default agent with new project's system prompt
+            newAgent = await agentOptions.agentFactory({});
+            // 3. Transfer anchors to the NEW agent
+            newAgent.clearAnchors({ scope: 'persistent' });
             const newAnchors = await getProjectAnchors(newProjectId);
             for (const anchor of newAnchors) {
-                agent.addAnchor({
+                newAgent.addAnchor({
                     id: anchor.id,
                     content: anchor.content,
                     priority: anchor.priority,
@@ -442,18 +452,45 @@ export async function handleProjectSwitch(oldProjectId, agent, teamOptions) {
                     tags: anchor.tags,
                 });
             }
+            // 4. Set history on the NEW agent (not the old one)
+            if (messages.length > 0) {
+                await newAgent.setHistory(messages, { turnCount: messageCount });
+            }
+        }
+        catch {
+            // If agent recreation fails, fall back to updating the old agent
+            newAgent = undefined;
         }
     }
-    catch {
-        // Context refresh is best-effort
-    }
-    // Set the updated history (with context message if any)
-    if (agent) {
-        if (messages.length > 0) {
-            await agent.setHistory(messages, { turnCount: messageCount });
+    // If no new agent was created, update the old agent as before
+    if (!newAgent) {
+        try {
+            // Update old agent's anchors
+            if (agent?.clearAnchors && agent.addAnchor) {
+                agent.clearAnchors({ scope: 'persistent' });
+                const newAnchors = await getProjectAnchors(newProjectId);
+                for (const anchor of newAnchors) {
+                    agent.addAnchor({
+                        id: anchor.id,
+                        content: anchor.content,
+                        priority: anchor.priority,
+                        scope: anchor.scope,
+                        tags: anchor.tags,
+                    });
+                }
+            }
         }
-        else {
-            agent.clearHistory();
+        catch {
+            // Context refresh is best-effort
+        }
+        // Set the updated history on the old agent
+        if (agent) {
+            if (messages.length > 0) {
+                await agent.setHistory(messages, { turnCount: messageCount });
+            }
+            else {
+                agent.clearHistory();
+            }
         }
     }
     // Handle team switching if team options provided
@@ -496,6 +533,7 @@ export async function handleProjectSwitch(oldProjectId, agent, teamOptions) {
         contextRefreshed,
         contextMessage,
         newTeam,
+        newAgent,
     };
 }
 /**

package/dist/commands-v2/types.d.ts

@@ -43,6 +43,11 @@ export interface CommandContextV2 {
      * Used when switching projects to create new team.
      */
     agentFactory?: (config: Record<string, unknown>, systemPromptAddition?: string, useMinimalSystemPrompt?: boolean, noTools?: boolean) => Promise<Agent>;
+    /**
+     * Update live project state so agentFactory creates agents with fresh context.
+     * Called during project switch before recreating the default agent.
+     */
+    updateProjectState?: (projectId: number | null) => Promise<void>;
     /**
      * Replace the current agent with a restored one.
      * Used by /resume command to restore from a saved session.

package/dist/db/repositories/document-repository.js

@@ -179,6 +179,7 @@ export const documentRepository = {
             design: 0,
             notes: 0,
             plan: 0,
+            'app-model': 0,
         };
         for (const row of results) {
             counts[row.doc_type] = row.count;

package/dist/db/schema.d.ts

@@ -83,7 +83,7 @@ export type WorkItemType = 'feature' | 'bug' | 'tech-debt' | 'chore';
 export type WorkItemStatus = 'backlog' | 'in_progress' | 'completed' | 'skipped';
 export type WorkItemPriority = 'critical' | 'high' | 'medium' | 'low';
 export type GuidedStep = 'plan' | 'implement' | 'test' | 'commit' | 'review';
-export type DocumentType = 'prd' | 'architecture' | 'design' | 'notes' | 'plan';
+export type DocumentType = 'prd' | 'architecture' | 'design' | 'notes' | 'plan' | 'app-model';
 export type PlanStatus = 'draft' | 'approved' | 'in_progress' | 'completed' | 'abandoned';
 export type TerminalSessionStatus = 'active' | 'stale' | 'dead';
 export interface TerminalSessionRecord {

package/dist/index.js

@@ -11,7 +11,7 @@ process.env.FORCE_COLOR = '3';
 import { perf, flushStartupPerf } from './utils/startup-perf.js';
 perf('imports-start');
 import { createAgent } from './agent.js';
-import { getModelForTier } from './models/index.js';
+import { getModelForTier, getProviderMetadata } from './models/index.js';
 import { ReplV2 } from './repl-v2.js';
 import { AgentTeam, setActiveSharedContext } from './multi-agent/index.js';
 import { getStyles } from './themes/index.js';
@@ -320,34 +320,48 @@ async function main() {
             }
         }
     }
+    // ==========================================================================
+    // Mutable project state — closures read these live so agentFactory
+    // always sees the current project context (not stale startup values).
+    // ==========================================================================
+    const liveProjectState = {
+        dbProject: null,
+        projectContext: undefined,
+        guidedModeContext: undefined,
+    };
     // Load project memory (COMPILR.md or CLAUDE.md)
     perf('project-memory-start');
     const projectMemory = loadProjectMemory();
-    let projectContext;
     if (projectMemory.found && projectMemory.filePath) {
-        projectContext = projectMemory.content;
+        liveProjectState.projectContext = projectMemory.content;
     }
     // ==========================================================================
     // Load guided mode context from database (if project uses guided mode)
     // ==========================================================================
     perf('project-db-start');
-    let guidedModeContext;
     // Determine which project to load based on projectStartup setting
     const projectStartupMode = getProjectStartupMode();
-    let dbProject = null;
     if (projectStartupMode === 'last') {
         // Try to load the last opened project
         const lastProjectId = getLastProjectId();
         if (lastProjectId !== null) {
-            dbProject = projectRepository.getById(lastProjectId);
+            liveProjectState.dbProject = projectRepository.getById(lastProjectId);
             // If last project no longer exists (deleted), don't auto-load any project
         }
         // If no lastProjectId remembered, don't auto-load any project
     }
     // else projectStartupMode === 'off': don't auto-load any project
-    if (dbProject) {
+    if (liveProjectState.dbProject) {
+        const dbProject = liveProjectState.dbProject;
         // Set as active project for tools to use
         setActiveProject({ id: dbProject.id, name: dbProject.name, displayName: dbProject.displayName, path: dbProject.path });
+        // Reload project memory from the DB project's path (not CWD)
+        // The initial loadProjectMemory() above uses process.cwd() which may
+        // load the wrong COMPILR.md/CLAUDE.md (e.g., workspace-level instead of project-specific)
+        if (dbProject.path) {
+            const memory = loadProjectMemory({ cwd: dbProject.path });
+            liveProjectState.projectContext = memory.found ? memory.content : undefined;
+        }
         // If in guided mode, generate context
         if (shouldInjectGuidedContext(dbProject)) {
             // Get work item counts
@@ -376,7 +390,7 @@ async function main() {
                 inProgressCount: statusCounts.in_progress,
                 completedCount: statusCounts.completed,
             };
-            guidedModeContext = getFullGuidedPrompt(contextOptions);
+            liveProjectState.guidedModeContext = getFullGuidedPrompt(contextOptions);
         }
     }
     // ==========================================================================
@@ -386,8 +400,8 @@ async function main() {
     // Load global anchors (always)
     const globalAnchors = getGlobalAnchorManager().getAll({ scope: 'persistent' });
     // Load project-specific anchors (if in a tracked project)
-    const projectAnchors = dbProject
-        ? getAnchorManager(String(dbProject.id)).getAll({ scope: 'persistent' })
+    const projectAnchors = liveProjectState.dbProject
+        ? getAnchorManager(String(liveProjectState.dbProject.id)).getAll({ scope: 'persistent' })
         : [];
     // Combine into persistedAnchors array for agent
     const persistedAnchors = [
@@ -404,7 +418,7 @@ async function main() {
             priority: a.priority,
             scope: a.scope,
             tags: a.tags,
-            projectId: String(dbProject?.id),
+            projectId: String(liveProjectState.dbProject?.id),
         })),
     ];
     // ==========================================================================
@@ -463,8 +477,8 @@ async function main() {
     // ==========================================================================
     perf('mcp-init-fire');
     // Check if there are MCP servers to connect — fire the promise but don't await yet
-    const mcpServerCount = loadMCPConfig(dbProject?.path).length;
-    const mcpInitPromise = mcpServerCount > 0 ? initializeMCP(dbProject?.path) : null;
+    const mcpServerCount = loadMCPConfig(liveProjectState.dbProject?.path).length;
+    const mcpInitPromise = mcpServerCount > 0 ? initializeMCP(liveProjectState.dbProject?.path) : null;
     // Mutable ref for MCP tools — read by team agent factory when creating new agents.
     // Updated when background MCP init completes.
     let mcpToolsRef = [];
@@ -472,9 +486,10 @@ async function main() {
     // Episode Recorder Setup (work history tracking)
     // ==========================================================================
     const createEpisodeRecorder = (agentId) => {
-        if (!dbProject)
+        if (!liveProjectState.dbProject)
             return undefined;
-        const episodesPath = path.join(getSessionsPath(), `project-${String(dbProject.id)}`, 'episodes.json');
+        const projectId = liveProjectState.dbProject.id;
+        const episodesPath = path.join(getSessionsPath(), `project-${String(projectId)}`, 'episodes.json');
         const store = new FileEpisodeStore({ filePath: episodesPath });
         // Set global store for recall_work tool access
         setGlobalEpisodeStore(store);
@@ -486,7 +501,7 @@ async function main() {
             onBatchFlushed: () => {
                 updateWorkSummaryAnchor({
                     store,
-                    projectId: String(dbProject.id),
+                    projectId: String(projectId),
                     getAnchorManager,
                 });
             },
@@ -500,16 +515,16 @@ async function main() {
         model,
         minimal: options.minimal,
         quiet: true,
-        enableMetaTools: !options.minimal, // Use meta-tools for token optimization
+        enableMetaTools: !options.minimal && getProviderMetadata(provider).supportsMetaTools,
         onPermissionRequest,
         onIterationLimitReached,
         onSuggest: (event) => {
             // Store suggestion to be applied after agent finishes
             sharedState.pendingSuggestion = event.action;
         },
-        projectName: dbProject?.displayName,
-        projectContext,
-        guidedModeContext,
+        projectName: liveProjectState.dbProject?.displayName,
+        projectContext: liveProjectState.projectContext,
+        guidedModeContext: liveProjectState.guidedModeContext,
         // Anchors - library handles re-injection on every LLM call
         enableAnchors: true,
         persistedAnchors: persistedAnchors.length > 0 ? persistedAnchors : undefined,
@@ -537,9 +552,11 @@ async function main() {
         episodeRecorder: defaultEpisodeRecorder,
     });
     perf('create-agent-done');
+    // Mutable ref so grantSession and onDefaultAgentSwapped closures track the current default agent
+    let defaultAgentRef = agent;
     // Bind grantSession for the permission handler to use
     sharedState.grantSession = (toolName) => {
-        agent.grantSessionPermission(toolName);
+        defaultAgentRef.grantSessionPermission(toolName);
     };
     // ==========================================================================
     // Create AgentTeam with the default agent (or restore from persistence)
@@ -554,15 +571,15 @@ async function main() {
             provider,
             model: agentModel,
             minimal: options.minimal,
-            enableMetaTools: !options.minimal && !noTools, // Disable meta-tools if noTools is set
+            enableMetaTools: !options.minimal && !noTools && getProviderMetadata(provider).supportsMetaTools,
             onPermissionRequest,
             onIterationLimitReached,
             onSuggest: (event) => {
                 sharedState.pendingSuggestion = event.action;
             },
-            projectName: dbProject?.displayName,
-            projectContext,
-            guidedModeContext,
+            projectName: liveProjectState.dbProject?.displayName,
+            projectContext: liveProjectState.projectContext,
+            guidedModeContext: liveProjectState.guidedModeContext,
             enableAnchors: true,
             persistedAnchors: persistedAnchors.length > 0 ? persistedAnchors : undefined,
             enableGuardrails: true,
@@ -605,11 +622,11 @@ async function main() {
     // Set the active shared context for activity recording
     setActiveSharedContext(team.sharedContext);
     // Populate shared context with actual project info so agents know the project name
-    if (dbProject) {
+    if (liveProjectState.dbProject) {
         team.sharedContext.setProject({
-            id: dbProject.id,
-            name: dbProject.displayName,
-            path: dbProject.path,
+            id: liveProjectState.dbProject.id,
+            name: liveProjectState.dbProject.displayName,
+            path: liveProjectState.dbProject.path,
         });
     }
     // ==========================================================================
@@ -636,7 +653,7 @@ async function main() {
         provider,
         version: VERSION,
         updateAvailable,
-        projectName: dbProject?.displayName ?? process.cwd().split('/').pop(),
+        projectName: liveProjectState.dbProject?.displayName ?? process.cwd().split('/').pop(),
         // Set up V2 permission overlay callback when UI is ready
         onUIReady: (showOverlay) => {
             sharedState.showPermissionOverlayV2 = showOverlay;
@@ -705,6 +722,58 @@ async function main() {
         onTeamReplaced: (newTeam) => {
             sharedState.team = newTeam;
         },
+        // Recreate default agent on project switch — updates liveProjectState
+        // so agentFactory reads fresh project context for the new agent.
+        onProjectStateUpdate: (projectId) => {
+            if (projectId !== null) {
+                liveProjectState.dbProject = projectRepository.getById(projectId);
+                if (liveProjectState.dbProject?.path) {
+                    const memory = loadProjectMemory({ cwd: liveProjectState.dbProject.path });
+                    liveProjectState.projectContext = memory.found ? memory.content : undefined;
+                }
+                else {
+                    liveProjectState.projectContext = undefined;
+                }
+                if (liveProjectState.dbProject && shouldInjectGuidedContext(liveProjectState.dbProject)) {
+                    const statusCounts = workItemRepository.getStatusCounts(liveProjectState.dbProject.id);
+                    let currentItem = null;
+                    if (liveProjectState.dbProject.currentItemId) {
+                        currentItem = workItemRepository.getByItemId(liveProjectState.dbProject.id, liveProjectState.dbProject.currentItemId);
+                    }
+                    else {
+                        const inProgressItems = workItemRepository.query({
+                            project_id: liveProjectState.dbProject.id,
+                            status: 'in_progress',
+                            limit: 1,
+                        });
+                        if (inProgressItems.items.length > 0) {
+                            currentItem = inProgressItems.items[0];
+                        }
+                    }
+                    const contextOptions = {
+                        project: liveProjectState.dbProject,
+                        currentItem,
+                        backlogCount: statusCounts.backlog,
+                        inProgressCount: statusCounts.in_progress,
+                        completedCount: statusCounts.completed,
+                    };
+                    liveProjectState.guidedModeContext = getFullGuidedPrompt(contextOptions);
+                }
+                else {
+                    liveProjectState.guidedModeContext = undefined;
+                }
+            }
+            else {
+                liveProjectState.dbProject = null;
+                liveProjectState.projectContext = undefined;
+                liveProjectState.guidedModeContext = undefined;
+            }
+            return Promise.resolve();
+        },
+        // Keep defaultAgentRef in sync when project switch creates a new default agent
+        onDefaultAgentSwapped: (newAgent) => {
+            defaultAgentRef = newAgent;
+        },
         // Set session prefix for VS Code diff IPC after session registration
         onSessionRegistered: (sessionId) => {
             sharedState.sessionPrefix = sessionId.slice(0, 8);

package/dist/models/providers.d.ts

@@ -9,11 +9,13 @@ import type { ProviderKey } from '../utils/credentials.js';
 import { type ProviderMetadata as SdkProviderMetadata } from '@compilr-dev/sdk';
 export { type OthersProviderModel, TOGETHER_MODELS, GROQ_MODELS, FIREWORKS_MODELS, PERPLEXITY_MODELS, OPENROUTER_MODELS, getModelsForOthersProvider, } from '@compilr-dev/sdk';
 /**
- * CLI-extended provider metadata — adds credentialKey for encrypted storage.
+ * CLI-extended provider metadata — adds credentialKey and capability flags.
  */
 export interface ProviderMetadata extends SdkProviderMetadata {
     /** Credential key for API key storage (CLI-specific) */
     credentialKey: ProviderKey;
+    /** Whether this provider handles the meta-tools indirection pattern well */
+    supportsMetaTools: boolean;
 }
 /**
  * CLI-extended provider metadata registry.

package/dist/models/providers.js

@@ -22,6 +22,14 @@ const CREDENTIAL_KEYS = {
     openrouter: 'openrouter',
     custom: 'openai', // Custom uses openai-compatible format by default
 };
+/**
+ * Meta-tools capability: which providers handle the indirection pattern well.
+ * When false, all tools are registered directly (higher token cost, but reliable).
+ */
+const SUPPORTS_META_TOOLS = {
+    claude: true,
+    gemini: true,
+};
 /**
  * CLI-extended provider metadata registry.
  * Merges SDK metadata with CLI credential keys.
@@ -33,6 +41,7 @@ export const PROVIDER_METADATA = (() => {
         result[providerType] = {
             ...sdkMeta,
             credentialKey: CREDENTIAL_KEYS[providerType],
+            supportsMetaTools: SUPPORTS_META_TOOLS[providerType] ?? false,
         };
     }
     return result;

package/dist/repl-helpers.js

@@ -7,6 +7,7 @@
  */
 import { builtinSkills, platformSkills } from '@compilr-dev/sdk';
 import { codingSkills } from '@compilr-dev/agents-coding';
+import { factorySkills } from '@compilr-dev/factory';
 import * as fs from 'fs';
 import * as path from 'path';
 import { findBacklogPath, parseBacklogItems } from './tools/backlog.js';
@@ -203,6 +204,7 @@ export function hasBacklogItems(backlogPath) {
  */
 export function getSkillPrompt(name) {
     const skill = platformSkills.find((s) => s.name === name)
+        ?? factorySkills.find((s) => s.name === name)
         ?? builtinSkills.find((s) => s.name === name)
         ?? codingSkills.find((s) => s.name === name);
     return skill?.prompt ?? null;

package/dist/repl-v2.d.ts

@@ -160,6 +160,16 @@ export interface ReplV2Options {
      * see the restored team (with all agents) instead of the initial one.
      */
     onTeamReplaced?: (newTeam: AgentTeam) => void;
+    /**
+     * Callback to update live project state in index.ts before recreating the default agent.
+     * Updates liveProjectState (COMPILR.md, guided context) so agentFactory sees fresh values.
+     */
+    onProjectStateUpdate?: (projectId: number | null) => Promise<void>;
+    /**
+     * Callback invoked after the default agent is swapped on project switch.
+     * Allows index.ts to update defaultAgentRef for grantSession.
+     */
+    onDefaultAgentSwapped?: (newAgent: Agent) => void;
 }
 /**
  * Options for switchAgent().
@@ -220,6 +230,8 @@ export declare class ReplV2 {
     private readonly onBackgroundDelegationReady?;
     private readonly onSessionRegistered?;
     private readonly onTeamReplaced?;
+    private readonly onProjectStateUpdate?;
+    private readonly onDefaultAgentSwapped?;
     private readonly authOnly;
     private restoredSessionInfo;
     private currentExecutingBackgroundAgentId;

package/dist/repl-v2.js

@@ -197,6 +197,8 @@ export class ReplV2 {
     onBackgroundDelegationReady;
     onSessionRegistered;
     onTeamReplaced;
+    onProjectStateUpdate;
+    onDefaultAgentSwapped;
     authOnly;
     restoredSessionInfo = null;
     // Phase 3b: Track which background agent is currently executing (for permission routing)
@@ -242,6 +244,8 @@ export class ReplV2 {
         this.onBackgroundDelegationReady = options.onBackgroundDelegationReady;
         this.onSessionRegistered = options.onSessionRegistered;
         this.onTeamReplaced = options.onTeamReplaced;
+        this.onProjectStateUpdate = options.onProjectStateUpdate;
+        this.onDefaultAgentSwapped = options.onDefaultAgentSwapped;
         this.authOnly = options.authOnly ?? false;
     }
     /**
@@ -734,6 +738,7 @@ export class ReplV2 {
      */
     restoreAgent(newAgent) {
         this.agent = newAgent;
+        this.onDefaultAgentSwapped?.(newAgent);
     }
     /**
      * Get the current agent instance.
@@ -1667,6 +1672,7 @@ export class ReplV2 {
             agent: this.agent,
             team: this.team,
             agentFactory: this.agentFactory,
+            updateProjectState: this.onProjectStateUpdate,
             setTeam: (newTeam) => {
                 const oldTeam = this.team;
                 this.team = newTeam;
@@ -2511,15 +2517,26 @@ export class ReplV2 {
                             }
                             // Handle get_tool_info - show compact summary
                             if (toolName === 'get_tool_info') {
-                                const innerResult = result.success && typeof result.result === 'object'
-                                    ? result.result
-                                    : {};
-                                const name = typeof innerResult.name === 'string' ? innerResult.name : '?';
+                                let name = '?';
+                                if (result.success) {
+                                    if (typeof result.result === 'string') {
+                                        // Compact schema format (SDK 0.1.15+): "tool_name(...)\n  description"
+                                        const parenIdx = result.result.indexOf('(');
+                                        if (parenIdx > 0)
+                                            name = result.result.slice(0, parenIdx);
+                                    }
+                                    else if (typeof result.result === 'object' && result.result !== null) {
+                                        // Legacy object format: { name, description, parameters }
+                                        const obj = result.result;
+                                        if (typeof obj.name === 'string')
+                                            name = obj.name;
+                                    }
+                                }
                                 this.ui.print({
                                     type: 'tool-result',
                                     name: 'get_tool_info',
                                     params: name,
-                                    summary: `Schema for ${name}`,
+                                    summary: `Schema: ${name}`,
                                     success: result.success,
                                     agentId: activeAgentId,
                                 });
@@ -3234,13 +3251,12 @@ export class ReplV2 {
         if (metrics.toolCalls > 0) {
             parts.push(`${String(metrics.toolCalls)} tool${metrics.toolCalls > 1 ? 's' : ''}`);
         }
-        // DEBUG: Show payload debug info (chars sent to provider)
+        // DEBUG: Show payload debug info (token estimates sent to provider)
         if (metrics.debugPayload) {
-            const { systemChars, contentsChars, toolsChars } = metrics.debugPayload;
-            const totalChars = systemChars + contentsChars + toolsChars;
-            const estTokens = Math.ceil(totalChars / 4);
-            // Format: [dbg 2calls sent:123k (~31k est) sys:10k cont:100k tools:13k]
-            parts.push(`[dbg ${String(metrics.apiCalls)}calls sent:${formatTokens(totalChars)} (~${formatTokens(estTokens)} est) sys:${formatTokens(systemChars)} cont:${formatTokens(contentsChars)} tools:${formatTokens(toolsChars)}]`);
+            const { systemTokens, contentsTokens, toolsTokens } = metrics.debugPayload;
+            const totalTokens = systemTokens + contentsTokens + toolsTokens;
+            // Format: [dbg 2calls sent:31k sys:10k cont:8k tools:13k]
+            parts.push(`[dbg ${String(metrics.apiCalls)}calls sent:${formatTokens(totalTokens)} sys:${formatTokens(systemTokens)} cont:${formatTokens(contentsTokens)} tools:${formatTokens(toolsTokens)}]`);
         }
         // Print as muted info line
         this.ui.print({ type: 'turn-summary', parts });

package/dist/tool-names.d.ts

@@ -92,11 +92,20 @@ export declare const TOOL_NAMES: {
     readonly ARTIFACT_LIST: "artifact_list";
     readonly ARTIFACT_DELETE: "artifact_delete";
     readonly RECALL_WORK: "recall_work";
+    readonly APP_MODEL_GET: "app_model_get";
+    readonly APP_MODEL_UPDATE: "app_model_update";
+    readonly APP_MODEL_VALIDATE: "app_model_validate";
+    readonly FACTORY_SCAFFOLD: "factory_scaffold";
+    readonly FACTORY_LIST_TOOLKITS: "factory_list_toolkits";
 };
 /** Type for all valid tool names */
 export type ToolName = (typeof TOOL_NAMES)[keyof typeof TOOL_NAMES];
 /** Array of all direct tool names (always available) */
 export declare const DIRECT_TOOL_NAMES: readonly ToolName[];
+/** Hot tools — used in >50% of turns, always declared as direct schemas */
+export declare const HOT_TOOL_NAMES: readonly ToolName[];
+/** Warm tools — used occasionally, moved to meta-registry in hot-tools mode */
+export declare const WARM_TOOL_NAMES: readonly ToolName[];
 /** Array of all meta-tool names (tool discovery) */
 export declare const META_TOOL_NAMES: readonly ToolName[];
 /** Array of all meta-registry tool names (accessed via use_tool) */