Update server.js

server.js

@@ -32,6 +32,16 @@ const MODELS = {
       return data.message || data.text || "";
     }
   },
+  "cryo2": {
+    name: "Cryo 2",
+    label: "cryo2",
+    description: "Reliable & smart",
+    call: async (prompt) => {
+      const params = new URLSearchParams({ BK9: "You are Cryo, a precise developer AI. Always respond with valid JSON only, no markdown.", q: prompt, model: "compound-beta-mini" });
+      const { data } = await axios.get(`https://api.bk9.dev/ai/BK94?${params}`, { timeout: 30000 });
+      return data.BK9 || data.response || data.message || "";
+    }
+  },
   "cryo3": {
     name: "Cryo 3",
     label: "cryo3",
@@ -62,66 +72,41 @@ const ALLOWED_CMDS = [
 ];
 
 const COMMANDS_REFERENCE = `
-=== SHELL COMMANDS AVAILABLE (cwd = /home) ===
+=== SHELL COMMANDS (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)
+EXPLORE:
+  ls -l                           List files
+  find . -name "*.js"             Find files
+  stat filename                   File metadata
 
-READING CONTENT:
-  cat file                        Read entire file
+READ:
+  cat file                        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
+  sed -n 'X,Yp' file              Lines X to Y
+  grep -n "pattern" file          Lines matching (with numbers)
+  grep -C3 "pattern" file         Match + 3 lines context
 
-EDITING (surgical, safe):
+EDIT (surgical):
   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
+  sed -i '12s/old/new/' file      Replace on line 12 only
+  sed -i 'X,Ys/old/new/g' file    Replace in line range X-Y
+  sed -i 'Xd' file                Delete line X
+  sed -i 'X,Yd' file              Delete lines X to Y
 
-SYNTAX / ERROR CHECKING:
-  node --check file.js            JavaScript syntax validation
-  npm test                        Run project tests
+BACKUP:
+  cp file file.bak                Backup before editing
 
-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
+CHECK:
+  node --check file.js            JS syntax validation
+  wc -l file                      Count 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
-===============================================
+1. Always grep -n BEFORE editing to find exact line numbers
+2. Always node --check after any sed edit
+3. Use sed -n to read sections before modifying
+4. Back up file with cp before major edits
+5. Use grep -C3 to understand context before insertion
 `;
 
 // ── Multer ─────────────────────────────────────────────────────────────────
@@ -131,15 +116,70 @@ const storage = multer.diskStorage({
 });
 const upload = multer({ storage });
 
-// ── Helpers ────────────────────────────────────────────────────────────────
+// ── ROBUST JSON PARSER ─────────────────────────────────────────────��───────
+// Handles: plain text, markdown fenced, partial JSON, escaped newlines
 function parseJSON(raw) {
   if (!raw) return null;
-  let s = raw.replace(/```json\s*/gi, "").replace(/```\s*/g, "").trim();
-  const m = s.match(/\{[\s\S]*\}/);
-  if (m) s = m[0];
-  try { return JSON.parse(s); } catch { return null; }
+  let s = String(raw).trim();
+
+  // Strip markdown fences
+  s = s.replace(/^```(?:json)?\s*/i, "").replace(/\s*```\s*$/, "").trim();
+
+  // Try direct parse first
+  try { return JSON.parse(s); } catch {}
+
+  // Extract outermost {...} object
+  const start = s.indexOf("{");
+  const end = s.lastIndexOf("}");
+  if (start !== -1 && end !== -1 && end > start) {
+    try { return JSON.parse(s.slice(start, end + 1)); } catch {}
+  }
+
+  // Try to fix common issues: unescaped newlines in string values
+  try {
+    const fixed = s
+      .replace(/:\s*"([\s\S]*?)"/g, (m, v) => ': "' + v.replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t") + '"')
+      .replace(/,\s*}/g, "}").replace(/,\s*\]/g, "]");
+    const fStart = fixed.indexOf("{"), fEnd = fixed.lastIndexOf("}");
+    if (fStart !== -1 && fEnd !== -1) return JSON.parse(fixed.slice(fStart, fEnd + 1));
+  } catch {}
+
+  return null;
+}
+
+// ── EXTRACT COMMANDS FROM TEXT ─────────────────────────────────────────────
+// When AI returns markdown/prose instead of JSON, pull shell commands from it
+function extractCommandsFromText(text) {
+  const cmds = [];
+  // Match lines starting with $ or lines inside code blocks
+  const codeBlockRe = /```(?:bash|sh|shell)?\s*([\s\S]*?)```/gi;
+  let m;
+  while ((m = codeBlockRe.exec(text)) !== null) {
+    const lines = m[1].split("\n").map(l => l.replace(/^\$\s*/, "").trim()).filter(l => l && !l.startsWith("#"));
+    cmds.push(...lines);
+  }
+  // Also match lines starting with $ outside code blocks
+  const lines = text.split("\n");
+  for (const line of lines) {
+    const stripped = line.replace(/^\$\s*/, "").trim();
+    const firstWord = stripped.split(/\s+/)[0];
+    if (line.trim().startsWith("$") && ALLOWED_CMDS.includes(firstWord)) {
+      if (!cmds.includes(stripped)) cmds.push(stripped);
+    }
+  }
+  return cmds.filter(cmd => ALLOWED_CMDS.includes(cmd.split(/\s+/)[0]));
 }
 
+// ── EXTRACT CONTENT FROM TEXT ──────────────────────────────────────────────
+// Pull file content from markdown code block in plain-text AI response
+function extractContentFromText(text) {
+  // Match ```js ... ``` or ```javascript ... ``` or ``` ... ```
+  const m = text.match(/```(?:js|javascript|typescript|ts|python|py|sh|bash)?\s*([\s\S]+?)```/i);
+  if (m) return m[1].trim();
+  return null;
+}
+
+// ── runCmd ─────────────────────────────────────────────────────────────────
 function runCmd(command) {
   return new Promise(resolve => {
     const name = command.trim().split(/\s+/)[0];
@@ -152,6 +192,7 @@ function runCmd(command) {
   });
 }
 
+// ── SMART CONTEXT ──────────────────────────────────────────────────────────
 function getSmartContext(content, query, maxLines = 120) {
   const lines = content.split("\n");
   if (lines.length <= maxLines) return content;
@@ -172,16 +213,14 @@ function getSmartContext(content, query, maxLines = 120) {
   return head + middle + tail;
 }
 
-// ── Versioning ─────────────────────────────────────────────────────────────
+// ── 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;
@@ -200,16 +239,14 @@ function versionFile(filePath) {
   return vName;
 }
 
-// ── Task Management ────────────────────────────────────────────────────────
+// ── TASK MANAGEMENT ────────────────────────────────────────────────────────
 function readTasks() {
   if (!fs.existsSync(TASK_FILE)) return [];
   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))];
@@ -217,7 +254,7 @@ function updateTasks(newTasks) {
   return merged;
 }
 
-// ── Command History ────────────────────────────────────────────────────────
+// ── COMMAND HISTORY ────────────────────────────────────────────────────────
 function appendCmdHistory(entries) {
   let hist = [];
   if (fs.existsSync(CMD_HISTORY_FILE)) {
@@ -228,49 +265,42 @@ function appendCmdHistory(entries) {
   fs.writeFileSync(CMD_HISTORY_FILE, JSON.stringify(hist, null, 2), "utf8");
 }
 
-// ── Project Metadata ───────────────────────────────────────────────────────
+// ── 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 {}; }
 }
-
 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 ───────────────────────────────────────────────────
+// ── 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"
-  };
+  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"];
+async function callAI(system, query, modelKey = "cryo2") {
+  const model = MODELS[modelKey] || MODELS["cryo2"];
   const prompt = system ? `${system}\n\n${query}` : query;
   return model.call(prompt);
 }
 
-// ── Syntax fix loop ────────────────────────────────────────────────────────
+// ── 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}`);
@@ -288,19 +318,202 @@ async function syntaxFixLoop(filePath, send, modelKey, maxAttempts = 3) {
     const absPath = path.join(HOME_DIR, filePath);
     const broken = fs.readFileSync(absPath, "utf8");
     const fixedRaw = await callAI(
-      `Fix JS syntax. Return ONLY JSON: {"content":"fixed file","fix":"what changed"}`,
-      `Error:\n${check.stderr}\n\nFile:\n${broken.slice(0, 3000)}`,
+      `Fix this JavaScript syntax error. Return ONLY a JSON object with no extra text:\n{"content":"<complete fixed file here>","fix":"<one line description of fix>"}`,
+      `SYNTAX ERROR:\n${check.stderr}\n\nFILE CONTENT:\n${broken.slice(0, 3000)}`,
       modelKey
     );
     const fixed = parseJSON(fixedRaw);
     if (fixed?.content) {
       fs.writeFileSync(absPath, fixed.content, "utf8");
       send("status", { text: `Fix applied: ${fixed.fix || "syntax correction"}` });
-    } else break;
+    } else {
+      // Try extracting content from markdown if JSON parse failed
+      const extracted = extractContentFromText(fixedRaw || "");
+      if (extracted) {
+        fs.writeFileSync(absPath, extracted, "utf8");
+        send("status", { text: "Extracted fix from response" });
+      } else break;
+    }
   }
   return false;
 }
 
+// ── ITERATIVE COMMAND LOOP ─────────────────────────────────────────────────
+// Core agentic loop: ask AI for commands → run them → feed results back → repeat until done
+async function runAgentLoop(opts) {
+  const { filePath, fileContent: initialContent, message, modelKey, send, maxRounds = 6 } = opts;
+  const absPath = path.join(HOME_DIR, filePath);
+  const fileLines = initialContent.split("\n").length;
+  const smartCtx = getSmartContext(initialContent, message);
+  const allCommandResults = [];
+  const historyEntries = [];
+  let cmdIndex = 0;
+  let fileContent = initialContent;
+
+  // ── ROUND 1: Master plan ───────────────────────────────────────────────
+  send("status", { text: "Analyzing request..." });
+
+  const planPrompt = `You are Cryo - a developer AI agent. You operate on files using shell commands.
+
+${COMMANDS_REFERENCE}
+
+FILE: ${filePath} (${fileLines} lines)
+CONTENT PREVIEW:
+${smartCtx.substring(0, 2000)}
+
+USER REQUEST: "${message}"
+
+IMPORTANT: You MUST respond with ONLY a raw JSON object. No prose. No markdown. No explanation outside JSON.
+The JSON must have exactly this shape:
+{
+  "task_type": "query" or "edit" or "create",
+  "status": "brief status shown to user",
+  "tasks": [{"task": "subtask description", "done": false}],
+  "commands": ["cmd1", "cmd2", "cmd3"],
+  "reasoning": "why these commands",
+  "done": false
+}
+
+RULES:
+- For EDITS: always start with grep -n to find line numbers, then sed -i to edit, then node --check to verify
+- For READS: use cat, head, tail, sed -n, grep
+- For SEARCH/REPLACE: grep -n first to find exact lines, then sed -i 's/old/new/g'
+- For DELETE: grep -n to find lines, then sed -i 'Xd' to delete
+- For VIEW LINES: sed -n 'X,Yp' filename
+- For BACKUP: cp file file.bak before major edits
+- commands array must only contain commands from the ALLOWED list
+- NEVER include node_modules, npm install, or destructive commands`;
+
+  const planRaw = await callAI(planPrompt, "", modelKey);
+  let plan = parseJSON(planRaw);
+
+  // Fallback: if AI returned markdown/prose, extract commands from it
+  if (!plan || !plan.commands) {
+    const extracted = extractCommandsFromText(planRaw || "");
+    plan = {
+      task_type: "edit",
+      status: "Running extracted commands...",
+      tasks: [{ task: message, done: false }],
+      commands: extracted.length > 0 ? extracted : [],
+      reasoning: "Extracted from response",
+      done: false
+    };
+  }
+
+  send("status", { text: plan.status || "Processing..." });
+  if (plan.tasks?.length > 0) send("task_update", { tasks: plan.tasks });
+
+  // ── EXECUTE INITIAL COMMANDS ───────────────────────────────────────────
+  for (const cmd of (plan.commands || [])) {
+    const idx = cmdIndex++;
+    send("status", { text: `[${idx + 1}] ${cmd}` });
+    send("command", { cmd, index: idx });
+    const result = await runCmd(cmd);
+    allCommandResults.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),
+      stderr: result.stderr.substring(0, 500),
+      index: idx, isError: result.code !== 0 && !!result.stderr
+    });
+
+    // Auto syntax-fix if node --check fails
+    if (cmd.includes("node --check") && result.code !== 0 && result.stderr) {
+      const target = cmd.split(/\s+/).pop().replace(/\s*\(.*\)$/, "");
+      send("status", { text: `Syntax error in ${target} — fixing...` });
+      await syntaxFixLoop(target, send, modelKey, 3);
+      fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
+    }
+  }
+
+  fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
+
+  // ── ITERATIVE ROUNDS: keep running until AI says done ─────────────────
+  for (let round = 2; round <= maxRounds; round++) {
+    const resultsText = allCommandResults.slice(-8)
+      .map(r => `$ ${r.cmd}\nSTDOUT: ${r.stdout.substring(0, 400)}${r.stderr ? `\nSTDERR: ${r.stderr.substring(0, 200)}` : ""}\nEXIT: ${r.code}`)
+      .join("\n\n");
+
+    send("status", { text: `Round ${round}: deciding next steps...` });
+
+    const continuePrompt = `You are Cryo - a developer AI agent completing a task.
+
+USER REQUEST: "${message}"
+FILE: ${filePath}
+CURRENT CONTENT (first 60 lines):
+${fileContent.split("\n").slice(0, 60).join("\n")}
+
+COMMANDS ALREADY RUN:
+${resultsText}
+
+Decide what to do NEXT. If the task is complete, set "done": true and "commands": [].
+If more commands are needed, list ONLY the next batch (max 5 commands).
+
+IMPORTANT: Respond with ONLY raw JSON, no markdown, no prose:
+{
+  "done": true or false,
+  "status": "what was accomplished or what's next",
+  "commands": ["next cmd1", "next cmd2"],
+  "reasoning": "why"
+}
+
+If done=true, commands must be empty [].
+Only use commands from: ${ALLOWED_CMDS.join(", ")}`;
+
+    const contRaw = await callAI(continuePrompt, "", modelKey);
+    let cont = parseJSON(contRaw);
+
+    if (!cont) {
+      // Try extracting from text
+      const extracted = extractCommandsFromText(contRaw || "");
+      if (extracted.length === 0) {
+        // AI gave no more commands — treat as done
+        break;
+      }
+      cont = { done: false, commands: extracted, status: "Continuing...", reasoning: "Extracted" };
+    }
+
+    if (cont.done || !cont.commands || cont.commands.length === 0) {
+      send("status", { text: cont.status || "Task complete" });
+      break;
+    }
+
+    send("status", { text: cont.status || `Round ${round}...` });
+
+    for (const cmd of cont.commands) {
+      const idx = cmdIndex++;
+      send("status", { text: `[${idx + 1}] ${cmd}` });
+      send("command", { cmd, index: idx });
+      const result = await runCmd(cmd);
+      allCommandResults.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),
+        stderr: result.stderr.substring(0, 500),
+        index: idx, isError: result.code !== 0 && !!result.stderr
+      });
+
+      if (cmd.includes("node --check") && result.code !== 0 && result.stderr) {
+        const target = cmd.split(/\s+/).pop().replace(/\s*\(.*\)$/, "");
+        send("status", { text: `Syntax error — fixing...` });
+        await syntaxFixLoop(target, send, modelKey, 3);
+        fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
+      }
+    }
+
+    fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
+  }
+
+  appendCmdHistory(historyEntries);
+
+  return {
+    allCommandResults,
+    fileContent,
+    plan,
+    hadSedEdits: allCommandResults.some(r => r.cmd.startsWith("sed -i") && r.code === 0)
+  };
+}
+
 // ── FILE TREE ──────────────────────────────────────────────────────────────
 app.get("/api/tree", (req, res) => {
   const buildTree = (dir, base = HOME_DIR) => {
@@ -355,9 +568,7 @@ app.get("/api/download", (req, res) => {
   res.download(fp);
 });
 
-app.get("/api/tasks", (req, res) => {
-  res.json({ tasks: readTasks() });
-});
+app.get("/api/tasks", (req, res) => res.json({ tasks: readTasks() }));
 
 app.get("/api/history", (req, res) => {
   if (!fs.existsSync(CMD_HISTORY_FILE)) return res.json({ history: [] });
@@ -407,10 +618,10 @@ app.post("/api/chat", async (req, res) => {
     try { res.write(`data: ${JSON.stringify({ type, ...data })}\n\n`); } catch {}
   };
 
-  const { message, currentFile, model: modelKey = "cryo4" } = req.body;
+  const { message, currentFile, model: modelKey = "cryo2" } = req.body;
 
   try {
-    // ── Web search detection ───────────────────────────────────────────────
+    // ── Web search (no file context) ───────────────────────────────────────
     if (needsWebSearch(message) && !currentFile) {
       send("status", { text: "Searching the web..." });
       send("web_search", { query: message });
@@ -430,40 +641,61 @@ app.post("/api/chat", async (req, res) => {
     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);
 
-    // ── No file: create from scratch ───────────────────────────────────────
+    // ── NO FILE: Create from scratch ───────────────────────────────────────
     if (!hasFile) {
       send("status", { text: "Planning what to build..." });
 
-      const aiRaw = await callAI(
-        `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,
-        modelKey
-      );
+      const createPrompt = `You are Cryo - a precise developer AI. Create the code the user requested.
 
+USER REQUEST: "${message}"
+
+Respond with ONLY a raw JSON object (no markdown, no prose around it):
+{
+  "filename": "appropriate filename like bot.js or app.py",
+  "description": "one line description of what this is",
+  "tasks": [{"task": "what you built", "done": true}],
+  "content": "COMPLETE working file content here",
+  "status": "Created - brief description"
+}
+
+RULES:
+- content must be a complete, working file
+- Escape all special characters in content properly for JSON
+- filename must have correct extension for the language`;
+
+      const aiRaw = await callAI(createPrompt, "", modelKey);
       let parsed = parseJSON(aiRaw);
+
+      // Fallback: extract code from markdown response
       if (!parsed?.content) {
+        const extracted = extractContentFromText(aiRaw || "");
+        // Try to guess filename from response
+        const fnMatch = aiRaw.match(/(?:file|save|name)[^a-z]*?([a-z0-9_-]+\.[a-z]{2,4})/i);
         parsed = {
-          filename: "index.js", content: aiRaw,
-          description: "Generated", tasks: [{ task: "Generate file", done: true }], status: "Created"
+          filename: fnMatch?.[1] || "index.js",
+          content: extracted || aiRaw,
+          description: "Generated code",
+          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} task(s)` });
       send("task_update", { tasks: parsed.tasks || [] });
       send("status", { text: "Checking generated code..." });
 
       const tmpName = `__cryo_new_${Date.now()}.js`;
       const tmpPath = path.join(HOME_DIR, tmpName);
       fs.writeFileSync(tmpPath, parsed.content, "utf8");
-      await syntaxFixLoop(tmpName, send, modelKey, 3);
-      parsed.content = fs.readFileSync(tmpPath, "utf8");
+
+      // Only syntax-check JS files
+      if (parsed.filename.endsWith(".js") || parsed.filename.endsWith(".ts")) {
+        await syntaxFixLoop(tmpName, send, modelKey, 3);
+        parsed.content = fs.readFileSync(tmpPath, "utf8");
+      }
       fs.unlinkSync(tmpPath);
 
       send("status", { text: `Saving ${parsed.filename}...` });
@@ -471,109 +703,44 @@ Return ONLY valid JSON (no markdown):
       fs.mkdirSync(path.dirname(savePath), { recursive: true });
       fs.writeFileSync(savePath, parsed.content, "utf8");
 
-      const finalCheck = await runCmd(`node --check ${parsed.filename}`);
-      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
-      });
+      if (parsed.filename.endsWith(".js")) {
+        const finalCheck = await runCmd(`node --check ${parsed.filename}`);
+        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
+        });
+      }
 
       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: parsed.status || `Created \`${parsed.filename}\`` });
       send("tree_update", {});
       res.write("data: [DONE]\n\n");
       res.end();
       return;
     }
 
-    // ── File exists: analyze + command loop + edit/answer ──────────────────
-    send("status", { text: "Analyzing request..." });
-    const smartCtx = getSmartContext(fileContent, message);
-
-    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.
-
-${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 EXISTS: Iterative agent loop ──────────���──────────────────────
+    send("status", { text: "Analyzing..." });
 
-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"
-}`,
-      message,
-      modelKey
-    );
-
-    let plan = parseJSON(masterPlanRaw);
-    if (!plan) plan = { task_type: "query", status: "Analyzing...", tasks: [], commands: [], reasoning: "" };
-
-    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("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),
-        stderr: result.stderr.substring(0, 500),
-        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 in ${targetFile} — entering fix loop...` });
-        await syntaxFixLoop(targetFile, send, modelKey, 3);
-        fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
-      }
-    }
+    const loopResult = await runAgentLoop({
+      filePath, fileContent, message, modelKey, send, maxRounds: 6
+    });
 
-    appendCmdHistory(historyEntries);
-    fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
+    const { allCommandResults, hadSedEdits, plan } = loopResult;
+    fileContent = loopResult.fileContent;
 
-    const resultsText = commandResults
-      .map(r => `$ ${r.cmd}\n${r.stdout.substring(0, 500)}${r.stderr ? `\nSTDERR: ${r.stderr.substring(0, 200)}` : ""}`)
+    const resultsText = allCommandResults
+      .map(r => `$ ${r.cmd}\n${r.stdout.substring(0, 400)}${r.stderr ? `\nSTDERR: ${r.stderr.substring(0, 150)}` : ""}`)
       .join("\n\n");
 
     send("status", { text: "Synthesizing..." });
 
+    // ── QUERY: just answer ─────────────────────────────────────────────
     if (plan.task_type === "query") {
-      // Check if answer might need web info
       if (needsWebSearch(message)) {
         send("web_search", { query: message });
         try {
@@ -582,34 +749,35 @@ Respond ONLY with valid JSON (no markdown):
           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)}`,
+            `You are Cryo. Answer the question based on the file content and command results. Be concise and direct. Return ONLY JSON: {"answer":"your answer here"}`,
+            `Question: "${message}"\nCommand results:\n${resultsText}\nFile context:\n${fileContent.substring(0, 1500)}`,
             modelKey
           );
           const ans = parseJSON(ansRaw);
-          send("message", { text: ans?.answer || ansRaw || "No answer generated." });
+          send("message", { text: ans?.answer || ansRaw || "Could not generate answer." });
         }
       } 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)}`,
+          `You are Cryo. Answer the question based on file content and command output. Return ONLY JSON: {"answer":"your answer here"}`,
+          `Question: "${message}"\nCommand results:\n${resultsText}\nFile:\n${fileContent.substring(0, 1500)}`,
           modelKey
         );
         const ans = parseJSON(ansRaw);
-        send("message", { text: ans?.answer || ansRaw || "No answer generated." });
+        send("message", { text: ans?.answer || ansRaw || "Could not generate answer." });
       }
 
     } else {
-      const hadSedEdits = commandResults.some(r => r.cmd.startsWith("sed -i") && r.code === 0);
-
+      // ── EDIT/CREATE: sed was used → verify & summarize ─────────────────
       if (hadSedEdits) {
-        send("status", { text: "Verifying sed edits..." });
-        await syntaxFixLoop(filePath, send, modelKey, 3);
-        fileContent = fs.readFileSync(absPath, "utf8");
+        send("status", { text: "Verifying edits..." });
+        if (filePath.endsWith(".js")) {
+          await syntaxFixLoop(filePath, send, modelKey, 3);
+        }
+        fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
 
         const sumRaw = await callAI(
-          `Summarize file changes. Return ONLY JSON: {"summary":"what changed","tasks_completed":["t1"]}`,
-          `User: ${message}\nCommands:\n${resultsText}`,
+          `Summarize what changed in the file. Return ONLY JSON: {"summary":"what changed","tasks_completed":["t1"]}`,
+          `User request: ${message}\nCommands run:\n${resultsText}`,
           modelKey
         );
         const sum = parseJSON(sumRaw);
@@ -619,45 +787,54 @@ Respond ONLY with valid JSON (no markdown):
         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 successfully." });
 
       } else {
+        // ── No sed edits were made → ask AI for complete file content ───
         const editRaw = await callAI(
-          `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.`,
+          `You are Cryo. Produce the COMPLETE updated file based on the user's request.
+RULES: Preserve everything not changed. Output must be the full working file.
+Return ONLY valid JSON (no markdown):
+{"content":"COMPLETE file content here","description":"what changed","status":"Done - brief summary"}`,
+          `User request: "${message}"\nFile: ${filePath}\nCurrent content:\n${fileContent.substring(0, 4000)}\nCommand results:\n${resultsText}\n\nProduce complete updated file.`,
           modelKey
         );
 
         let editParsed = parseJSON(editRaw);
+
+        // Fallback: extract code from markdown
         if (!editParsed?.content) {
-          editParsed = { content: fileContent, description: "No changes", status: "Done", tasks_completed: [] };
+          const extracted = extractContentFromText(editRaw || "");
+          editParsed = extracted
+            ? { content: extracted, description: "Updated", status: "Done" }
+            : { content: fileContent, description: "No changes made", status: "Done" };
         }
 
-        // Add Cryo inline comments
-        editParsed.content = editParsed.content;
-
         versionFile(filePath);
 
-        send("status", { text: "Checking new content before saving..." });
+        // Pre-save syntax check
+        send("status", { text: "Checking 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, modelKey, 3);
-        editParsed.content = fs.readFileSync(tmpPath, "utf8");
+
+        if (filePath.endsWith(".js")) {
+          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}` });
 
-        await syntaxFixLoop(filePath, send, modelKey, 3);
+        if (filePath.endsWith(".js")) {
+          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" }))
+          ...(plan.tasks || []).map(t => ({ ...t, done: true }))
         ];
         saveTasks(allTasks);
         updateMeta({ last_ai_edit: new Date().toISOString() });
@@ -668,10 +845,10 @@ Return ONLY valid JSON:
       }
     }
 
+    // ── Pending tasks check ────────────────────────────────────────────
     const latestTasks = readTasks();
     const stillPending = latestTasks.filter(t => !t.done);
     if (stillPending.length > 0) {
-      send("status", { text: `${stillPending.length} tasks still pending` });
       send("pending_tasks", { tasks: stillPending, count: stillPending.length });
     }