chainlesschain 0.37.12 → 0.40.1

package/src/repl/agent-repl.js

@@ -26,6 +26,22 @@ 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,
+  saveMessages,
+  getSession,
+} from "../lib/session-manager.js";
+import { storeMemory, consolidateMemory } from "../lib/hierarchical-memory.js";
+import { CLIContextEngineering } from "../lib/cli-context-engineering.js";
+import { createChatFn } from "../lib/cowork-adapter.js";
+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
@@ -195,7 +211,12 @@ const TOOLS = [
 const skillLoader = new CLISkillLoader();
 
 /**
- * Execute a tool call (with plan mode filtering)
+ * Reference to the runtime DB for hook execution (set during startAgentRepl)
+ */
+let _hookDb = null;
+
+/**
+ * Execute a tool call (with plan mode filtering and hook pipeline)
  */
 async function executeTool(name, args) {
   // Plan mode: check if tool is allowed
@@ -218,6 +239,61 @@ async function executeTool(name, args) {
     };
   }
 
+  // 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);
@@ -402,13 +478,23 @@ async function executeTool(name, args) {
 }
 
 /**
- * Send a chat completion request with tools
+ * Send a chat completion request with tools.
+ * Supports all 7 providers via cowork-adapter: ollama, anthropic, openai, deepseek, dashscope, gemini, mistral
  */
-async function chatWithTools(messages, options) {
-  const { provider, model, baseUrl, apiKey } = options;
+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 for some models
+    // Ollama supports tool calling natively
     const response = await fetch(`${baseUrl}/api/chat`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -425,43 +511,153 @@ async function chatWithTools(messages, options) {
     }
 
     return await response.json();
-  } else if (provider === "openai") {
+  }
+
+  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.openai.com/v1";
-    const key = apiKey || process.env.OPENAI_API_KEY;
-    if (!key) throw new Error("API key required");
+        : "https://api.anthropic.com/v1";
 
-    const response = await fetch(`${url}/chat/completions`, {
+    const response = await fetch(`${url}/messages`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${key}`,
+        "x-api-key": key,
+        "anthropic-version": "2023-06-01",
       },
-      body: JSON.stringify({
-        model: model || "gpt-4o-mini",
-        messages,
-        tools: TOOLS,
-      }),
+      body: JSON.stringify(body),
     });
 
     if (!response.ok) {
-      throw new Error(`API error: ${response.status}`);
+      throw new Error(`Anthropic 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 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),
+      },
+    }));
   }
 
-  throw new Error(`Unsupported provider: ${provider}`);
+  return { message };
 }
 
 /**
@@ -556,7 +752,8 @@ function formatToolArgs(name, args) {
   }
 }
 
-const SYSTEM_PROMPT = `You are ChainlessChain AI Assistant, a powerful agentic coding assistant running in the terminal.
+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.
 
@@ -570,6 +767,7 @@ Key behaviors:
 - Be concise but thorough
 
 Current working directory: ${process.cwd()}`;
+}
 
 /**
  * Start the agentic REPL
@@ -578,9 +776,82 @@ export async function startAgentRepl(options = {}) {
   let model = options.model || "qwen2:7b";
   let provider = options.provider || "ollama";
   const baseUrl = options.baseUrl || "http://localhost:11434";
-  const apiKey = options.apiKey || process.env.OPENAI_API_KEY;
+  const apiKey = options.apiKey || null;
+
+  // Bootstrap runtime (best-effort, DB not required)
+  let db = null;
+  let contextEngine = null;
+  let sessionId = null;
+
+  try {
+    const ctx = await bootstrap({ verbose: false });
+    db = ctx.db || null;
+  } catch (_err) {
+    // Continue without DB — static prompt fallback
+  }
+
+  // Initialize permanent memory
+  let permanentMemory = null;
+  try {
+    const dataDir = process.env.CHAINLESSCHAIN_DATA_DIR || process.cwd();
+    const memoryDir = path.join(dataDir, "memory");
+    permanentMemory = new CLIPermanentMemory({ db, memoryDir });
+    permanentMemory.initialize();
+  } catch (_err) {
+    // Non-critical
+  }
 
-  const messages = [{ role: "system", content: SYSTEM_PROMPT }];
+  contextEngine = new CLIContextEngineering({ db, permanentMemory });
+
+  // Initialize autonomous agent
+  const autonomousAgent = new CLIAutonomousAgent();
+
+  // Set hook DB reference for tool pipeline
+  _hookDb = db;
+
+  // Resume existing session or create new one
+  if (db && options.sessionId) {
+    try {
+      const existing = getSession(db, options.sessionId);
+      if (existing && existing.messages) {
+        sessionId = existing.id;
+      }
+    } catch (_err) {
+      // Non-critical — will create new session
+    }
+  }
+
+  if (db && !sessionId) {
+    try {
+      const session = createSession(db, {
+        title: `Agent ${new Date().toISOString().slice(0, 10)}`,
+        provider,
+        model,
+      });
+      sessionId = session.id;
+    } catch (_err) {
+      // Non-critical
+    }
+  }
+
+  const messages = [{ role: "system", content: getBaseSystemPrompt() }];
+
+  // Load resumed session messages
+  if (db && options.sessionId && sessionId) {
+    try {
+      const existing = getSession(db, sessionId);
+      if (existing && existing.messages) {
+        const parsed =
+          typeof existing.messages === "string"
+            ? JSON.parse(existing.messages)
+            : existing.messages;
+        messages.push(...parsed.filter((m) => m.role !== "system"));
+        logger.info(`Resumed session ${sessionId} (${parsed.length} messages)`);
+      }
+    } catch (_err) {
+      // Non-critical
+    }
+  }
 
   const getPrompt = () => {
     const planManager = getPlanModeManager();
@@ -605,6 +876,12 @@ export async function startAgentRepl(options = {}) {
   logger.log(
     chalk.gray(`Model: ${model}  Provider: ${provider}  CWD: ${process.cwd()}`),
   );
+  if (sessionId) {
+    logger.log(chalk.gray(`Session: ${sessionId}`));
+  }
+  if (db) {
+    logger.log(chalk.gray("Context: instinct + memory + notes (DB connected)"));
+  }
   logger.log(
     chalk.gray(
       "Describe what you want to do. I can read/write files, run commands, and more.",
@@ -640,7 +917,23 @@ export async function startAgentRepl(options = {}) {
       );
       logger.log(`  ${chalk.cyan("/provider")}   Show/change provider`);
       logger.log(`  ${chalk.cyan("/clear")}      Clear conversation`);
-      logger.log(`  ${chalk.cyan("/compact")}    Keep only last 4 messages`);
+      logger.log(
+        `  ${chalk.cyan("/compact")}    Smart compact (importance-based)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/task")}       Set task objective (/task <objective>)`,
+      );
+      logger.log(`  ${chalk.cyan("/task clear")} Clear current task`);
+      logger.log(`  ${chalk.cyan("/session")}    Show current session info`);
+      logger.log(
+        `  ${chalk.cyan("/reindex")}    Reindex notes for BM25 search`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/stats")}      Show context engine statistics`,
+      );
+      logger.log(
+        `  ${chalk.cyan("/auto")}       Autonomous goal execution (ReAct loop)`,
+      );
       logger.log(
         `  ${chalk.cyan("/cowork")}     Multi-agent collaboration (debate, compare)`,
       );
@@ -657,7 +950,10 @@ export async function startAgentRepl(options = {}) {
       logger.log("  Run shell commands (git, npm, etc.)");
       logger.log("  Search codebase by filename or content");
       logger.log("  Run 138 built-in skills (code-review, summarize, etc.)");
-      logger.log("  Plan mode: analyze first, execute after approval\n");
+      logger.log("  Plan mode: analyze first, execute after approval");
+      logger.log(
+        "  Context engineering: instinct + memory + notes injection\n",
+      );
       prompt();
       return;
     }
@@ -677,10 +973,31 @@ export async function startAgentRepl(options = {}) {
     if (trimmed.startsWith("/provider")) {
       const arg = trimmed.slice(9).trim();
       if (arg) {
-        provider = arg;
-        logger.info(`Provider: ${chalk.cyan(provider)}`);
+        const supported = [
+          "ollama",
+          "anthropic",
+          "openai",
+          "deepseek",
+          "dashscope",
+          "mistral",
+          "gemini",
+          "volcengine",
+        ];
+        if (supported.includes(arg)) {
+          provider = arg;
+          logger.info(`Provider: ${chalk.cyan(provider)}`);
+        } else {
+          logger.info(
+            `Unsupported provider. Available: ${supported.join(", ")}`,
+          );
+        }
       } else {
         logger.info(`Current provider: ${chalk.cyan(provider)}`);
+        logger.info(
+          chalk.gray(
+            "Available: ollama, anthropic, openai, deepseek, dashscope, mistral, gemini, volcengine",
+          ),
+        );
       }
       prompt();
       return;
@@ -694,13 +1011,107 @@ export async function startAgentRepl(options = {}) {
     }
 
     if (trimmed === "/compact") {
-      // Keep system prompt + last 4 messages
-      if (messages.length > 5) {
+      if (contextEngine && messages.length > 5) {
+        const compacted = contextEngine.smartCompact(messages);
+        messages.length = 0;
+        messages.push(...compacted);
+        logger.info(
+          `Compacted to ${messages.length} messages (importance-based)`,
+        );
+      } else if (messages.length > 5) {
+        // Fallback: original logic
         const systemMsg = messages[0];
         const recent = messages.slice(-4);
         messages.length = 0;
         messages.push(systemMsg, ...recent);
-        logger.info("Conversation compacted to last 4 messages");
+        logger.info("Compacted to last 4 messages");
+      }
+      prompt();
+      return;
+    }
+
+    // Task commands
+    if (trimmed.startsWith("/task")) {
+      const taskArg = trimmed.slice(5).trim();
+      if (taskArg === "clear") {
+        contextEngine.clearTask();
+        logger.info("Task cleared");
+      } else if (taskArg) {
+        contextEngine.setTask(taskArg);
+        logger.info(`Task set: ${chalk.cyan(taskArg)}`);
+      } else {
+        if (contextEngine.taskContext) {
+          logger.info(
+            `Current task: ${chalk.cyan(contextEngine.taskContext.objective)}`,
+          );
+        } else {
+          logger.info("No task set. Usage: /task <objective>");
+        }
+      }
+      prompt();
+      return;
+    }
+
+    // Session info
+    if (trimmed.startsWith("/session")) {
+      const sessionArg = trimmed.slice(8).trim();
+      if (sessionArg.startsWith("resume ")) {
+        const resumeId = sessionArg.slice(7).trim();
+        if (!db) {
+          logger.info("No database available for session resume");
+        } else {
+          try {
+            const existing = getSession(db, resumeId);
+            if (existing && existing.messages) {
+              const parsed =
+                typeof existing.messages === "string"
+                  ? JSON.parse(existing.messages)
+                  : existing.messages;
+              messages.length = 1; // keep system prompt
+              messages.push(...parsed.filter((m) => m.role !== "system"));
+              sessionId = existing.id;
+              logger.info(
+                `Resumed session ${sessionId} (${parsed.length} messages)`,
+              );
+            } else {
+              logger.info(`Session not found: ${resumeId}`);
+            }
+          } catch (err) {
+            logger.error(`Resume failed: ${err.message}`);
+          }
+        }
+      } else {
+        logger.info(`Session ID: ${sessionId || "none"}`);
+        logger.info(`Messages: ${messages.length}`);
+        logger.info(`DB: ${db ? "connected" : "not available"}`);
+      }
+      prompt();
+      return;
+    }
+
+    // Reindex notes
+    if (trimmed === "/reindex") {
+      if (contextEngine) {
+        contextEngine.reindexNotes();
+        const stats = contextEngine.getStats();
+        logger.info(`Notes reindexed: ${stats.notesIndexed} documents`);
+      } else {
+        logger.info("Context engine not available");
+      }
+      prompt();
+      return;
+    }
+
+    // Stats
+    if (trimmed === "/stats") {
+      if (contextEngine) {
+        const stats = contextEngine.getStats();
+        logger.info(`DB connected: ${stats.hasDb}`);
+        logger.info(`Notes indexed: ${stats.notesIndexed}`);
+        logger.info(`Error history: ${stats.errorCount}`);
+        logger.info(`Active task: ${stats.hasTask}`);
+      } else {
+        logger.info("Context engine not available");
       }
       prompt();
       return;
@@ -715,10 +1126,16 @@ export async function startAgentRepl(options = {}) {
       if (!subCmd || subCmd === "help") {
         logger.log(chalk.bold("\nCowork Commands:"));
         logger.log(
-          `  ${chalk.cyan("/cowork debate <file>")}     Multi-perspective code review`,
+          `  ${chalk.cyan("/cowork debate <file>")}      Multi-perspective code review`,
+        );
+        logger.log(
+          `  ${chalk.cyan("/cowork compare <prompt>")}   A/B solution comparison`,
+        );
+        logger.log(
+          `  ${chalk.cyan("/cowork graph <path>")}       Code knowledge graph (ASCII)`,
         );
         logger.log(
-          `  ${chalk.cyan("/cowork compare <prompt>")}  A/B solution comparison`,
+          `  ${chalk.cyan("/cowork decision <topic>")}   Architecture decision tracking`,
         );
         logger.log("");
       } else if (subCmd === "debate" && coworkInput) {
@@ -787,9 +1204,88 @@ export async function startAgentRepl(options = {}) {
         } catch (err) {
           logger.error(`Compare failed: ${err.message}`);
         }
+      } else if (subCmd === "graph" && coworkInput) {
+        try {
+          const { analyzeCodeKnowledgeGraph } =
+            await import("../lib/cowork/code-knowledge-graph-cli.js");
+          process.stdout.write(chalk.gray("\n  Analyzing code graph...\n"));
+          const result = await analyzeCodeKnowledgeGraph({
+            target: coworkInput,
+            llmOptions: { provider, model, baseUrl, apiKey },
+          });
+          // ASCII dependency graph
+          if (result.entities && result.entities.length > 0) {
+            process.stdout.write(chalk.bold("  Code Knowledge Graph:\n"));
+            for (const entity of result.entities.slice(0, 15)) {
+              const deps = (entity.dependencies || []).slice(0, 3).join(", ");
+              process.stdout.write(
+                `  ${chalk.cyan(entity.name)} [${entity.type}]${deps ? ` → ${deps}` : ""}\n`,
+              );
+            }
+            if (result.relationships && result.relationships.length > 0) {
+              process.stdout.write(chalk.bold("\n  Relationships:\n"));
+              for (const rel of result.relationships.slice(0, 10)) {
+                process.stdout.write(
+                  `  ${rel.source} ${chalk.gray(`—${rel.type}→`)} ${rel.target}\n`,
+                );
+              }
+            }
+          } else {
+            process.stdout.write(
+              `  ${JSON.stringify(result).substring(0, 500)}\n`,
+            );
+          }
+          process.stdout.write("\n");
+          messages.push({
+            role: "assistant",
+            content: `[Cowork Graph] Analyzed ${(result.entities || []).length} entities with ${(result.relationships || []).length} relationships.`,
+          });
+        } catch (err) {
+          logger.error(`Graph analysis failed: ${err.message}`);
+        }
+      } else if (subCmd === "decision" && coworkInput) {
+        try {
+          const { analyzeDecisions } =
+            await import("../lib/cowork/decision-kb-cli.js");
+          process.stdout.write(chalk.gray("\n  Analyzing decisions...\n"));
+          const result = await analyzeDecisions({
+            target: coworkInput,
+            llmOptions: { provider, model, baseUrl, apiKey },
+          });
+          if (result.decisions && result.decisions.length > 0) {
+            process.stdout.write(chalk.bold("  Architecture Decisions:\n"));
+            for (const d of result.decisions) {
+              const statusColor =
+                d.status === "accepted"
+                  ? chalk.green
+                  : d.status === "rejected"
+                    ? chalk.red
+                    : chalk.yellow;
+              process.stdout.write(
+                `  ${statusColor(`[${d.status || "proposed"}]`)} ${chalk.cyan(d.title || d.id)}\n`,
+              );
+              if (d.rationale) {
+                process.stdout.write(
+                  `    ${chalk.gray(d.rationale.substring(0, 100))}\n`,
+                );
+              }
+            }
+          } else {
+            process.stdout.write(
+              `  ${JSON.stringify(result).substring(0, 500)}\n`,
+            );
+          }
+          process.stdout.write("\n");
+          messages.push({
+            role: "assistant",
+            content: `[Cowork Decision] Found ${(result.decisions || []).length} architecture decisions.`,
+          });
+        } catch (err) {
+          logger.error(`Decision analysis failed: ${err.message}`);
+        }
       } else {
         logger.info(
-          "Usage: /cowork debate <file-or-topic> or /cowork compare <prompt>",
+          "Usage: /cowork debate <file> | compare <prompt> | graph <path> | decision <topic>",
         );
       }
 
@@ -797,6 +1293,144 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // Autonomous agent commands
+    if (trimmed.startsWith("/auto")) {
+      const autoArg = trimmed.slice(5).trim();
+
+      if (!autoArg || autoArg === "help") {
+        logger.log(chalk.bold("\nAutonomous Agent Commands:"));
+        logger.log(
+          `  ${chalk.cyan("/auto <goal>")}      Submit a goal for autonomous execution`,
+        );
+        logger.log(
+          `  ${chalk.cyan("/auto status")}      Show current goal status`,
+        );
+        logger.log(
+          `  ${chalk.cyan("/auto pause")}       Pause the running goal`,
+        );
+        logger.log(`  ${chalk.cyan("/auto resume")}      Resume a paused goal`);
+        logger.log(
+          `  ${chalk.cyan("/auto cancel")}      Cancel the running goal`,
+        );
+        logger.log(`  ${chalk.cyan("/auto list")}        List all goals`);
+        logger.log("");
+      } else if (autoArg === "status") {
+        const goals = autonomousAgent.listGoals();
+        const running = goals.find(
+          (g) =>
+            g.status === GoalStatus.RUNNING || g.status === GoalStatus.PAUSED,
+        );
+        if (running) {
+          const detail = autonomousAgent.getGoalStatus(running.id);
+          logger.info(`Goal: ${chalk.cyan(detail.description)}`);
+          logger.info(
+            `Status: ${detail.status}  Steps: ${detail.steps.length}  Iterations: ${detail.iterations}`,
+          );
+          for (const step of detail.steps) {
+            const icon =
+              step.status === "completed"
+                ? "✓"
+                : step.status === "running"
+                  ? "→"
+                  : step.status === "failed"
+                    ? "✗"
+                    : "○";
+            logger.log(
+              `  ${icon} ${step.description} ${step.error ? chalk.red(`(${step.error})`) : ""}`,
+            );
+          }
+        } else {
+          logger.info("No active goal. Use /auto <goal> to submit one.");
+        }
+      } else if (autoArg === "pause") {
+        const goals = autonomousAgent.listGoals();
+        const running = goals.find((g) => g.status === GoalStatus.RUNNING);
+        if (running) {
+          autonomousAgent.pauseGoal(running.id);
+          logger.info(`Paused goal: ${running.description}`);
+        } else {
+          logger.info("No running goal to pause.");
+        }
+      } else if (autoArg === "resume") {
+        const goals = autonomousAgent.listGoals();
+        const paused = goals.find((g) => g.status === GoalStatus.PAUSED);
+        if (paused) {
+          autonomousAgent.resumeGoal(paused.id);
+          logger.info(`Resumed goal: ${paused.description}`);
+        } else {
+          logger.info("No paused goal to resume.");
+        }
+      } else if (autoArg === "cancel") {
+        const goals = autonomousAgent.listGoals();
+        const active = goals.find(
+          (g) =>
+            g.status === GoalStatus.RUNNING || g.status === GoalStatus.PAUSED,
+        );
+        if (active) {
+          autonomousAgent.cancelGoal(active.id);
+          logger.info(`Cancelled goal: ${active.description}`);
+        } else {
+          logger.info("No active goal to cancel.");
+        }
+      } else if (autoArg === "list") {
+        const goals = autonomousAgent.listGoals();
+        if (goals.length === 0) {
+          logger.info("No goals submitted yet.");
+        } else {
+          for (const g of goals) {
+            logger.log(
+              `  [${g.status}] ${g.description} (${g.steps} steps, ${g.iterations} iterations)`,
+            );
+          }
+        }
+      } else {
+        // Submit new goal
+        // Lazy-init autonomous agent with LLM chat function
+        if (!autonomousAgent._initialized) {
+          const chatFn = createChatFn({ provider, model, baseUrl, apiKey });
+          autonomousAgent.initialize({
+            llmChat: chatFn,
+            toolExecutor: executeTool,
+          });
+        }
+
+        // Set up event listeners for live output
+        const goalListener = (evt) => {
+          if (evt.goalId) {
+            if (evt.result)
+              process.stdout.write(
+                chalk.green(`  Goal completed: ${evt.result}\n`),
+              );
+            if (evt.error)
+              process.stdout.write(chalk.red(`  Goal failed: ${evt.error}\n`));
+          }
+        };
+        const stepListener = (evt) => {
+          process.stdout.write(chalk.gray(`  [step] ${evt.step}\n`));
+        };
+
+        autonomousAgent.on("goal:completed", goalListener);
+        autonomousAgent.on("goal:failed", goalListener);
+        autonomousAgent.on("step:started", stepListener);
+        autonomousAgent.on("step:completed", (evt) => {
+          process.stdout.write(chalk.green(`  [done] ${evt.step}\n`));
+        });
+
+        logger.info(`Submitting goal: ${chalk.cyan(autoArg)}`);
+        try {
+          const { goalId } = await autonomousAgent.submitGoal(autoArg);
+          logger.info(
+            `Goal ${goalId} submitted. Use /auto status to track progress.`,
+          );
+        } catch (err) {
+          logger.error(`Failed to submit goal: ${err.message}`);
+        }
+      }
+
+      prompt();
+      return;
+    }
+
     // Plan mode commands
     if (trimmed.startsWith("/plan")) {
       const planManager = getPlanModeManager();
@@ -858,6 +1492,58 @@ export async function startAgentRepl(options = {}) {
           planManager.rejectPlan("User rejected");
           logger.info("Plan rejected. Exited plan mode.");
         }
+      } else if (subCmd === "risk") {
+        if (!planManager.isActive() || !planManager.currentPlan) {
+          logger.info("No active plan to assess.");
+        } else {
+          const risk = planManager.getRiskAssessment();
+          logger.log(
+            `\nRisk Level: ${chalk.bold(risk.level.toUpperCase())} (total: ${risk.totalScore}, max: ${risk.maxScore}, avg: ${risk.averageScore})`,
+          );
+          for (const item of risk.itemScores) {
+            const color =
+              item.score >= 6
+                ? chalk.red
+                : item.score >= 3
+                  ? chalk.yellow
+                  : chalk.green;
+            logger.log(`  ${color(`[${item.score}]`)} ${item.title}`);
+          }
+          logger.log("");
+        }
+      } else if (subCmd === "execute") {
+        if (!planManager.isActive()) {
+          logger.info("No active plan.");
+        } else if (planManager.state !== PlanState.APPROVED) {
+          logger.info("Plan must be approved first. Use /plan approve.");
+        } else {
+          logger.info("Executing plan items in DAG order...");
+          try {
+            const { results, success } = await planManager.executePlan(
+              async (item) => {
+                if (item.tool && item.params) {
+                  process.stdout.write(
+                    chalk.gray(`  [${item.tool}] ${item.title}\n`),
+                  );
+                  return await executeTool(item.tool, item.params);
+                }
+                return { skipped: true };
+              },
+            );
+            for (const r of results) {
+              const icon = r.success ? chalk.green("✓") : chalk.red("✗");
+              logger.log(
+                `  ${icon} ${r.item.title}${r.error ? ` — ${r.error}` : ""}`,
+              );
+            }
+            logger.info(
+              `Plan execution ${success ? "completed" : "finished with errors"}.`,
+            );
+            planManager.exitPlanMode({ savePlan: true });
+          } catch (err) {
+            logger.error(`Plan execution failed: ${err.message}`);
+          }
+        }
       } else if (subCmd === "exit") {
         if (planManager.isActive()) {
           planManager.exitPlanMode({ savePlan: true });
@@ -878,13 +1564,27 @@ export async function startAgentRepl(options = {}) {
     // Add user message
     messages.push({ role: "user", content: trimmed });
 
+    // Auto-select best model based on task type
+    let activeModel = model;
+    const taskDetection = detectTaskType(trimmed);
+    if (taskDetection.confidence > 0.3) {
+      const recommended = selectModelForTask(provider, taskDetection.taskType);
+      if (recommended && recommended !== activeModel) {
+        activeModel = recommended;
+        logger.info(
+          chalk.gray(`[auto] ${taskDetection.name} → ${activeModel}`),
+        );
+      }
+    }
+
     try {
       process.stdout.write("\n");
       const response = await agentLoop(messages, {
         provider,
-        model,
+        model: activeModel,
         baseUrl,
         apiKey,
+        contextEngine,
       });
 
       if (response) {
@@ -893,9 +1593,34 @@ export async function startAgentRepl(options = {}) {
       } else {
         process.stdout.write("\n");
       }
+
+      // Auto-save session
+      if (db && sessionId) {
+        try {
+          saveMessages(db, sessionId, messages);
+        } catch (_e) {
+          // Non-critical
+        }
+      }
+      // Store as episodic memory
+      if (db) {
+        try {
+          storeMemory(db, trimmed, { importance: 0.3, type: "episodic" });
+        } catch (_e) {
+          // Non-critical
+        }
+      }
     } catch (err) {
       logger.error(`Error: ${err.message}`);
 
+      // Record error for context injection
+      if (contextEngine) {
+        contextEngine.recordError({
+          step: "agent-loop",
+          message: err.message,
+        });
+      }
+
       // If connection error, provide helpful message
       if (
         err.message.includes("ECONNREFUSED") ||
@@ -911,7 +1636,37 @@ export async function startAgentRepl(options = {}) {
     prompt();
   });
 
-  rl.on("close", () => {
+  rl.on("close", async () => {
+    // Save session on exit
+    if (db && sessionId) {
+      try {
+        saveMessages(db, sessionId, messages);
+      } catch (_e) {
+        // Non-critical
+      }
+    }
+    // Auto-summarize session into permanent memory
+    if (permanentMemory && messages.length > 4) {
+      try {
+        permanentMemory.autoSummarize(messages);
+      } catch (_e) {
+        // Non-critical
+      }
+    }
+    // Consolidate memory
+    if (db) {
+      try {
+        consolidateMemory(db);
+      } catch (_e) {
+        // Non-critical
+      }
+    }
+    // Shutdown runtime
+    try {
+      await shutdown();
+    } catch (_e) {
+      // Non-critical
+    }
     process.exit(0);
   });
 }