chainlesschain 0.40.2 → 0.41.0

package/src/repl/agent-repl.js

@@ -10,9 +10,9 @@
  *  - run_shell: Execute a shell command
  *  - search_files: Search for files by name/content
  *  - list_dir: List directory contents
- *  - db_query: Query the ChainlessChain database
- *  - note_add: Add a note
- *  - note_search: Search notes
+ *  - run_skill: Run a built-in skill
+ *  - list_skills: List available skills
+ *  - run_code: Write and execute code (Python/Node.js/Bash)
  *
  * The AI decides which tools to call based on user intent.
  */
@@ -21,11 +21,8 @@ import readline from "readline";
 import chalk from "chalk";
 import fs from "fs";
 import path from "path";
-import { execSync } from "child_process";
-import { fileURLToPath } from "url";
 import { logger } from "../lib/logger.js";
 import { getPlanModeManager, PlanState } from "../lib/plan-mode.js";
-import { CLISkillLoader } from "../lib/skill-loader.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
 import {
   createSession,
@@ -39,176 +36,15 @@ import {
   detectTaskType,
   selectModelForTask,
 } from "../lib/task-model-selector.js";
-import { executeHooks, HookEvents } from "../lib/hook-manager.js";
 import { CLIPermanentMemory } from "../lib/permanent-memory.js";
 import { CLIAutonomousAgent, GoalStatus } from "../lib/autonomous-agent.js";
-
-/**
- * Tool definitions for function calling
- */
-const TOOLS = [
-  {
-    type: "function",
-    function: {
-      name: "read_file",
-      description: "Read a file's content",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "File path to read" },
-        },
-        required: ["path"],
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "write_file",
-      description: "Write content to a file (create or overwrite)",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "File path" },
-          content: { type: "string", description: "File content" },
-        },
-        required: ["path", "content"],
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "edit_file",
-      description: "Replace a specific string in a file with new content",
-      parameters: {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "File path" },
-          old_string: {
-            type: "string",
-            description: "Exact string to find and replace",
-          },
-          new_string: {
-            type: "string",
-            description: "Replacement string",
-          },
-        },
-        required: ["path", "old_string", "new_string"],
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "run_shell",
-      description:
-        "Execute a shell command and return the output. Use for running tests, installing packages, git operations, etc.",
-      parameters: {
-        type: "object",
-        properties: {
-          command: { type: "string", description: "Shell command to execute" },
-          cwd: {
-            type: "string",
-            description: "Working directory (optional)",
-          },
-        },
-        required: ["command"],
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "search_files",
-      description: "Search for files by name pattern or content",
-      parameters: {
-        type: "object",
-        properties: {
-          pattern: {
-            type: "string",
-            description: "Glob pattern or search string",
-          },
-          directory: {
-            type: "string",
-            description: "Directory to search in (default: cwd)",
-          },
-          content_search: {
-            type: "boolean",
-            description: "If true, search file contents instead of names",
-          },
-        },
-        required: ["pattern"],
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "list_dir",
-      description: "List contents of a directory",
-      parameters: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "Directory path (default: cwd)",
-          },
-        },
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "run_skill",
-      description:
-        "Run a built-in ChainlessChain skill. Available skills include: code-review, summarize, translate, refactor, unit-test, debug, explain-code, browser-automation, data-analysis, git-history-analyzer, and 130+ more. Use list_skills first to discover available skills.",
-      parameters: {
-        type: "object",
-        properties: {
-          skill_name: {
-            type: "string",
-            description:
-              "Name of the skill to run (e.g. code-review, summarize, translate)",
-          },
-          input: {
-            type: "string",
-            description: "Input text or parameters for the skill",
-          },
-        },
-        required: ["skill_name", "input"],
-      },
-    },
-  },
-  {
-    type: "function",
-    function: {
-      name: "list_skills",
-      description:
-        "List available built-in skills, optionally filtered by category or keyword",
-      parameters: {
-        type: "object",
-        properties: {
-          category: {
-            type: "string",
-            description:
-              "Filter by category (e.g. development, automation, data)",
-          },
-          query: {
-            type: "string",
-            description: "Search keyword to filter skills",
-          },
-        },
-      },
-    },
-  },
-];
-
-/**
- * Shared multi-layer skill loader
- */
-const skillLoader = new CLISkillLoader();
+import {
+  AGENT_TOOLS,
+  getBaseSystemPrompt,
+  executeTool as coreExecuteTool,
+  agentLoop as coreAgentLoop,
+  formatToolArgs,
+} from "../lib/agent-core.js";
 
 /**
  * Reference to the runtime DB for hook execution (set during startAgentRepl)
@@ -216,564 +52,43 @@ const skillLoader = new CLISkillLoader();
 let _hookDb = null;
 
 /**
- * Execute a tool call (with plan mode filtering and hook pipeline)
+ * Execute a tool call — delegates to agent-core with REPL's hookDb and cwd.
  */
 async function executeTool(name, args) {
-  // Plan mode: check if tool is allowed
-  const planManager = getPlanModeManager();
-  if (planManager.isActive() && !planManager.isToolAllowed(name)) {
-    // In plan mode, log the blocked tool as a plan item
-    planManager.addPlanItem({
-      title: `${name}: ${formatToolArgs(name, args)}`,
-      tool: name,
-      params: args,
-      estimatedImpact:
-        name === "run_shell"
-          ? "high"
-          : name === "write_file"
-            ? "medium"
-            : "low",
-    });
-    return {
-      error: `[Plan Mode] Tool "${name}" is blocked during planning. It has been added to the plan. Use /plan approve to execute.`,
-    };
-  }
-
-  // PreToolUse hook
-  if (_hookDb) {
-    try {
-      await executeHooks(_hookDb, HookEvents.PreToolUse, {
-        tool: name,
-        args,
-        timestamp: new Date().toISOString(),
-      });
-    } catch (_err) {
-      // Hook failure should not block tool execution
-    }
-  }
-
-  let toolResult;
-  try {
-    toolResult = await _executeToolInner(name, args);
-  } catch (err) {
-    // ToolError hook
-    if (_hookDb) {
-      try {
-        await executeHooks(_hookDb, HookEvents.ToolError, {
-          tool: name,
-          args,
-          error: err.message,
-        });
-      } catch (_err) {
-        // Non-critical
-      }
-    }
-    throw err;
-  }
-
-  // PostToolUse hook
-  if (_hookDb) {
-    try {
-      await executeHooks(_hookDb, HookEvents.PostToolUse, {
-        tool: name,
-        args,
-        result:
-          typeof toolResult === "object"
-            ? JSON.stringify(toolResult).substring(0, 500)
-            : String(toolResult).substring(0, 500),
-      });
-    } catch (_err) {
-      // Non-critical
-    }
-  }
-
-  return toolResult;
-}
-
-/**
- * Inner tool execution logic (separated for hook wrapping)
- */
-async function _executeToolInner(name, args) {
-  switch (name) {
-    case "read_file": {
-      const filePath = path.resolve(args.path);
-      if (!fs.existsSync(filePath)) {
-        return { error: `File not found: ${filePath}` };
-      }
-      const content = fs.readFileSync(filePath, "utf8");
-      // Truncate very long files
-      if (content.length > 50000) {
-        return {
-          content: content.substring(0, 50000) + "\n...(truncated)",
-          size: content.length,
-        };
-      }
-      return { content };
-    }
-
-    case "write_file": {
-      const filePath = path.resolve(args.path);
-      const dir = path.dirname(filePath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-      fs.writeFileSync(filePath, args.content, "utf8");
-      return { success: true, path: filePath, size: args.content.length };
-    }
-
-    case "edit_file": {
-      const filePath = path.resolve(args.path);
-      if (!fs.existsSync(filePath)) {
-        return { error: `File not found: ${filePath}` };
-      }
-      const content = fs.readFileSync(filePath, "utf8");
-      if (!content.includes(args.old_string)) {
-        return { error: "old_string not found in file" };
-      }
-      const newContent = content.replace(args.old_string, args.new_string);
-      fs.writeFileSync(filePath, newContent, "utf8");
-      return { success: true, path: filePath };
-    }
-
-    case "run_shell": {
-      try {
-        const output = execSync(args.command, {
-          cwd: args.cwd || process.cwd(),
-          encoding: "utf8",
-          timeout: 30000,
-          maxBuffer: 1024 * 1024,
-        });
-        return { stdout: output.substring(0, 10000) };
-      } catch (err) {
-        return {
-          error: err.message.substring(0, 2000),
-          stderr: (err.stderr || "").substring(0, 2000),
-          exitCode: err.status,
-        };
-      }
-    }
-
-    case "search_files": {
-      const dir = args.directory ? path.resolve(args.directory) : process.cwd();
-      try {
-        if (args.content_search) {
-          // Use grep/findstr for content search
-          const cmd =
-            process.platform === "win32"
-              ? `findstr /s /i /n "${args.pattern}" *`
-              : `grep -r -l -i "${args.pattern}" . --include="*" 2>/dev/null | head -20`;
-          const output = execSync(cmd, {
-            cwd: dir,
-            encoding: "utf8",
-            timeout: 10000,
-          });
-          return { matches: output.trim().split("\n").slice(0, 20) };
-        } else {
-          // File name search
-          const cmd =
-            process.platform === "win32"
-              ? `dir /s /b *${args.pattern}* 2>NUL`
-              : `find . -name "*${args.pattern}*" -type f 2>/dev/null | head -20`;
-          const output = execSync(cmd, {
-            cwd: dir,
-            encoding: "utf8",
-            timeout: 10000,
-          });
-          return {
-            files: output.trim().split("\n").filter(Boolean).slice(0, 20),
-          };
-        }
-      } catch {
-        return { files: [], message: "No matches found" };
-      }
-    }
-
-    case "list_dir": {
-      const dirPath = args.path ? path.resolve(args.path) : process.cwd();
-      if (!fs.existsSync(dirPath)) {
-        return { error: `Directory not found: ${dirPath}` };
-      }
-      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-      return {
-        entries: entries.map((e) => ({
-          name: e.name,
-          type: e.isDirectory() ? "dir" : "file",
-        })),
-      };
-    }
-
-    case "run_skill": {
-      const allSkills = skillLoader.getResolvedSkills();
-      if (allSkills.length === 0) {
-        return {
-          error:
-            "No skills found. Make sure you're in the ChainlessChain project root or have skills installed.",
-        };
-      }
-      const match = allSkills.find(
-        (s) => s.id === args.skill_name || s.dirName === args.skill_name,
-      );
-      if (!match || !match.hasHandler) {
-        return {
-          error: `Skill "${args.skill_name}" not found or has no handler. Use list_skills to see available skills.`,
-        };
-      }
-      try {
-        const handlerPath = path.join(match.skillDir, "handler.js");
-        const imported = await import(
-          `file://${handlerPath.replace(/\\/g, "/")}`
-        );
-        const handler = imported.default || imported;
-        if (handler.init) await handler.init(match);
-        const task = {
-          params: { input: args.input },
-          input: args.input,
-          action: args.input,
-        };
-        const context = {
-          projectRoot: process.cwd(),
-          workspacePath: process.cwd(),
-        };
-        const result = await handler.execute(task, context, match);
-        return result;
-      } catch (err) {
-        return { error: `Skill execution failed: ${err.message}` };
-      }
-    }
-
-    case "list_skills": {
-      let skills = skillLoader.getResolvedSkills();
-      if (skills.length === 0) {
-        return { error: "No skills found." };
-      }
-      if (args.category) {
-        skills = skills.filter(
-          (s) => s.category.toLowerCase() === args.category.toLowerCase(),
-        );
-      }
-      if (args.query) {
-        const q = args.query.toLowerCase();
-        skills = skills.filter(
-          (s) =>
-            s.id.includes(q) ||
-            s.description.toLowerCase().includes(q) ||
-            s.category.toLowerCase().includes(q),
-        );
-      }
-      return {
-        count: skills.length,
-        skills: skills.map((s) => ({
-          id: s.id,
-          category: s.category,
-          source: s.source,
-          hasHandler: s.hasHandler,
-          description: (s.description || "").substring(0, 80),
-        })),
-      };
-    }
-
-    default:
-      return { error: `Unknown tool: ${name}` };
-  }
+  return coreExecuteTool(name, args, { hookDb: _hookDb, cwd: process.cwd() });
 }
 
 /**
- * Send a chat completion request with tools.
- * Supports all 7 providers via cowork-adapter: ollama, anthropic, openai, deepseek, dashscope, gemini, mistral
- */
-async function chatWithTools(rawMessages, options) {
-  const { provider, model, baseUrl, apiKey, contextEngine: ce } = options;
-
-  // Build optimized messages via context engine (or use raw)
-  // Find last user message for relevance matching (not tool/assistant)
-  const lastUserMsg = [...rawMessages].reverse().find((m) => m.role === "user");
-  const messages = ce
-    ? ce.buildOptimizedMessages(rawMessages, {
-        userQuery: lastUserMsg?.content,
-      })
-    : rawMessages;
-
-  if (provider === "ollama") {
-    // Ollama supports tool calling natively
-    const response = await fetch(`${baseUrl}/api/chat`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        model,
-        messages,
-        tools: TOOLS,
-        stream: false,
-      }),
-    });
-
-    if (!response.ok) {
-      throw new Error(`Ollama error: ${response.status}`);
-    }
-
-    return await response.json();
-  }
-
-  if (provider === "anthropic") {
-    // Anthropic: extract system messages, use tools format
-    const key = apiKey || process.env.ANTHROPIC_API_KEY;
-    if (!key) throw new Error("ANTHROPIC_API_KEY required");
-
-    const systemMsgs = messages.filter((m) => m.role === "system");
-    const otherMsgs = messages.filter((m) => m.role !== "system");
-
-    // Convert TOOLS to Anthropic format
-    const anthropicTools = TOOLS.map((t) => ({
-      name: t.function.name,
-      description: t.function.description,
-      input_schema: t.function.parameters,
-    }));
-
-    const body = {
-      model: model || "claude-sonnet-4-20250514",
-      max_tokens: 4096,
-      messages: otherMsgs,
-      tools: anthropicTools,
-    };
-    if (systemMsgs.length > 0) {
-      body.system = systemMsgs.map((m) => m.content).join("\n");
-    }
-
-    const url =
-      baseUrl && baseUrl !== "http://localhost:11434"
-        ? baseUrl
-        : "https://api.anthropic.com/v1";
-
-    const response = await fetch(`${url}/messages`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": key,
-        "anthropic-version": "2023-06-01",
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      throw new Error(`Anthropic error: ${response.status}`);
-    }
-
-    const data = await response.json();
-    // Normalize Anthropic response to Ollama-like format
-    return _normalizeAnthropicResponse(data);
-  }
-
-  // OpenAI-compatible providers (openai, deepseek, dashscope, mistral, gemini)
-  const providerUrls = {
-    openai: "https://api.openai.com/v1",
-    deepseek: "https://api.deepseek.com/v1",
-    dashscope: "https://dashscope.aliyuncs.com/compatible-mode/v1",
-    mistral: "https://api.mistral.ai/v1",
-    gemini: "https://generativelanguage.googleapis.com/v1beta/openai",
-    volcengine: "https://ark.cn-beijing.volces.com/api/v3",
-  };
-
-  const providerApiKeyEnvs = {
-    openai: "OPENAI_API_KEY",
-    deepseek: "DEEPSEEK_API_KEY",
-    dashscope: "DASHSCOPE_API_KEY",
-    mistral: "MISTRAL_API_KEY",
-    gemini: "GEMINI_API_KEY",
-    volcengine: "VOLCENGINE_API_KEY",
-  };
-
-  const url =
-    baseUrl && baseUrl !== "http://localhost:11434"
-      ? baseUrl
-      : providerUrls[provider];
-
-  if (!url) {
-    throw new Error(
-      `Unsupported provider: ${provider}. Supported: ollama, anthropic, openai, deepseek, dashscope, mistral, gemini, volcengine`,
-    );
-  }
-
-  const envKey = providerApiKeyEnvs[provider] || "OPENAI_API_KEY";
-  const key = apiKey || process.env[envKey];
-  if (!key) throw new Error(`${envKey} required for provider ${provider}`);
-
-  const defaultModels = {
-    openai: "gpt-4o-mini",
-    deepseek: "deepseek-chat",
-    dashscope: "qwen-turbo",
-    mistral: "mistral-large-latest",
-    gemini: "gemini-2.0-flash",
-    volcengine: "doubao-seed-1-6-251015",
-  };
-
-  const response = await fetch(`${url}/chat/completions`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${key}`,
-    },
-    body: JSON.stringify({
-      model: model || defaultModels[provider] || "gpt-4o-mini",
-      messages,
-      tools: TOOLS,
-    }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`${provider} API error: ${response.status}`);
-  }
-
-  const data = await response.json();
-  // Normalize to Ollama-like format
-  if (!data.choices || !data.choices[0]) {
-    throw new Error("Invalid API response: no choices returned");
-  }
-  const choice = data.choices[0];
-  return {
-    message: choice.message,
-  };
-}
-
-/**
- * Normalize Anthropic API response to Ollama-like format for uniform handling
- */
-function _normalizeAnthropicResponse(data) {
-  const content = data.content || [];
-  const textBlocks = content.filter((b) => b.type === "text");
-  const toolBlocks = content.filter((b) => b.type === "tool_use");
-
-  const message = {
-    role: "assistant",
-    content: textBlocks.map((b) => b.text).join("\n") || "",
-  };
-
-  if (toolBlocks.length > 0) {
-    message.tool_calls = toolBlocks.map((b) => ({
-      id: b.id,
-      type: "function",
-      function: {
-        name: b.name,
-        arguments: JSON.stringify(b.input),
-      },
-    }));
-  }
-
-  return { message };
-}
-
-/**
- * Agentic loop - keeps calling tools until the AI gives a final text response
+ * Agentic loop — wraps agent-core's async generator with REPL display output.
  */
 async function agentLoop(messages, options) {
-  const MAX_ITERATIONS = 10;
-
-  for (let i = 0; i < MAX_ITERATIONS; i++) {
-    const result = await chatWithTools(messages, options);
-    const msg = result?.message;
-
-    if (!msg) {
-      return "(No response from LLM)";
-    }
-
-    // Check for tool calls
-    const toolCalls = msg.tool_calls;
-
-    if (!toolCalls || toolCalls.length === 0) {
-      // No tool calls — final text response
-      return msg.content || "";
-    }
-
-    // Add assistant message with tool calls
-    messages.push(msg);
-
-    // Execute each tool call
-    for (const call of toolCalls) {
-      const fn = call.function;
-      const toolName = fn.name;
-      let toolArgs;
-
-      try {
-        toolArgs =
-          typeof fn.arguments === "string"
-            ? JSON.parse(fn.arguments)
-            : fn.arguments;
-      } catch {
-        toolArgs = {};
-      }
-
-      // Show what the AI is doing
+  for await (const event of coreAgentLoop(messages, options)) {
+    if (event.type === "tool-executing") {
       process.stdout.write(
-        chalk.gray(`  [${toolName}] ${formatToolArgs(toolName, toolArgs)}\n`),
+        chalk.gray(
+          `  [${event.tool}] ${formatToolArgs(event.tool, event.args)}\n`,
+        ),
       );
-
-      const toolResult = await executeTool(toolName, toolArgs);
-
-      // Show brief result
-      if (toolResult.error) {
-        process.stdout.write(chalk.red(`  Error: ${toolResult.error}\n`));
-      } else if (toolResult.success) {
+    } else if (event.type === "tool-result") {
+      if (event.error || event.result?.error) {
+        process.stdout.write(
+          chalk.red(`  Error: ${event.error || event.result?.error}\n`),
+        );
+      } else if (event.result?.success) {
         process.stdout.write(chalk.green(`  Done\n`));
       }
-
-      // Add tool result to messages
-      messages.push({
-        role: "tool",
-        content: JSON.stringify(toolResult).substring(0, 5000),
-        tool_call_id: call.id,
-      });
+    } else if (event.type === "response-complete") {
+      return event.content;
     }
   }
-
-  return "(Reached max tool call iterations)";
-}
-
-/**
- * Format tool args for display
- */
-function formatToolArgs(name, args) {
-  switch (name) {
-    case "read_file":
-      return args.path;
-    case "write_file":
-      return `${args.path} (${args.content?.length || 0} chars)`;
-    case "edit_file":
-      return args.path;
-    case "run_shell":
-      return args.command;
-    case "search_files":
-      return args.pattern;
-    case "list_dir":
-      return args.path || ".";
-    case "run_skill":
-      return `${args.skill_name}: ${(args.input || "").substring(0, 50)}`;
-    case "list_skills":
-      return args.category || args.query || "all";
-    default:
-      return JSON.stringify(args).substring(0, 60);
-  }
-}
-
-function getBaseSystemPrompt() {
-  return `You are ChainlessChain AI Assistant, a powerful agentic coding assistant running in the terminal.
-
-You have access to tools that let you read files, write files, edit files, run shell commands, and search the codebase. When the user asks you to do something, USE THE TOOLS to actually do it — don't just describe what should be done.
-
-Key behaviors:
-- When asked to modify code, read the file first, then edit it
-- When asked to create something, use write_file to create it
-- When asked to run/test something, use run_shell to execute it
-- When asked about files or code, use read_file and search_files to find information
-- You have multi-layer skills (built-in, marketplace, global, project-level) — use list_skills to discover them and run_skill to execute them
-- Always explain what you're doing and show results
-- Be concise but thorough
-
-Current working directory: ${process.cwd()}`;
+  return "";
 }
 
 /**
  * Start the agentic REPL
  */
 export async function startAgentRepl(options = {}) {
-  let model = options.model || "qwen2:7b";
+  let model = options.model || "qwen2.5:7b";
   let provider = options.provider || "ollama";
   const baseUrl = options.baseUrl || "http://localhost:11434";
   const apiKey = options.apiKey || null;
@@ -834,7 +149,9 @@ export async function startAgentRepl(options = {}) {
     }
   }
 
-  const messages = [{ role: "system", content: getBaseSystemPrompt() }];
+  const messages = [
+    { role: "system", content: getBaseSystemPrompt(process.cwd()) },
+  ];
 
   // Load resumed session messages
   if (db && options.sessionId && sessionId) {
@@ -1551,9 +868,59 @@ export async function startAgentRepl(options = {}) {
         } else {
           logger.info("Not in plan mode.");
         }
+      } else if (subCmd.startsWith("interactive")) {
+        // Interactive planning with LLM-generated plan + skill recommendations
+        const planRequest =
+          subCmd.slice(11).trim() || "Help me with the current task";
+        try {
+          const { CLIInteractivePlanner } =
+            await import("../lib/interactive-planner.js");
+          const { TerminalInteractionAdapter } =
+            await import("../lib/interaction-adapter.js");
+          const chatFn = createChatFn({ provider, model, baseUrl, apiKey });
+          const planner = new CLIInteractivePlanner({
+            llmChat: chatFn,
+            db,
+            interaction: new TerminalInteractionAdapter(),
+          });
+
+          logger.info("Generating interactive plan...");
+          const result = await planner.startPlanSession(planRequest, {
+            cwd: process.cwd(),
+          });
+
+          if (result.plan) {
+            logger.log(
+              chalk.bold(
+                `\n  Plan: ${result.plan.overview?.title || "Untitled"}`,
+              ),
+            );
+            logger.log(
+              chalk.gray(`  ${result.plan.overview?.description || ""}\n`),
+            );
+            for (const step of result.plan.steps || []) {
+              const toolStr = step.tool ? chalk.cyan(` [${step.tool}]`) : "";
+              logger.log(`  ${step.step}. ${step.title}${toolStr}`);
+            }
+            if (result.plan.recommendations?.skills?.length > 0) {
+              logger.log(chalk.bold("\n  Recommended skills:"));
+              for (const s of result.plan.recommendations.skills) {
+                logger.log(`    - ${chalk.cyan(s.id)}: ${s.description}`);
+              }
+            }
+            logger.log("");
+            logger.info(
+              "Use /plan interactive:confirm, /plan interactive:cancel, or /plan interactive:regenerate",
+            );
+          } else {
+            logger.info(result.message || "Failed to generate plan");
+          }
+        } catch (err) {
+          logger.error(`Interactive plan failed: ${err.message}`);
+        }
       } else {
         logger.info(
-          "Unknown /plan subcommand. Try: /plan, /plan show, /plan approve, /plan reject, /plan exit",
+          "Unknown /plan subcommand. Try: /plan, /plan show, /plan approve, /plan reject, /plan exit, /plan interactive <request>",
         );
       }
 
@@ -1564,6 +931,36 @@ export async function startAgentRepl(options = {}) {
     // Add user message
     messages.push({ role: "user", content: trimmed });
 
+    // Slot-filling: detect intent and fill missing parameters interactively
+    try {
+      const { CLISlotFiller } = await import("../lib/slot-filler.js");
+      const intent = CLISlotFiller.detectIntent(trimmed);
+      if (intent) {
+        const defs = CLISlotFiller.getSlotDefinitions(intent.type);
+        const missing = defs.required.filter((s) => !intent.entities[s]);
+        if (missing.length > 0) {
+          const { TerminalInteractionAdapter } =
+            await import("../lib/interaction-adapter.js");
+          const interaction = new TerminalInteractionAdapter();
+          const filler = new CLISlotFiller({ interaction });
+          const result = await filler.fillSlots(intent, {
+            cwd: process.cwd(),
+          });
+          if (result.filledSlots.length > 0) {
+            const parts = Object.entries(result.entities)
+              .filter(([, v]) => v)
+              .map(([k, v]) => `${k}: ${v}`);
+            // Append context to the last user message
+            const lastMsg = messages[messages.length - 1];
+            lastMsg.content += `\n\n[Context — user provided: ${parts.join(", ")}]`;
+            logger.info(chalk.gray(`[slot-fill] ${parts.join(", ")}`));
+          }
+        }
+      }
+    } catch (_err) {
+      // Slot-filling failure is non-critical
+    }
+
     // Auto-select best model based on task type
     let activeModel = model;
     const taskDetection = detectTaskType(trimmed);