sandal-db 1.0.2 → 1.0.4

package/dist/cli.js

@@ -3,15 +3,287 @@
 // src/cli.ts
 import fs4 from "node:fs";
 import { Command } from "commander";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 import ora2 from "ora";
-import { input as input2, select, confirm as confirm2 } from "@inquirer/prompts";
+import { input as input2, select as select2, confirm } from "@inquirer/prompts";
 
 // src/config/index.ts
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import dotenv from "dotenv";
+
+// src/config/models.ts
+import chalk from "chalk";
+import Table from "cli-table3";
+import { select, input } from "@inquirer/prompts";
+var PROVIDER_MODELS = {
+  google: [
+    {
+      id: "gemini-3.8-flash",
+      name: "Gemini 3.8 Flash",
+      description: "Latest Gemini 3 Flash. High speed, low latency, advanced reasoning & multimodal",
+      contextWindow: "1M",
+      badge: "Latest Flagship",
+      recommended: true
+    },
+    {
+      id: "gemini-3.7-flash",
+      name: "Gemini 3.7 Flash",
+      description: "Hybrid reasoning model with dynamic thinking tokens",
+      contextWindow: "1M",
+      badge: "Hybrid Reasoning"
+    },
+    {
+      id: "gemini-3.1-pro-preview",
+      name: "Gemini 3.1 Pro",
+      description: "Frontier reasoning for complex schemas, agentic planning & SQL logic",
+      contextWindow: "2M",
+      badge: "Frontier Pro"
+    },
+    {
+      id: "gemini-2.5-flash",
+      name: "Gemini 2.5 Flash",
+      description: "Production workhorse, high throughput, balanced performance",
+      contextWindow: "1M",
+      badge: "Production Stable"
+    },
+    {
+      id: "gemini-2.5-pro",
+      name: "Gemini 2.5 Pro",
+      description: "Deep reasoning and complex SQL query generation across massive schemas",
+      contextWindow: "2M"
+    },
+    {
+      id: "gemini-3.5-flash-lite",
+      name: "Gemini 3.5 Flash-Lite",
+      description: "Ultra-fast lightweight model for budget-sensitive high-QPS tasks",
+      contextWindow: "1M",
+      badge: "Fast & Budget"
+    },
+    {
+      id: "gemini-2.5-flash-lite",
+      name: "Gemini 2.5 Flash-Lite",
+      description: "Fast and economical multimodal model",
+      contextWindow: "1M"
+    },
+    {
+      id: "gemini-2.0-flash",
+      name: "Gemini 2.0 Flash",
+      description: "Stable legacy 2.0 Flash model",
+      contextWindow: "1M"
+    }
+  ],
+  openai: [
+    {
+      id: "gpt-5.6-sol",
+      name: "GPT-5.6 Sol",
+      description: "Flagship frontier model for complex professional work, coding & database tasks",
+      contextWindow: "1M+",
+      badge: "Latest Flagship",
+      recommended: true
+    },
+    {
+      id: "gpt-6-astra",
+      name: "GPT-6 Astra",
+      description: "OpenAI most capable model, built for hardest end-to-end coding & reasoning",
+      contextWindow: "1M+",
+      badge: "Frontier Peak"
+    },
+    {
+      id: "gpt-5.6-terra",
+      name: "GPT-5.6 Terra",
+      description: "Balanced intelligence and cost for general database exploration",
+      contextWindow: "1M+",
+      badge: "Balanced"
+    },
+    {
+      id: "gpt-5.6-luna",
+      name: "GPT-5.6 Luna",
+      description: "Optimized for high-volume, cost-sensitive production workloads",
+      contextWindow: "1M+",
+      badge: "Economical"
+    },
+    {
+      id: "gpt-5.4",
+      name: "GPT-5.4",
+      description: "High-performance model for coding and analytical workflows",
+      contextWindow: "272K+"
+    },
+    {
+      id: "gpt-5.4-mini",
+      name: "GPT-5.4 Mini",
+      description: "Strongest mini model for coding, tool use, and subagents",
+      contextWindow: "128K",
+      badge: "Fast & Smart"
+    },
+    {
+      id: "o4-mini",
+      name: "o4-mini",
+      description: "Next-gen fast, cost-efficient reasoning model with thinking capabilities",
+      contextWindow: "200K",
+      badge: "Fast Reasoning"
+    },
+    {
+      id: "o3-mini",
+      name: "o3-mini",
+      description: "Compact reasoning model with configurable thinking effort",
+      contextWindow: "200K"
+    },
+    {
+      id: "o3",
+      name: "o3",
+      description: "High-compute reasoning model for complex analytics and tricky queries",
+      contextWindow: "200K",
+      badge: "Deep Reasoning"
+    },
+    {
+      id: "gpt-4.1",
+      name: "GPT-4.1",
+      description: "Smartest non-reasoning direct chat & generation model",
+      contextWindow: "128K"
+    },
+    {
+      id: "gpt-4o",
+      name: "GPT-4o",
+      description: "Versatile multimodal workhorse for general tasks",
+      contextWindow: "128K"
+    },
+    {
+      id: "gpt-4o-mini",
+      name: "GPT-4o Mini",
+      description: "Affordable small model for fast queries and schema lookups",
+      contextWindow: "128K"
+    }
+  ],
+  anthropic: [
+    {
+      id: "claude-sonnet-5",
+      name: "Claude Sonnet 5",
+      description: "Optimal balance of speed, intelligence & 1M token context window",
+      contextWindow: "1M",
+      badge: "Latest Flagship",
+      recommended: true
+    },
+    {
+      id: "claude-opus-5",
+      name: "Claude Opus 5",
+      description: "Complex agentic coding, database refactoring & enterprise reasoning",
+      contextWindow: "1M",
+      badge: "Deep Intelligence"
+    },
+    {
+      id: "claude-fable-5-1",
+      name: "Claude Fable 5.1",
+      description: "Demanding reasoning and long-horizon autonomous agentic work",
+      contextWindow: "1M",
+      badge: "Long Horizon"
+    },
+    {
+      id: "claude-haiku-4-5",
+      name: "Claude Haiku 4.5",
+      description: "Fastest Claude model with near-frontier intelligence for rapid responses",
+      contextWindow: "200K",
+      badge: "Ultra Fast"
+    },
+    {
+      id: "claude-sonnet-4-6",
+      name: "Claude Sonnet 4.6",
+      description: "Pinned dateless enterprise release for production stability",
+      contextWindow: "500K"
+    },
+    {
+      id: "claude-3-7-sonnet-latest",
+      name: "Claude 3.7 Sonnet",
+      description: "Hybrid reasoning model with adjustable thinking budgets",
+      contextWindow: "200K",
+      badge: "Hybrid Reasoning"
+    },
+    {
+      id: "claude-3-5-sonnet-latest",
+      name: "Claude 3.5 Sonnet",
+      description: "Industry benchmark for coding and function calling",
+      contextWindow: "200K"
+    },
+    {
+      id: "claude-3-5-haiku-latest",
+      name: "Claude 3.5 Haiku",
+      description: "Ultra-fast lightweight tool use model",
+      contextWindow: "200K"
+    }
+  ]
+};
+function getModelsForProvider(provider) {
+  return PROVIDER_MODELS[provider] || [];
+}
+function getModelChoices(provider, currentModel) {
+  const models = getModelsForProvider(provider);
+  const choices = models.map((m) => {
+    const isCurrent = m.id === currentModel;
+    const badgeText = m.badge ? chalk.dim(` [${m.badge}]`) : "";
+    const recText = m.recommended ? chalk.green(" \u2605 Recommended") : "";
+    const currentText = isCurrent ? chalk.cyan(" (Current)") : "";
+    return {
+      name: `${chalk.bold(m.id)}${recText}${badgeText}${currentText}`,
+      value: m.id,
+      description: `${m.name} (Context: ${m.contextWindow}) \u2014 ${m.description}`
+    };
+  });
+  choices.push({
+    name: chalk.yellow("Custom model (type manually)..."),
+    value: "__custom__",
+    description: "Specify an unlisted or experimental model identifier"
+  });
+  return choices;
+}
+async function promptModelSelection(provider, currentModel) {
+  const choices = getModelChoices(provider, currentModel);
+  const selected = await select({
+    message: `Select LLM model for ${chalk.bold.cyan(provider.toUpperCase())}:`,
+    choices,
+    pageSize: 10
+  });
+  if (selected === "__custom__") {
+    const custom = await input({
+      message: "Enter custom model name:",
+      validate: (val) => val.trim().length > 0 ? true : "Model name cannot be empty."
+    });
+    return custom.trim();
+  }
+  return selected;
+}
+function renderModelsTable(provider) {
+  const providers = provider ? [provider] : ["google", "openai", "anthropic"];
+  const lines = [];
+  for (const prov of providers) {
+    const models = getModelsForProvider(prov);
+    const table = new Table({
+      head: [
+        chalk.bold.cyan("Model ID"),
+        chalk.bold.cyan("Display Name"),
+        chalk.bold.cyan("Context"),
+        chalk.bold.cyan("Category / Badge"),
+        chalk.bold.cyan("Description")
+      ],
+      colWidths: [26, 20, 10, 20, 42],
+      wordWrap: true
+    });
+    for (const m of models) {
+      const idCol = m.recommended ? chalk.green.bold(`\u2605 ${m.id}`) : chalk.white.bold(m.id);
+      const badgeCol = m.badge ? chalk.yellow(m.badge) : chalk.gray("-");
+      table.push([idCol, m.name, m.contextWindow, badgeCol, m.description]);
+    }
+    lines.push(
+      chalk.bold.magenta(`
+=== Available Public Models for ${prov.toUpperCase()} ===
+`)
+    );
+    lines.push(table.toString());
+  }
+  return lines.join("\n");
+}
+
+// src/config/index.ts
 dotenv.config();
 var CONFIG_DIR_NAME = ".sandal";
 var LEGACY_CONFIG_DIR_NAME = ".db-agent";
@@ -85,6 +357,17 @@ function maskApiKey(rawKey) {
   }
   return `${trimmed.slice(0, 4)}...${trimmed.slice(-4)}`;
 }
+function getStoredApiKeyForProvider(provider) {
+  const config = readConfig();
+  switch (provider) {
+    case "google":
+      return process.env.GEMINI_API_KEY || config.geminiApiKey;
+    case "openai":
+      return process.env.OPENAI_API_KEY || config.openaiApiKey;
+    case "anthropic":
+      return process.env.ANTHROPIC_API_KEY || config.anthropicApiKey;
+  }
+}
 function getDefaultModelForProvider(provider) {
   switch (provider) {
     case "google":
@@ -154,7 +437,7 @@ function resolveCredentials(options) {
         keySource = "config";
       }
     }
-    if (!apiKey) {
+    if (!apiKey && !options.cliProvider) {
       if (process.env.GEMINI_API_KEY || config.geminiApiKey) {
         provider = "google";
         apiKey = process.env.GEMINI_API_KEY || config.geminiApiKey;
@@ -170,6 +453,8 @@ function resolveCredentials(options) {
       } else {
         keySource = "none";
       }
+    } else if (!apiKey) {
+      keySource = "none";
     }
   }
   const model = options.cliModel || config.defaultModel || getDefaultModelForProvider(provider);
@@ -965,12 +1250,12 @@ function createChatModel(options) {
 }
 
 // src/repl.ts
-import readline from "node:readline";
+import readline2 from "node:readline";
 import fs3 from "node:fs";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import boxen2 from "boxen";
 import ora from "ora";
-import Table from "cli-table3";
+import Table2 from "cli-table3";
 
 // src/agent/graph.ts
 import { Annotation, StateGraph, START, END, MemorySaver } from "@langchain/langgraph";
@@ -1382,19 +1667,51 @@ function classifyMongoQuery(rawText, query, rowThreshold, options) {
 }
 
 // src/safety/confirm.ts
-import chalk from "chalk";
+import readline from "node:readline";
+import chalk2 from "chalk";
 import boxen from "boxen";
-import { confirm, input } from "@inquirer/prompts";
-async function requestUserConfirmation(query, safety, affectedRows) {
+async function defaultAsk(promptText) {
+  process.stdin.resume();
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(promptText, (answer) => {
+      rl.close();
+      process.stdin.resume();
+      resolve(answer);
+    });
+  });
+}
+async function promptConfirm(message, defaultValue, ask = defaultAsk) {
+  const suffix = defaultValue ? chalk2.gray(" (Y/n): ") : chalk2.gray(" (y/N): ");
+  const response = (await ask(`${message}${suffix}`)).trim().toLowerCase();
+  if (!response) {
+    return defaultValue;
+  }
+  if (["y", "yes", "true", "1"].includes(response)) {
+    return true;
+  }
+  if (["n", "no", "false", "0"].includes(response)) {
+    return false;
+  }
+  return defaultValue;
+}
+async function promptInput(message, ask = defaultAsk) {
+  const response = await ask(message);
+  return response.trim();
+}
+async function requestUserConfirmation(query, safety, affectedRows, ask = defaultAsk) {
   const queryDisplay = (query.sql || query.rawDisplay || "").trim();
   if (safety.isFullWipe) {
     const boxContent = [
-      chalk.bold.red("\u{1F6A8} CRITICAL: FULL DATABASE / ALL TABLES WIPE ATTEMPTED \u{1F6A8}"),
+      chalk2.bold.red("\u{1F6A8} CRITICAL: FULL DATABASE / ALL TABLES WIPE ATTEMPTED \u{1F6A8}"),
       "",
-      chalk.yellow(queryDisplay),
+      chalk2.yellow(queryDisplay),
       "",
-      ...safety.warnings.length ? [chalk.red(safety.warnings.join("\n")), ""] : [],
-      chalk.bold.white(`Type ${chalk.red.underline(safety.literalWord || "DROP DATABASE")} to proceed:`)
+      ...safety.warnings.length ? [chalk2.red(safety.warnings.join("\n")), ""] : [],
+      chalk2.bold.white(`Type ${chalk2.red.underline(safety.literalWord || "DROP DATABASE")} to proceed:`)
     ].join("\n");
     console.log(
       boxen(boxContent, {
@@ -1404,9 +1721,10 @@ async function requestUserConfirmation(query, safety, affectedRows) {
         margin: { top: 1, bottom: 1 }
       })
     );
-    const typed = await input({
-      message: chalk.red.bold(`Type "${safety.literalWord || "DROP DATABASE"}" to confirm full wipe:`)
-    });
+    const typed = await promptInput(
+      chalk2.red.bold(`Type "${safety.literalWord || "DROP DATABASE"}" to confirm full wipe: `),
+      ask
+    );
     if (typed.trim() === safety.literalWord) {
       return { confirmed: true };
     }
@@ -1417,20 +1735,20 @@ async function requestUserConfirmation(query, safety, affectedRows) {
   }
   if (safety.category === "dangerous") {
     const lines2 = [
-      chalk.bold.hex("#FFA500")("\u26A0\uFE0F  DANGEROUS OPERATION"),
+      chalk2.bold.hex("#FFA500")("\u26A0\uFE0F  DANGEROUS OPERATION"),
       "",
-      chalk.white(queryDisplay),
+      chalk2.white(queryDisplay),
       ""
     ];
     if (affectedRows !== null) {
       lines2.push(
-        chalk.bold.yellow(`Affected rows: ${affectedRows.toLocaleString()}`),
+        chalk2.bold.yellow(`Affected rows: ${affectedRows.toLocaleString()}`),
         ""
       );
     }
     if (safety.warnings.length > 0) {
       for (const w of safety.warnings) {
-        lines2.push(chalk.red(`\u2022 ${w}`));
+        lines2.push(chalk2.red(`\u2022 ${w}`));
       }
       lines2.push("");
     }
@@ -1443,11 +1761,12 @@ async function requestUserConfirmation(query, safety, affectedRows) {
       })
     );
     if (safety.requiresLiteralWord && safety.literalWord) {
-      const typed = await input({
-        message: chalk.hex("#FFA500").bold(
-          `Destructive operation with no filter. Type "${safety.literalWord}" to confirm:`
-        )
-      });
+      const typed = await promptInput(
+        chalk2.hex("#FFA500").bold(
+          `Destructive operation with no filter. Type "${safety.literalWord}" to confirm: `
+        ),
+        ask
+      );
       if (typed.trim() === safety.literalWord) {
         return { confirmed: true };
       }
@@ -1456,31 +1775,32 @@ async function requestUserConfirmation(query, safety, affectedRows) {
         reason: `Confirmation word mismatch (expected "${safety.literalWord}"). Operation cancelled.`
       };
     }
-    const answer2 = await confirm({
-      message: chalk.hex("#FFA500").bold("Proceed with dangerous operation?"),
-      default: false
-    });
+    const answer2 = await promptConfirm(
+      chalk2.hex("#FFA500").bold("Proceed with dangerous operation?"),
+      false,
+      ask
+    );
     return { confirmed: answer2 };
   }
   if (safety.isStructural) {
     const lines2 = [
-      chalk.bold.cyan("\u{1F6E0}\uFE0F  STRUCTURAL DDL OPERATION"),
+      chalk2.bold.cyan("\u{1F6E0}\uFE0F  STRUCTURAL DDL OPERATION"),
       "",
-      chalk.white(queryDisplay),
+      chalk2.white(queryDisplay),
       "",
-      chalk.cyan(`Effect: ${safety.explanation || "Modifies database structure."}`)
+      chalk2.cyan(`Effect: ${safety.explanation || "Modifies database structure."}`)
     ];
     if (safety.suggestedAlternative) {
       lines2.push(
         "",
-        chalk.yellow("\u{1F4A1} Recommendation:"),
-        chalk.gray(safety.suggestedAlternative)
+        chalk2.yellow("\u{1F4A1} Recommendation:"),
+        chalk2.gray(safety.suggestedAlternative)
       );
     }
     if (safety.warnings.length > 0) {
       lines2.push("");
       for (const w of safety.warnings) {
-        lines2.push(chalk.yellow(`\u2022 ${w}`));
+        lines2.push(chalk2.yellow(`\u2022 ${w}`));
       }
     }
     console.log(
@@ -1491,20 +1811,21 @@ async function requestUserConfirmation(query, safety, affectedRows) {
         margin: { top: 1, bottom: 1 }
       })
     );
-    const answer2 = await confirm({
-      message: chalk.cyan.bold("Apply this structural change?"),
-      default: true
-    });
+    const answer2 = await promptConfirm(
+      chalk2.cyan.bold("Apply this structural change?"),
+      true,
+      ask
+    );
     return { confirmed: answer2 };
   }
   if (safety.category === "write") {
     const lines2 = [
-      chalk.bold.magenta("\u270F\uFE0F  DATABASE WRITE OPERATION"),
+      chalk2.bold.magenta("\u270F\uFE0F  DATABASE WRITE OPERATION"),
       "",
-      chalk.white(queryDisplay)
+      chalk2.white(queryDisplay)
     ];
     if (affectedRows !== null) {
-      lines2.push("", chalk.magenta(`Estimated affected rows: ${affectedRows.toLocaleString()}`));
+      lines2.push("", chalk2.magenta(`Estimated affected rows: ${affectedRows.toLocaleString()}`));
     }
     console.log(
       boxen(lines2.join("\n"), {
@@ -1514,16 +1835,17 @@ async function requestUserConfirmation(query, safety, affectedRows) {
         margin: { top: 1, bottom: 1 }
       })
     );
-    const answer2 = await confirm({
-      message: chalk.magenta.bold("Execute write query?"),
-      default: false
-    });
+    const answer2 = await promptConfirm(
+      chalk2.magenta.bold("Execute write query?"),
+      false,
+      ask
+    );
     return { confirmed: answer2 };
   }
   const lines = [
-    chalk.bold.green("\u{1F50D} READ QUERY"),
+    chalk2.bold.green("\u{1F50D} READ QUERY"),
     "",
-    chalk.white(queryDisplay)
+    chalk2.white(queryDisplay)
   ];
   console.log(
     boxen(lines.join("\n"), {
@@ -1533,10 +1855,11 @@ async function requestUserConfirmation(query, safety, affectedRows) {
       margin: { top: 1, bottom: 1 }
     })
   );
-  const answer = await confirm({
-    message: chalk.green.bold("Execute read query?"),
-    default: true
-  });
+  const answer = await promptConfirm(
+    chalk2.green.bold("Execute read query?"),
+    true,
+    ask
+  );
   return { confirmed: answer };
 }
 
@@ -1666,8 +1989,33 @@ var OBVIOUS_DATABASE_PATTERNS = [
   /\b(?:table|tables|collection|collections|schema|column|columns|index|indexes|foreign key|primary key)\b/i,
   /\b(?:find|aggregate|count|where|group by|order by|having|limit|join|left join|inner join)\b/i,
   /\b(?:how many (?:users|rows|records|orders|items|products|documents))\b/i,
-  /\b(?:database|postgres|mongodb|mongo|pg_)\b/i
+  /\b(?:database|postgres|mongodb|mongo|pg_)\b/i,
+  /\b(?:query|queries|sql|result|results|rows?|records?)\b/i
 ];
+function isExplicitNoQuery(input3) {
+  const trimmed = input3.trim();
+  const patterns = [
+    // don't / do not / shouldn't / stop / avoid running / executing / calling / issuing query / queries / sql / command
+    /\b(?:don'?t|do\s+not|never|shouldn'?t|stop|avoid)\s+(?:run|running|execute|executing|call|calling|issue|issuing|send|sending|make|making)\s+(?:any\s+|the\s+|a\s+|new\s+)?(?:query|queries|sql|command|db\s+query|database\s+query)\b/i,
+    // without / no running / executing / making queries
+    /\b(?:without|no)\s+(?:running|executing|making|issuing|calling)\s+(?:any\s+|the\s+|a\s+|new\s+)?(?:query|queries|sql|command)\b/i,
+    // no query / no queries / skip the query / skip execution
+    /\b(?:no\s+query|no\s+queries|skip\s+(?:the\s+)?query|skip\s+execution)\b/i,
+    // don't query / do not query (the database)
+    /\b(?:don'?t|do\s+not|never)\s+query(?:\s+(?:the\s+database|the\s+db|again))?\b/i,
+    // don't / do not run / execute it
+    /\b(?:don'?t|do\s+not|never)\s+(?:run|execute)\s+it\b/i,
+    // don't execute anything / don't run anything
+    /\b(?:don'?t|do\s+not|never)\s+(?:run|execute)\s+anything\b/i,
+    // just use / take / look at / do something with the previous / last / prior results / output / rows
+    /\bjust\s+(?:use|take|from|look\s+at|work\s+with|do\s+something\s+with)\s+(?:the\s+)?(?:previous|last|prior|above|earlier)\s+(?:results?|data|output|rows?)\b/i,
+    // from / using / with the previous results ... don't run / do not run / without querying
+    /\b(?:from|using|with)\s+(?:the\s+)?(?:previous|last|prior|above|earlier)\s+(?:results?|data|output|rows?)[^,\n.]*?(?:don'?t|do\s+not|without)\s+(?:run|running|query|querying)\b/i,
+    // don't run ... previous results
+    /\b(?:don'?t|do\s+not|without)\s+(?:run|running|execute|executing)[^,\n.]*?(?:previous|last|prior|above|earlier)\s+(?:results?|data|output|rows?)\b/i
+  ];
+  return patterns.some((pattern) => pattern.test(trimmed));
+}
 async function classifyIntent(input3, model, historyContext) {
   const trimmed = input3.trim();
   for (const pattern of OBVIOUS_OUT_OF_SCOPE_PATTERNS) {
@@ -1678,6 +2026,9 @@ async function classifyIntent(input3, model, historyContext) {
       };
     }
   }
+  if (isExplicitNoQuery(trimmed)) {
+    return { isDatabaseTask: true };
+  }
   for (const pattern of OBVIOUS_DATABASE_PATTERNS) {
     if (pattern.test(trimmed)) {
       return {
@@ -1688,7 +2039,9 @@ async function classifyIntent(input3, model, historyContext) {
   if (/^(?:tables|collections|schema|indexes|views|stats|count|info)$/i.test(trimmed)) {
     return { isDatabaseTask: true };
   }
-  if (historyContext && /^(?:now\s+|and\s+|also\s+|then\s+)?(?:count|sort|filter|show|order|group|limit|delete|update|find|export|why|how many|what about|which ones?|where)\b/i.test(trimmed)) {
+  if (historyContext && /^(?:now\s+|and\s+|also\s+|then\s+)?(?:count|sort|filter|show|order|group|limit|delete|update|find|export|why|how many|what about|which ones?|where|don'?t|do not|format|summarize|explain)\b/i.test(
+    trimmed
+  )) {
     return { isDatabaseTask: true };
   }
   if (!model) {
@@ -1753,10 +2106,22 @@ var AgentStateAnnotation = Annotation.Root({
     reducer: (_, update) => update ?? [],
     default: () => []
   }),
+  requiresQuery: Annotation({
+    reducer: (_, update) => update ?? true,
+    default: () => true
+  }),
+  queryExecuted: Annotation({
+    reducer: (_, update) => update ?? false,
+    default: () => false
+  }),
   generatedQuery: Annotation({
     reducer: (_, update) => update,
     default: () => void 0
   }),
+  lastGeneratedQuery: Annotation({
+    reducer: (curr, update) => update ?? curr,
+    default: () => void 0
+  }),
   safety: Annotation({
     reducer: (_, update) => update,
     default: () => void 0
@@ -1777,6 +2142,10 @@ var AgentStateAnnotation = Annotation.Root({
     reducer: (_, update) => update,
     default: () => void 0
   }),
+  lastQueryResult: Annotation({
+    reducer: (curr, update) => update ?? curr,
+    default: () => void 0
+  }),
   analysis: Annotation({
     reducer: (_, update) => update,
     default: () => void 0
@@ -1785,6 +2154,10 @@ var AgentStateAnnotation = Annotation.Root({
     reducer: (_, update) => update,
     default: () => void 0
   }),
+  lastStats: Annotation({
+    reducer: (curr, update) => update ?? curr,
+    default: () => void 0
+  }),
   conclusion: Annotation({
     reducer: (_, update) => update,
     default: () => void 0
@@ -1794,7 +2167,7 @@ var AgentStateAnnotation = Annotation.Root({
     default: () => false
   }),
   messages: Annotation({
-    reducer: (curr, update) => curr.concat(update ?? []),
+    reducer: (curr, update) => update !== void 0 ? update : curr,
     default: () => []
   })
 });
@@ -1813,6 +2186,94 @@ function createDatabaseAgent(config) {
       requiresSchemaRefresh: false
     };
   }
+  async function determineActionNode(state) {
+    const userInput = state.userInput.trim();
+    const baseReset = {
+      queryExecuted: false,
+      generatedQuery: void 0,
+      queryResult: void 0,
+      safety: void 0,
+      confirmed: false,
+      cancelReason: void 0,
+      conclusion: void 0
+    };
+    if (isExplicitNoQuery(userInput)) {
+      return {
+        ...baseReset,
+        requiresQuery: false
+      };
+    }
+    const isObviousLiveQuery = /^(?:SELECT|INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|TRUNCATE|GRANT|REVOKE)\b/i.test(userInput) || /^(?:find|search|fetch|get|select|show|display|list|count|delete|update|insert|remove)\s+(?:all\s+|the\s+|every\s+|top\s+\d+\s+)?(?:users?|orders?|products?|customers?|items?|rows?|records?|documents?|accounts?|entries)\b/i.test(userInput) || /\bhow\s+many\s+(?:users|orders|products|items|rows|records|documents|customers|accounts)\b/i.test(userInput);
+    if (isObviousLiveQuery) {
+      return {
+        ...baseReset,
+        requiresQuery: true
+      };
+    }
+    const hasPreviousResults = Boolean(
+      state.lastQueryResult && state.lastQueryResult.rows && state.lastQueryResult.rows.length > 0
+    );
+    const isOperatingOnPreviousResults = hasPreviousResults && /\b(?:previous|last|prior|above|earlier)\s+(?:results?|data|output|rows?)\b/i.test(userInput) && /\b(?:format|display|convert|export|show|summarize|explain|calculate|count|average|find|filter|sort|list)\b/i.test(userInput);
+    if (isOperatingOnPreviousResults) {
+      return {
+        ...baseReset,
+        requiresQuery: false
+      };
+    }
+    const isSchemaOrMetaQuestion = /\b(?:schema|database\s+structure)\b/i.test(userInput) || /\b(?:explain|describe|what|tell\s+me\s+about)\b.*?\b(?:tables?|collections?|columns?|indexes?|foreign\s+keys?|schema)\b/i.test(userInput) || /\b(?:what\s+(?:tables|collections|columns)\s+(?:exist|are\s+there|do\s+we\s+have))\b/i.test(userInput) || /\b(?:what\s+was\s+the\s+(?:last|previous)\s+query|why\s+did\s+(?:the\s+last\s+query|it)\s+fail)\b/i.test(userInput);
+    if (isSchemaOrMetaQuestion && (state.schemaSummary || state.messages.length > 0)) {
+      return {
+        ...baseReset,
+        requiresQuery: false
+      };
+    }
+    const historyMessages = state.messages.slice(-4);
+    const prevQueryStr = state.lastGeneratedQuery?.sql || state.lastGeneratedQuery?.rawDisplay || "None";
+    const prevRowsCount = state.lastQueryResult?.rowCount ?? state.lastQueryResult?.rows?.length ?? 0;
+    const routerPrompt = `Determine whether fulfilling this user request requires generating and executing a LIVE database query (SQL or MongoDB) against the database, or if it should be answered directly without executing any query.
+
+User Request: "${userInput}"
+
+Recent Context:
+- Previous Query: ${prevQueryStr}
+- Previous Rows Returned: ${prevRowsCount}
+- Schema Summary Available: ${state.schemaSummary ? "Yes" : "No"}
+
+Rules:
+1. If the user explicitly asks NOT to run a query (e.g., "don't run query", "without querying", "do not execute queries"), requiresQuery MUST be false.
+2. If the user asks to format, summarize, filter, inspect, or calculate based on the previous results or conversation context, requiresQuery MUST be false.
+3. If the user asks about the schema structure, columns, or general knowledge answerable from context, requiresQuery MUST be false.
+4. If the user asks to retrieve fresh records from a table/collection, count rows in the database, modify, insert, delete, or create database objects, requiresQuery MUST be true.
+
+Respond with JSON only:
+{"requiresQuery": boolean, "reason": "<short explanation>"}`;
+    try {
+      const response = await model.invoke([
+        ...historyMessages,
+        new HumanMessage2(routerPrompt)
+      ]);
+      const content = typeof response.content === "string" ? response.content.trim() : "";
+      const jsonMatch = content.match(/\{[\s\S]*?\}/);
+      if (jsonMatch) {
+        const parsed = JSON.parse(jsonMatch[0]);
+        if (typeof parsed.requiresQuery === "boolean") {
+          return {
+            ...baseReset,
+            requiresQuery: parsed.requiresQuery
+          };
+        }
+      }
+      return {
+        ...baseReset,
+        requiresQuery: true
+      };
+    } catch {
+      return {
+        ...baseReset,
+        requiresQuery: true
+      };
+    }
+  }
   async function identifyTargetsNode(state) {
     const historyMessages = state.messages.slice(-4);
     const prompt = `Based on this user request: "${state.userInput}"
@@ -1922,7 +2383,8 @@ Do not wrap with markdown or code fences.`;
     if (!state.generatedQuery || !state.safety) {
       return { confirmed: false, cancelReason: "Missing query or safety classification." };
     }
-    const result = await requestUserConfirmation(
+    const confirmHandler = config.confirmFn || requestUserConfirmation;
+    const result = await confirmHandler(
       state.generatedQuery,
       state.safety,
       state.affectedRowCount ?? null
@@ -1983,7 +2445,8 @@ Do not wrap with markdown or code fences.`;
       const conclusion = state.cancelReason || "Operation was not executed.";
       return {
         conclusion,
-        messages: [new HumanMessage2(state.userInput), new AIMessage(conclusion)]
+        queryExecuted: false,
+        messages: [...state.messages, new HumanMessage2(state.userInput), new AIMessage(conclusion)]
       };
     }
     const res = state.queryResult;
@@ -1991,14 +2454,18 @@ Do not wrap with markdown or code fences.`;
       const conclusion = "No query was executed.";
       return {
         conclusion,
-        messages: [new HumanMessage2(state.userInput), new AIMessage(conclusion)]
+        queryExecuted: false,
+        messages: [...state.messages, new HumanMessage2(state.userInput), new AIMessage(conclusion)]
       };
     }
     if (!res.success) {
       const conclusion = `Query failed with error: ${res.error} (took ${res.durationMs}ms)`;
       return {
         conclusion,
-        messages: [new HumanMessage2(state.userInput), new AIMessage(conclusion)]
+        queryExecuted: true,
+        lastQueryResult: res,
+        lastGeneratedQuery: state.generatedQuery,
+        messages: [...state.messages, new HumanMessage2(state.userInput), new AIMessage(conclusion)]
       };
     }
     const prompt = `User request: "${state.userInput}"
@@ -2023,7 +2490,11 @@ Ground your response strictly in the query results above. Never hallucinate rows
 ${conclusion}` : conclusion;
       return {
         conclusion,
-        messages: [new HumanMessage2(state.userInput), new AIMessage(historyAiText)]
+        queryExecuted: true,
+        lastQueryResult: res,
+        lastGeneratedQuery: state.generatedQuery,
+        lastStats: state.stats,
+        messages: [...state.messages, new HumanMessage2(state.userInput), new AIMessage(historyAiText)]
       };
     } catch (err) {
       const conclusion = `Query executed successfully (${res.rowCount ?? 0} rows, ${res.durationMs}ms).`;
@@ -2032,16 +2503,88 @@ ${conclusion}` : conclusion;
 ${conclusion}` : conclusion;
       return {
         conclusion,
-        messages: [new HumanMessage2(state.userInput), new AIMessage(historyAiText)]
+        queryExecuted: true,
+        lastQueryResult: res,
+        lastGeneratedQuery: state.generatedQuery,
+        lastStats: state.stats,
+        messages: [...state.messages, new HumanMessage2(state.userInput), new AIMessage(historyAiText)]
+      };
+    }
+  }
+  async function answerDirectNode(state) {
+    const historyMessages = state.messages.slice(-6);
+    let contextDetails = "";
+    if (state.lastQueryResult && state.lastQueryResult.rows && state.lastQueryResult.rows.length > 0) {
+      const queryStr = state.lastGeneratedQuery?.sql || state.lastGeneratedQuery?.rawDisplay || "N/A";
+      contextDetails += `
+\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+`;
+      contextDetails += `PREVIOUS QUERY EXECUTION DETAILS:
+`;
+      contextDetails += `- Executed Query: ${queryStr}
+`;
+      contextDetails += `- Rows returned: ${state.lastQueryResult.rowCount ?? state.lastQueryResult.rows.length}
+`;
+      contextDetails += `- Rows data (sample up to 25 rows):
+${JSON.stringify(state.lastQueryResult.rows.slice(0, 25), null, 2)}
+`;
+      if (state.lastStats) {
+        contextDetails += `- Computed statistics: ${JSON.stringify(state.lastStats, null, 2)}
+`;
+      }
+      contextDetails += `\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550
+`;
+    }
+    const prompt = `You are "SANDAL", an expert database assistant.
+The user has provided a request that MUST be answered directly WITHOUT generating or executing any database query.
+
+User Request: "${state.userInput}"
+
+Database Schema:
+${state.schemaSummary || "No schema loaded."}
+${contextDetails}
+
+Guidelines:
+1. Provide a direct, helpful, and accurate natural-language response to the user's request.
+2. If the user asked to do something with previous results (e.g. summarize, format, count, calculate, extract, sort), perform that operation using the PREVIOUS QUERY EXECUTION DETAILS above.
+3. If the user asked to use previous results but NO previous results exist in the session, politely explain that no previous query results are available in this session.
+4. DO NOT output, execute, or propose any new database queries.
+5. Ground your answer strictly in the available schema, history, or previous query results. Never hallucinate data.`;
+    try {
+      const response = await model.invoke([
+        ...historyMessages,
+        new HumanMessage2(prompt)
+      ]);
+      const conclusion = typeof response.content === "string" ? response.content : JSON.stringify(response.content);
+      return {
+        conclusion,
+        queryExecuted: false,
+        generatedQuery: void 0,
+        queryResult: void 0,
+        messages: [...state.messages, new HumanMessage2(state.userInput), new AIMessage(conclusion)]
+      };
+    } catch (err) {
+      const conclusion = `Unable to process request: ${err.message}`;
+      return {
+        conclusion,
+        queryExecuted: false,
+        generatedQuery: void 0,
+        queryResult: void 0,
+        messages: [...state.messages, new HumanMessage2(state.userInput), new AIMessage(conclusion)]
       };
     }
   }
-  const workflow = new StateGraph(AgentStateAnnotation).addNode("inspect_schema", inspectSchemaNode).addNode("identify_targets", identifyTargetsNode).addNode("generate_query", generateQueryNode).addNode("classify_safety", classifySafetyNode).addNode("request_confirmation", requestConfirmationNode).addNode("execute_query", executeQueryNode).addNode("analyze_results", analyzeResultsNode).addNode("produce_conclusion", produceConclusionNode).addEdge(START, "inspect_schema").addEdge("inspect_schema", "identify_targets").addEdge("identify_targets", "generate_query").addEdge("generate_query", "classify_safety").addEdge("classify_safety", "request_confirmation").addConditionalEdges("request_confirmation", (state) => {
+  const workflow = new StateGraph(AgentStateAnnotation).addNode("inspect_schema", inspectSchemaNode).addNode("determine_action", determineActionNode).addNode("identify_targets", identifyTargetsNode).addNode("generate_query", generateQueryNode).addNode("classify_safety", classifySafetyNode).addNode("request_confirmation", requestConfirmationNode).addNode("execute_query", executeQueryNode).addNode("analyze_results", analyzeResultsNode).addNode("produce_conclusion", produceConclusionNode).addNode("answer_direct", answerDirectNode).addEdge(START, "inspect_schema").addEdge("inspect_schema", "determine_action").addConditionalEdges("determine_action", (state) => {
+    if (state.requiresQuery) {
+      return "identify_targets";
+    }
+    return "answer_direct";
+  }).addEdge("identify_targets", "generate_query").addEdge("generate_query", "classify_safety").addEdge("classify_safety", "request_confirmation").addConditionalEdges("request_confirmation", (state) => {
     if (state.confirmed && !state.cancelReason) {
       return "execute_query";
     }
     return "produce_conclusion";
-  }).addEdge("execute_query", "analyze_results").addEdge("analyze_results", "produce_conclusion").addEdge("produce_conclusion", END);
+  }).addEdge("execute_query", "analyze_results").addEdge("analyze_results", "produce_conclusion").addEdge("produce_conclusion", END).addEdge("answer_direct", END);
   const checkpointer = new MemorySaver();
   const app = workflow.compile({ checkpointer });
   return app;
@@ -2050,19 +2593,19 @@ ${conclusion}` : conclusion;
 // src/markdown.ts
 import { Marked } from "marked";
 import { markedTerminal } from "marked-terminal";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 function createMarkdownRenderer(options = {}) {
   const terminalOptions = {
-    heading: chalk2.bold.cyan,
-    firstHeading: chalk2.bold.cyan.underline,
-    codespan: chalk2.yellow,
-    code: chalk2.yellow,
-    blockquote: chalk2.gray.italic,
+    heading: chalk3.bold.cyan,
+    firstHeading: chalk3.bold.cyan.underline,
+    codespan: chalk3.yellow,
+    code: chalk3.yellow,
+    blockquote: chalk3.gray.italic,
     hr: (input3) => {
       const w = Math.min(options.width ?? (process.stdout.columns || 80), 80);
-      return chalk2.gray(input3 && input3.trim() ? input3 : "\u2500".repeat(w));
+      return chalk3.gray(input3 && input3.trim() ? input3 : "\u2500".repeat(w));
     },
-    table: chalk2.reset,
+    table: chalk3.reset,
     tableOptions: {
       style: {
         head: ["cyan", "bold"],
@@ -2248,6 +2791,10 @@ var ChatMemoryManager = class {
         if (m.query) {
           text = `[Executed Query: ${m.query}]
 ${text}`;
+        }
+        if (m.resultSample && m.resultSample.length > 0) {
+          text += `
+[Previous Query Results Sample: ${JSON.stringify(m.resultSample.slice(0, 10))}]`;
         }
         result.push(new AIMessage2(text));
       }
@@ -2266,7 +2813,8 @@ ${text}`;
     return recent.map((m) => {
       const prefix = m.role === "user" ? "User:" : "Assistant:";
       const q = m.query ? ` (Query: ${m.query})` : "";
-      return `${prefix} ${m.content}${q}`;
+      const rc = typeof m.rowCount === "number" ? ` (${m.rowCount} rows)` : "";
+      return `${prefix} ${m.content}${q}${rc}`;
     }).join("\n");
   }
   /**
@@ -2312,6 +2860,8 @@ var ReplSession = class {
   agent;
   memoryManager;
   classifierOptions;
+  rl;
+  currentSpinner;
   constructor(options) {
     this.adapter = options.adapter;
     this.model = options.model;
@@ -2327,11 +2877,7 @@ var ReplSession = class {
       allowFullWipe: this.allowFullWipe,
       rowThresholdForDangerousUpdate: this.rowThreshold
     };
-    this.agent = createDatabaseAgent({
-      adapter: this.adapter,
-      model: this.model,
-      classifierOptions: this.classifierOptions
-    });
+    this.initAgent();
     this.memoryManager = new ChatMemoryManager();
     const initialSession = this.memoryManager.createSession("New Chat", this.adapter.connectionUrl);
     this.sessionId = initialSession.id;
@@ -2339,21 +2885,55 @@ var ReplSession = class {
       addSavedConnection(this.adapter.connectionUrl);
     }
   }
+  initAgent() {
+    this.agent = createDatabaseAgent({
+      adapter: this.adapter,
+      model: this.model,
+      classifierOptions: this.classifierOptions,
+      confirmFn: async (query, safety, affectedRows) => {
+        if (this.currentSpinner && this.currentSpinner.isSpinning) {
+          this.currentSpinner.stop();
+        }
+        const confirmResult = await requestUserConfirmation(
+          query,
+          safety,
+          affectedRows,
+          this.askQuestion.bind(this)
+        );
+        if (confirmResult.confirmed && this.currentSpinner) {
+          this.currentSpinner.text = chalk4.cyan("Executing query and analyzing...");
+          this.currentSpinner.start();
+        }
+        return confirmResult;
+      }
+    });
+  }
+  askQuestion(query) {
+    process.stdin.resume();
+    if (!this.rl || this.rl.closed) {
+      this.rl = readline2.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true
+      });
+    }
+    return new Promise((resolve) => this.rl.question(query, resolve));
+  }
   getPromptText() {
-    return chalk3.cyan(`sandal [${this.adapter.type}]> `);
+    return chalk4.cyan(`sandal [${this.adapter.type}]> `);
   }
   async start() {
     this.setupSignalHandlers();
     this.printWelcomeBanner();
-    const rl = readline.createInterface({
+    process.stdin.resume();
+    this.rl = readline2.createInterface({
       input: process.stdin,
       output: process.stdout,
       terminal: true
     });
-    const askQuestion = (query) => {
-      return new Promise((resolve) => rl.question(query, resolve));
-    };
+    const askQuestion = this.askQuestion.bind(this);
     while (this.isRunning) {
+      process.stdin.resume();
       const input3 = await askQuestion(this.getPromptText());
       const trimmed = input3.trim();
       if (!trimmed) continue;
@@ -2378,12 +2958,12 @@ var ReplSession = class {
         continue;
       }
       if (trimmed === ".refresh") {
-        const spinner = ora(chalk3.blue("Refreshing schema cache...")).start();
+        const spinner = ora(chalk4.blue("Refreshing schema cache...")).start();
         try {
           await this.adapter.inspectSchema(true);
-          spinner.succeed(chalk3.green("Schema refreshed successfully."));
+          spinner.succeed(chalk4.green("Schema refreshed successfully."));
         } catch (err) {
-          spinner.fail(chalk3.red(`Failed to refresh schema: ${err.message}`));
+          spinner.fail(chalk4.red(`Failed to refresh schema: ${err.message}`));
         }
         continue;
       }
@@ -2437,18 +3017,18 @@ var ReplSession = class {
         this.handleClearChat();
         continue;
       }
-      const intentSpinner = ora(chalk3.blue("Analyzing intent...")).start();
+      const intentSpinner = ora(chalk4.blue("Analyzing intent...")).start();
       const historySummary = this.memoryManager.getRecentSummary(this.sessionId, 4);
       const intent = await classifyIntent(trimmed, this.model, historySummary);
       intentSpinner.stop();
       if (!intent.isDatabaseTask) {
         console.log(
           boxen2(
-            `${chalk3.bold.red("\u{1F6E1}\uFE0F GUARDRAIL ENFORCEMENT")}
+            `${chalk4.bold.red("\u{1F6E1}\uFE0F GUARDRAIL ENFORCEMENT")}
 
-${chalk3.yellow(REFUSAL_MESSAGE)}
+${chalk4.yellow(REFUSAL_MESSAGE)}
 
-${chalk3.gray(
+${chalk4.gray(
               `Reason: ${intent.reason || "Non-database request rejected"}`
             )}`,
             {
@@ -2461,7 +3041,8 @@ ${chalk3.gray(
         );
         continue;
       }
-      const agentSpinner = ora(chalk3.cyan("Agent planning query...")).start();
+      const agentSpinner = ora(chalk4.cyan("Agent thinking...")).start();
+      this.currentSpinner = agentSpinner;
       try {
         const historyMessages = this.memoryManager.toLangChainMessages(this.sessionId, 6);
         const result = await this.agent.invoke(
@@ -2475,16 +3056,18 @@ ${chalk3.gray(
             }
           }
         );
-        agentSpinner.stop();
-        if (result.queryResult && result.queryResult.success && result.queryResult.rows) {
+        if (agentSpinner.isSpinning) {
+          agentSpinner.stop();
+        }
+        if (result.queryExecuted && result.queryResult && result.queryResult.success && result.queryResult.rows) {
           this.renderRowsTable(result.queryResult);
         }
         if (result.conclusion) {
-          console.log("\n" + chalk3.green("\u{1F916} Answer:"));
+          console.log("\n" + chalk4.green("\u{1F916} Answer:"));
           if (this.renderMarkdown) {
             console.log(renderMarkdown(result.conclusion) + "\n");
           } else {
-            console.log(chalk3.white(result.conclusion) + "\n");
+            console.log(chalk4.white(result.conclusion) + "\n");
           }
         }
         this.memoryManager.addMessage(
@@ -2493,47 +3076,62 @@ ${chalk3.gray(
           this.adapter.connectionUrl
         );
         if (result.conclusion) {
-          const queryStr = result.generatedQuery?.sql || result.generatedQuery?.rawDisplay;
+          const queryStr = result.queryExecuted ? result.generatedQuery?.sql || result.generatedQuery?.rawDisplay : void 0;
           this.memoryManager.addMessage(
             this.sessionId,
             {
               role: "assistant",
               content: result.conclusion,
               query: queryStr,
-              rowCount: result.queryResult?.rowCount
+              rowCount: result.queryExecuted ? result.queryResult?.rowCount : void 0,
+              resultSample: result.queryExecuted ? result.queryResult?.rows?.slice(0, 15) : void 0
             },
             this.adapter.connectionUrl
           );
         }
       } catch (err) {
-        agentSpinner.fail(chalk3.red(`Execution failed: ${err.message}`));
+        if (agentSpinner.isSpinning) {
+          agentSpinner.fail(chalk4.red(`Execution failed: ${err.message}`));
+        } else {
+          console.error(chalk4.red(`
+Execution failed: ${err.message}
+`));
+        }
+      } finally {
+        if (agentSpinner.isSpinning) {
+          agentSpinner.stop();
+        }
+        this.currentSpinner = void 0;
+        process.stdin.resume();
       }
     }
-    rl.close();
+    if (this.rl && !this.rl.closed) {
+      this.rl.close();
+    }
     await this.shutdown();
   }
   async handleSwitchConnection(targetUrl, ask) {
     let urlToConnect = targetUrl;
     if (!urlToConnect) {
       const saved = getSavedConnections();
-      console.log(chalk3.bold.cyan("\nDatabase Connections:"));
+      console.log(chalk4.bold.cyan("\nDatabase Connections:"));
       if (saved.length === 0) {
-        console.log(chalk3.gray("  (No previous connections saved)"));
+        console.log(chalk4.gray("  (No previous connections saved)"));
       } else {
         saved.forEach((url, i) => {
           const isCurrent = url === this.adapter.connectionUrl;
-          const currentTag = isCurrent ? chalk3.green(" (Current)") : "";
+          const currentTag = isCurrent ? chalk4.green(" (Current)") : "";
           console.log(`  [${i + 1}] ${maskUrl(url)}${currentTag}`);
         });
       }
-      console.log(chalk3.gray("  [N] Enter a new connection URL"));
-      console.log(chalk3.gray("  [C] Cancel\n"));
-      const choice = (await ask(chalk3.cyan("Select a connection [number, N, C]: "))).trim();
+      console.log(chalk4.gray("  [N] Enter a new connection URL"));
+      console.log(chalk4.gray("  [C] Cancel\n"));
+      const choice = (await ask(chalk4.cyan("Select a connection [number, N, C]: "))).trim();
       if (!choice || choice.toLowerCase() === "c") {
         return;
       }
       if (choice.toLowerCase() === "n") {
-        const entered = (await ask(chalk3.cyan("Enter database connection URL: "))).trim();
+        const entered = (await ask(chalk4.cyan("Enter database connection URL: "))).trim();
         if (!entered) return;
         urlToConnect = entered;
       } else {
@@ -2541,19 +3139,19 @@ ${chalk3.gray(
         if (!isNaN(num) && num >= 1 && num <= saved.length) {
           urlToConnect = saved[num - 1];
         } else {
-          console.log(chalk3.red("Invalid selection."));
+          console.log(chalk4.red("Invalid selection."));
           return;
         }
       }
     }
     if (urlToConnect === this.adapter.connectionUrl && this.adapter.isConnected()) {
-      console.log(chalk3.yellow("\nAlready connected to this database.\n"));
+      console.log(chalk4.yellow("\nAlready connected to this database.\n"));
       return;
     }
     try {
       detectDatabaseType(urlToConnect);
     } catch (e) {
-      console.log(chalk3.red(`Invalid connection URL: ${e.message}`));
+      console.log(chalk4.red(`Invalid connection URL: ${e.message}`));
       return;
     }
     const spinner = ora(`Connecting to ${maskUrl(urlToConnect)}...`).start();
@@ -2566,58 +3164,53 @@ ${chalk3.gray(
       } catch {
       }
       this.adapter = newAdapter;
-      this.agent = createDatabaseAgent({
-        adapter: this.adapter,
-        model: this.model,
-        classifierOptions: this.classifierOptions
-      });
+      this.initAgent();
       addSavedConnection(urlToConnect);
       spinner.succeed(
-        chalk3.green(
+        chalk4.green(
           `Switched to ${newAdapter.type.toUpperCase()} database: ${newAdapter.databaseName} (${newAdapter.getMaskedUrl()})`
         )
       );
       console.log(
-        chalk3.gray(
+        chalk4.gray(
           `Chat session [${this.sessionId}] continuing with conversation memory on the new database.
 `
         )
       );
     } catch (err) {
-      spinner.fail(chalk3.red(`Failed to connect to database: ${err.message}`));
+      spinner.fail(chalk4.red(`Failed to connect to database: ${err.message}`));
     }
   }
   async handleModelCommand(newModel, ask) {
     let targetModel = newModel;
     if (!targetModel) {
       console.log(
-        chalk3.bold.cyan(`
-Current Model: `) + chalk3.white(this.modelName) + chalk3.gray(` (${this.provider})`)
+        chalk4.bold.cyan(`
+Current Model: `) + chalk4.white(this.modelName) + chalk4.gray(` (${this.provider})`)
       );
-      console.log(chalk3.bold.yellow("Suggested models for " + this.provider + ":"));
-      const commonModels = {
-        google: ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-2.0-flash"],
-        openai: ["gpt-4o", "gpt-4o-mini", "o3-mini"],
-        anthropic: [
-          "claude-3-5-sonnet-latest",
-          "claude-3-5-haiku-latest",
-          "claude-3-7-sonnet-latest"
-        ]
-      };
-      const list = commonModels[this.provider] || [];
+      console.log(chalk4.bold.yellow(`
+Available models for ${this.provider.toUpperCase()}:`));
+      const list = getModelsForProvider(this.provider);
       list.forEach((m, i) => {
-        const isCurrent = m === this.modelName ? chalk3.green(" (Current)") : "";
-        console.log(`  [${i + 1}] ${m}${isCurrent}`);
+        const isCurrent = m.id === this.modelName ? chalk4.green(" (Current)") : "";
+        const rec = m.recommended ? chalk4.yellow(" [\u2605 Recommended]") : "";
+        const badge = m.badge ? chalk4.dim(` [${m.badge}]`) : "";
+        console.log(
+          `  [${i + 1}] ${chalk4.bold(m.id)}${rec}${badge}${isCurrent}
+      ${chalk4.gray(
+            `${m.name} (${m.contextWindow}) \u2014 ${m.description}`
+          )}`
+        );
       });
-      console.log(chalk3.gray("  [O] Other (type custom model name)"));
-      console.log(chalk3.gray("  [C] Cancel\n"));
-      const input3 = (await ask(chalk3.cyan("Select model [number, name, C]: "))).trim();
+      console.log(chalk4.gray("  [O] Other (type custom model name)"));
+      console.log(chalk4.gray("  [C] Cancel\n"));
+      const input3 = (await ask(chalk4.cyan("Select model [number, name, C]: "))).trim();
       if (!input3 || input3.toLowerCase() === "c") return;
       const num = parseInt(input3, 10);
       if (!isNaN(num) && num >= 1 && num <= list.length) {
-        targetModel = list[num - 1];
+        targetModel = list[num - 1].id;
       } else if (input3.toLowerCase() === "o") {
-        const custom = (await ask(chalk3.cyan("Enter model name: "))).trim();
+        const custom = (await ask(chalk4.cyan("Enter model name: "))).trim();
         if (!custom) return;
         targetModel = custom;
       } else {
@@ -2629,11 +3222,11 @@ Current Model: `) + chalk3.white(this.modelName) + chalk3.gray(` (${this.provide
       if (resolved.apiKey) {
         this.apiKey = resolved.apiKey;
       } else {
-        console.log(chalk3.yellow(`
+        console.log(chalk4.yellow(`
 No API key found for ${this.provider.toUpperCase()}.`));
-        this.apiKey = (await ask(chalk3.cyan(`Enter API key for ${this.provider.toUpperCase()}: `))).trim();
+        this.apiKey = (await ask(chalk4.cyan(`Enter API key for ${this.provider.toUpperCase()}: `))).trim();
         if (!this.apiKey) {
-          console.log(chalk3.red("API key is required."));
+          console.log(chalk4.red("API key is required."));
           return;
         }
       }
@@ -2645,92 +3238,129 @@ No API key found for ${this.provider.toUpperCase()}.`));
         apiKey: this.apiKey
       });
       this.modelName = targetModel;
-      this.agent = createDatabaseAgent({
-        adapter: this.adapter,
-        model: this.model,
-        classifierOptions: this.classifierOptions
-      });
-      console.log(chalk3.green(`
+      this.initAgent();
+      console.log(chalk4.green(`
 Updated active model to: ${targetModel} [${this.provider}]
 `));
     } catch (err) {
-      console.log(chalk3.red(`
+      console.log(chalk4.red(`
 Failed to update model: ${err.message}
 `));
     }
   }
   async handleProviderCommand(newProvider, ask) {
-    let p = newProvider.toLowerCase();
+    let p = newProvider.toLowerCase().trim();
     if (!["google", "openai", "anthropic"].includes(p)) {
-      console.log(chalk3.bold.cyan(`
-Current Provider: `) + chalk3.blue(this.provider));
+      console.log(chalk4.bold.cyan(`
+Current Provider: `) + chalk4.blue(this.provider));
       console.log("Available providers:");
       console.log("  [1] Google Gemini (google)");
       console.log("  [2] OpenAI (openai)");
       console.log("  [3] Anthropic (anthropic)");
       console.log("  [C] Cancel\n");
-      const ans = (await ask(chalk3.cyan("Select provider [1-3, name, C]: "))).trim().toLowerCase();
+      const ans = (await ask(chalk4.cyan("Select provider [1-3, name, C]: "))).trim().toLowerCase();
       if (!ans || ans === "c") return;
       if (ans === "1" || ans === "google") p = "google";
       else if (ans === "2" || ans === "openai") p = "openai";
       else if (ans === "3" || ans === "anthropic") p = "anthropic";
       else {
-        console.log(chalk3.red("Invalid provider."));
+        console.log(chalk4.red("Invalid provider."));
         return;
       }
     }
-    const resolved = resolveCredentials({ cliProvider: p });
-    let key = resolved.apiKey;
-    if (!key) {
-      console.log(chalk3.yellow(`
-No API key found for ${p.toUpperCase()}.`));
-      key = (await ask(chalk3.cyan(`Enter API key for ${p.toUpperCase()}: `))).trim();
-      if (!key) {
-        console.log(chalk3.red("API key cannot be empty."));
-        return;
+    const typedProvider = p;
+    let key = getStoredApiKeyForProvider(typedProvider);
+    if (key) {
+      console.log(
+        chalk4.gray(`Found stored API key for ${typedProvider.toUpperCase()} (${maskApiKey(key)})`)
+      );
+    } else {
+      console.log(chalk4.yellow(`
+No stored API key found for ${typedProvider.toUpperCase()}.`));
+      key = (await ask(chalk4.cyan(`Enter API key for ${typedProvider.toUpperCase()}: `))).trim();
+      while (!key) {
+        console.log(chalk4.red("API key cannot be empty."));
+        key = (await ask(chalk4.cyan(`Enter API key for ${typedProvider.toUpperCase()} (or C to cancel): `))).trim();
+        if (key.toLowerCase() === "c") return;
       }
-      const save = (await ask(chalk3.cyan("Save this API key to ~/.sandal/config.json? (Y/n): "))).trim().toLowerCase();
+      const save = (await ask(chalk4.cyan("Save this API key to ~/.sandal/config.json? (Y/n): "))).trim().toLowerCase();
       if (save !== "n") {
-        if (p === "google") writeConfig({ geminiApiKey: key, defaultProvider: "google" });
-        else if (p === "openai") writeConfig({ openaiApiKey: key, defaultProvider: "openai" });
-        else if (p === "anthropic") writeConfig({ anthropicApiKey: key, defaultProvider: "anthropic" });
+        if (typedProvider === "google") writeConfig({ geminiApiKey: key });
+        else if (typedProvider === "openai") writeConfig({ openaiApiKey: key });
+        else if (typedProvider === "anthropic") writeConfig({ anthropicApiKey: key });
       }
     }
-    const defaultModel = getDefaultModelForProvider(p);
+    const providerModels = getModelsForProvider(typedProvider);
+    console.log(chalk4.bold.yellow(`
+Available models for ${typedProvider.toUpperCase()}:`));
+    providerModels.forEach((m, i) => {
+      const isCurrent = typedProvider === this.provider && m.id === this.modelName ? chalk4.green(" (Current)") : "";
+      const rec = m.recommended ? chalk4.yellow(" [\u2605 Recommended]") : "";
+      const badge = m.badge ? chalk4.dim(` [${m.badge}]`) : "";
+      console.log(
+        `  [${i + 1}] ${chalk4.bold(m.id)}${rec}${badge}${isCurrent}
+      ${chalk4.gray(
+          `${m.name} (${m.contextWindow}) \u2014 ${m.description}`
+        )}`
+      );
+    });
+    const defaultModel = getDefaultModelForProvider(typedProvider);
+    console.log(chalk4.gray(`  [Enter] Default (${defaultModel})`));
+    console.log(chalk4.gray("  [O] Other (type custom model name)"));
+    console.log(chalk4.gray("  [C] Cancel\n"));
+    const choice = (await ask(chalk4.cyan(`Select model [1-${providerModels.length}, name, Enter]: `))).trim();
+    if (choice.toLowerCase() === "c") return;
+    let targetModel = defaultModel;
+    const mNum = parseInt(choice, 10);
+    if (!isNaN(mNum) && mNum >= 1 && mNum <= providerModels.length) {
+      targetModel = providerModels[mNum - 1].id;
+    } else if (choice.toLowerCase() === "o") {
+      const custom = (await ask(chalk4.cyan("Enter custom model name: "))).trim();
+      if (!custom) return;
+      targetModel = custom;
+    } else if (choice) {
+      targetModel = choice;
+    }
+    const saveDefault = (await ask(chalk4.cyan(`Save ${typedProvider.toUpperCase()} and ${targetModel} as your default in ~/.sandal/config.json? (y/N): `))).trim().toLowerCase();
+    if (saveDefault === "y" || saveDefault === "yes") {
+      writeConfig({
+        defaultProvider: typedProvider,
+        defaultModel: targetModel
+      });
+      console.log(chalk4.green("Saved default provider and model to ~/.sandal/config.json."));
+    }
     try {
       this.model = createChatModel({
-        provider: p,
-        model: defaultModel,
+        provider: typedProvider,
+        model: targetModel,
         apiKey: key
       });
-      this.provider = p;
-      this.modelName = defaultModel;
+      this.provider = typedProvider;
+      this.modelName = targetModel;
       this.apiKey = key;
-      this.agent = createDatabaseAgent({
-        adapter: this.adapter,
-        model: this.model,
-        classifierOptions: this.classifierOptions
-      });
+      this.initAgent();
       console.log(
-        chalk3.green(`
-Switched provider to ${p.toUpperCase()} with model ${defaultModel}.
-`)
+        chalk4.green(
+          `
+Switched provider to ${chalk4.bold(typedProvider.toUpperCase())} with model ${chalk4.bold(targetModel)}.
+`
+        )
       );
     } catch (err) {
-      console.log(chalk3.red(`Failed to switch provider: ${err.message}
+      console.log(chalk4.red(`Failed to switch provider: ${err.message}
 `));
     }
   }
   async handleKeyCommand(arg, ask) {
     const sub = arg.toLowerCase().trim();
     if (sub === "remove" || sub === "clear" || sub === "delete") {
-      const confirmAns = (await ask(chalk3.yellow(`Remove stored API key for provider "${this.provider}"? (y/N): `))).trim().toLowerCase();
+      const confirmAns = (await ask(chalk4.yellow(`Remove stored API key for provider "${this.provider}"? (y/N): `))).trim().toLowerCase();
       if (confirmAns === "y" || confirmAns === "yes") {
         removeApiKey(this.provider);
         this.apiKey = void 0;
-        console.log(chalk3.green(`
+        console.log(chalk4.green(`
 Removed stored API key for "${this.provider}" from ~/.sandal/config.json.`));
-        console.log(chalk3.gray(`Subsequent requests with this provider will prompt for a key.
+        console.log(chalk4.gray(`Subsequent requests with this provider will prompt for a key.
 `));
       }
       return;
@@ -2738,10 +3368,10 @@ Removed stored API key for "${this.provider}" from ~/.sandal/config.json.`));
     if (sub.startsWith("set")) {
       let newKey = sub.replace(/^set\s*/, "").trim();
       if (!newKey) {
-        newKey = (await ask(chalk3.cyan(`Enter new API key for ${this.provider}: `))).trim();
+        newKey = (await ask(chalk4.cyan(`Enter new API key for ${this.provider}: `))).trim();
       }
       if (!newKey) {
-        console.log(chalk3.red("API key cannot be empty."));
+        console.log(chalk4.red("API key cannot be empty."));
         return;
       }
       this.apiKey = newKey;
@@ -2753,55 +3383,47 @@ Removed stored API key for "${this.provider}" from ~/.sandal/config.json.`));
         model: this.modelName,
         apiKey: newKey
       });
-      this.agent = createDatabaseAgent({
-        adapter: this.adapter,
-        model: this.model,
-        classifierOptions: this.classifierOptions
-      });
-      console.log(chalk3.green(`
+      this.initAgent();
+      console.log(chalk4.green(`
 Updated API key for "${this.provider}" and refreshed model.
 `));
       return;
     }
-    console.log(chalk3.bold.cyan("\nAPI Key Status:"));
-    console.log(`  Provider:   ${chalk3.blue(this.provider)}`);
-    console.log(`  Model:      ${chalk3.white(this.modelName)}`);
+    console.log(chalk4.bold.cyan("\nAPI Key Status:"));
+    console.log(`  Provider:   ${chalk4.blue(this.provider)}`);
+    console.log(`  Model:      ${chalk4.white(this.modelName)}`);
     console.log(
-      `  Active Key: ${this.apiKey ? chalk3.yellow(maskApiKey(this.apiKey)) : chalk3.red("None (not set)")}`
+      `  Active Key: ${this.apiKey ? chalk4.yellow(maskApiKey(this.apiKey)) : chalk4.red("None (not set)")}`
     );
-    console.log(chalk3.gray("\nUsage:"));
-    console.log(chalk3.gray("  .key remove         - Remove stored key from ~/.sandal/config.json"));
-    console.log(chalk3.gray("  .key set <api-key>  - Update API key on the fly\n"));
+    console.log(chalk4.gray("\nUsage:"));
+    console.log(chalk4.gray("  .key remove         - Remove stored key from ~/.sandal/config.json"));
+    console.log(chalk4.gray("  .key set <api-key>  - Update API key on the fly\n"));
   }
   handleListChats() {
     const list = this.memoryManager.listSessions();
     if (list.length === 0) {
-      console.log(chalk3.yellow("\nNo saved chat sessions found.\n"));
+      console.log(chalk4.yellow("\nNo saved chat sessions found.\n"));
       return;
     }
-    console.log(chalk3.bold.cyan("\nSaved Chat Sessions:"));
+    console.log(chalk4.bold.cyan("\nSaved Chat Sessions:"));
     list.forEach((s, i) => {
       const isActive = s.id === this.sessionId;
-      const activeMarker = isActive ? chalk3.green(" [ACTIVE]") : "";
+      const activeMarker = isActive ? chalk4.green(" [ACTIVE]") : "";
       const dateStr = new Date(s.updatedAt).toLocaleString();
       console.log(
-        `  [${i + 1}] ${chalk3.bold(s.title)}${activeMarker}
-      ID: ${chalk3.gray(s.id)} | ${chalk3.yellow(s.messageCount + " messages")} | ${chalk3.gray(dateStr)}`
+        `  [${i + 1}] ${chalk4.bold(s.title)}${activeMarker}
+      ID: ${chalk4.gray(s.id)} | ${chalk4.yellow(s.messageCount + " messages")} | ${chalk4.gray(dateStr)}`
       );
     });
-    console.log(chalk3.gray("\nCommands: .chat <id|num> to switch, .new to start fresh chat\n"));
+    console.log(chalk4.gray("\nCommands: .chat <id|num> to switch, .new to start fresh chat\n"));
   }
   handleNewChat() {
     const newSession = this.memoryManager.createSession("New Chat", this.adapter.connectionUrl);
     this.sessionId = newSession.id;
-    this.agent = createDatabaseAgent({
-      adapter: this.adapter,
-      model: this.model,
-      classifierOptions: this.classifierOptions
-    });
-    console.log(chalk3.green(`
+    this.initAgent();
+    console.log(chalk4.green(`
 Started fresh chat session: ${this.sessionId}`));
-    console.log(chalk3.gray("Chat memory is clean for this new session.\n"));
+    console.log(chalk4.gray("Chat memory is clean for this new session.\n"));
   }
   handleSwitchChat(arg) {
     const list = this.memoryManager.listSessions();
@@ -2816,26 +3438,22 @@ Started fresh chat session: ${this.sessionId}`));
       if (found) targetId = found.id;
     }
     if (!targetId) {
-      console.log(chalk3.red(`
+      console.log(chalk4.red(`
 Chat session "${arg}" not found. Use .chats to list sessions.
 `));
       return;
     }
     const session = this.memoryManager.getSession(targetId);
     if (!session) {
-      console.log(chalk3.red(`
+      console.log(chalk4.red(`
 Could not load chat session "${targetId}".
 `));
       return;
     }
     this.sessionId = session.id;
-    this.agent = createDatabaseAgent({
-      adapter: this.adapter,
-      model: this.model,
-      classifierOptions: this.classifierOptions
-    });
+    this.initAgent();
     console.log(
-      chalk3.green(
+      chalk4.green(
         `
 Switched to chat: "${session.title}" (${session.messages.length} messages in memory).
 `
@@ -2845,46 +3463,42 @@ Switched to chat: "${session.title}" (${session.messages.length} messages in mem
   handleShowHistory() {
     const session = this.memoryManager.getSession(this.sessionId);
     if (!session || session.messages.length === 0) {
-      console.log(chalk3.yellow(`
+      console.log(chalk4.yellow(`
 No message history in current chat (${this.sessionId}).
 `));
       return;
     }
-    console.log(chalk3.bold.cyan(`
+    console.log(chalk4.bold.cyan(`
 Chat History: "${session.title}" [${this.sessionId}]:`));
-    console.log(chalk3.gray("\u2500".repeat(60)));
+    console.log(chalk4.gray("\u2500".repeat(60)));
     for (const msg of session.messages) {
       const time = new Date(msg.timestamp).toLocaleTimeString();
       if (msg.role === "user") {
-        console.log(`${chalk3.bold.blue("\u{1F464} User")} ${chalk3.gray(`(${time})`)}:
+        console.log(`${chalk4.bold.blue("\u{1F464} User")} ${chalk4.gray(`(${time})`)}:
   ${msg.content}`);
       } else if (msg.role === "assistant") {
         if (msg.query) {
-          console.log(`  ${chalk3.gray(`[Query: ${msg.query}]`)}`);
+          console.log(`  ${chalk4.gray(`[Query: ${msg.query}]`)}`);
         }
-        console.log(`${chalk3.bold.green("\u{1F916} Assistant")} ${chalk3.gray(`(${time})`)}:
+        console.log(`${chalk4.bold.green("\u{1F916} Assistant")} ${chalk4.gray(`(${time})`)}:
   ${msg.content}`);
       }
-      console.log(chalk3.gray("\u2500".repeat(60)));
+      console.log(chalk4.gray("\u2500".repeat(60)));
     }
     console.log("");
   }
   handleClearChat() {
     this.memoryManager.clearSession(this.sessionId);
-    this.agent = createDatabaseAgent({
-      adapter: this.adapter,
-      model: this.model,
-      classifierOptions: this.classifierOptions
-    });
-    console.log(chalk3.green(`
+    this.initAgent();
+    console.log(chalk4.green(`
 Chat memory for session [${this.sessionId}] has been cleared.
 `));
   }
   handleRenderMarkdown(arg) {
     if (!arg) {
-      console.log(chalk3.yellow("Usage: .md <markdown text or file path>"));
-      console.log(chalk3.gray("Example: .md # Hello World"));
-      console.log(chalk3.gray("Example: .md ./README.md"));
+      console.log(chalk4.yellow("Usage: .md <markdown text or file path>"));
+      console.log(chalk4.gray("Example: .md # Hello World"));
+      console.log(chalk4.gray("Example: .md ./README.md"));
       return;
     }
     try {
@@ -2900,21 +3514,21 @@ Chat memory for session [${this.sessionId}] has been cleared.
   renderRowsTable(queryResult) {
     const rows = queryResult.rows;
     if (!rows || rows.length === 0) {
-      console.log(chalk3.gray("(0 rows returned)"));
+      console.log(chalk4.gray("(0 rows returned)"));
       return;
     }
     const fields = queryResult.fields && queryResult.fields.length > 0 ? queryResult.fields : Object.keys(rows[0] || {});
     if (fields.length === 0) return;
     const displayRows = rows.slice(0, 25);
-    const table = new Table({
-      head: fields.map((f) => chalk3.cyan.bold(f)),
+    const table = new Table2({
+      head: fields.map((f) => chalk4.cyan.bold(f)),
       style: { head: [], border: ["gray"] }
     });
     for (const r of displayRows) {
       table.push(
         fields.map((f) => {
           const val = r[f];
-          if (val === null || val === void 0) return chalk3.gray("NULL");
+          if (val === null || val === void 0) return chalk4.gray("NULL");
           if (typeof val === "object") {
             try {
               return JSON.stringify(val);
@@ -2928,55 +3542,55 @@ Chat memory for session [${this.sessionId}] has been cleared.
     }
     console.log(table.toString());
     if (rows.length > 25) {
-      console.log(chalk3.yellow(`Showing first 25 of ${rows.length.toLocaleString()} rows.`));
+      console.log(chalk4.yellow(`Showing first 25 of ${rows.length.toLocaleString()} rows.`));
     }
     console.log(
-      chalk3.gray(
+      chalk4.gray(
         `Total rows: ${queryResult.rowCount ?? rows.length} | Execution duration: ${queryResult.durationMs}ms
 `
       )
     );
   }
   async handleListEntities() {
-    const spinner = ora(chalk3.blue("Inspecting schema...")).start();
+    const spinner = ora(chalk4.blue("Inspecting schema...")).start();
     try {
       const schema = await this.adapter.inspectSchema(false);
       spinner.stop();
       if (schema.type === "postgres") {
         const tables = schema.tables || [];
         if (tables.length === 0) {
-          console.log(chalk3.yellow("No tables found in public schema."));
+          console.log(chalk4.yellow("No tables found in public schema."));
           return;
         }
-        console.log(chalk3.bold.cyan(`
+        console.log(chalk4.bold.cyan(`
 Tables in "${schema.databaseName}":`));
         for (const t of tables) {
           console.log(
-            `  \u2022 ${chalk3.bold(t.name)} ${chalk3.gray(`(~${t.approximateRowCount ?? 0} rows, ${t.columns.length} columns)`)}`
+            `  \u2022 ${chalk4.bold(t.name)} ${chalk4.gray(`(~${t.approximateRowCount ?? 0} rows, ${t.columns.length} columns)`)}`
           );
         }
         console.log("");
       } else {
         const collections = schema.collections || [];
         if (collections.length === 0) {
-          console.log(chalk3.yellow("No collections found."));
+          console.log(chalk4.yellow("No collections found."));
           return;
         }
-        console.log(chalk3.bold.cyan(`
+        console.log(chalk4.bold.cyan(`
 Collections in "${schema.databaseName}":`));
         for (const c of collections) {
           console.log(
-            `  \u2022 ${chalk3.bold(c.name)} ${chalk3.gray(`(${c.documentCount ?? 0} docs, ${c.fields.length} sampled fields)`)}`
+            `  \u2022 ${chalk4.bold(c.name)} ${chalk4.gray(`(${c.documentCount ?? 0} docs, ${c.fields.length} sampled fields)`)}`
           );
         }
         console.log("");
       }
     } catch (err) {
-      spinner.fail(chalk3.red(`Failed to list entities: ${err.message}`));
+      spinner.fail(chalk4.red(`Failed to list entities: ${err.message}`));
     }
   }
   async handleShowSchema(entityName) {
-    const spinner = ora(chalk3.blue("Fetching schema details...")).start();
+    const spinner = ora(chalk4.blue("Fetching schema details...")).start();
     try {
       const schema = await this.adapter.inspectSchema(false);
       spinner.stop();
@@ -2989,14 +3603,14 @@ Collections in "${schema.databaseName}":`));
           (t) => t.name.toLowerCase() === entityName.toLowerCase()
         );
         if (!table) {
-          console.log(chalk3.red(`Table "${entityName}" not found.`));
+          console.log(chalk4.red(`Table "${entityName}" not found.`));
           return;
         }
-        console.log(chalk3.bold.cyan(`
+        console.log(chalk4.bold.cyan(`
 Schema for table: ${table.schema}.${table.name}`));
-        const tableDetails = new Table({
+        const tableDetails = new Table2({
           head: ["Column", "Data Type", "Nullable", "Primary Key", "Default"].map(
-            (h) => chalk3.cyan.bold(h)
+            (h) => chalk4.cyan.bold(h)
           )
         });
         for (const c of table.columns) {
@@ -3004,8 +3618,8 @@ Schema for table: ${table.schema}.${table.name}`));
             c.name,
             c.dataType,
             c.isNullable ? "YES" : "NO",
-            c.isPrimaryKey ? chalk3.green("YES") : "NO",
-            c.defaultValue ?? chalk3.gray("NULL")
+            c.isPrimaryKey ? chalk4.green("YES") : "NO",
+            c.defaultValue ?? chalk4.gray("NULL")
           ]);
         }
         console.log(tableDetails.toString());
@@ -3014,13 +3628,13 @@ Schema for table: ${table.schema}.${table.name}`));
           (c) => c.name.toLowerCase() === entityName.toLowerCase()
         );
         if (!collection) {
-          console.log(chalk3.red(`Collection "${entityName}" not found.`));
+          console.log(chalk4.red(`Collection "${entityName}" not found.`));
           return;
         }
-        console.log(chalk3.bold.cyan(`
+        console.log(chalk4.bold.cyan(`
 Schema for collection: ${collection.name}`));
-        const colDetails = new Table({
-          head: ["Field", "Inferred Types"].map((h) => chalk3.cyan.bold(h))
+        const colDetails = new Table2({
+          head: ["Field", "Inferred Types"].map((h) => chalk4.cyan.bold(h))
         });
         for (const f of collection.fields) {
           colDetails.push([f.name, f.types.join(", ")]);
@@ -3028,22 +3642,22 @@ Schema for collection: ${collection.name}`));
         console.log(colDetails.toString());
       }
     } catch (err) {
-      spinner.fail(chalk3.red(`Failed to inspect schema: ${err.message}`));
+      spinner.fail(chalk4.red(`Failed to inspect schema: ${err.message}`));
     }
   }
   printWelcomeBanner() {
     const banner = [
-      chalk3.bold.cyan("SANDAL: Safe Agentic Natural-language Database Access Layer"),
-      chalk3.gray("LangGraph + Multi-Provider AI (Gemini, OpenAI, Anthropic)"),
+      chalk4.bold.cyan("SANDAL: Safe Agentic Natural-language Database Access Layer"),
+      chalk4.gray("LangGraph + Multi-Provider AI (Gemini, OpenAI, Anthropic)"),
       "",
-      `${chalk3.bold("Database:")}      ${chalk3.green(this.adapter.type.toUpperCase())} (${this.adapter.getMaskedUrl()})`,
-      `${chalk3.bold("LLM Provider:")}  ${chalk3.blue(this.provider)} [${chalk3.white(this.modelName)}]`,
-      `${chalk3.bold("Chat Session:")}  ${chalk3.yellow(this.sessionId)}`,
-      `${chalk3.bold("Strict Mode:")}   ${this.strictMode ? chalk3.green("ON (Full wipes blocked)") : chalk3.yellow("OFF")}`,
-      `${chalk3.bold("Markdown:")}      ${this.renderMarkdown ? chalk3.green("ENABLED") : chalk3.gray("DISABLED")}`,
+      `${chalk4.bold("Database:")}      ${chalk4.green(this.adapter.type.toUpperCase())} (${this.adapter.getMaskedUrl()})`,
+      `${chalk4.bold("LLM Provider:")}  ${chalk4.blue(this.provider)} [${chalk4.white(this.modelName)}]`,
+      `${chalk4.bold("Chat Session:")}  ${chalk4.yellow(this.sessionId)}`,
+      `${chalk4.bold("Strict Mode:")}   ${this.strictMode ? chalk4.green("ON (Full wipes blocked)") : chalk4.yellow("OFF")}`,
+      `${chalk4.bold("Markdown:")}      ${this.renderMarkdown ? chalk4.green("ENABLED") : chalk4.gray("DISABLED")}`,
       "",
-      chalk3.gray("Type your natural language request or SQL/Mongo query."),
-      chalk3.gray("Commands: .connect, .model, .chats, .new, .history, .key, .help, exit")
+      chalk4.gray("Type your natural language request or SQL/Mongo query."),
+      chalk4.gray("Commands: .connect, .model, .chats, .new, .history, .key, .help, exit")
     ].join("\n");
     console.log(
       boxen2(banner, {
@@ -3058,26 +3672,26 @@ Schema for collection: ${collection.name}`));
     console.log(
       boxen2(
         [
-          chalk3.bold.cyan("SANDAL REPL Commands:"),
+          chalk4.bold.cyan("SANDAL REPL Commands:"),
           "",
-          `${chalk3.bold(".tables / .collections")}   List all tables or collections with row counts`,
-          `${chalk3.bold(".schema [name]")}           Show columns, types, and indexes for a table`,
-          `${chalk3.bold(".connect / .switch")}       Switch database connection (shows saved connections)`,
-          `${chalk3.bold(".model [name]")}            Change active LLM model on the fly`,
-          `${chalk3.bold(".provider [name]")}         Switch LLM provider (google, openai, anthropic)`,
-          `${chalk3.bold(".key [remove | set]")}      View, remove, or update API key`,
-          `${chalk3.bold(".chats")}                   List saved chat sessions`,
-          `${chalk3.bold(".chat <id | num>")}         Switch to another chat session`,
-          `${chalk3.bold(".new")}                     Start a fresh chat session with clear memory`,
-          `${chalk3.bold(".history")}                 Show conversation history for current chat`,
-          `${chalk3.bold(".clear-chat")}              Clear memory for current chat`,
-          `${chalk3.bold(".md [file | text]")}        Render markdown file or text in terminal`,
-          `${chalk3.bold(".refresh")}                 Force refresh cached schema introspection`,
-          `${chalk3.bold(".clear")}                   Clear terminal screen`,
-          `${chalk3.bold(".help")}                    Display this command reference`,
-          `${chalk3.bold("exit / quit")}              Gracefully disconnect and exit`,
+          `${chalk4.bold(".tables / .collections")}   List all tables or collections with row counts`,
+          `${chalk4.bold(".schema [name]")}           Show columns, types, and indexes for a table`,
+          `${chalk4.bold(".connect / .switch")}       Switch database connection (shows saved connections)`,
+          `${chalk4.bold(".model [name]")}            Change active LLM model on the fly`,
+          `${chalk4.bold(".provider [name]")}         Switch LLM provider (google, openai, anthropic)`,
+          `${chalk4.bold(".key [remove | set]")}      View, remove, or update API key`,
+          `${chalk4.bold(".chats")}                   List saved chat sessions`,
+          `${chalk4.bold(".chat <id | num>")}         Switch to another chat session`,
+          `${chalk4.bold(".new")}                     Start a fresh chat session with clear memory`,
+          `${chalk4.bold(".history")}                 Show conversation history for current chat`,
+          `${chalk4.bold(".clear-chat")}              Clear memory for current chat`,
+          `${chalk4.bold(".md [file | text]")}        Render markdown file or text in terminal`,
+          `${chalk4.bold(".refresh")}                 Force refresh cached schema introspection`,
+          `${chalk4.bold(".clear")}                   Clear terminal screen`,
+          `${chalk4.bold(".help")}                    Display this command reference`,
+          `${chalk4.bold("exit / quit")}              Gracefully disconnect and exit`,
           "",
-          chalk3.bold.yellow("Example Natural Language Requests:"),
+          chalk4.bold.yellow("Example Natural Language Requests:"),
           '  "Show top 10 users signed up in the last 30 days"',
           '  "Now count how many of them are active" (multi-turn follow-up)',
           '  "Calculate total revenue grouped by product category"',
@@ -3102,13 +3716,16 @@ Schema for collection: ${collection.name}`));
     process.on("SIGTERM", handleExit);
   }
   async shutdown() {
+    if (this.rl && !this.rl.closed) {
+      this.rl.close();
+    }
     if (this.adapter.isConnected()) {
       try {
         await this.adapter.disconnect();
       } catch {
       }
     }
-    console.log(chalk3.cyan("\nDatabase connection closed. Goodbye! \u{1F44B}\n"));
+    console.log(chalk4.cyan("\nDatabase connection closed. Goodbye! \u{1F44B}\n"));
   }
 };
 
@@ -3136,7 +3753,18 @@ program.name("sandal-db").description("SANDAL - Safe Agentic Natural-language Da
   "--markdown",
   "Render LLM answers formatted as terminal markdown (default: true)",
   true
-).option("--no-markdown", "Disable terminal markdown rendering").action(async (cliDbUrl, options) => {
+).option("--no-markdown", "Disable terminal markdown rendering").option(
+  "--select-model",
+  "Interactively choose a model from the list of available models"
+).option(
+  "--models [provider]",
+  "List all publicly available models in the terminal (google | openai | anthropic)"
+).action(async (cliDbUrl, options) => {
+  if (options.models !== void 0) {
+    const prov = typeof options.models === "string" && options.models.trim() ? options.models.toLowerCase() : options.provider ? options.provider.toLowerCase() : void 0;
+    console.log(renderModelsTable(prov));
+    return;
+  }
   try {
     await runCli({
       cliDbUrl,
@@ -3146,10 +3774,11 @@ program.name("sandal-db").description("SANDAL - Safe Agentic Natural-language Da
       strictMode: options.strict !== false,
       allowFullWipe: Boolean(options.allowFullWipe),
       rowThreshold: parseInt(options.threshold, 10) || 50,
-      renderMarkdown: options.markdown !== false
+      renderMarkdown: options.markdown !== false,
+      selectModel: Boolean(options.selectModel)
     });
   } catch (err) {
-    console.error(chalk4.red(`
+    console.error(chalk5.red(`
 Error: ${err.message}`));
     process.exit(1);
   }
@@ -3160,6 +3789,12 @@ var configCmd = program.command("config").description(
   "--set-provider <provider>",
   "Set default LLM provider (google | openai | anthropic)"
 ).option("--set-model <model>", "Set default model name").option(
+  "--select-model",
+  "Interactively select default model from the available models list"
+).option(
+  "--models [provider]",
+  "List all publicly available models in the terminal (google | openai | anthropic)"
+).option(
   "--set-markdown <boolean>",
   "Enable or disable default terminal markdown rendering (true | false)"
 ).option(
@@ -3174,7 +3809,22 @@ var configCmd = program.command("config").description(
 ).option(
   "--show",
   "Display current stored configuration (with masked secrets)"
-).option("--path", "Print the path to the configuration file").action((opts) => {
+).option("--path", "Print the path to the configuration file").action(async (opts) => {
+  if (opts.models !== void 0) {
+    const prov = typeof opts.models === "string" && opts.models.trim() ? opts.models.toLowerCase() : void 0;
+    console.log(renderModelsTable(prov));
+    return;
+  }
+  if (opts.selectModel) {
+    const cfg = readConfig();
+    const prov = opts.setProvider || cfg.defaultProvider || "google";
+    const chosen = await promptModelSelection(prov, cfg.defaultModel);
+    writeConfig({ defaultModel: chosen });
+    console.log(chalk5.green(`
+Updated default model to: ${chosen} (${prov})
+`));
+    return;
+  }
   if (opts.path) {
     console.log(getConfigFilePath());
     return;
@@ -3182,9 +3832,9 @@ var configCmd = program.command("config").description(
   if (opts.connections) {
     const list = getSavedConnections();
     if (list.length === 0) {
-      console.log(chalk4.yellow("\nNo saved database connections found.\n"));
+      console.log(chalk5.yellow("\nNo saved database connections found.\n"));
     } else {
-      console.log(chalk4.bold.cyan("\nSaved Database Connections:"));
+      console.log(chalk5.bold.cyan("\nSaved Database Connections:"));
       list.forEach((url, i) => {
         console.log(`  [${i + 1}] ${maskUrl(url)}`);
       });
@@ -3195,47 +3845,47 @@ var configCmd = program.command("config").description(
   if (opts.removeConnection) {
     const removed = removeSavedConnection(opts.removeConnection);
     if (removed) {
-      console.log(chalk4.green(`Removed connection from saved history.`));
+      console.log(chalk5.green(`Removed connection from saved history.`));
     } else {
-      console.log(chalk4.red(`Connection "${opts.removeConnection}" not found in history.`));
+      console.log(chalk5.red(`Connection "${opts.removeConnection}" not found in history.`));
     }
     return;
   }
   if (opts.removeKey !== void 0) {
     const prov = typeof opts.removeKey === "string" && opts.removeKey.trim() ? opts.removeKey.toLowerCase() : "all";
     removeApiKey(prov);
-    console.log(chalk4.green(`Removed API key for "${prov}" from ~/.sandal/config.json.`));
+    console.log(chalk5.green(`Removed API key for "${prov}" from ~/.sandal/config.json.`));
     return;
   }
   if (opts.show) {
     const cfg = readConfig();
     const saved = getSavedConnections();
     console.log(
-      chalk4.bold.cyan("\nSaved Configuration (~/.sandal/config.json):")
+      chalk5.bold.cyan("\nSaved Configuration (~/.sandal/config.json):")
     );
     console.log(
-      `  Database URL:       ${cfg.dbUrl ? chalk4.green(maskUrl(cfg.dbUrl)) : chalk4.gray("Not set")}`
+      `  Database URL:       ${cfg.dbUrl ? chalk5.green(maskUrl(cfg.dbUrl)) : chalk5.gray("Not set")}`
     );
     console.log(
-      `  Default Provider:   ${cfg.defaultProvider ? chalk4.blue(cfg.defaultProvider) : chalk4.gray("Not set (defaults to google)")}`
+      `  Default Provider:   ${cfg.defaultProvider ? chalk5.blue(cfg.defaultProvider) : chalk5.gray("Not set (defaults to google)")}`
     );
     console.log(
-      `  Default Model:      ${cfg.defaultModel ? chalk4.white(cfg.defaultModel) : chalk4.gray("Default for provider")}`
+      `  Default Model:      ${cfg.defaultModel ? chalk5.white(cfg.defaultModel) : chalk5.gray("Default for provider")}`
     );
     console.log(
-      `  Markdown Rendering: ${cfg.renderMarkdown !== false ? chalk4.green("enabled") : chalk4.yellow("disabled")}`
+      `  Markdown Rendering: ${cfg.renderMarkdown !== false ? chalk5.green("enabled") : chalk5.yellow("disabled")}`
     );
     console.log(
-      `  Saved Connections:  ${saved.length > 0 ? chalk4.cyan(`${saved.length} connection(s)`) : chalk4.gray("None")}`
+      `  Saved Connections:  ${saved.length > 0 ? chalk5.cyan(`${saved.length} connection(s)`) : chalk5.gray("None")}`
     );
     console.log(
-      `  Gemini Key:         ${cfg.geminiApiKey ? chalk4.yellow(maskApiKey(cfg.geminiApiKey)) : chalk4.gray("Not set")}`
+      `  Gemini Key:         ${cfg.geminiApiKey ? chalk5.yellow(maskApiKey(cfg.geminiApiKey)) : chalk5.gray("Not set")}`
     );
     console.log(
-      `  OpenAI Key:         ${cfg.openaiApiKey ? chalk4.yellow(maskApiKey(cfg.openaiApiKey)) : chalk4.gray("Not set")}`
+      `  OpenAI Key:         ${cfg.openaiApiKey ? chalk5.yellow(maskApiKey(cfg.openaiApiKey)) : chalk5.gray("Not set")}`
     );
     console.log(
-      `  Anthropic Key:      ${cfg.anthropicApiKey ? chalk4.yellow(maskApiKey(cfg.anthropicApiKey)) : chalk4.gray("Not set")}
+      `  Anthropic Key:      ${cfg.anthropicApiKey ? chalk5.yellow(maskApiKey(cfg.anthropicApiKey)) : chalk5.gray("Not set")}
 `
     );
     return;
@@ -3246,44 +3896,64 @@ var configCmd = program.command("config").description(
     updates.dbUrl = opts.setDb;
     addSavedConnection(opts.setDb);
     console.log(
-      chalk4.green(`Updated default database URL: ${maskUrl(opts.setDb)}`)
+      chalk5.green(`Updated default database URL: ${maskUrl(opts.setDb)}`)
     );
   }
   if (opts.setProvider) {
     const p = opts.setProvider.toLowerCase();
     if (!["google", "openai", "anthropic"].includes(p)) {
       console.error(
-        chalk4.red("Invalid provider. Expected google, openai, or anthropic.")
+        chalk5.red("Invalid provider. Expected google, openai, or anthropic.")
       );
       process.exit(1);
     }
     updates.defaultProvider = p;
-    console.log(chalk4.green(`Updated default provider: ${p}`));
+    console.log(chalk5.green(`Updated default provider: ${p}`));
+    const existingKey = getStoredApiKeyForProvider(p);
+    if (!existingKey && !opts.setKey && !opts.setGemini && !opts.setOpenai && !opts.setAnthropic) {
+      console.log(chalk5.yellow(`
+No stored API key found for ${p.toUpperCase()}.`));
+      const newKey = await input2({
+        message: `Enter API key for ${p.toUpperCase()}:`,
+        validate: (val) => val.trim().length > 0 ? true : "API key cannot be empty."
+      });
+      if (p === "google") updates.geminiApiKey = newKey.trim();
+      else if (p === "openai") updates.openaiApiKey = newKey.trim();
+      else if (p === "anthropic") updates.anthropicApiKey = newKey.trim();
+      console.log(chalk5.green(`Saved API key for ${p.toUpperCase()}.`));
+    }
+    if (!opts.setModel) {
+      console.log(chalk5.cyan(`
+Choose default model for ${p.toUpperCase()}:`));
+      const chosenModel = await promptModelSelection(p);
+      updates.defaultModel = chosenModel;
+      console.log(chalk5.green(`Updated default model for ${p}: ${chosenModel}`));
+    }
   }
   if (opts.setModel) {
     updates.defaultModel = opts.setModel;
-    console.log(chalk4.green(`Updated default model: ${opts.setModel}`));
+    console.log(chalk5.green(`Updated default model: ${opts.setModel}`));
   }
   if (opts.setMarkdown !== void 0) {
     const val = opts.setMarkdown.toLowerCase() === "true" || opts.setMarkdown === "1" || opts.setMarkdown === "yes";
     updates.renderMarkdown = val;
     console.log(
-      chalk4.green(
+      chalk5.green(
         `Updated default markdown rendering: ${val ? "enabled" : "disabled"}.`
       )
     );
   }
   if (opts.setGemini) {
     updates.geminiApiKey = opts.setGemini;
-    console.log(chalk4.green("Updated Gemini API key."));
+    console.log(chalk5.green("Updated Gemini API key."));
   }
   if (opts.setOpenai) {
     updates.openaiApiKey = opts.setOpenai;
-    console.log(chalk4.green("Updated OpenAI API key."));
+    console.log(chalk5.green("Updated OpenAI API key."));
   }
   if (opts.setAnthropic) {
     updates.anthropicApiKey = opts.setAnthropic;
-    console.log(chalk4.green("Updated Anthropic API key."));
+    console.log(chalk5.green("Updated Anthropic API key."));
   }
   if (opts.setKey) {
     const current = readConfig();
@@ -3291,11 +3961,11 @@ var configCmd = program.command("config").description(
     if (prov === "google") updates.geminiApiKey = opts.setKey;
     else if (prov === "openai") updates.openaiApiKey = opts.setKey;
     else if (prov === "anthropic") updates.anthropicApiKey = opts.setKey;
-    console.log(chalk4.green(`Updated API key for provider "${prov}".`));
+    console.log(chalk5.green(`Updated API key for provider "${prov}".`));
   }
   if (Object.keys(updates).length > 0) {
     writeConfig(updates);
-    console.log(chalk4.gray(`Saved to ${getConfigFilePath()}`));
+    console.log(chalk5.gray(`Saved to ${getConfigFilePath()}`));
   } else {
     configCmd.help();
   }
@@ -3311,13 +3981,13 @@ program.command("markdown [fileOrText]").alias("md").description("Render markdow
       content = Buffer.concat(chunks).toString("utf-8");
     } else {
       console.log(
-        chalk4.yellow(
+        chalk5.yellow(
           "\nUsage: sandal md <file | text> or pipe markdown to sandal md"
         )
       );
-      console.log(chalk4.gray("Example: sandal md README.md"));
-      console.log(chalk4.gray('Example: sandal md "# Hello World"'));
-      console.log(chalk4.gray("Example: cat notes.md | sandal md\n"));
+      console.log(chalk5.gray("Example: sandal md README.md"));
+      console.log(chalk5.gray('Example: sandal md "# Hello World"'));
+      console.log(chalk5.gray("Example: cat notes.md | sandal md\n"));
       return;
     }
   } else {
@@ -3347,7 +4017,7 @@ async function runCli(opts) {
   let dbUrl = resolved.dbUrl;
   if (!dbUrl) {
     console.log(
-      chalk4.yellow(
+      chalk5.yellow(
         "\nNo database connection URL found in CLI flags, environment, or config."
       )
     );
@@ -3362,7 +4032,7 @@ async function runCli(opts) {
         }
       }
     });
-    const saveDb = await confirm2({
+    const saveDb = await confirm({
       message: "Save this database URL to ~/.sandal/config.json for future runs?",
       default: true
     });
@@ -3377,34 +4047,55 @@ async function runCli(opts) {
   }
   let provider = resolved.provider;
   let apiKey = resolved.apiKey;
+  const isProviderExplicitlyChanged = Boolean(
+    opts.cliProvider && opts.cliProvider.toLowerCase() !== config.defaultProvider
+  );
   if (!apiKey) {
-    console.log(chalk4.yellow("\nNo API key found in environment or config."));
-    provider = await select({
-      message: "Select your LLM provider:",
-      choices: [
-        { name: "Google Gemini (GEMINI_API_KEY)", value: "google" },
-        { name: "OpenAI (OPENAI_API_KEY)", value: "openai" },
-        { name: "Anthropic (ANTHROPIC_API_KEY)", value: "anthropic" }
-      ]
-    });
+    if (opts.cliProvider) {
+      console.log(
+        chalk5.yellow(`
+No API key found for ${provider.toUpperCase()} in environment or config.`)
+      );
+    } else {
+      console.log(chalk5.yellow("\nNo API key found in environment or config."));
+      provider = await select2({
+        message: "Select your LLM provider:",
+        choices: [
+          { name: "Google Gemini (GEMINI_API_KEY)", value: "google" },
+          { name: "OpenAI (OPENAI_API_KEY)", value: "openai" },
+          { name: "Anthropic (ANTHROPIC_API_KEY)", value: "anthropic" }
+        ]
+      });
+    }
     apiKey = await input2({
       message: `Enter your ${provider.toUpperCase()} API key:`,
       validate: (val) => val.trim().length > 0 ? true : "API key cannot be empty."
     });
-    const saveKey = await confirm2({
-      message: "Save this API key to ~/.sandal/config.json?",
+    let chosenModel = opts.cliModel;
+    if (!chosenModel) {
+      chosenModel = await promptModelSelection(provider);
+    }
+    const saveKey = await confirm({
+      message: "Save this API key and default model to ~/.sandal/config.json?",
       default: true
     });
     if (saveKey) {
-      if (provider === "google")
-        writeConfig({ geminiApiKey: apiKey, defaultProvider: "google" });
-      else if (provider === "openai")
-        writeConfig({ openaiApiKey: apiKey, defaultProvider: "openai" });
-      else if (provider === "anthropic")
-        writeConfig({ anthropicApiKey: apiKey, defaultProvider: "anthropic" });
+      const updates = {
+        defaultProvider: provider,
+        defaultModel: chosenModel
+      };
+      if (provider === "google") updates.geminiApiKey = apiKey;
+      else if (provider === "openai") updates.openaiApiKey = apiKey;
+      else if (provider === "anthropic") updates.anthropicApiKey = apiKey;
+      writeConfig(updates);
     }
   }
-  const modelName = opts.cliModel || resolved.model || getDefaultModelForProvider(provider);
+  let modelName = opts.cliModel;
+  if (opts.selectModel || isProviderExplicitlyChanged && !opts.cliModel) {
+    modelName = await promptModelSelection(provider, resolved.model);
+  } else if (!modelName) {
+    modelName = resolved.model || getDefaultModelForProvider(provider);
+  }
   const dbSpinner = ora2(
     `Connecting to database (${maskUrl(dbUrl)})...`
   ).start();
@@ -3412,13 +4103,13 @@ async function runCli(opts) {
   try {
     await adapter.connect();
     dbSpinner.succeed(
-      chalk4.green(
+      chalk5.green(
         `Connected to ${adapter.type.toUpperCase()} database: ${adapter.databaseName}`
       )
     );
     addSavedConnection(dbUrl);
   } catch (err) {
-    dbSpinner.fail(chalk4.red(`Failed to connect to database: ${err.message}`));
+    dbSpinner.fail(chalk5.red(`Failed to connect to database: ${err.message}`));
     process.exit(1);
   }
   const model = createChatModel({
@@ -3426,6 +4117,7 @@ async function runCli(opts) {
     model: modelName,
     apiKey
   });
+  process.stdin.resume();
   const repl = new ReplSession({
     adapter,
     model,