fix_logs_chat

Author: build_agent

AGENTS.md

@@ -176,7 +176,7 @@ Implemented and known-working:
   highlights, selection → "Add to Chat" floating action
 - Chat panel: Ask/Agent modes, slash commands, model dropdown, file mention
   chips with individual remove, drag-files-into-chat, code-block Apply,
-  streaming agent thinking, regenerate / copy / stop · shared SVG chevrons
+  regenerate / copy / stop · shared SVG chevrons
   (`ChevronExpand` / `PlayTriangle`) for disclosures and small affordances
 - Composer: `MentionInput` auto-grow; avoid spurious empty-state scrollbar
   (overflow hidden until max height — see `MentionInput.tsx` + `styles.css`)

app/backend/src/agent/executor.ts

@@ -1,6 +1,6 @@
 import { listFiles, readFile, writeFile, searchCode, buildCodebaseMapSummary, globFiles } from "../tools/file.js";
 import { runSmartCommand } from "../tools/smartCommand.js";
-import { applyPatches, type PatchResult } from "../tools/patch.js";
+import { applyPatches, patchApplyErrorCode, validateWritePatchPayload, type PatchResult } from "../tools/patch.js";
 import { autoValidate, summarizeValidation, type ValidationReport } from "../validation/validator.js";
 import { startAgentCommand } from "./commandLog.js";
 import { getWorkspace } from "../utils/workspace.js";
@@ -253,12 +253,26 @@ export async function executeTool(
       case "write_patch": {
         const raw = String(input.patches ?? input.patch ?? "");
         const path = typeof input.path === "string" ? input.path : undefined;
-        if (!raw) return { ok: false, summary: "write_patch: missing 'patches'" };
+        if (!raw) return { ok: false, summary: "[WP_INPUT] write_patch: missing 'patches'." };
+        const pathTrim = path?.trim();
+        const formatErr = validateWritePatchPayload(raw, pathTrim);
+        if (formatErr) return { ok: false, summary: `[${formatErr.code}] ${formatErr.message}` };
         const results: PatchResult[] = await applyPatches(raw, path);
-        if (results.length === 0) return { ok: false, summary: "write_patch: no valid SEARCH/REPLACE blocks parsed" };
+        if (results.length === 0) {
+          return {
+            ok: false,
+            summary:
+              "[WP_PARSE_NONE] No SEARCH/REPLACE blocks could be parsed. Use FILE: path then SEARCH/REPLACE/END, or pass path + body starting with SEARCH.",
+          };
+        }
 
         const ok = results.every((r) => r.applied);
-        const lines = results.map((r) => r.applied ? `OK ${r.path}` : `FAIL ${r.path}: ${r.error}`);
+        const lines = results.map((r) => {
+          if (r.applied) return `OK ${r.path}`;
+          const code = patchApplyErrorCode(r.error);
+          const oneLine = (r.error ?? "unknown").replace(/\s+/g, " ").trim();
+          return `FAIL [${code}] ${r.path} — ${oneLine}`;
+        });
         let validation: ValidationReport = { ran: [], ok: true };
         if (ok) validation = await autoValidate();
         const valSummary = ok ? `\n${summarizeValidation(validation)}` : "";

app/backend/src/agent/runner.ts

@@ -0,0 +1,38 @@
+/**
+ * Strip ReAct / rubric junk that models paste into FINAL or Ask-mode replies.
+ * The user bubble must not show planning THOUGHT or "(lang) describing that I…" meta.
+ */
+export function sanitizeAssistantFinalText(raw: string): string {
+  let s = raw.replace(/\r\n/g, "\n").trim();
+  if (!s) return s;
+
+  // Drop leaked THOUGHT blocks (same line or following lines)
+  const lineThought = s.search(/\n\s*THOUGHT\s*:/i);
+  if (lineThought >= 0) s = s.slice(0, lineThought).trim();
+
+  const inlineThought = s.search(/\sTHOUGHT\s*:/i);
+  if (inlineThought >= 0 && !/^\s*THOUGHT\s*:/im.test(s)) {
+    s = s.slice(0, inlineThought).trim();
+  }
+
+  if (/^\s*THOUGHT\s*:/im.test(s)) {
+    s = s.replace(/^\s*THOUGHT\s*:\s*/i, "").trim();
+    const again = s.search(/\n\s*THOUGHT\s*:/i);
+    if (again >= 0) s = s.slice(0, again).trim();
+  }
+
+  // System-shaped meta many models leak before the real answer
+  s = s
+    .replace(/^\s*\([^)]{0,120}\)\s*(?:describing|explaining|summarizing)\s+that\s+[^\n]+(?:\n|$)/i, "")
+    .trim();
+
+  return s.trim();
+}
+
+/** If sanitizer wiped useful content, keep original so the UI isn’t blank. */
+export function sanitizeFinalOrKeep(raw: string, minLen = 12): string {
+  const cleaned = sanitizeAssistantFinalText(raw);
+  if (cleaned.length >= minLen) return cleaned;
+  if (cleaned.length > 0 && raw.trim().length < minLen) return cleaned;
+  return raw.trim();
+}

app/backend/src/agent/sanitizeFinal.ts

@@ -164,18 +164,10 @@ async function runAgentInBackground(state: SessionState): Promise<void> {
     session.status = "completed";
     session.result = result;
     session.completedAt = Date.now();
-    
-    // Emit a synthetic "session_completed" event so listeners know it's done
-    const doneEvent: AgentEvent = { type: "final", result: result.result };
-    for (const listener of state.listeners) {
-      const l = listener;
-      setImmediate(() => {
-        try {
-          l(doneEvent);
-        } catch { /* ignore */ }
-      });
-    }
-    
+
+    // `runAgent` already emitted `final` through onEvent (and it's in session.events).
+    // Do not broadcast a second `final` — downstream UIs would append duplicate events.
+
     logger.info(`Session completed: ${session.id}`);
 
   } catch (err) {

app/backend/src/agent/sessionManager.ts

@@ -338,13 +338,37 @@ async function* _sseStream(res: Response, ollama: boolean): AsyncGenerator<strin
       }
       try {
         const obj = JSON.parse(payload) as {
-          choices?: { delta?: { content?: string }; message?: { content?: string } }[];
+          choices?: Array<{
+            delta?: {
+              content?: string | null;
+              /** Some OpenAI / proxy variants stream reasoning separately from answer tokens. */
+              reasoning?: string | null;
+              reasoning_content?: string | null;
+            };
+            message?: { content?: string };
+          }>;
           message?: { content?: string };
           done?: boolean;
         };
         const delta = ollama
           ? (obj.message?.content ?? "")
-          : (obj.choices?.[0]?.delta?.content ?? obj.choices?.[0]?.message?.content ?? "");
+          : (() => {
+              const choice0 = obj.choices?.[0];
+              const d = choice0?.delta as Record<string, unknown> | undefined;
+              const msg0 = choice0?.message;
+              const content =
+                (typeof d?.content === "string" ? d.content : "") ||
+                (typeof msg0?.content === "string" ? msg0.content : "");
+              // Merge reasoning-shaped fields so the ReAct trace / THOUGHT preview can stream like other providers.
+              let reasoning = "";
+              if (d) {
+                for (const k of ["reasoning", "reasoning_content", "thinking"] as const) {
+                  const v = d[k];
+                  if (typeof v === "string") reasoning += v;
+                }
+              }
+              return reasoning + content;
+            })();
         if (delta) yield delta;
       } catch { /* skip malformed chunk */ }
     }

app/backend/src/llm/client.ts

@@ -94,7 +94,7 @@ TOOLS:
 - search_code: {"type":"search_code","input":{"query":"function name"}}
 - glob: {"type":"glob","input":{"pattern":"**/*.ts"}}
 - run_command: {"type":"run_command","input":{"cmd":"npm test"}}
-- write_patch: {"type":"write_patch","input":{"patches":"FILE:path\\nSEARCH\\n<old>\\nREPLACE\\n<new>\\nEND"}}
+- write_patch: {"type":"write_patch","input":{"patches":"FILE:path\\nSEARCH\\n<old>\\nREPLACE\\n<new>\\nEND"}} — after FILE: rel/path the next line must be SEARCH then REPLACE (never raw file body under FILE:); new file = SEARCH\\n\\nREPLACE\\n<content>\\nEND. Or {"path":"x.ts","patches":"SEARCH\\n..."} only.
 - create_file: {"type":"create_file","input":{"path":"src/new.ts","content":"// file content"}}
 
 Parallel: emit multiple ACTION lines for independent ops (e.g. reading several files at once).
@@ -120,8 +120,8 @@ FINAL: I'm doing well! How can I help you with your code today?
 RULES:
 1. ONE action per turn (THOUGHT + ACTION, or THOUGHT + FINAL)
 2. Questions about files → read_file first
-3. Creating/editing files → use write_patch (never paste code in FINAL)
-4. Simple questions → FINAL directly
+3. Creating/editing files → use write_patch (never paste code in FINAL); each FILE: block must use SEARCH/REPLACE lines as in TOOLS. On patch failure read OBSERVATION codes like [WP_SEARCH_MISS].
+4. Simple questions → FINAL directly (user-facing text only — no meta-rubric, no THOUGHT pasted into FINAL)
 5. Match user's language in FINAL`;
 
 /** Even more compact for simple tasks */
@@ -144,7 +144,8 @@ export const ASK_SYSTEM_PROMPT_COMPACT = `Helpful coding assistant. Answer in Ma
 - Use fenced code blocks with language tags
 - Be concise, skip filler
 - If proposing changes, show the patched code
-- Never output THOUGHT/ACTION/FINAL format`;
+- Never output THOUGHT/ACTION/FINAL format
+- Reply in plain Markdown only — no internal meta-rubric lines (e.g. language tags "describing that I…")`;
 
 /** Ultra-short ASK system prompt (minimal token use). */
 export const ASK_SYSTEM_PROMPT_MINIMAL = `Coding assistant. Reply in Markdown only (no tools). Short answers; code in fenced blocks.`;

app/backend/src/llm/prompt-compact.ts

@@ -92,9 +92,11 @@ Available tools (set "type" to one of these):
 - "search_code"   input: { "query": "text" }
 - "glob"          input: { "pattern": "**/*.ts" }  — find files matching a glob pattern (** = any depth, * = within segment).
 - "run_command"   input: { "cmd": "shell command" }  — Executes shell commands. Long-running processes (servers, watchers, builds) auto-detect and return immediately when ready. See "Execution Intelligence" below.
-- "write_patch"   input: { "patches": "FILE: path\\nSEARCH\\n<old>\\nREPLACE\\n<new>\\nEND\\n..." }
+- "write_patch"   input: { "patches": "FILE: path\\nSEARCH\\n<old>\\nREPLACE\\n<new>\\nEND\\n..." } — optional { "path": "rel/path", "patches": "SEARCH\\n..." } for single-file edits only (body must start with SEARCH).
 - "create_file"   input: { "path": "rel/path", "content": "full file content" }  — create or overwrite a file directly (simpler than write_patch for new files).
 
+write_patch shape is strict: after every \`FILE: <relative-path>\` line, the next line must be exactly \`SEARCH\`, then the old text, then a line exactly \`REPLACE\`, then the new text, then optional \`END\`. Do not paste a full file right under \`FILE:\` without those markers. New file: empty SEARCH (\`SEARCH\\n\\nREPLACE\\n<full content>\\nEND\`). On failure, OBSERVATION may include bracket codes (\`[WP_FMT_AFTER_FILE]\`, \`[WP_SEARCH_MISS]\`, etc.)—read them and adjust the patch or re-read the file.
+
 **Parallel execution**: You may emit MULTIPLE ACTION blocks in a single response. All are dispatched concurrently. Only do this for genuinely independent operations (e.g. reading several unrelated files, creating multiple files that don't depend on each other). Format:
 THOUGHT: I need to read A and B to understand the issue.
 ACTION: {"type":"read_file","input":{"path":"src/a.ts"}}
@@ -160,6 +162,10 @@ Iteration awareness — pace yourself:
 
 - FINAL must be a SHORT summary describing what files were created/modified and why,
   pointing the user at the diff. Do NOT repeat the file contents in FINAL.
+- The text you put in FINAL is shown to the user **verbatim**. Do NOT paste internal
+  rubrics like \`(Vietnamese) describing that I can read code…\`, and do NOT repeat
+  or paste your THOUGHT inside FINAL — keep planning in THOUGHT only; FINAL is the
+  actual answer they read.
 
 Reasoning & tool discipline (keep THOUGHT to 1–6 sentences, but make them *useful*):
 - Anchor each THOUGHT in evidence: what you learned from RECENT STEPS / OBSERVATION (or previews),
@@ -244,7 +250,8 @@ Guidelines:
 - For non-trivial questions: brief diagnosis → concrete steps or options → note trade-offs or risks when relevant.
 - Separate facts you can infer from the prompt from guesses; say what you would open or run to verify.
 - If you need a file you weren't given, say which file you'd want to see.
-- NEVER output THOUGHT/ACTION/FINAL/JSON tool calls. Plain Markdown only.`;
+- NEVER output THOUGHT/ACTION/FINAL/JSON tool calls. Plain Markdown only.
+- Write as if speaking to the user: no internal rubrics (e.g. \`(Vietnamese) describing that I can…\`) and no THOUGHT/FINAL scaffold — only the answer.`;
 
 export function buildAskMessage(task: string, relevant: ScoredFile[], history: { role: string; content: string }[]): string {
   const filesBlock = relevant.length === 0

app/backend/src/llm/prompt.ts

@@ -13,6 +13,87 @@ export interface PatchResult {
   error?: string;
 }
 
+/** Short stable codes for OBSERVATION summaries so the model and UI can scan failures quickly. */
+export type PatchApplyErrorCode = "WP_SEARCH_MISS" | "WP_SEARCH_AMBIGUOUS" | "WP_FILE_MISSING" | "WP_APPLY";
+
+export function patchApplyErrorCode(error: string | undefined): PatchApplyErrorCode {
+  if (!error) return "WP_APPLY";
+  if (error === "SEARCH text not found") return "WP_SEARCH_MISS";
+  if (/^SEARCH text matches \d+ times\b/.test(error)) return "WP_SEARCH_AMBIGUOUS";
+  if (error.startsWith("File not found:")) return "WP_FILE_MISSING";
+  return "WP_APPLY";
+}
+
+export type WritePatchFormatError = {
+  code: WritePatchFormatCode;
+  message: string;
+};
+
+export type WritePatchFormatCode =
+  | "WP_EMPTY"
+  | "WP_FMT_FILE_TRUNC"
+  | "WP_FMT_AFTER_FILE"
+  | "WP_FMT_DEFAULT_SEARCH"
+  | "WP_FMT_NEED_FILE_OR_PATH";
+
+/**
+ * Structural validation before parsing/applying. Catches the common model mistake:
+ * `FILE: path` then raw file body with no SEARCH/REPLACE markers.
+ *
+ * @returns `null` if shape is acceptable for `parsePatch`; otherwise code + message (summary uses `[code] message`).
+ */
+export function validateWritePatchPayload(raw: string, defaultPathTrimmed?: string): WritePatchFormatError | null {
+  const text = raw.replace(/\r\n/g, "\n");
+  const t = text.trim();
+  if (!t) return { code: "WP_EMPTY", message: "write_patch patches string is empty." };
+
+  if (/^FILE:/m.test(t)) {
+    const parts = t.split(/(?=^FILE:)/m);
+    for (const part of parts) {
+      const seg = part.trim();
+      if (!seg.startsWith("FILE:")) continue;
+      const nl = seg.indexOf("\n");
+      if (nl === -1) {
+        return {
+          code: "WP_FMT_FILE_TRUNC",
+          message:
+            'Each FILE: line must be followed by a newline, then a line exactly "SEARCH", then old text, a line "REPLACE", new text, optional "END".',
+        };
+      }
+      const pathHint = seg.slice(0, nl).replace(/^FILE:[ \t]*/i, "").trim() || "(path)";
+      const afterPath = seg.slice(nl + 1);
+      if (!afterPath.startsWith("SEARCH\n")) {
+        return {
+          code: "WP_FMT_AFTER_FILE",
+          message:
+            `After FILE: ${pathHint} the next line must be exactly "SEARCH", then old text, then "REPLACE", then new text, then optional "END". ` +
+            `Do not paste raw file content under FILE:. For a new file use SEARCH\\n\\nREPLACE\\n<full file>\\nEND.`,
+        };
+      }
+    }
+    return null;
+  }
+
+  if (defaultPathTrimmed) {
+    if (!t.startsWith("SEARCH\n")) {
+      return {
+        code: "WP_FMT_DEFAULT_SEARCH",
+        message:
+          'When using input.path, the patches body must start with "SEARCH\\n", then old text, "REPLACE\\n", then new text. ' +
+          "Or use multi-file format: FILE: rel/path then SEARCH/REPLACE blocks.",
+      };
+    }
+    return null;
+  }
+
+  return {
+    code: "WP_FMT_NEED_FILE_OR_PATH",
+    message:
+      "Include at least one FILE: <relative-path> block with SEARCH/REPLACE/END, " +
+      'or pass path plus a body that starts with "SEARCH\\n".',
+  };
+}
+
 /**
  * Parse a patch payload. Two accepted shapes:
  *