ccjk 12.2.0 → 12.2.1

package/dist/chunks/cli-hook.mjs

@@ -3,13 +3,13 @@ import { a as getGlobalStateManager, g as getGlobalConvoyManager, S as SessionIn
 import { n as nanoid } from '../shared/ccjk.BoApaI4j.mjs';
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
+import process__default from 'node:process';
 import 'node:child_process';
 import 'node:fs/promises';
 import 'node:os';
 import 'node:path';
 import './main.mjs';
 import 'module';
-import 'node:process';
 import 'node:stream';
 import 'node:readline';
 import 'node:crypto';
@@ -992,6 +992,418 @@ function getGlobalMayorAgent(config) {
   return globalMayorAgent;
 }
 
+class MetricsCollector {
+  metrics = /* @__PURE__ */ new Map();
+  taskMetrics = /* @__PURE__ */ new Map();
+  performanceMetrics = /* @__PURE__ */ new Map();
+  maxRecords;
+  retentionPeriod;
+  constructor(options = {}) {
+    this.maxRecords = options.maxRecords ?? 1e3;
+    this.retentionPeriod = options.retentionPeriod ?? 36e5;
+  }
+  /**
+   * Record a metric value
+   */
+  recordMetric(agentId, metricName, value, metadata) {
+    if (!this.metrics.has(agentId)) {
+      this.metrics.set(agentId, /* @__PURE__ */ new Map());
+    }
+    const agentMetrics = this.metrics.get(agentId);
+    if (!agentMetrics.has(metricName)) {
+      agentMetrics.set(metricName, []);
+    }
+    const records = agentMetrics.get(metricName);
+    records.push({
+      timestamp: Date.now(),
+      value,
+      metadata
+    });
+    this.trimRecords(records);
+  }
+  /**
+   * Record CPU usage
+   */
+  recordCpuUsage(agentId, usage) {
+    this.recordMetric(agentId, "cpu_usage", usage);
+    this.updatePerformanceMetrics(agentId, { cpuUsage: usage });
+  }
+  /**
+   * Record memory usage
+   */
+  recordMemoryUsage(agentId, usage) {
+    this.recordMetric(agentId, "memory_usage", usage);
+    this.updatePerformanceMetrics(agentId, { memoryUsage: usage });
+  }
+  /**
+   * Record response time
+   */
+  recordResponseTime(agentId, responseTime) {
+    this.recordMetric(agentId, "response_time", responseTime);
+    this.updatePerformanceMetrics(agentId, { responseTime });
+  }
+  /**
+   * Record task completion
+   */
+  recordTaskCompletion(agentId, success, duration) {
+    if (!this.taskMetrics.has(agentId)) {
+      this.taskMetrics.set(agentId, {
+        totalTasks: 0,
+        completedTasks: 0,
+        failedTasks: 0,
+        avgDuration: 0,
+        successRate: 0
+      });
+    }
+    const metrics = this.taskMetrics.get(agentId);
+    metrics.totalTasks++;
+    if (success) {
+      metrics.completedTasks++;
+    } else {
+      metrics.failedTasks++;
+    }
+    metrics.avgDuration = (metrics.avgDuration * (metrics.totalTasks - 1) + duration) / metrics.totalTasks;
+    metrics.successRate = metrics.completedTasks / metrics.totalTasks;
+    this.recordMetric(agentId, "task_duration", duration, { success });
+  }
+  /**
+   * Record error
+   */
+  recordError(agentId, errorType, errorMessage) {
+    this.recordMetric(agentId, "error", 1, { errorType, errorMessage });
+    this.updatePerformanceMetrics(agentId, { errorCount: 1 });
+  }
+  /**
+   * Get agent metrics
+   */
+  getAgentMetrics(agentId) {
+    const taskMetrics = this.taskMetrics.get(agentId);
+    const cpuRecords = this.getMetricRecords(agentId, "cpu_usage");
+    const memoryRecords = this.getMetricRecords(agentId, "memory_usage");
+    const responseTimeRecords = this.getMetricRecords(agentId, "response_time");
+    const cpuUsage = cpuRecords.length > 0 ? cpuRecords[cpuRecords.length - 1].value : 0;
+    const memoryUsage = memoryRecords.length > 0 ? memoryRecords[memoryRecords.length - 1].value : 0;
+    this.calculateAverage(responseTimeRecords.map((r) => r.value));
+    taskMetrics ? taskMetrics.failedTasks / taskMetrics.totalTasks : 0;
+    return {
+      tasksExecuted: taskMetrics?.totalTasks ?? 0,
+      tasksSucceeded: taskMetrics?.completedTasks ?? 0,
+      tasksFailed: taskMetrics?.failedTasks ?? 0,
+      avgTaskDuration: taskMetrics?.avgDuration ?? 0,
+      successRate: taskMetrics?.successRate ?? 0,
+      totalExecutionTime: taskMetrics?.avgDuration ?? 0,
+      avgConfidence: 0.8,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      cpuUsage,
+      memoryUsage
+    };
+  }
+  /**
+   * Get metric snapshot
+   */
+  getMetricSnapshot(agentId, metricName, timeRange) {
+    const records = this.getMetricRecords(agentId, metricName, timeRange);
+    const values = records.map((r) => r.value);
+    if (values.length === 0) {
+      return {
+        metricName,
+        agentId,
+        timestamp: Date.now(),
+        current: 0,
+        min: 0,
+        max: 0,
+        avg: 0,
+        count: 0
+      };
+    }
+    return {
+      metricName,
+      agentId,
+      timestamp: Date.now(),
+      current: values[values.length - 1],
+      min: Math.min(...values),
+      max: Math.max(...values),
+      avg: this.calculateAverage(values),
+      count: values.length
+    };
+  }
+  /**
+   * Get aggregated metrics
+   */
+  getAggregatedMetrics(agentId, metricName, timeRange) {
+    const records = this.getMetricRecords(agentId, metricName, timeRange);
+    const values = records.map((r) => r.value).sort((a, b) => a - b);
+    if (values.length === 0) {
+      return {
+        min: 0,
+        max: 0,
+        avg: 0,
+        median: 0,
+        p95: 0,
+        p99: 0,
+        count: 0
+      };
+    }
+    return {
+      min: values[0],
+      max: values[values.length - 1],
+      avg: this.calculateAverage(values),
+      median: this.calculatePercentile(values, 50),
+      p95: this.calculatePercentile(values, 95),
+      p99: this.calculatePercentile(values, 99),
+      count: values.length
+    };
+  }
+  /**
+   * Get task metrics
+   */
+  getTaskMetrics(agentId) {
+    return this.taskMetrics.get(agentId);
+  }
+  /**
+   * Get performance metrics
+   */
+  getPerformanceMetrics(agentId) {
+    return this.performanceMetrics.get(agentId);
+  }
+  /**
+   * Get all agents with metrics
+   */
+  getAllAgents() {
+    return Array.from(this.metrics.keys());
+  }
+  /**
+   * Clear metrics for an agent
+   */
+  clearAgentMetrics(agentId) {
+    this.metrics.delete(agentId);
+    this.taskMetrics.delete(agentId);
+    this.performanceMetrics.delete(agentId);
+  }
+  /**
+   * Clear all metrics
+   */
+  clearAll() {
+    this.metrics.clear();
+    this.taskMetrics.clear();
+    this.performanceMetrics.clear();
+  }
+  /**
+   * Export metrics to JSON
+   */
+  exportMetrics(agentId) {
+    if (agentId) {
+      return {
+        agentId,
+        metrics: this.getAgentMetrics(agentId),
+        taskMetrics: this.getTaskMetrics(agentId),
+        performanceMetrics: this.getPerformanceMetrics(agentId),
+        timestamp: Date.now()
+      };
+    }
+    const allMetrics = {};
+    for (const id of this.getAllAgents()) {
+      allMetrics[id] = {
+        metrics: this.getAgentMetrics(id),
+        taskMetrics: this.getTaskMetrics(id),
+        performanceMetrics: this.getPerformanceMetrics(id)
+      };
+    }
+    return {
+      agents: allMetrics,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Get metric records
+   */
+  getMetricRecords(agentId, metricName, timeRange) {
+    const agentMetrics = this.metrics.get(agentId);
+    if (!agentMetrics) {
+      return [];
+    }
+    const records = agentMetrics.get(metricName) ?? [];
+    if (timeRange) {
+      const cutoff = Date.now() - timeRange;
+      return records.filter((r) => r.timestamp >= cutoff);
+    }
+    return records;
+  }
+  /**
+   * Update performance metrics
+   */
+  updatePerformanceMetrics(agentId, update) {
+    if (!this.performanceMetrics.has(agentId)) {
+      this.performanceMetrics.set(agentId, {
+        cpuUsage: 0,
+        memoryUsage: 0,
+        responseTime: 0,
+        errorCount: 0,
+        requestCount: 0,
+        timestamp: Date.now()
+      });
+    }
+    const metrics = this.performanceMetrics.get(agentId);
+    if (update.cpuUsage !== void 0) {
+      metrics.cpuUsage = update.cpuUsage;
+    }
+    if (update.memoryUsage !== void 0) {
+      metrics.memoryUsage = update.memoryUsage;
+    }
+    if (update.responseTime !== void 0) {
+      metrics.requestCount++;
+      metrics.responseTime = (metrics.responseTime * (metrics.requestCount - 1) + update.responseTime) / metrics.requestCount;
+    }
+    if (update.errorCount !== void 0) {
+      metrics.errorCount += update.errorCount;
+    }
+    metrics.timestamp = Date.now();
+  }
+  /**
+   * Trim old records
+   */
+  trimRecords(records) {
+    const cutoff = Date.now() - this.retentionPeriod;
+    while (records.length > 0 && records[0].timestamp < cutoff) {
+      records.shift();
+    }
+    while (records.length > this.maxRecords) {
+      records.shift();
+    }
+  }
+  /**
+   * Calculate average
+   */
+  calculateAverage(values) {
+    if (values.length === 0) {
+      return 0;
+    }
+    return values.reduce((sum, val) => sum + val, 0) / values.length;
+  }
+  /**
+   * Calculate percentile
+   */
+  calculatePercentile(sortedValues, percentile) {
+    if (sortedValues.length === 0) {
+      return 0;
+    }
+    const index = Math.ceil(percentile / 100 * sortedValues.length) - 1;
+    return sortedValues[Math.max(0, index)];
+  }
+}
+let globalMetricsCollector;
+function getMetricsCollector(options) {
+  if (!globalMetricsCollector) {
+    globalMetricsCollector = new MetricsCollector(options);
+  }
+  return globalMetricsCollector;
+}
+
+const promptUserQuestion = async (question) => {
+  if (!process__default.stdin.isTTY || !process__default.stdout.isTTY) {
+    return null;
+  }
+  try {
+    const inquirer = (await import('./index3.mjs').then(function (n) { return n.c; })).default;
+    const choices = question.options.map((option) => ({
+      name: option.description ? `${option.label} \u2014 ${option.description}` : option.label,
+      value: option.value
+    }));
+    const defaultIndex = typeof question.defaultValue === "string" ? Math.max(0, choices.findIndex((choice) => choice.value === question.defaultValue)) : 0;
+    const { selected } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "selected",
+        message: question.prompt,
+        choices,
+        default: defaultIndex
+      }
+    ]);
+    return {
+      value: selected,
+      source: "option"
+    };
+  } catch {
+    return null;
+  }
+};
+
+const DEFAULT_PHASE_SUMMARY = {
+  calls: 0,
+  failures: 0,
+  successRate: 0,
+  avgDurationMs: 0
+};
+class ExecutionTelemetry {
+  constructor(maxEvents = 2e3) {
+    this.maxEvents = maxEvents;
+  }
+  events = [];
+  record(event) {
+    const entry = {
+      id: `te-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      timestamp: Date.now(),
+      ...event
+    };
+    this.events.push(entry);
+    if (this.events.length > this.maxEvents) {
+      this.events.shift();
+    }
+    return entry;
+  }
+  getRecent(limit = 50) {
+    if (limit <= 0) {
+      return [];
+    }
+    return this.events.slice(-limit);
+  }
+  summarize() {
+    const phaseStats = {
+      execution: { ...DEFAULT_PHASE_SUMMARY },
+      intent: { ...DEFAULT_PHASE_SUMMARY },
+      elicitation: { ...DEFAULT_PHASE_SUMMARY },
+      skill: { ...DEFAULT_PHASE_SUMMARY },
+      agent: { ...DEFAULT_PHASE_SUMMARY },
+      mcp: { ...DEFAULT_PHASE_SUMMARY },
+      route: { ...DEFAULT_PHASE_SUMMARY }
+    };
+    let totalSuccess = 0;
+    let durationCount = 0;
+    let durationTotal = 0;
+    for (const event of this.events) {
+      const summary = phaseStats[event.phase];
+      summary.calls++;
+      if (!event.success) {
+        summary.failures++;
+      } else {
+        totalSuccess++;
+      }
+      if (typeof event.durationMs === "number") {
+        durationTotal += event.durationMs;
+        durationCount++;
+        summary.avgDurationMs = (summary.avgDurationMs * (summary.calls - 1) + event.durationMs) / summary.calls;
+      }
+      summary.successRate = summary.calls === 0 ? 0 : (summary.calls - summary.failures) / summary.calls;
+    }
+    return {
+      totalEvents: this.events.length,
+      overallSuccessRate: this.events.length === 0 ? 0 : totalSuccess / this.events.length,
+      avgDurationMs: durationCount === 0 ? 0 : durationTotal / durationCount,
+      phaseStats
+    };
+  }
+  clear() {
+    this.events = [];
+  }
+}
+let globalExecutionTelemetry = null;
+function getGlobalExecutionTelemetry() {
+  if (!globalExecutionTelemetry) {
+    globalExecutionTelemetry = new ExecutionTelemetry();
+  }
+  return globalExecutionTelemetry;
+}
+
 class IntentRouter extends EventEmitter {
   config;
   // Keywords for intent detection
@@ -1385,15 +1797,78 @@ function getGlobalIntentRouter(config) {
   return globalRouter$1;
 }
 
+const MCP_TOOL_PROFILES = [
+  {
+    tool: "filesystem",
+    keywords: ["file", "directory", "folder", "workspace", "path", "read", "write"],
+    basePriority: 5,
+    intentBoost: {
+      feature: 2,
+      refactor: 2,
+      bug_fix: 2
+    }
+  },
+  {
+    tool: "github",
+    keywords: ["github", "repository", "repo", "pr", "pull request", "issue", "commit"],
+    basePriority: 4,
+    intentBoost: {
+      feature: 1,
+      bug_fix: 1
+    }
+  },
+  {
+    tool: "web-search",
+    keywords: ["search", "research", "web", "documentation", "docs", "latest", "reference"],
+    basePriority: 3,
+    intentBoost: {
+      question: 2,
+      plan: 1
+    }
+  },
+  {
+    tool: "context7",
+    keywords: ["library", "framework", "package", "sdk", "api docs", "best practice"],
+    basePriority: 4,
+    intentBoost: {
+      feature: 2,
+      plan: 2,
+      question: 1
+    }
+  },
+  {
+    tool: "ide",
+    keywords: ["diagnostic", "error", "lint", "typecheck", "compile", "warning"],
+    basePriority: 3,
+    intentBoost: {
+      bug_fix: 2,
+      refactor: 1
+    }
+  },
+  {
+    tool: "playwright",
+    keywords: ["browser", "webpage", "e2e", "ui test", "automation", "screenshot"],
+    basePriority: 2,
+    intentBoost: {
+      feature: 1,
+      bug_fix: 1
+    }
+  }
+];
 class AutoExecutor extends EventEmitter {
   config;
-  intentRouter = getGlobalIntentRouter();
+  metricsCollector = getMetricsCollector();
   constructor(config = {}) {
     super();
     this.config = {
       autoCreateSkills: config.autoCreateSkills !== void 0 ? config.autoCreateSkills : true,
       autoCreateAgents: config.autoCreateAgents !== void 0 ? config.autoCreateAgents : true,
       autoSelectMcp: config.autoSelectMcp !== void 0 ? config.autoSelectMcp : true,
+      enableElicitation: config.enableElicitation !== void 0 ? config.enableElicitation : true,
+      maxMcpTools: config.maxMcpTools !== void 0 ? Math.max(1, config.maxMcpTools) : 3,
+      askUserQuestion: config.askUserQuestion || promptUserQuestion,
+      intentRouter: config.intentRouter || getGlobalIntentRouter(),
+      telemetry: config.telemetry || getGlobalExecutionTelemetry(),
       verbose: config.verbose !== void 0 ? config.verbose : false
     };
   }
@@ -1401,36 +1876,141 @@ class AutoExecutor extends EventEmitter {
    * Execute user request automatically
    */
   async execute(userInput) {
+    const executionId = `exec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const startedAt = Date.now();
     this.emit("execution:started", { input: userInput });
+    this.config.telemetry.record({
+      executionId,
+      phase: "execution",
+      action: "start",
+      success: true,
+      metadata: {
+        inputLength: userInput.length
+      }
+    });
     try {
-      const routeResult = await this.intentRouter.route(userInput);
-      const { route, intent } = routeResult;
+      const routeStart = Date.now();
+      const routeResult = await this.config.intentRouter.route(userInput);
+      this.config.telemetry.record({
+        executionId,
+        phase: "intent",
+        action: "route",
+        success: true,
+        durationMs: Date.now() - routeStart,
+        metadata: {
+          initialRoute: routeResult.route,
+          confidence: routeResult.intent.confidence,
+          intentType: routeResult.intent.type,
+          complexity: routeResult.intent.complexity
+        }
+      });
+      const elicitationResult = await this.resolveRouteWithElicitation(
+        routeResult.route,
+        routeResult.intent,
+        executionId
+      );
+      const route = elicitationResult.route;
+      const intent = elicitationResult.intent;
       this.log(`Intent analyzed: ${intent.type} (${intent.complexity})`);
       this.log(`Suggested route: ${route}`);
+      const skillDetectStart = Date.now();
       const skillReq = await this.detectSkillRequirement(userInput, intent);
+      this.config.telemetry.record({
+        executionId,
+        phase: "skill",
+        action: "detect",
+        success: true,
+        durationMs: Date.now() - skillDetectStart,
+        metadata: {
+          needed: skillReq.needed,
+          reason: skillReq.reason
+        }
+      });
+      const agentDetectStart = Date.now();
       const agentReq = await this.detectAgentRequirement(userInput, intent);
+      this.config.telemetry.record({
+        executionId,
+        phase: "agent",
+        action: "detect",
+        success: true,
+        durationMs: Date.now() - agentDetectStart,
+        metadata: {
+          needed: agentReq.needed,
+          reason: agentReq.reason
+        }
+      });
+      const mcpDetectStart = Date.now();
       const mcpReq = await this.detectMcpRequirement(userInput, intent);
+      this.config.telemetry.record({
+        executionId,
+        phase: "mcp",
+        action: "detect",
+        success: true,
+        durationMs: Date.now() - mcpDetectStart,
+        metadata: {
+          needed: mcpReq.needed,
+          selectedTools: mcpReq.tools,
+          candidates: mcpReq.candidates,
+          reason: mcpReq.reason
+        }
+      });
       const agentsCreated = [];
       const skillsCreated = [];
       const mcpToolsUsed = [];
       if (this.config.autoCreateSkills && skillReq.needed) {
         this.log(`Auto-creating skill: ${skillReq.skillName}`);
+        const skillCreateStart = Date.now();
         const skillId = await this.autoCreateSkill(skillReq);
         skillsCreated.push(skillId);
+        this.config.telemetry.record({
+          executionId,
+          phase: "skill",
+          action: "create",
+          success: true,
+          durationMs: Date.now() - skillCreateStart,
+          metadata: {
+            skillId,
+            skillName: skillReq.skillName
+          }
+        });
         this.emit("skill:created", { skillId, skillReq });
       }
       if (this.config.autoCreateAgents && agentReq.needed) {
         this.log(`Auto-creating agent: ${agentReq.domain}`);
+        const agentCreateStart = Date.now();
         const agentId = await this.autoCreateAgent(agentReq);
         agentsCreated.push(agentId);
+        this.config.telemetry.record({
+          executionId,
+          phase: "agent",
+          action: "create",
+          success: true,
+          durationMs: Date.now() - agentCreateStart,
+          metadata: {
+            agentId,
+            agentType: agentReq.agentType,
+            domain: agentReq.domain
+          }
+        });
         this.emit("agent:created", { agentId, agentReq });
       }
       if (this.config.autoSelectMcp && mcpReq.needed) {
         this.log(`Auto-selecting MCP tools: ${mcpReq.tools.join(", ")}`);
         mcpToolsUsed.push(...mcpReq.tools);
+        this.config.telemetry.record({
+          executionId,
+          phase: "mcp",
+          action: "select",
+          success: true,
+          metadata: {
+            tools: mcpReq.tools,
+            candidates: mcpReq.candidates
+          }
+        });
         this.emit("mcp:selected", { tools: mcpReq.tools, mcpReq });
       }
       let result;
+      const routeExecutionStart = Date.now();
       switch (route) {
         case "mayor":
           result = await this.executeMayor(userInput, intent, agentsCreated, skillsCreated, mcpToolsUsed);
@@ -1447,13 +2027,174 @@ class AutoExecutor extends EventEmitter {
         default:
           throw new Error(`Unknown route: ${route}`);
       }
+      const routeDuration = Date.now() - routeExecutionStart;
+      this.config.telemetry.record({
+        executionId,
+        phase: "route",
+        action: route,
+        success: true,
+        durationMs: routeDuration,
+        metadata: {
+          intentType: intent.type,
+          complexity: intent.complexity
+        }
+      });
+      const totalDuration = Date.now() - startedAt;
+      this.metricsCollector.recordResponseTime("auto-executor", totalDuration);
+      this.metricsCollector.recordTaskCompletion("auto-executor", true, totalDuration);
+      this.config.telemetry.record({
+        executionId,
+        phase: "execution",
+        action: "complete",
+        success: true,
+        durationMs: totalDuration,
+        metadata: {
+          route,
+          agentsCreated: agentsCreated.length,
+          skillsCreated: skillsCreated.length,
+          mcpToolsUsed: mcpToolsUsed.length
+        }
+      });
+      result.insights = this.buildExecutionInsights({
+        initialRoute: routeResult.route,
+        resolvedRoute: route,
+        elicitationAsked: elicitationResult.elicitationAsked,
+        userSelectedRoute: elicitationResult.userSelectedRoute,
+        mcpReq,
+        totalDurationMs: totalDuration,
+        executionId
+      });
       this.emit("execution:completed", result);
       return result;
     } catch (error) {
+      const totalDuration = Date.now() - startedAt;
+      const errorMessage = this.getErrorMessage(error);
+      this.metricsCollector.recordResponseTime("auto-executor", totalDuration);
+      this.metricsCollector.recordTaskCompletion("auto-executor", false, totalDuration);
+      this.metricsCollector.recordError("auto-executor", "execution_error", errorMessage);
+      this.config.telemetry.record({
+        executionId,
+        phase: "execution",
+        action: "complete",
+        success: false,
+        durationMs: totalDuration,
+        metadata: {
+          error: errorMessage
+        }
+      });
       this.emit("execution:failed", { error, input: userInput });
       throw error;
     }
   }
+  /**
+   * Resolve route with optional structured elicitation.
+   * This keeps model autonomy but lets users disambiguate complex intent.
+   */
+  async resolveRouteWithElicitation(suggestedRoute, intent, executionId) {
+    if (!this.config.enableElicitation || !this.shouldAskRouteQuestion(intent)) {
+      return {
+        route: suggestedRoute,
+        intent,
+        elicitationAsked: false,
+        userSelectedRoute: false
+      };
+    }
+    const question = this.buildRouteQuestion(suggestedRoute, intent);
+    const askStart = Date.now();
+    const answer = await this.config.askUserQuestion(question);
+    this.config.telemetry.record({
+      executionId,
+      phase: "elicitation",
+      action: "route-choice",
+      success: true,
+      durationMs: Date.now() - askStart,
+      metadata: {
+        asked: true,
+        suggestedRoute,
+        answered: Boolean(answer),
+        selected: answer?.value
+      }
+    });
+    if (!answer) {
+      return {
+        route: suggestedRoute,
+        intent,
+        elicitationAsked: true,
+        userSelectedRoute: false
+      };
+    }
+    return this.applyRouteAnswer(suggestedRoute, intent, answer);
+  }
+  shouldAskRouteQuestion(intent) {
+    if (intent.complexity === "trivial" || intent.complexity === "simple") {
+      return false;
+    }
+    const lowConfidence = intent.confidence < 0.65;
+    const multiRouteIndicators = intent.requiresPlanning && intent.requiresMultipleAgents;
+    return lowConfidence || multiRouteIndicators;
+  }
+  buildRouteQuestion(suggestedRoute, intent) {
+    const routeLabels = {
+      direct: "Direct execution",
+      feature: "Feature implementation",
+      plan: "Plan first",
+      mayor: "Multi-agent orchestration"
+    };
+    const options = [
+      {
+        value: suggestedRoute,
+        label: `Use recommended: ${routeLabels[suggestedRoute]}`,
+        description: `Best guess from intent analysis (confidence ${Math.round(intent.confidence * 100)}%)`
+      },
+      {
+        value: "plan",
+        label: routeLabels.plan,
+        description: "Start with architecture and implementation plan"
+      },
+      {
+        value: "feature",
+        label: routeLabels.feature,
+        description: "Implement directly with focused feature workflow"
+      },
+      {
+        value: "direct",
+        label: routeLabels.direct,
+        description: "Run quickly without extra orchestration"
+      },
+      {
+        value: "mayor",
+        label: routeLabels.mayor,
+        description: "Use specialized agents for decomposition and coordination"
+      }
+    ].filter((option, index, arr) => arr.findIndex((x) => x.value === option.value) === index);
+    return {
+      id: "execution-route-choice",
+      prompt: "How should I execute this request?",
+      options,
+      defaultValue: suggestedRoute
+    };
+  }
+  applyRouteAnswer(suggestedRoute, intent, answer) {
+    const selectedRoute = ["direct", "feature", "plan", "mayor"].includes(answer.value) ? answer.value : suggestedRoute;
+    if (selectedRoute === suggestedRoute) {
+      return {
+        route: suggestedRoute,
+        intent,
+        elicitationAsked: true,
+        userSelectedRoute: false
+      };
+    }
+    return {
+      route: selectedRoute,
+      intent: {
+        ...intent,
+        suggestedRoute: selectedRoute,
+        reasoning: `${intent.reasoning} \u2022 User selected route: ${selectedRoute}`
+      },
+      elicitationAsked: true,
+      userSelectedRoute: true
+    };
+  }
   /**
    * Detect if a new skill is needed
    */
@@ -1576,31 +2317,28 @@ class AutoExecutor extends EventEmitter {
   /**
    * Detect which MCP tools are needed
    */
-  async detectMcpRequirement(input, _intent) {
+  async detectMcpRequirement(input, intent) {
     const normalized = input.toLowerCase();
-    const tools = [];
-    if (normalized.includes("file") || normalized.includes("directory") || normalized.includes("folder")) {
-      tools.push("filesystem");
-    }
-    if (normalized.includes("github") || normalized.includes("repository") || normalized.includes("pr")) {
-      tools.push("github");
-    }
-    if (normalized.includes("search") || normalized.includes("documentation") || normalized.includes("docs")) {
-      tools.push("web-search");
-    }
-    if (normalized.includes("browser") || normalized.includes("webpage") || normalized.includes("ui test")) {
-      tools.push("playwright");
-    }
-    if (normalized.includes("library") || normalized.includes("framework") || normalized.includes("package")) {
-      tools.push("context7");
-    }
-    if (normalized.includes("diagnostic") || normalized.includes("error") || normalized.includes("lint")) {
-      tools.push("ide");
-    }
+    const scoredTools = MCP_TOOL_PROFILES.map((profile) => {
+      const matchedKeywords = profile.keywords.filter((keyword) => normalized.includes(keyword));
+      if (matchedKeywords.length === 0) {
+        return null;
+      }
+      const intentBoost = profile.intentBoost?.[intent.type] ?? 0;
+      const complexityBoost = intent.complexity === "complex" || intent.complexity === "very_complex" ? 1 : 0;
+      const score = profile.basePriority + matchedKeywords.length * 2 + intentBoost + complexityBoost;
+      return {
+        tool: profile.tool,
+        score
+      };
+    }).filter((item) => item !== null).sort((a, b) => b.score - a.score);
+    const candidates = scoredTools.map((item) => item.tool);
+    const tools = scoredTools.slice(0, this.config.maxMcpTools).map((item) => item.tool);
     return {
       needed: tools.length > 0,
       tools,
-      reason: tools.length > 0 ? `Requires MCP tools: ${tools.join(", ")}` : "No MCP tools needed"
+      candidates,
+      reason: tools.length > 0 ? candidates.length > tools.length ? `Selected top ${tools.length}/${candidates.length} MCP tools by capability score: ${tools.join(", ")}` : `Requires MCP tools: ${tools.join(", ")}` : "No MCP tools needed"
     };
   }
   /**
@@ -1778,6 +2516,48 @@ class AutoExecutor extends EventEmitter {
       details: { input }
     };
   }
+  buildExecutionInsights(options) {
+    return {
+      decisionProfile: options.userSelectedRoute ? "user_guided" : "automatic",
+      routeDecision: {
+        initial: options.initialRoute,
+        final: options.resolvedRoute,
+        elicitationAsked: options.elicitationAsked,
+        userSelectedRoute: options.userSelectedRoute
+      },
+      mcpSelection: {
+        selected: options.mcpReq.tools,
+        candidates: options.mcpReq.candidates,
+        truncated: options.mcpReq.candidates.length > options.mcpReq.tools.length,
+        reason: options.mcpReq.reason
+      },
+      telemetry: {
+        totalDurationMs: options.totalDurationMs,
+        eventCount: this.getExecutionTelemetryEventCount(options.executionId)
+      }
+    };
+  }
+  getExecutionTelemetryEventCount(executionId) {
+    return this.config.telemetry.getRecent(500).filter((event) => event.executionId === executionId).length;
+  }
+  /**
+   * Get aggregated execution telemetry.
+   */
+  getTelemetrySummary() {
+    return this.config.telemetry.summarize();
+  }
+  /**
+   * Get recent execution telemetry events.
+   */
+  getTelemetryEvents(limit = 50) {
+    return this.config.telemetry.getRecent(limit);
+  }
+  getErrorMessage(error) {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return String(error);
+  }
   /**
    * Log message if verbose
    */
@@ -1960,6 +2740,7 @@ class CliInterceptor extends EventEmitter {
   showIntentMessage(_input) {
     console.log("\n\u{1F9E0} Analyzing your request...");
     console.log("   System will automatically handle: skills, agents, MCP tools\n");
+    console.log("   Smart mode: ambiguity checks + capability-ranked tool selection + telemetry\n");
   }
   /**
    * Enable interceptor
@@ -2223,6 +3004,27 @@ ${"=".repeat(60)}`);
       }
       console.log();
     }
+    if (result.insights) {
+      console.log("\u2728 Smart Upgrade Signals:");
+      console.log(`   Route decision: ${result.insights.routeDecision.initial} \u2192 ${result.insights.routeDecision.final}`);
+      if (result.insights.routeDecision.userSelectedRoute) {
+        console.log("   Mode: User-guided route disambiguation");
+      } else if (result.insights.routeDecision.elicitationAsked) {
+        console.log("   Mode: Asked for route preference (kept recommended)");
+      } else {
+        console.log("   Mode: Fully automatic route decision");
+      }
+      if (result.insights.mcpSelection.selected.length > 0) {
+        if (result.insights.mcpSelection.truncated) {
+          console.log(`   MCP ranking: selected ${result.insights.mcpSelection.selected.length} of ${result.insights.mcpSelection.candidates.length} candidates`);
+        }
+        console.log(`   MCP reason: ${result.insights.mcpSelection.reason}`);
+      } else {
+        console.log("   MCP reason: no external tools needed");
+      }
+      console.log(`   Telemetry: ${result.insights.telemetry.eventCount} events, ${result.insights.telemetry.totalDurationMs}ms`);
+      console.log();
+    }
     if (result.convoyId) {
       console.log(`\u{1F4E6} Convoy: ${result.convoyId}`);
       console.log();

package/dist/chunks/package.mjs

@@ -1,3 +1,3 @@
-const version = "12.2.0";
+const version = "12.2.1";
 
 export { version };

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "ccjk",
   "type": "module",
-  "version": "12.2.0",
+  "version": "12.2.1",
+  "packageManager": "pnpm@10.17.1",
   "description": "CLI toolkit for Claude Code and Codex setup. Simplifies MCP service installation, API configuration, workflow management, and multi-provider support with guided interactive setup.",
   "author": {
     "name": "CCJK Team",
@@ -80,66 +81,6 @@
   "engines": {
     "node": ">=20"
   },
-  "dependencies": {
-    "fdir": "^6.5.0",
-    "globby": "^14.1.0",
-    "ioredis": "^5.9.3",
-    "tar": "^7.5.9",
-    "tinyglobby": "^0.2.15",
-    "web-tree-sitter": "^0.26.5",
-    "better-sqlite3": "^12.6.2"
-  },
-  "devDependencies": {
-    "@antfu/eslint-config": "^5.4.1",
-    "@types/better-sqlite3": "^7.6.13",
-    "@types/fs-extra": "^11.0.4",
-    "@types/inquirer": "^9.0.9",
-    "@types/node": "^22.18.6",
-    "@types/semver": "^7.7.1",
-    "@types/uuid": "^11.0.0",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "@vitest/coverage-v8": "^3.2.4",
-    "@vitest/ui": "^3.2.4",
-    "concurrently": "^9.2.1",
-    "eslint": "^9.36.0",
-    "eslint-plugin-format": "^1.4.0",
-    "husky": "^9.1.7",
-    "lint-staged": "^16.2.7",
-    "pkgroll": "^2.26.3",
-    "prettier": "^3.8.1",
-    "shx": "^0.4.0",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3",
-    "unbuild": "^3.6.1",
-    "vitest": "^3.2.4",
-    "@anthropic-ai/sdk": "^0.52.0",
-    "ansis": "^4.2.0",
-    "cac": "^6.7.14",
-    "chokidar": "^4.0.3",
-    "consola": "^3.4.2",
-    "dayjs": "^1.11.19",
-    "find-up-simple": "^1.0.1",
-    "fs-extra": "^11.3.3",
-    "gray-matter": "^4.0.3",
-    "handlebars": "^4.7.8",
-    "i18next": "^25.8.13",
-    "i18next-fs-backend": "^2.6.1",
-    "inquirer": "^12.9.6",
-    "inquirer-toggle": "^1.0.1",
-    "lowdb": "^7.0.1",
-    "nanoid": "^5.1.6",
-    "ofetch": "^1.5.1",
-    "ohash": "^1.1.4",
-    "ora": "^8.2.0",
-    "pathe": "^2.0.3",
-    "semver": "^7.7.4",
-    "smol-toml": "^1.6.0",
-    "tinyexec": "^1.0.2",
-    "trash": "^10.1.0",
-    "tweetnacl": "^1.0.3",
-    "uuid": "^11.1.0"
-  },
   "scripts": {
     "dev": "tsx ./src/cli.ts",
     "build": "unbuild",
@@ -147,6 +88,7 @@
     "typecheck": "tsc --noEmit",
     "release:verify": "node scripts/release-verify.mjs",
     "release:verify:full": "node scripts/release-verify.mjs --with-tests",
+    "prepublishOnly": "node scripts/validate-prepublish.mjs && pnpm contract:check && pnpm build && pnpm test:run",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "test": "vitest",
@@ -168,6 +110,7 @@
     "test:integration:run": "NODE_ENV=test vitest run --config vitest.integration.config.ts",
     "test:integration:ui": "NODE_ENV=test vitest --config vitest.integration.config.ts --ui",
     "test:integration:coverage": "NODE_ENV=test vitest run --config vitest.integration.config.ts --coverage",
+    "prepare": "husky",
     "format": "prettier --write src/**/*.ts",
     "prepublish:fix": "node scripts/fix-package-catalog.mjs",
     "cleanup": "node scripts/cleanup.js",
@@ -202,5 +145,65 @@
     "i18n:check": "tsx scripts/check-i18n.ts",
     "i18n:report": "tsx scripts/check-i18n.ts --report",
     "contract:check": "node scripts/check-remote-contract.mjs"
+  },
+  "dependencies": {
+    "fdir": "^6.5.0",
+    "globby": "^14.1.0",
+    "ioredis": "^5.9.3",
+    "tar": "^7.5.9",
+    "tinyglobby": "^0.2.15",
+    "web-tree-sitter": "^0.26.5",
+    "better-sqlite3": "^12.6.2"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^5.4.1",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^22.18.6",
+    "@types/semver": "^7.7.1",
+    "@types/uuid": "^11.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
+    "concurrently": "^9.2.1",
+    "eslint": "^9.36.0",
+    "eslint-plugin-format": "^1.4.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "pkgroll": "^2.26.3",
+    "prettier": "^3.8.1",
+    "shx": "^0.4.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "unbuild": "^3.6.1",
+    "vitest": "^3.2.4",
+    "@anthropic-ai/sdk": "^0.52.0",
+    "ansis": "^4.2.0",
+    "cac": "^6.7.14",
+    "chokidar": "^4.0.3",
+    "consola": "^3.4.2",
+    "dayjs": "^1.11.19",
+    "find-up-simple": "^1.0.1",
+    "fs-extra": "^11.3.3",
+    "gray-matter": "^4.0.3",
+    "handlebars": "^4.7.8",
+    "i18next": "^25.8.13",
+    "i18next-fs-backend": "^2.6.1",
+    "inquirer": "^12.9.6",
+    "inquirer-toggle": "^1.0.1",
+    "lowdb": "^7.0.1",
+    "nanoid": "^5.1.6",
+    "ofetch": "^1.5.1",
+    "ohash": "^1.1.4",
+    "ora": "^8.2.0",
+    "pathe": "^2.0.3",
+    "semver": "^7.7.4",
+    "smol-toml": "^1.6.0",
+    "tinyexec": "^1.0.2",
+    "trash": "^10.1.0",
+    "tweetnacl": "^1.0.3",
+    "uuid": "^11.1.0"
   }
-}
+}