Update server.js

server.js

@@ -952,7 +952,9 @@ COMMANDS FORMAT RULES — VIOLATIONS WILL CRASH THE SYSTEM:
 - EVERY command must be a complete shell command runnable in bash
 - NEVER include comments, explanations, or step labels inside the commands array
 
-CRITICAL: done:true only when sed -n CONFIRMS the change is physically in the file, OR full_rewrite:true is set.`;
+CRITICAL: done:true only when sed -n or grep CONFIRMS the change is physically in the file, OR full_rewrite:true is set.
+NEVER set done:true based only on the fact that sed ran — sed exits 0 even when the pattern did not match.
+MANDATORY last step before done:true: run grep -n to prove the new code exists in the file.`;
 
     const contRaw = await callAI(continuePrompt, "", modelKey, transcript);
     let cont = sanitizeAIResponse(parseJSON(contRaw));
@@ -1050,6 +1052,33 @@ CRITICAL: done:true only when sed -n CONFIRMS the change is physically in the fi
     if (cont.done || !cont.commands || cont.commands.length === 0) {
       // Double-check: are all tasks actually marked done?
       const stillPending = sessionTasks.filter(t => !t.done);
+
+      // ── MANDATORY GROUND-TRUTH CHECK ─────────────────────────────────
+      // Never trust the AI's self-reported done:true without verifying
+      // the actual file on disk. The AI cannot see its own sed output —
+      // it only knows what it sent, not what actually landed.
+      if (cont.done && stillPending.length === 0) {
+        fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
+        const checkRaw = await callAI(
+          `Check if the user's request is fully present in the file content.
+Return ONLY JSON: {"verified": true | false, "reason": "what is present or missing"}`,
+          `REQUEST: "${message}"\nFILE CONTENT:\n${fileContent.substring(0, 3000)}`,
+          modelKey,
+          transcript
+        );
+        const check = parseJSON(checkRaw);
+        if (check?.verified === false) {
+          // AI claimed done but the change isn't in the file — keep going
+          send("status", { text: `Verification failed: ${check.reason} — retrying...` });
+          // Force one more round
+          sessionTasks = sessionTasks.map(t => ({ ...t, done: false }));
+          send("task_update", { tasks: sessionTasks });
+          if (round < maxRounds) continue;
+        }
+        send("status", { text: cont.status || "All tasks complete ✓" });
+        break;
+      }
+
       if (stillPending.length === 0 || cont.done) {
         send("status", { text: cont.status || "All tasks complete ✓" });
         break;
@@ -1073,7 +1102,12 @@ CRITICAL: done:true only when sed -n CONFIRMS the change is physically in the fi
     fileContent,
     plan,
     sessionTasks,
-    hadSedEdits: allCommandResults.some(r => r.cmd.startsWith("sed -i") && r.code === 0),
+    // A sed edit only "happened" if it ran AND produced output or was verified — exit 0 alone is not enough
+    // because `sed -i` returns 0 even when the pattern didn't match anything on some systems.
+    hadSedEdits: allCommandResults.some(r =>
+      r.cmd.startsWith("sed -i") && r.code === 0 &&
+      (r.structured?.linesChanged === "applied" || !r.stderr)
+    ),
     hadTeeWrites: allCommandResults.some(r => (r.cmd.startsWith("tee ") || r.cmd.includes(" > ")) && r.code === 0),
     hadFullRewrite: allCommandResults.some(r => r.cmd.startsWith("[full_rewrite]") && r.code === 0),
   };
@@ -1383,20 +1417,39 @@ RIGHT — content that is source code: "content": "const x = require('y');\\n\\n
         }
         fileContent = fs.existsSync(absPath) ? fs.readFileSync(absPath, "utf8") : fileContent;
 
-        const sumRaw = await callAI(
-          `Summarize what changed. Return ONLY JSON: {"summary":"one sentence of what changed","tasks_completed":["t1"]}`,
-          `ORIGINAL REQUEST: "${message}"\nCOMMAND LOG:\n${resultsText.substring(0, 1200)}`,
+        // ── GROUND-TRUTH VERIFICATION ────────────────────────────────────
+        // Ask the AI to check the ACTUAL file content against the request.
+        // This is the only honest source — not the command log.
+        const verifyRaw = await callAI(
+          `You are a code reviewer. Compare the user's request against the ACTUAL file content below.
+Determine if the request was fully implemented.
+Return ONLY JSON (no markdown):
+{
+  "implemented": true | false,
+  "summary": "one honest sentence: what changed, or what is MISSING if not implemented",
+  "missing": "describe what is still missing, or null if fully done"
+}`,
+          `ORIGINAL REQUEST: "${message}"
+ACTUAL FILE CONTENT (this is the real file on disk — trust this, not the command log):
+${fileContent.substring(0, 3500)}`,
           modelKey,
           transcript
         );
-        const sum = parseJSON(sumRaw);
-        const allTasks = [...existingTasks.map(t => ({ ...t, done: true })), ...(plan.tasks || []).map(t => ({ ...t, done: true }))];
+        const verify = parseJSON(verifyRaw);
+
+        const allTasks = [...existingTasks.map(t => ({ ...t, done: true })), ...(plan.tasks || []).map(t => ({ ...t, done: verify?.implemented !== false }))];
         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 successfully." });
+        send("file_updated", { filename: filePath, content: fileContent, description: verify?.summary || "Updated" });
+
+        if (verify?.implemented === false) {
+          // Change did NOT land — report honestly, do not claim success
+          send("message", { text: `⚠️ Edit incomplete: ${verify.summary}${verify.missing ? ` — still missing: ${verify.missing}` : ""}` });
+        } else {
+          send("message", { text: verify?.summary || "Changes applied successfully." });
+        }
 
       } else {
         // ── No sed edits were made → ask AI for complete file content ───
@@ -1453,15 +1506,31 @@ CURRENT FILE CONTENT (line numbers for reference):\n${
         }
         fileContent = fs.readFileSync(absPath, "utf8");
 
+        // Verify honestly against real file
+        const verifyFbRaw = await callAI(
+          `You are a code reviewer. Check if the user's request is implemented in the actual file.
+Return ONLY JSON:
+{"implemented": true | false, "summary": "one honest sentence", "missing": "what is missing or null"}`,
+          `REQUEST: "${message}"\nACTUAL FILE (trust this):\n${fileContent.substring(0, 3500)}`,
+          modelKey,
+          transcript
+        );
+        const verifyFb = parseJSON(verifyFbRaw);
+
         const allTasks = [
           ...existingTasks.map(t => ({ ...t, done: true })),
-          ...(plan.tasks || []).map(t => ({ ...t, done: true }))
+          ...(plan.tasks || []).map(t => ({ ...t, done: verifyFb?.implemented !== false }))
         ];
         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("file_updated", { filename: filePath, content: fileContent, description: verifyFb?.summary || editParsed.description });
+
+        if (verifyFb?.implemented === false) {
+          send("message", { text: `⚠️ Edit incomplete: ${verifyFb.summary}${verifyFb.missing ? ` — still missing: ${verifyFb.missing}` : ""}` });
+        } else {
+          send("message", { text: verifyFb?.summary || editParsed.status || editParsed.description });
+        }
         send("tree_update", {});
       }
     }