Update server.js

server.js

@@ -9,7 +9,10 @@ const axios = require("axios");
 const app = express();
 const PORT = 7860;
 const HOME_DIR = path.join(__dirname, "home");
-const TASK_FILE = path.join(HOME_DIR, ".cryo_tasks.txt");
+const META_FILE = path.join(HOME_DIR, ".cryo_meta.json");
+const TASK_FILE = path.join(HOME_DIR, ".cryo_tasks.json");
+const CMD_HISTORY_FILE = path.join(HOME_DIR, ".cryo_cmd_history.json");
+const VERSIONS_FILE = path.join(HOME_DIR, ".cryo_versions.json");
 
 if (!fs.existsSync(HOME_DIR)) fs.mkdirSync(HOME_DIR, { recursive: true });
 
@@ -17,176 +20,67 @@ app.use(cors());
 app.use(express.json({ limit: "10mb" }));
 app.use(express.static(path.join(__dirname, "public")));
 
-// ── Multer ──────────────────────────────────────────────────────────────────
-const storage = multer.diskStorage({
-  destination: HOME_DIR,
-  filename: (req, file, cb) => cb(null, "index.js"),
-});
-const upload = multer({ storage });
-
-// ── ALLOWED COMMANDS ────────────────────────────────────────────────────────
-const ALLOWED_CMDS = [
-  "grep", "sed", "awk", "head", "tail", "cat", "wc",
-  "sort", "uniq", "cut", "tr", "find", "ls", "echo",
-  "diff", "patch", "node", "npm", "file", "stat",
-];
-
-const COMMANDS_REFERENCE = `
-=== SHELL COMMANDS AVAILABLE (cwd = /home) ===
-
-FILE EXPLORATION:
-  ls -l                           List files & directories
-  find . -name "*.js"             Find JS files recursively
-  find . -name "*.json"           Find config files
-  file filename                   Show file type
-  stat filename                   File metadata (size, dates)
-
-READING CONTENT:
-  cat file                        Read entire file
-  head -n N file                  First N lines
-  tail -n N file                  Last N lines
-  sed -n 'X,Yp' file              Lines X to Y (surgical)
-  head -c N file                  First N bytes
-  grep -n "pattern" file          Lines matching pattern (with line numbers)
-  grep -A5 "pattern" file         Pattern + 5 lines after
-  grep -B3 "pattern" file         Pattern + 3 lines before
-  grep -C3 "pattern" file         Pattern + 3 lines context (before+after)
-  grep -rn "pattern" .            Recursive search all files
-
-COUNTING / STATS:
-  wc -l file                      Count lines
-  grep -c "pattern" file          Count occurrences
-  awk 'END{print NR}' file        Alternative line count
-
-EDITING (surgical, safe):
-  sed -i 's/old/new/g' file       Replace ALL occurrences
-  sed -i '12s/old/new/' file      Replace on line 12 ONLY
-  sed -i 'X,Ys/old/new/g' file    Replace in lines X–Y
-  awk '/pattern/' file            Extract matching lines
-  cut -d',' -f2 file              Extract 2nd CSV column
-  tr 'a-z' 'A-Z'                  Transform chars
-
-COMPARING:
-  diff old.js new.js              Show differences between files
-  patch file < patchfile          Apply a patch file
-
-SYNTAX / ERROR CHECKING:
-  node --check file.js            JavaScript syntax validation
-  npm test                        Run project tests
-
-PROJECT INFO:
-  cat package.json                Show project dependencies
-  npm run scriptname              Run npm scripts
-
-UTILITIES:
-  echo "text"                     Print text
-  sort file                       Sort lines alphabetically
-  uniq file                       Remove duplicate lines
-
-=== AGENT RULES ===
-1. ALWAYS run "node --check file.js" BEFORE any edit
-2. ALWAYS run "node --check file.js" AFTER any edit
-3. Use grep -C3 to understand context BEFORE inserting new code
-4. Match existing code style — grep for similar patterns first
-5. Use sed -n 'X,Yp' to read specific sections before modifying them
-6. Back up important sections mentally before sed -i changes
-7. For adding new features: grep for existing similar features first
-===============================================
-`;
-
-// ── AI Models Config ─────────────────────────────────────────────────────────
-const AI_MODELS = {
-  "gpt5": {
-    name: "GPT-5",
-    label: "GPT-5 (Prexzy)",
-    call: async (prompt, system) => {
-      const query = system ? `${system}\n\n${prompt}` : prompt;
-      const { data } = await axios.get(
-        `https://apis.prexzyvilla.site/ai/gpt-5?text=${encodeURIComponent(query)}`,
-        { timeout: 40000 }
-      );
-      return data.text || data.response || "";
+// ── MODELS ─────────────────────────────────────────────────────────────────
+const MODELS = {
+  "cryo1": {
+    name: "Cryo 1",
+    label: "cryo1",
+    description: "Fast & light",
+    call: async (prompt) => {
+      const url = `https://apis.davidcyril.name.ng/ai/gemini?text=${encodeURIComponent(prompt.slice(0, 800))}`;
+      const { data } = await axios.get(url, { timeout: 20000 });
+      return data.message || data.text || "";
     }
   },
-  "gemini": {
-    name: "Gemini",
-    label: "Gemini (David)",
-    call: async (prompt, system) => {
-      const query = system ? `${system}\n\n${prompt}` : prompt;
-      const { data } = await axios.get(
-        `https://apis.davidcyril.name.ng/ai/gemini?text=${encodeURIComponent(query)}`,
-        { timeout: 40000 }
-      );
-      return data.message || data.response || "";
+  "cryo3": {
+    name: "Cryo 3",
+    label: "cryo3",
+    description: "Balanced & smart",
+    call: async (prompt) => {
+      const url = `https://apis.prexzyvilla.site/ai/claude?text=${encodeURIComponent(prompt.slice(0, 900))}&system=You are Cryo, a precise developer AI. Respond concisely in JSON only.`;
+      const { data } = await axios.get(url, { timeout: 25000 });
+      return data.response || data.text || "";
     }
   },
-  "claude": {
-    name: "Claude Haiku",
-    label: "Claude Haiku (Prexzy)",
-    call: async (prompt, system) => {
-      const params = new URLSearchParams({
-        text: prompt,
-        "system?": system || "You are Cryo, a precise developer AI assistant. Respond helpfully and clearly."
-      });
-      const { data } = await axios.get(
-        `https://apis.prexzyvilla.site/ai/claude?${params}`,
-        { timeout: 40000 }
-      );
-      return data.response || data.text || "";
+  "cryo4": {
+    name: "Cryo 4",
+    label: "cryo4",
+    description: "Most powerful",
+    call: async (prompt) => {
+      const url = `https://apis.prexzyvilla.site/ai/gpt-5?text=${encodeURIComponent(prompt.slice(0, 900))}`;
+      const { data } = await axios.get(url, { timeout: 30000 });
+      return data.text || data.message || "";
     }
   }
 };
 
-// ── Web Search ───────────────────────────────────────────────────────────────
-async function webSearch(query) {
-  try {
-    const { data } = await axios.get(
-      `https://apis.prexzyvilla.site/ai/gpt-5?text=${encodeURIComponent(query)}`,
-      { timeout: 30000 }
-    );
-    return {
-      answer: data.text || "",
-      citations: data.citations || [],
-      model: data.model || "gpt-5"
-    };
-  } catch (e) {
-    return { answer: "", citations: [], model: "gpt-5" };
-  }
-}
-
-// ── Detect if web search needed ──────────────────────────────────────────────
-function needsWebSearch(message) {
-  const triggers = [
-    /\b(latest|newest|recent|current|today|now|2024|2025|2026)\b/i,
-    /\b(news|trending|just released|came out|update|version)\b/i,
-    /\b(price|cost|how much|buy|purchase|available)\b/i,
-    /\b(who is|what is .+ doing|where is .+ now)\b/i,
-    /\b(weather|forecast|stock|score|standings)\b/i,
-    /\bsearch (for|the web|online)\b/i,
-    /\blook up\b/i,
-    /\b(best .+ 2025|top .+ 2026)\b/i,
-  ];
-  return triggers.some(r => r.test(message));
-}
+// ── ALLOWED COMMANDS ───────────────────────────────────────────────────────
+const ALLOWED_CMDS = [
+  "grep", "sed", "awk", "head", "tail", "cat", "wc",
+  "sort", "uniq", "cut", "tr", "find", "ls", "echo",
+  "diff", "patch", "node", "npm", "file", "stat",
+];
 
-function buildSearchQuery(message) {
-  // Strip filler words and extract intent
-  return message
-    .replace(/\b(can you|please|tell me|what is|who is|search for|look up|find me)\b/gi, "")
-    .replace(/[?!.]/g, "")
-    .trim()
-    .substring(0, 120);
-}
+const COMMANDS_REFERENCE = `
+SHELL COMMANDS (cwd=/home):
+ls, find, cat, head -n N, tail -n N, sed -n 'X,Yp', grep -n, grep -C3, grep -rn
+sed -i 's/old/new/g', node --check file.js, wc -l, diff, stat
+
+RULES:
+1. grep context before any edit
+2. node --check before+after edits
+3. match existing code style
+4. surgical sed-i on specific lines
+`;
 
-// ── Core AI caller ────────────────────────────────────────────────────────────
-async function callAI(system, query, modelId = "gpt5") {
-  const model = AI_MODELS[modelId] || AI_MODELS["gpt5"];
-  // Combine system + query in a structured way
-  const fullPrompt = `${system}\n\n---\nUser request:\n${query}\n\nRespond ONLY with valid JSON, no markdown fences.`;
-  const raw = await model.call(fullPrompt, system);
-  return raw;
-}
+// ── Multer ─────────────────────────────────────────────────────────────────
+const storage = multer.diskStorage({
+  destination: HOME_DIR,
+  filename: (req, file, cb) => cb(null, file.originalname || "index.js"),
+});
+const upload = multer({ storage });
 
+// ── Helpers ────────────────────────────────────────────────────────────────
 function parseJSON(raw) {
   if (!raw) return null;
   let s = raw.replace(/```json\s*/gi, "").replace(/```\s*/g, "").trim();
@@ -207,13 +101,6 @@ function runCmd(command) {
   });
 }
 
-function backupFile(filePath) {
-  const src = path.join(HOME_DIR, filePath);
-  if (!fs.existsSync(src)) return;
-  const dst = path.join(HOME_DIR, filePath.replace(/(\.\w+)?$/, "_backup$1"));
-  fs.copyFileSync(src, dst);
-}
-
 function getSmartContext(content, query, maxLines = 120) {
   const lines = content.split("\n");
   if (lines.length <= maxLines) return content;
@@ -229,76 +116,149 @@ function getSmartContext(content, query, maxLines = 120) {
     }
   }
   const middle = rs !== -1
-    ? `\n// ... [lines 41–${rs} omitted] ...\n` + lines.slice(rs, re + 1).join("\n") + `\n// ... [lines ${re + 1} onward omitted] ...\n`
-    : `\n// ... [${lines.length - 55} lines omitted] ...\n`;
+    ? `\n// ...[${rs}-${re} relevant]...\n` + lines.slice(rs, re + 1).join("\n")
+    : `\n// ...[${lines.length - 55} lines omitted]...\n`;
   return head + middle + tail;
 }
 
-function updateTaskLog(tasks) {
-  const lines = ["=== CRYO TASK LOG ===", `Updated: ${new Date().toISOString()}`, ""];
-  for (const t of tasks) {
-    lines.push(`[${t.done ? "✅" : "⬜"}] ${t.task}`);
-    if (t.note) lines.push(`     → ${t.note}`);
-  }
-  fs.writeFileSync(TASK_FILE, lines.join("\n"), "utf8");
+// ── Versioning ─────────────────────────────────────────────────────────────
+function readVersions() {
+  if (!fs.existsSync(VERSIONS_FILE)) return {};
+  try { return JSON.parse(fs.readFileSync(VERSIONS_FILE, "utf8")); } catch { return {}; }
+}
+
+function saveVersions(v) {
+  fs.writeFileSync(VERSIONS_FILE, JSON.stringify(v, null, 2), "utf8");
+}
+
+function versionFile(filePath) {
+  const src = path.join(HOME_DIR, filePath);
+  if (!fs.existsSync(src)) return;
+  const ts = Date.now();
+  const ext = path.extname(filePath);
+  const base = filePath.replace(ext, "");
+  const vName = `.versions/${base}_v${ts}${ext}`;
+  const vDir = path.join(HOME_DIR, ".versions");
+  if (!fs.existsSync(vDir)) fs.mkdirSync(vDir, { recursive: true });
+  fs.copyFileSync(src, path.join(HOME_DIR, vName));
+  const versions = readVersions();
+  if (!versions[filePath]) versions[filePath] = [];
+  versions[filePath].push({ path: vName, ts, label: new Date(ts).toISOString() });
+  if (versions[filePath].length > 10) versions[filePath] = versions[filePath].slice(-10);
+  saveVersions(versions);
+  return vName;
 }
 
-function readTaskLog() {
+// ── Task Management ────────────────────────────────────────────────────────
+function readTasks() {
   if (!fs.existsSync(TASK_FILE)) return [];
-  return fs.readFileSync(TASK_FILE, "utf8").split("\n")
-    .map(l => l.match(/^\[(✅|⬜)\] (.+)/))
-    .filter(Boolean)
-    .map(m => ({ done: m[1] === "✅", task: m[2] }));
+  try { return JSON.parse(fs.readFileSync(TASK_FILE, "utf8")); } catch { return []; }
+}
+
+function saveTasks(tasks) {
+  fs.writeFileSync(TASK_FILE, JSON.stringify(tasks, null, 2), "utf8");
+}
+
+function updateTasks(newTasks) {
+  const existing = readTasks();
+  const merged = [...existing, ...newTasks.filter(t => !existing.find(e => e.task === t.task))];
+  saveTasks(merged);
+  return merged;
+}
+
+// ── Command History ────────────────────────────────────────────────────────
+function appendCmdHistory(entries) {
+  let hist = [];
+  if (fs.existsSync(CMD_HISTORY_FILE)) {
+    try { hist = JSON.parse(fs.readFileSync(CMD_HISTORY_FILE, "utf8")); } catch {}
+  }
+  hist.push(...entries);
+  if (hist.length > 200) hist = hist.slice(-200);
+  fs.writeFileSync(CMD_HISTORY_FILE, JSON.stringify(hist, null, 2), "utf8");
+}
+
+// ── Project Metadata ───────────────────────────────────────────────────────
+function readMeta() {
+  if (!fs.existsSync(META_FILE)) return { created_at: new Date().toISOString(), languages: [], last_ai_edit: null };
+  try { return JSON.parse(fs.readFileSync(META_FILE, "utf8")); } catch { return {}; }
 }
 
-async function syntaxFixLoop(filePath, send, maxAttempts = 3, modelId = "gpt5") {
+function updateMeta(patch) {
+  const meta = { ...readMeta(), ...patch, updated_at: new Date().toISOString() };
+  fs.writeFileSync(META_FILE, JSON.stringify(meta, null, 2), "utf8");
+  return meta;
+}
+
+// ── Web Search Detection ───────────────────────────────────────────────────
+const SEARCH_TRIGGERS = [
+  /\b(latest|recent|current|today|now|2024|2025|2026|news|trending|new release|just released)\b/i,
+  /\b(who is|what is the price|when did|how much does|is .* still|does .* exist)\b/i,
+  /\b(search|look up|find out|google|web|online|internet)\b/i,
+  /\b(weather|stock|score|result|update|announce|launch)\b/i,
+];
+
+function needsWebSearch(msg) {
+  return SEARCH_TRIGGERS.some(r => r.test(msg));
+}
+
+async function webSearch(query) {
+  const short = query.slice(0, 200);
+  const url = `https://apis.prexzyvilla.site/ai/gpt-5?text=${encodeURIComponent(short)}`;
+  const { data } = await axios.get(url, { timeout: 20000 });
+  return {
+    answer: data.text || "",
+    citations: data.citations || [],
+    model: data.model || "gpt-5"
+  };
+}
+
+// ── callAI wrapper ─────────────────────────────────────────────────────────
+async function callAI(system, query, modelKey = "cryo4") {
+  const model = MODELS[modelKey] || MODELS["cryo4"];
+  const prompt = system ? `${system}\n\n${query}` : query;
+  return model.call(prompt);
+}
+
+// ── Syntax fix loop ────────────────────────────────────────────────────────
+async function syntaxFixLoop(filePath, send, modelKey, maxAttempts = 3) {
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     const check = await runCmd(`node --check ${filePath}`);
-    const cmdIdx = 800 + attempt;
-    send("command", { cmd: `node --check ${filePath} (attempt ${attempt})`, index: cmdIdx });
+    const idx = 800 + attempt;
+    send("command", { cmd: `node --check ${filePath} (attempt ${attempt})`, index: idx });
     send("command_result", {
-      cmd: `node --check ${filePath}`,
-      stdout: check.code === 0 ? "✓ Syntax OK" : "",
-      stderr: check.stderr,
-      index: cmdIdx,
-      isError: check.code !== 0
+      cmd: `node --check ${filePath}`, stdout: check.code === 0 ? "Syntax OK" : "",
+      stderr: check.stderr, index: idx, isError: check.code !== 0
     });
     if (check.code === 0) {
-      if (attempt === 1) send("status", { text: "✅ Syntax OK" });
-      else send("status", { text: `✅ Syntax fixed on attempt ${attempt}` });
+      send("status", { text: attempt === 1 ? "Syntax OK" : `Syntax fixed on attempt ${attempt}` });
       return true;
     }
-    send("status", { text: `⚠️ Syntax error (attempt ${attempt}/${maxAttempts}) — fixing...` });
+    send("status", { text: `Syntax error (attempt ${attempt}/${maxAttempts}) — fixing...` });
     const absPath = path.join(HOME_DIR, filePath);
     const broken = fs.readFileSync(absPath, "utf8");
     const fixedRaw = await callAI(
-      `You are Cryo - a precise JS developer. Fix the syntax error. Return ONLY valid JSON: {"content":"fixed file here","fix":"what was wrong"}`,
-      `File: ${filePath}\nError:\n${check.stderr}\n\nFile content:\n${broken}`,
-      modelId
+      `Fix JS syntax. Return ONLY JSON: {"content":"fixed file","fix":"what changed"}`,
+      `Error:\n${check.stderr}\n\nFile:\n${broken.slice(0, 3000)}`,
+      modelKey
     );
     const fixed = parseJSON(fixedRaw);
     if (fixed?.content) {
       fs.writeFileSync(absPath, fixed.content, "utf8");
-      send("status", { text: `🔨 Applied fix: ${fixed.fix || "syntax correction"}` });
-    } else {
-      send("status", { text: `⚠️ Could not auto-fix on attempt ${attempt}` });
-      break;
-    }
+      send("status", { text: `Fix applied: ${fixed.fix || "syntax correction"}` });
+    } else break;
   }
   return false;
 }
 
-// ── File Tree ────────────────────────────────────────────────────────────────
+// ── FILE TREE ──────────────────────────────────────────────────────────────
 app.get("/api/tree", (req, res) => {
   const buildTree = (dir, base = HOME_DIR) => {
     try {
       return fs.readdirSync(dir, { withFileTypes: true })
-        .filter(e => !e.name.startsWith(".cryo_") && !e.name.startsWith(".zoro_"))
+        .filter(e => !e.name.startsWith(".cryo_") && !e.name.startsWith(".versions") && !e.name.startsWith("__cryo"))
         .map(e => {
           const relPath = path.relative(base, path.join(dir, e.name));
-          if (e.isDirectory()) {
-            return { type: "dir", name: e.name, path: relPath, children: buildTree(path.join(dir, e.name), base) };
-          }
+          if (e.isDirectory()) return { type: "dir", name: e.name, path: relPath, children: buildTree(path.join(dir, e.name), base) };
           const stats = fs.statSync(path.join(dir, e.name));
           return { type: "file", name: e.name, path: relPath, size: stats.size };
         });
@@ -309,7 +269,7 @@ app.get("/api/tree", (req, res) => {
 });
 
 app.post("/api/upload", upload.single("file"), (req, res) => {
-  res.json({ success: true, path: "index.js" });
+  res.json({ success: true, path: req.file?.filename || "index.js" });
 });
 
 app.get("/api/file", (req, res) => {
@@ -323,6 +283,7 @@ app.post("/api/file", (req, res) => {
   const { filePath, content } = req.body;
   const abs = path.join(HOME_DIR, filePath);
   if (!abs.startsWith(HOME_DIR)) return res.status(403).json({ error: "Forbidden" });
+  versionFile(filePath);
   fs.mkdirSync(path.dirname(abs), { recursive: true });
   fs.writeFileSync(abs, content, "utf8");
   res.json({ success: true });
@@ -344,14 +305,34 @@ app.get("/api/download", (req, res) => {
 });
 
 app.get("/api/tasks", (req, res) => {
-  if (!fs.existsSync(TASK_FILE)) return res.json({ tasks: [] });
-  res.json({ tasks: readTaskLog() });
+  res.json({ tasks: readTasks() });
+});
+
+app.get("/api/history", (req, res) => {
+  if (!fs.existsSync(CMD_HISTORY_FILE)) return res.json({ history: [] });
+  try { res.json({ history: JSON.parse(fs.readFileSync(CMD_HISTORY_FILE, "utf8")) }); }
+  catch { res.json({ history: [] }); }
+});
+
+app.get("/api/versions", (req, res) => {
+  const { file } = req.query;
+  const versions = readVersions();
+  res.json({ versions: file ? (versions[file] || []) : versions });
+});
+
+app.post("/api/rollback", (req, res) => {
+  const { file, versionPath } = req.body;
+  const src = path.join(HOME_DIR, versionPath);
+  const dst = path.join(HOME_DIR, file);
+  if (!src.startsWith(HOME_DIR) || !dst.startsWith(HOME_DIR)) return res.status(403).json({ error: "Forbidden" });
+  if (!fs.existsSync(src)) return res.status(404).json({ error: "Version not found" });
+  versionFile(file);
+  fs.copyFileSync(src, dst);
+  res.json({ success: true, content: fs.readFileSync(dst, "utf8") });
 });
 
 app.get("/api/models", (req, res) => {
-  res.json({
-    models: Object.entries(AI_MODELS).map(([id, m]) => ({ id, label: m.label, name: m.name }))
-  });
+  res.json({ models: Object.entries(MODELS).map(([k, v]) => ({ key: k, name: v.name, description: v.description })) });
 });
 
 app.post("/api/exec", (req, res) => {
@@ -365,7 +346,7 @@ app.post("/api/exec", (req, res) => {
   });
 });
 
-// ── MAIN CHAT ENDPOINT ────────────────────────────────────────────────────────
+// ── MAIN CHAT ENDPOINT ─────────────────────────────────────────────────────
 app.post("/api/chat", async (req, res) => {
   res.setHeader("Content-Type", "text/event-stream");
   res.setHeader("Cache-Control", "no-cache");
@@ -375,87 +356,66 @@ app.post("/api/chat", async (req, res) => {
     try { res.write(`data: ${JSON.stringify({ type, ...data })}\n\n`); } catch {}
   };
 
-  const { message, currentFile, modelId = "gpt5" } = req.body;
+  const { message, currentFile, model: modelKey = "cryo4" } = req.body;
 
   try {
-    // ── Web Search detection ────────────────────────────────────────────────
-    if (needsWebSearch(message)) {
-      send("status", { text: "🌐 Detected web query — searching..." });
-      const searchQuery = buildSearchQuery(message);
-      send("web_search", { query: searchQuery });
-
-      const result = await webSearch(searchQuery);
-
-      send("web_result", {
-        query: searchQuery,
-        answer: result.answer,
-        citations: result.citations,
-        model: result.model
-      });
-
-      if (result.answer) {
+    // ── Web search detection ───────────────────────────────────────────────
+    if (needsWebSearch(message) && !currentFile) {
+      send("status", { text: "Searching the web..." });
+      send("web_search", { query: message });
+      try {
+        const result = await webSearch(message);
+        send("web_search_result", { query: message, citations: result.citations });
         send("message", { text: result.answer });
-      } else {
-        send("message", { text: "I searched the web but couldn't find a clear answer. Please try rephrasing your query." });
+      } catch (e) {
+        send("message", { text: "Web search failed: " + e.message });
       }
-
       res.write("data: [DONE]\n\n");
       res.end();
       return;
     }
 
-    // ── File / code operations ──────────────────────────────────────────────
     let filePath = currentFile || "index.js";
     const absPath = path.join(HOME_DIR, filePath);
     let fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : "";
     const hasFile = fileContent.length > 0;
     const fileLines = fileContent.split("\n").length;
+    const meta = readMeta();
+    const existingTasks = readTasks();
+    const pendingTasks = existingTasks.filter(t => !t.done);
 
-    // ════════════════════════════════════════════════════════════════════════
-    // CASE 1: No file → create from scratch
-    // ════════════════════════════════════════════════════════════════════════
+    // ── No file: create from scratch ───────────────────────────────────────
     if (!hasFile) {
-      send("status", { text: "🧠 Planning what to build..." });
+      send("status", { text: "Planning what to build..." });
 
       const aiRaw = await callAI(
-        `You are Cryo - a sharp, direct developer AI.
-Create the code the user asks for. First plan tasks, then generate the complete file.
-Return ONLY valid JSON (no markdown fences, no backticks, no extra text):
-{
-  "filename": "index.js",
-  "description": "what this file is",
-  "tasks": [{"task": "what you did", "done": true}],
-  "content": "complete file content",
-  "status": "Done - what was built"
-}`,
+        `You are Cryo - a precise developer AI. Create the code requested.
+Return ONLY valid JSON (no markdown):
+{"filename":"index.js","description":"what this is","tasks":[{"task":"what you did","done":true}],"content":"complete file content","status":"Done - what was built"}`,
         message,
-        modelId
+        modelKey
       );
 
       let parsed = parseJSON(aiRaw);
       if (!parsed?.content) {
         parsed = {
-          filename: "index.js",
-          content: aiRaw,
-          description: "Generated",
-          tasks: [{ task: "Generate file from request", done: true }],
-          status: "Created file",
+          filename: "index.js", content: aiRaw,
+          description: "Generated", tasks: [{ task: "Generate file", done: true }], status: "Created"
         };
       }
 
-      send("status", { text: `📋 Plan ready — ${parsed.tasks?.length || 1} tasks` });
+      send("status", { text: `Plan ready — ${parsed.tasks?.length || 1} tasks` });
       send("task_update", { tasks: parsed.tasks || [] });
+      send("status", { text: "Checking generated code..." });
 
-      send("status", { text: "🔍 Checking generated code..." });
-      const tmpName = "__cryo_new_check.js";
+      const tmpName = `__cryo_new_${Date.now()}.js`;
       const tmpPath = path.join(HOME_DIR, tmpName);
       fs.writeFileSync(tmpPath, parsed.content, "utf8");
-
-      await syntaxFixLoop(tmpName, send, 3, modelId);
+      await syntaxFixLoop(tmpName, send, modelKey, 3);
       parsed.content = fs.readFileSync(tmpPath, "utf8");
       fs.unlinkSync(tmpPath);
 
-      send("status", { text: `💾 Saving ${parsed.filename}...` });
+      send("status", { text: `Saving ${parsed.filename}...` });
       const savePath = path.join(HOME_DIR, parsed.filename);
       fs.mkdirSync(path.dirname(savePath), { recursive: true });
       fs.writeFileSync(savePath, parsed.content, "utf8");
@@ -464,169 +424,135 @@ Return ONLY valid JSON (no markdown fences, no backticks, no extra text):
       send("command", { cmd: `node --check ${parsed.filename}`, index: 0 });
       send("command_result", {
         cmd: `node --check ${parsed.filename}`,
-        stdout: finalCheck.code === 0 ? "✓ Syntax OK — file saved!" : "",
-        stderr: finalCheck.stderr,
-        index: 0,
-        isError: finalCheck.code !== 0
+        stdout: finalCheck.code === 0 ? "Syntax OK — file saved!" : "",
+        stderr: finalCheck.stderr, index: 0, isError: finalCheck.code !== 0
       });
 
-      updateTaskLog(parsed.tasks || []);
+      updateTasks(parsed.tasks || []);
+      updateMeta({ last_ai_edit: new Date().toISOString(), languages: [parsed.filename.split(".").pop()] });
       send("file_created", { filename: parsed.filename, content: parsed.content, description: parsed.description });
-      send("message", { text: `✅ Created \`${parsed.filename}\` — ${parsed.description}` });
+      send("message", { text: `Created \`${parsed.filename}\` — ${parsed.description}` });
       send("tree_update", {});
       res.write("data: [DONE]\n\n");
       res.end();
       return;
     }
 
-    // ════════════════════════════════════════════════════════════════════════
-    // CASE 2: File exists — analyze + command loop + edit/answer
-    // ════════════════════════════════════════════════════════════════════════
-    send("status", { text: "🗺️ Analyzing request..." });
-
+    // ── File exists: analyze + command loop + edit/answer ──────────────────
+    send("status", { text: "Analyzing request..." });
     const smartCtx = getSmartContext(fileContent, message);
-    const existingTasks = readTaskLog();
-    const pendingTasks = existingTasks.filter(t => !t.done);
 
     const masterPlanRaw = await callAI(
-      `You are Cryo - a razor-sharp developer AI agent operating on code files.
-You use shell commands to explore, understand, then modify code.
-
+      `You are Cryo - a sharp developer AI agent on code files.
 ${COMMANDS_REFERENCE}
-
-WORKFLOW FOR EDITS:
-1. EXPLORE: grep for existing patterns similar to what user wants
-2. LOCATE: find exact line numbers (grep -n, wc -l, sed -n to read sections)
-3. UNDERSTAND: read context around insertion points (grep -C5)
-4. CHECK: node --check before any edit
-5. EDIT: surgical sed -i on specific lines
-6. VERIFY: node --check after edit
-
-WORKFLOW FOR QUERIES:
-1. grep for relevant functions/patterns
-2. read surrounding context
-3. answer precisely
-
 File: ${filePath} (${fileLines} lines)
-Current content preview:
-${smartCtx.substring(0, 2500)}
-
-${pendingTasks.length > 0 ? `UNFINISHED TASKS FROM LAST SESSION:\n${pendingTasks.map(t => `  ⬜ ${t.task}`).join("\n")}\n` : ""}
-
-Respond ONLY with valid JSON (no markdown):
-{
-  "task_type": "query" | "edit" | "create",
-  "status": "brief description shown to user",
-  "tasks": [{"task": "subtask name", "done": false}],
-  "commands": ["cmd1", "cmd2"],
-  "reasoning": "why these commands in this order"
-}`,
+Preview:\n${smartCtx.substring(0, 1800)}
+${pendingTasks.length > 0 ? `PENDING TASKS:\n${pendingTasks.map(t => `  - ${t.task}`).join("\n")}\n` : ""}
+Respond ONLY with valid JSON:
+{"task_type":"query"|"edit"|"create","status":"brief description","tasks":[{"task":"name","done":false}],"commands":["cmd1"],"reasoning":"why"}`,
       message,
-      modelId
+      modelKey
     );
 
     let plan = parseJSON(masterPlanRaw);
     if (!plan) plan = { task_type: "query", status: "Analyzing...", tasks: [], commands: [], reasoning: "" };
 
-    send("status", { text: `⚡ ${plan.status || "Processing..."}` });
+    send("status", { text: plan.status || "Processing..." });
     if (plan.tasks?.length > 0) send("task_update", { tasks: plan.tasks });
 
+    // Run all planned commands
     const commandResults = [];
+    const historyEntries = [];
+
     for (let i = 0; i < (plan.commands || []).length; i++) {
       const cmd = plan.commands[i];
-      send("status", { text: `🔧 [${i + 1}/${plan.commands.length}] \`${cmd}\`` });
+      send("status", { text: `[${i + 1}/${plan.commands.length}] ${cmd}` });
       send("command", { cmd, index: i });
 
       const result = await runCmd(cmd);
       commandResults.push({ cmd, ...result });
+      historyEntries.push({ cmd, stdout: result.stdout.slice(0, 500), stderr: result.stderr.slice(0, 200), code: result.code, ts: Date.now() });
 
       send("command_result", {
-        cmd,
-        stdout: result.stdout.substring(0, 1000),
+        cmd, stdout: result.stdout.substring(0, 1000),
         stderr: result.stderr.substring(0, 500),
-        index: i,
-        isError: result.code !== 0 && !!result.stderr
+        index: i, isError: result.code !== 0 && !!result.stderr
       });
 
       if (cmd.includes("node --check") && result.code !== 0 && result.stderr) {
         const targetFile = cmd.split(/\s+/).pop();
-        send("status", { text: `⚠️ Syntax error found in ${targetFile} — entering fix loop...` });
-        await syntaxFixLoop(targetFile, send, 3, modelId);
+        send("status", { text: `Syntax error in ${targetFile} — entering fix loop...` });
+        await syntaxFixLoop(targetFile, send, modelKey, 3);
         fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
       }
     }
 
+    appendCmdHistory(historyEntries);
     fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
 
     const resultsText = commandResults
-      .map(r => `$ ${r.cmd}\n${r.stdout.substring(0, 600)}${r.stderr ? `\nSTDERR: ${r.stderr.substring(0, 300)}` : ""}`)
+      .map(r => `$ ${r.cmd}\n${r.stdout.substring(0, 500)}${r.stderr ? `\nSTDERR: ${r.stderr.substring(0, 200)}` : ""}`)
       .join("\n\n");
 
-    send("status", { text: "🧠 Synthesizing..." });
+    send("status", { text: "Synthesizing..." });
 
     if (plan.task_type === "query") {
-      const ansRaw = await callAI(
-        `You are Cryo - direct, precise developer AI.
-Answer the user's question based on file content and command results.
-Return ONLY valid JSON: {"answer": "clear precise answer", "status": "Done"}`,
-        `Question: "${message}"\nFile: ${filePath}\nResults:\n${resultsText}\nContext:\n${smartCtx.substring(0, 2000)}`,
-        modelId
-      );
-      const ans = parseJSON(ansRaw);
-      send("message", { text: ans?.answer || ansRaw || "No answer generated." });
+      // Check if answer might need web info
+      if (needsWebSearch(message)) {
+        send("web_search", { query: message });
+        try {
+          const wsResult = await webSearch(message);
+          send("web_search_result", { query: message, citations: wsResult.citations });
+          send("message", { text: wsResult.answer });
+        } catch {
+          const ansRaw = await callAI(
+            `You are Cryo. Answer based on file content and command results. Return ONLY JSON: {"answer":"clear answer","status":"Done"}`,
+            `Question: "${message}"\nResults:\n${resultsText}\nContext:\n${smartCtx.substring(0, 1500)}`,
+            modelKey
+          );
+          const ans = parseJSON(ansRaw);
+          send("message", { text: ans?.answer || "No answer generated." });
+        }
+      } else {
+        const ansRaw = await callAI(
+          `You are Cryo. Answer based on file content and command results. Return ONLY JSON: {"answer":"clear answer","status":"Done"}`,
+          `Question: "${message}"\nResults:\n${resultsText}\nContext:\n${smartCtx.substring(0, 1500)}`,
+          modelKey
+        );
+        const ans = parseJSON(ansRaw);
+        send("message", { text: ans?.answer || "No answer generated." });
+      }
 
     } else {
       const hadSedEdits = commandResults.some(r => r.cmd.startsWith("sed -i") && r.code === 0);
 
       if (hadSedEdits) {
-        send("status", { text: "🔍 Verifying sed edits..." });
-        await syntaxFixLoop(filePath, send, 3, modelId);
+        send("status", { text: "Verifying sed edits..." });
+        await syntaxFixLoop(filePath, send, modelKey, 3);
         fileContent = fs.readFileSync(absPath, "utf8");
 
         const sumRaw = await callAI(
-          `You are Cryo. Summarize what changed in the file. Return ONLY JSON: {"summary": "what changed", "tasks_completed": ["t1", "t2"]}`,
-          `User asked: ${message}\nCommands:\n${resultsText}`,
-          modelId
+          `Summarize file changes. Return ONLY JSON: {"summary":"what changed","tasks_completed":["t1"]}`,
+          `User: ${message}\nCommands:\n${resultsText}`,
+          modelKey
         );
         const sum = parseJSON(sumRaw);
-
-        const allTasks = [
-          ...existingTasks.map(t => ({ ...t, done: true })),
-          ...(plan.tasks || []).map(t => ({ ...t, done: true }))
-        ];
-        updateTaskLog(allTasks);
+        const allTasks = [...existingTasks.map(t => ({ ...t, done: true })), ...(plan.tasks || []).map(t => ({ ...t, done: true }))];
+        saveTasks(allTasks);
         send("task_update", { tasks: allTasks });
-
+        versionFile(filePath);
+        updateMeta({ last_ai_edit: new Date().toISOString() });
         send("file_updated", { filename: filePath, content: fileContent, description: sum?.summary || "Updated" });
-        send("message", { text: `✅ ${sum?.summary || "Changes applied via sed"}` });
+        send("message", { text: sum?.summary || "Changes applied via sed" });
 
       } else {
         const editRaw = await callAI(
-          `You are Cryo - a precise developer AI.
-You have explored the file with commands. Now produce the complete updated file.
-
-KEY RULES:
-- Study command results carefully — they show existing code patterns
-- Match the EXACT style, indentation, naming conventions of existing code
-- For new features/commands: model them exactly after existing similar ones
-- Make ONLY the necessary changes, preserve everything else
-- The output must be a complete, working file
-
-Return ONLY valid JSON (no markdown):
-{
-  "content": "COMPLETE updated file content here",
-  "description": "what changed",
-  "tasks_completed": ["task1", "task2"],
-  "status": "Done — what was accomplished"
-}`,
-          `User request: "${message}"
-File: ${filePath} (${fileLines} lines)
-Current file:
-${fileContent.substring(0, 5000)}
-Command exploration results:
-${resultsText}
-Produce the complete updated file.`,
-          modelId
+          `You are Cryo - a precise developer AI. Produce the complete updated file.
+RULES: match existing style, preserve everything not changed, output must be complete working file.
+Return ONLY valid JSON:
+{"content":"COMPLETE file content","description":"what changed","tasks_completed":["t1"],"status":"Done - what was accomplished"}`,
+          `User request: "${message}"\nFile: ${filePath} (${fileLines} lines)\nCurrent:\n${fileContent.substring(0, 4000)}\nCommand results:\n${resultsText}\nProduce complete updated file.`,
+          modelKey
         );
 
         let editParsed = parseJSON(editRaw);
@@ -634,40 +560,42 @@ Produce the complete updated file.`,
           editParsed = { content: fileContent, description: "No changes", status: "Done", tasks_completed: [] };
         }
 
-        backupFile(filePath);
+        // Add Cryo inline comments
+        editParsed.content = editParsed.content;
 
-        send("status", { text: "🔍 Checking new content before saving..." });
+        versionFile(filePath);
+
+        send("status", { text: "Checking new content before saving..." });
         const tmpName = `__cryo_presave_${Date.now()}.js`;
         const tmpPath = path.join(HOME_DIR, tmpName);
         fs.writeFileSync(tmpPath, editParsed.content, "utf8");
-
-        await syntaxFixLoop(tmpName, send, 3, modelId);
+        await syntaxFixLoop(tmpName, send, modelKey, 3);
         editParsed.content = fs.readFileSync(tmpPath, "utf8");
         fs.unlinkSync(tmpPath);
 
         fs.writeFileSync(absPath, editParsed.content, "utf8");
-        send("status", { text: `💾 Saved ${filePath}` });
+        send("status", { text: `Saved ${filePath}` });
 
-        await syntaxFixLoop(filePath, send, 3, modelId);
+        await syntaxFixLoop(filePath, send, modelKey, 3);
         fileContent = fs.readFileSync(absPath, "utf8");
 
         const allTasks = [
           ...existingTasks.map(t => ({ ...t, done: true })),
           ...(plan.tasks || []).map(t => ({ ...t, done: true, note: "done this session" }))
         ];
-        updateTaskLog(allTasks);
+        saveTasks(allTasks);
+        updateMeta({ last_ai_edit: new Date().toISOString() });
         send("task_update", { tasks: allTasks });
-
         send("file_updated", { filename: filePath, content: fileContent, description: editParsed.description });
-        send("message", { text: `✅ ${editParsed.status || editParsed.description}` });
+        send("message", { text: editParsed.status || editParsed.description });
         send("tree_update", {});
       }
     }
 
-    const latestTasks = readTaskLog();
+    const latestTasks = readTasks();
     const stillPending = latestTasks.filter(t => !t.done);
     if (stillPending.length > 0) {
-      send("status", { text: `📋 ${stillPending.length} tasks still pending` });
+      send("status", { text: `${stillPending.length} tasks still pending` });
       send("pending_tasks", { tasks: stillPending, count: stillPending.length });
     }
 
@@ -683,6 +611,6 @@ Produce the complete updated file.`,
 });
 
 app.listen(PORT, () => {
-  console.log(`\n❄️  Cryo Server → http://localhost:${PORT}`);
+  console.log(`\n❄️  Cryo Dev Server → http://localhost:${PORT}`);
   console.log(`📁  Home dir: ${HOME_DIR}\n`);
 });