@taj-special/dravix-code 1.1.5 → 1.1.6

package/dist/cli/repl.js

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import chalk from 'chalk';
-import { streamChat, fetchSystemPrompt } from '../services/ai.js';
+import { streamChat, fetchSystemPrompt, FLASH_MODEL, PRO_MODEL } from '../services/ai.js';
 import { buildContext } from '../services/context.js';
 import { parseOps, executeSingleOp, computeDiff } from '../services/executor.js';
 import { handleCommand } from './commands.js';
@@ -12,6 +12,73 @@ import { getToken, getSavedUser } from '../services/auth.js';
 import { checkUsage, reportUsage, estimateTokens, usageBar, fmtNum, formatResetTime } from '../services/usage.js';
 // System prompt is fetched from server at runtime — not stored in this package
 const BASE_PROMPT = ``;
+// Critical behavioral rules — always injected into system prompt for every session
+const BEHAVIORAL_RULES = `
+
+## LANGUAGE RULE — HIGHEST PRIORITY, NO EXCEPTIONS:
+Identify the language of the user's message. Reply 100% in that same language — every single word of your response.
+- User wrote Tajik (contains: нест, кун, илова, файл, тағир...) → respond ONLY in Tajik
+- User wrote Russian (contains: удали, добавь, измени, файл...) → respond ONLY in Russian
+- User wrote English → respond ONLY in English
+This rule overrides everything. Even when editing files, your commentary is in the user's language.
+
+## EXECUTE IMMEDIATELY — never ask what to do, never explain before acting.
+
+## FILE OPERATIONS — use these exact tag formats:
+
+### READ a file (when content not yet provided):
+<read_file path="filename"/>
+
+### CHANGE something:
+<edit_file path="file.js">
+<find>
+exact old text copied from file
+</find>
+<replace>
+new text goes here
+</replace>
+</edit_file>
+
+### DELETE something — <replace> tag is COMPLETELY EMPTY, no spaces, no newlines inside:
+<edit_file path="file.js">
+<find>
+exact text to remove copied from file
+</find>
+<replace></replace>
+</edit_file>
+
+### CREATE or fully rewrite a file:
+<write_file path="file.js">
+full file content here
+</write_file>
+
+### RUN a command:
+<run_command>command here</run_command>
+
+## RULES:
+- File content labeled [File: name — FULL] is already provided — use it, do NOT read again.
+- Copy <find> text CHARACTER BY CHARACTER from the actual file — never write from memory.
+- Include enough surrounding lines so <find> matches exactly ONE location.
+- DELETE = <replace></replace> with nothing inside — if you put anything inside, it is NOT a delete.
+- "Found N identical occurrences" → add more lines to <find> until it is unique.
+
+## PERSONALITY & COMMUNICATION:
+- Be warm, friendly, and professional — like a skilled teammate who enjoys the work.
+- Before acting: one short sentence saying what you are about to do — write it in the SAME language the user used.
+- After acting: confirm what was done in a natural, friendly tone — in the SAME language the user used.
+- If the task is interesting or you notice something worth mentioning (a side effect, a tip, a related thing), say it briefly.
+- CRITICAL: Detect the user's language from their message and use that EXACT language for your entire response. Tajik → Tajik. Russian → Russian. English → English. This applies to ALL messages including when doing file operations.`;
+// Full prompt used when server returns empty
+const FALLBACK_PROMPT = `You are Dravix Code — a hyper-professional AI coding assistant running in the terminal.
+You are an elite software engineer who takes immediate, precise action on every request.
+
+Core identity:
+- You write production-quality code with no unnecessary comments or fluff
+- You take action first, explain only when absolutely necessary
+- You handle any language: TypeScript, JavaScript, Python, Go, Rust, HTML/CSS, SQL, and more
+- You work on any project type: web apps, mobile apps, CLIs, APIs, databases, scripts
+
+${BEHAVIORAL_RULES}`;
 // prompts removed
 // Removed — fetched from server
 const CREATOR_EXTRA = ``;
@@ -484,6 +551,61 @@ class MarkdownRenderer {
         return out;
     }
 }
+// ── Targeted section finder — finds proper HTML container boundaries ──
+function findSectionBlocks(content, keywords) {
+    const lines = content.split('\n');
+    const seen = new Set();
+    const out = [];
+    for (const kw of keywords) {
+        if (kw.length < 3)
+            continue;
+        const kwL = kw.toLowerCase();
+        for (let i = 0; i < lines.length; i++) {
+            if (seen.has(i))
+                continue;
+            if (!lines[i].toLowerCase().includes(kwL))
+                continue;
+            // ── Go UP: find enclosing container opening tag ──────────────
+            let startIdx = Math.max(0, i - 3);
+            const kwIndent = (lines[i].match(/^(\s*)/)?.[1] ?? '').length;
+            for (let j = i - 1; j >= Math.max(0, i - 60); j--) {
+                const trimmed = lines[j].trim();
+                const lineIndent = (lines[j].match(/^(\s*)/)?.[1] ?? '').length;
+                // Opening block tag at same or lower indent level
+                if (lineIndent <= kwIndent && /<(section|div|article|main|header|footer|ul|ol)\b[^>]*>/.test(trimmed)) {
+                    startIdx = j;
+                    break;
+                }
+                // CSS section comment  /* ═══ ... ═══ */
+                if (lineIndent <= kwIndent && /\/\*.*[═=─\-]{2,}/.test(trimmed)) {
+                    startIdx = Math.max(0, j);
+                    break;
+                }
+            }
+            // ── Go DOWN: find matching closing tag ───────────────────────
+            const openMatch = lines[startIdx].match(/<(section|div|article|main|header|footer|ul|ol)\b/);
+            let endIdx = Math.min(lines.length - 1, i + 180);
+            if (openMatch) {
+                const tag = openMatch[1];
+                let depth = 0;
+                for (let j = startIdx; j <= Math.min(lines.length - 1, i + 300); j++) {
+                    depth += (lines[j].match(new RegExp(`<${tag}[\\s>]`, 'g')) ?? []).length;
+                    depth -= (lines[j].match(new RegExp(`</${tag}>`, 'g')) ?? []).length;
+                    if (depth <= 0 && j > startIdx) {
+                        endIdx = j;
+                        break;
+                    }
+                }
+            }
+            const block = lines.slice(startIdx, endIdx + 1).join('\n');
+            out.push({ keyword: kw, lineNo: i + 1, block, startLine: startIdx + 1, endLine: endIdx + 1 });
+            for (let j = startIdx; j <= endIdx; j++)
+                seen.add(j);
+            break;
+        }
+    }
+    return out;
+}
 function normalizeResponse(text) {
     return text.replace(/```[\w]*\n?(<(?:write_file|edit_file|delete_file|create_folder|run_command|read_file|read_folder|search_code)[\s\S]*?(?:<\/(?:write_file|edit_file|run_command)>|<(?:delete_file|create_folder|read_file|read_folder|search_code)[^>]*\/>))\n?```/g, '$1');
 }
@@ -526,7 +648,148 @@ function clearMenu(lines) {
         process.stdout.write('\x1b[1A\x1b[2K');
     }
 }
-async function askPermission(label, key, alwaysAllowed, noAlways) {
+// Returns number of terminal lines printed (for clearing after acceptance)
+function printDiffPreview(op, cwd) {
+    let printed = 0;
+    try {
+        const cols = process.stdout.columns ?? 80;
+        const maxW = Math.min(cols - 12, 120);
+        const clip = (t) => t.length > maxW ? t.slice(0, maxW - 1) + '…' : t;
+        let diff = null;
+        if (op.type === 'write' && op.path && op.content !== undefined) {
+            const fp = path.resolve(cwd, op.path);
+            const old = fs.existsSync(fp) ? fs.readFileSync(fp, 'utf-8') : '';
+            diff = computeDiff(old, op.content);
+        }
+        else if (op.type === 'edit' && op.path && op.find !== undefined && op.replace !== undefined) {
+            // Find real line offset in file so line numbers match actual file
+            const rawDiff = computeDiff(op.find, op.replace);
+            try {
+                const fp = path.resolve(cwd, op.path);
+                if (fs.existsSync(fp)) {
+                    const fileContent = fs.readFileSync(fp, 'utf-8');
+                    const idx = fileContent.indexOf(op.find.trim());
+                    const offset = idx >= 0 ? fileContent.slice(0, idx).split('\n').length - 1 : 0;
+                    diff = rawDiff.map(d => ({ ...d, lineNo: d.lineNo + offset }));
+                }
+                else {
+                    diff = rawDiff;
+                }
+            }
+            catch {
+                diff = rawDiff;
+            }
+        }
+        if (!diff)
+            return 0;
+        const adds = diff.filter(d => d.kind === 'add').length;
+        const removes = diff.filter(d => d.kind === 'remove').length;
+        if (adds === 0 && removes === 0)
+            return 0;
+        const statStr = [
+            removes > 0 ? chalk.hex('#f87171').bold(`-${removes}`) : '',
+            adds > 0 ? chalk.hex('#34d399').bold(`+${adds}`) : '',
+        ].filter(Boolean).join('  ');
+        const writeLine = (s) => { process.stdout.write(s + '\n'); printed++; };
+        process.stdout.write('\n');
+        printed++;
+        writeLine(chalk.hex('#fbbf24')('  ~') +
+            chalk.hex('#94a3b8')('  ') +
+            chalk.hex('#e2e8f0')(op.path ?? '') +
+            (statStr ? '   ' + statStr : ''));
+        const CONTEXT = 2;
+        const show = new Uint8Array(diff.length);
+        for (let i = 0; i < diff.length; i++) {
+            if (diff[i].kind !== 'context') {
+                for (let c = Math.max(0, i - CONTEXT); c <= Math.min(diff.length - 1, i + CONTEXT); c++)
+                    show[c] = 1;
+            }
+        }
+        const renderLine = (line) => {
+            const num = String(line.lineNo).padStart(5, ' ');
+            if (line.kind === 'remove') {
+                const content = `  ${num}  ${chalk.hex('#f87171')('-')}  ${clip(line.text)}`;
+                writeLine('  ' + chalk.hex('#7f1d1d')('▌') + chalk.bgHex('#1c0a0a')(content.padEnd(cols - 3)));
+            }
+            else if (line.kind === 'add') {
+                const content = `  ${num}  ${chalk.hex('#34d399')('+')}  ${clip(line.text)}`;
+                writeLine('  ' + chalk.hex('#065f46')('▌') + chalk.bgHex('#021a0e')(content.padEnd(cols - 3)));
+            }
+            else {
+                writeLine(chalk.hex('#374151')(`       ${num}     ${clip(line.text)}`));
+            }
+        };
+        const hunks = [];
+        let curHunk = [];
+        let lastIdx = -1;
+        for (let i = 0; i < diff.length; i++) {
+            if (!show[i])
+                continue;
+            if (lastIdx >= 0 && i > lastIdx + 1) {
+                hunks.push(curHunk);
+                curHunk = [];
+            }
+            lastIdx = i;
+            curHunk.push(diff[i]);
+        }
+        if (curHunk.length > 0)
+            hunks.push(curHunk);
+        let shown = 0;
+        const MAX_LINES = 60;
+        for (let h = 0; h < hunks.length; h++) {
+            if (shown >= MAX_LINES)
+                break;
+            if (h > 0) {
+                writeLine(chalk.hex('#374151')('        ╌╌╌'));
+            }
+            const hunk = hunks[h];
+            const before = [];
+            const hRem = [];
+            const hAdd = [];
+            let pendingCtx = [];
+            let seenChange = false;
+            for (const line of hunk) {
+                if (line.kind === 'context') {
+                    if (!seenChange)
+                        before.push(line);
+                    else
+                        pendingCtx.push(line);
+                }
+                else {
+                    seenChange = true;
+                    pendingCtx = [];
+                    if (line.kind === 'remove')
+                        hRem.push(line);
+                    else
+                        hAdd.push(line);
+                }
+            }
+            for (const l of before)
+                renderLine(l);
+            for (const l of hRem) {
+                if (shown >= MAX_LINES)
+                    break;
+                renderLine(l);
+                shown++;
+            }
+            for (const l of hAdd) {
+                if (shown >= MAX_LINES)
+                    break;
+                renderLine(l);
+                shown++;
+            }
+            for (const l of pendingCtx)
+                renderLine(l);
+        }
+        const total = diff.filter(d => d.kind !== 'context').length;
+        if (total > MAX_LINES) {
+            writeLine(chalk.hex('#4b5563')(`        … ${total - MAX_LINES} more lines`));
+        }
+    }
+    catch { /* ignore */ }
+    return printed;
+}
+async function askPermission(label, key, alwaysAllowed, noAlways, diffShown, previewLineCount = 0) {
     if (!noAlways && alwaysAllowed.has(key))
         return true;
     return new Promise((resolve) => {
@@ -538,37 +801,48 @@ async function askPermission(label, key, alwaysAllowed, noAlways) {
         const { icon, paint } = opStyle(label);
         const optLabels = noAlways ? OPT_LABELS_RUN : OPT_LABELS_DEFAULT;
         const optCount = optLabels.length;
-        // run: 3-line box (╭header + │cmd + ╰) + blank + options
-        // file ops: 4-line box (╭ + │type + │value + ╰) + blank + options
-        const menuLines = (noAlways ? 3 : 4) + 1 + optCount;
+        // when diff already shown: just blank + options (no box)
+        const menuLines = diffShown ? (1 + optCount) : (noAlways ? 3 : 4) + 1 + optCount;
         function printMenu() {
             if (drawn)
                 clearMenu(menuLines);
             drawn = true;
-            let boxLines;
-            if (noAlways) {
-                const dashes = SEP.length - 2 - 'run command'.length - 1;
-                boxLines = [
-                    colors.dim('  ╭─ ') + colors.primary('run command') + colors.dim(' ' + '─'.repeat(Math.max(dashes, 1))),
-                    `  │  ${chalk.hex('#fbbf24')('$')}  ${chalk.white(opValue)}`,
-                    colors.dim('  ╰' + SEP),
+            let lines;
+            if (diffShown) {
+                // Diff already shown above — just show options, no redundant box
+                lines = [
+                    '',
+                    ...optLabels.map((lbl, i) => i === sel
+                        ? `  ${colors.primary('›')}  ${colors.primary.bold(lbl)}`
+                        : `     ${colors.muted(lbl)}`),
                 ];
             }
             else {
-                boxLines = [
-                    colors.dim('  ╭' + SEP),
-                    `  │  ${paint(icon + '  ' + opType)}`,
-                    `  │     ${chalk.white(opValue)}`,
-                    colors.dim('  ╰' + SEP),
+                let boxLines;
+                if (noAlways) {
+                    const dashes = SEP.length - 2 - 'run command'.length - 1;
+                    boxLines = [
+                        colors.dim('  ╭─ ') + colors.primary('run command') + colors.dim(' ' + '─'.repeat(Math.max(dashes, 1))),
+                        `  │  ${chalk.hex('#fbbf24')('$')}  ${chalk.white(opValue)}`,
+                        colors.dim('  ╰' + SEP),
+                    ];
+                }
+                else {
+                    boxLines = [
+                        colors.dim('  ╭' + SEP),
+                        `  │  ${paint(icon + '  ' + opType)}`,
+                        `  │     ${chalk.white(opValue)}`,
+                        colors.dim('  ╰' + SEP),
+                    ];
+                }
+                lines = [
+                    ...boxLines,
+                    '',
+                    ...optLabels.map((lbl, i) => i === sel
+                        ? `  ${colors.primary('›')}  ${colors.primary.bold(lbl)}`
+                        : `     ${colors.muted(lbl)}`),
                 ];
             }
-            const lines = [
-                ...boxLines,
-                '',
-                ...optLabels.map((lbl, i) => i === sel
-                    ? `  ${colors.primary('›')}  ${colors.primary.bold(lbl)}`
-                    : `     ${colors.muted(lbl)}`),
-            ];
             process.stdout.write(lines.join('\n') + '\n');
         }
         printMenu();
@@ -578,6 +852,10 @@ async function askPermission(label, key, alwaysAllowed, noAlways) {
         function confirm(idx) {
             cleanup();
             clearMenu(menuLines);
+            // Clear the diff preview lines (all except the first blank separator)
+            for (let i = 0; i < previewLineCount - 1; i++) {
+                process.stdout.write('\x1b[1A\x1b[2K');
+            }
             const skipIdx = noAlways ? 1 : 2;
             if (idx === skipIdx) {
                 process.stdout.write(`  ${colors.muted('○')}  ${colors.muted('Skipped: ' + label)}\n`);
@@ -1930,9 +2208,15 @@ export async function startRepl(cwd) {
     let SYSTEM_PROMPT = '';
     if (token) {
         const { prompt, webDesignerSkill } = await fetchSystemPrompt(token);
-        SYSTEM_PROMPT = prompt;
+        // Always inject behavioral rules — append to server prompt so critical rules are never missing
+        SYSTEM_PROMPT = prompt
+            ? prompt + '\n' + BEHAVIORAL_RULES
+            : FALLBACK_PROMPT;
         _serverWebDesignerSkill = webDesignerSkill;
     }
+    else {
+        SYSTEM_PROMPT = FALLBACK_PROMPT;
+    }
     // activeCwd can change when /resume loads a conversation from a different directory
     let activeCwd = cwd;
     const buildSystemMsg = (dir) => ({
@@ -1953,6 +2237,7 @@ export async function startRepl(cwd) {
     let pendingOutputTokens = 0;
     let pendingUserTokens = 0;
     let hasPendingReport = false;
+    let useProModel = false; // switched to PRO_MODEL after file op errors
     process.stdin.once('end', () => {
         console.log(colors.muted('\n  Goodbye!\n'));
         process.exit(0);
@@ -2002,24 +2287,40 @@ export async function startRepl(cwd) {
             if (readFileContinue) {
                 readFileContinue = false;
                 readFileTurnCount++;
-                if (readFileTurnCount > 3 && !forcedEditMode) {
+                // Remind AI of the original user request — show first + last line so pasted code
+                // doesn't eclipse the actual instruction written at the end.
+                const rawUserMsg = lastUserLine.trim();
+                const msgLines = rawUserMsg.split('\n').map(l => l.trim()).filter(Boolean);
+                let userReminder = '';
+                if (msgLines.length > 0) {
+                    const first = msgLines[0].slice(0, 100);
+                    const last = msgLines[msgLines.length - 1].slice(0, 150);
+                    const display = msgLines.length <= 2 ? msgLines.join(' / ').slice(0, 200) : `${first} [...] ${last}`;
+                    userReminder = `The user's request: "${display}". `;
+                }
+                const taskInstruction = userReminder
+                    ? `The user's exact request was: "${rawUserMsg.slice(0, 300)}"\nNow execute THIS request and ONLY this request — nothing else. Do not invent, add, or change anything the user did not ask for. Use the file content above to find the exact text and apply the change.`
+                    : `Execute the user's request using the file content above.`;
+                // Keep using FLASH_MODEL after file reads
+                if (readFileTurnCount > 5 && !forcedEditMode) {
                     forcedEditMode = true;
                     history.push({
                         role: 'system',
-                        content: `[FORCED EDIT MODE] You have done ${readFileTurnCount} read/search operations — reads are now BLOCKED.\nYou MUST output a tag RIGHT NOW. No more explanation, no more searching:\n  • <edit_file path="..."><find>EXACT text from file</find><replace>new content</replace></edit_file>\n  • <write_file path="...">COMPLETE file content here</write_file>\nIf you are unsure of exact text → use <write_file> with the complete corrected content. OUTPUT THE TAG NOW.`,
+                        content: `[CONTEXT READY] ${taskInstruction}\nDo not read any more files — use what is already in context.`,
                     });
                     process.stdout.write('\n' + colors.muted('  ⚠  Too many read operations — forced edit mode') + '\n');
                 }
-                else if (readFileTurnCount >= 2) {
-                    // Escalating signal: AI has read enough, must act now
+                else if (readFileTurnCount >= 3) {
                     history.push({
                         role: 'system',
-                        content: `[ACTION REQUIRED] You have done ${readFileTurnCount} read operations. STOP reading. You have enough context — output <edit_file> or <write_file> NOW. Do NOT search or read again. Output ONLY the tag.`,
+                        content: `[CONTEXT READY] ${taskInstruction}`,
                     });
                 }
                 else {
-                    // First continuation: gentle signal
-                    history.push({ role: 'system', content: 'You now have the file content. Proceed with the task — output the edit or write tag directly, no explanation needed.' });
+                    history.push({
+                        role: 'system',
+                        content: `[FILE CONTENT READY] ${taskInstruction}`,
+                    });
                 }
                 skipInput = true;
                 result = { text: '', lines: [] };
@@ -2089,11 +2390,19 @@ export async function startRepl(cwd) {
             if (!skipInput) {
                 readFileTurnCount = 0; // reset loop counter for each new user message
                 forcedEditMode = false; // reset forced edit mode for each new user message
+                useProModel = false; // reset model selection for each new user message
                 // ── Refresh project context (files may have changed since last turn) ──
                 history[0] = buildSystemMsg(activeCwd);
                 // ── Clear stale operational messages left from previous auto-continue turns ──
                 // They pollute future user messages when prepareMessages merges consecutive roles.
-                const STALE_PREFIXES = ['[File updated]', '[SYSTEM LIMIT]', '[BLOCKED]', 'Please proceed with the task'];
+                const STALE_PREFIXES = [
+                    '[File updated]', '[SYSTEM LIMIT]', '[BLOCKED]', 'Please proceed with the task',
+                    '[FORCED EDIT MODE]', '[ACTION REQUIRED]', '[Auto-reading',
+                    '[Web Designer mode', 'You have done ', 'You now have the file content',
+                    'You described the steps but', 'Your previous response was cut off',
+                    '[CONTEXT READY]', '[TARGET SECTION', '[FILE CONTENT READY]',
+                    'The user\'s exact request was:',
+                ];
                 for (let i = history.length - 1; i > 0; i--) {
                     if (history[i].role === 'system' &&
                         STALE_PREFIXES.some(p => history[i].content.startsWith(p))) {
@@ -2106,7 +2415,6 @@ export async function startRepl(cwd) {
                 }
                 // ── Auto-inject mentioned file contents ──────────────────────
                 // Files ≤ 3000 lines: full raw content injected — AI has exact text for <find>, no reads needed.
-                // Files > 3000 lines: first 300 lines preview + AI does ONE <read_file> to get target section.
                 const FILE_PATTERN = /[\w\-.\/\\]+\.\w{2,5}/g;
                 const mentioned = [...new Set(line.match(FILE_PATTERN) ?? [])];
                 let fileContext = '';
@@ -2116,20 +2424,14 @@ export async function startRepl(cwd) {
                     if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
                         try {
                             const content = fs.readFileSync(fullPath, 'utf-8');
-                            const lines = content.split('\n');
-                            const lineCount = lines.length;
+                            const fileLines = content.split('\n');
+                            const lineCount = fileLines.length;
                             if (lineCount <= FULL_INJECT_LINES) {
-                                fileContext += `\n\n[File: ${fname} — FULL CONTENT — ${lineCount} lines]\n` +
-                                    `⚠ Complete file is here — do NOT use <read_file> for this file. Use <edit_file> directly.\n\n` +
-                                    content;
+                                fileContext += `\n\n[File: ${fname} — ${lineCount} lines — FULL]\n` + content;
                             }
                             else {
-                                // Very large file (>3000 lines): preview + single read instruction
-                                const preview = lines.slice(0, 300).join('\n');
-                                fileContext += `\n\n[File: ${fname} — ${lineCount} lines — first 300 lines shown]\n` +
-                                    `⚠ Use <read_file path="${fname}"/> (no lines=) to get full content, then edit.\n\n` +
-                                    preview +
-                                    `\n\n... (${lineCount - 300} more lines)`;
+                                fileContext += `\n\n[File: ${fname} — ${lineCount} lines]\n` +
+                                    `Use: <search_code pattern="TERM" path="${fname}"/> → <read_file path="${fname}"/> → <edit_file>\n`;
                             }
                         }
                         catch { /* skip unreadable */ }
@@ -2237,7 +2539,8 @@ export async function startRepl(cwd) {
                         executedInlineOps.add(inlineOpFingerprint(op));
                     }
                     else {
-                        const allowed = await askPermission(label, key, alwaysAllowed, op.type === 'run');
+                        const previewLines = (op.type === 'write' || op.type === 'edit') ? printDiffPreview(op, activeCwd) : 0;
+                        const allowed = await askPermission(label, key, alwaysAllowed, op.type === 'run', previewLines > 0, previewLines);
                         executedInlineOps.add(inlineOpFingerprint(op));
                         if (!allowed) {
                             if (op.path)
@@ -2264,19 +2567,43 @@ export async function startRepl(cwd) {
                             process.stdout.write('\r\x1b[K');
                             printOpResult(opResult);
                             if (opResult.type === 'error' && op.type !== 'run') {
-                                // If text not found, include current file content so AI can retry accurately
                                 let errMsg = `[Operation failed — ${label}]: ${opResult.message ?? 'Unknown error'}`;
                                 if (opResult.message?.includes('not found') && op.path) {
                                     try {
                                         const fp = path.resolve(activeCwd, op.path);
                                         if (fs.existsSync(fp)) {
                                             const cur = fs.readFileSync(fp, 'utf-8');
-                                            const nLines = cur.split('\n').length;
-                                            if (nLines <= 400) {
-                                                errMsg += `\n\nCurrent content of ${op.path}:\n${cur}\n\nUse <write_file> with the complete corrected content.`;
+                                            const curLines = cur.split('\n');
+                                            const nLines = curLines.length;
+                                            const isDeleteOp = !op.replace || op.replace.trim() === '';
+                                            // Auto-search for what AI was trying to find — inject exact block
+                                            const findLines = (op.find ?? '').split('\n').map(l => l.replace(/^\s*\d+\s*[│|:]\s?/, '').trim()).filter(Boolean);
+                                            const searchTerm = findLines[0]?.slice(0, 60) ?? '';
+                                            let foundAt = -1;
+                                            if (searchTerm.length > 4) {
+                                                for (let si = 0; si < curLines.length; si++) {
+                                                    if (curLines[si].toLowerCase().includes(searchTerm.toLowerCase())) {
+                                                        foundAt = si;
+                                                        break;
+                                                    }
+                                                }
+                                            }
+                                            if (foundAt >= 0) {
+                                                // Found the approximate location — inject surrounding block
+                                                const start = Math.max(0, foundAt - 2);
+                                                const end = Math.min(curLines.length - 1, foundAt + 100);
+                                                const block = curLines.slice(start, end + 1).join('\n');
+                                                errMsg += `\n\n[FOUND near line ${foundAt + 1} in ${op.path}]:\n${block}\n`;
+                                                errMsg += isDeleteOp
+                                                    ? `\nDELETE FIX: Copy the EXACT full container (from its opening <div>/<section> tag through the matching closing tag) from above. Put it in <edit_file path="${op.path}"><find>EXACT_TEXT</find><replace></replace>. Text must match CHARACTER FOR CHARACTER.`
+                                                    : `\nEDIT FIX: Copy the EXACT text you want to change from above. Use <edit_file path="${op.path}"><find>EXACT_TEXT</find><replace>NEW_TEXT</replace>.`;
+                                            }
+                                            else if (nLines <= 400) {
+                                                errMsg += `\n\nFull content of ${op.path} (${nLines} lines):\n${cur}\n\nFIX: Copy the EXACT text from above into <find>. Character-for-character, no changes.`;
                                             }
                                             else {
-                                                errMsg += `\n\nFile has ${nLines} lines. Use the correct workflow:\n  1. <search_code pattern="first few words of what you want to find" path="${op.path}"/> — get line number\n  2. <read_file path="${op.path}" lines="N-M"/> — read that exact section\n  3. Copy the EXACT text (after the tab, without line numbers) into <find>`;
+                                                const safe = searchTerm.replace(/['"<>{}()\[\]]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 35);
+                                                errMsg += `\n\nFIX STEPS:\n1. <search_code pattern="${safe}" path="${op.path}"/>\n2. <read_file path="${op.path}" lines="N-M"/> (use line numbers from search)\n3. Copy EXACT text into <find> — no modifications, no line numbers`;
                                             }
                                         }
                                     }
@@ -2516,11 +2843,23 @@ export async function startRepl(cwd) {
                     // Pattern: response has numbered items like "2. something" or "3. something"
                     // but very few actual file operation tags were output → force continuation
                     if (!readFileContinue && !streamCancelled) {
+                        const hasAnyReadOp = allOps.some(op => op.type === 'read_file' || op.type === 'read_folder' || op.type === 'search_code');
+                        const writeOps = allOps.filter(op => op.type !== 'read_file' && op.type !== 'read_folder' && op.type !== 'search_code').length;
                         const plannedSteps = (normalized.match(/^\s*[2-9]\.\s+\S/mg) ?? []).length;
-                        const executedOps = allOps.filter(op => op.type !== 'read_file' && op.type !== 'read_folder' && op.type !== 'search_code').length;
-                        if (plannedSteps >= 1 && executedOps === 0 && !allOps.length) {
-                            history.push({ role: 'system', content: 'You described the steps but did not output any <edit_file> or <write_file> tags. Output the actual tags NOW to apply the changes. No more descriptions — just the tags.' });
+                        // AI described a plan (numbered steps 2+) but did nothing at all — force execution
+                        if (plannedSteps >= 1 && writeOps === 0 && !hasAnyReadOp) {
+                            history.push({ role: 'system', content: 'You described the steps but did not output any tags. Output the actual <edit_file> or <write_file> tags NOW to apply the changes. No explanation — just the tags.' });
                             readFileContinue = true;
+                            // AI gave a non-trivial response with zero operations of any kind
+                        }
+                        else if (writeOps === 0 && allOps.length === 0 && normalized.trim().length > 200) {
+                            const hasCodeFence = normalized.includes('```');
+                            const hasStepList = (normalized.match(/^\s*\d+[.)]\s+\S/mg) ?? []).length >= 2;
+                            const hasWouldNeed = /(?:should|would need to|need to|you(?:'d)? need to|we(?:'d)? need to)\s+(?:edit|modify|update|change|create|add|remove)/i.test(normalized);
+                            if ((hasCodeFence || hasStepList) && hasWouldNeed) {
+                                history.push({ role: 'system', content: 'You explained what to do but did not output any tags. Apply the changes NOW using <edit_file> or <write_file> tags. Do not re-explain — just output the tags.' });
+                                readFileContinue = true;
+                            }
                         }
                     }
                     const readOps = allOps.filter(op => op.type === 'read_file' || op.type === 'read_folder' || op.type === 'search_code');
@@ -2608,6 +2947,22 @@ export async function startRepl(cwd) {
                                             const lastLine = (res.output ?? '').split('\n').filter(Boolean).pop() ?? '';
                                             rightCol = chalk.hex('#6b7280')(lastLine.startsWith('Total:') ? lastLine.slice(7).trim() : `${ms}ms`);
                                             displayLabel = `"${op.pattern}"`;
+                                            // Auto-read section around first match so AI has exact text without another round-trip
+                                            const firstMatchLine = (res.output ?? '').match(/^([^\n:]+):(\d+):/m);
+                                            if (firstMatchLine) {
+                                                const matchFile = firstMatchLine[1].trim();
+                                                const matchLineNum = parseInt(firstMatchLine[2]);
+                                                if (!isNaN(matchLineNum) && matchFile) {
+                                                    const readStart = Math.max(1, matchLineNum - 3);
+                                                    const readEnd = matchLineNum + 280;
+                                                    const autoKey = `[File content — ${matchFile}][lines=${readStart}-${readEnd}]`;
+                                                    const alreadyHaveIt = history.slice(-10).some(m => m.role === 'system' && m.content.includes(`[File content — ${matchFile}]`));
+                                                    if (!alreadyHaveIt) {
+                                                        validOps.push({ type: 'read_file', path: matchFile, lines: `${readStart}-${readEnd}` });
+                                                        void autoKey;
+                                                    }
+                                                }
+                                            }
                                         }
                                         else if (op.type === 'read_folder') {
                                             ctxLabel = `[Folder contents — "${op.path}"]:\n${res.output ?? ''}`;
@@ -2708,7 +3063,8 @@ export async function startRepl(cwd) {
                                             continue;
                                         }
                                     }
-                                    const allowed = await askPermission(label, key, alwaysAllowed, op.type === 'run');
+                                    const previewLines2 = (op.type === 'write' || op.type === 'edit') ? printDiffPreview(op, activeCwd) : 0;
+                                    const allowed = await askPermission(label, key, alwaysAllowed, op.type === 'run', previewLines2 > 0, previewLines2);
                                     if (!allowed) {
                                         if (op.path)
                                             skippedPaths.add(op.path);
@@ -2737,7 +3093,47 @@ export async function startRepl(cwd) {
                                     printOpResult(opResult);
                                     // Collect file operation errors for AI feedback
                                     if (opResult.type === 'error' && op.type !== 'run') {
-                                        fileOpErrors.push(`[Operation failed — ${label}]: ${opResult.message ?? 'Unknown error'}`);
+                                        let errMsg = `[Operation failed — ${label}]: ${opResult.message ?? 'Unknown error'}`;
+                                        if (opResult.message?.includes('not found') && op.path) {
+                                            try {
+                                                const fp = path.resolve(activeCwd, op.path);
+                                                if (fs.existsSync(fp)) {
+                                                    const cur = fs.readFileSync(fp, 'utf-8');
+                                                    const curLines = cur.split('\n');
+                                                    const nLines = curLines.length;
+                                                    const isDeleteOp = !op.replace || op.replace.trim() === '';
+                                                    // Auto-search for approximate location of what AI tried to find
+                                                    const findLines = (op.find ?? '').split('\n').map(l => l.replace(/^\s*\d+\s*[│|:]\s?/, '').trim()).filter(Boolean);
+                                                    const searchTerm = findLines[0]?.slice(0, 60) ?? '';
+                                                    let foundAt = -1;
+                                                    if (searchTerm.length > 4) {
+                                                        for (let si = 0; si < curLines.length; si++) {
+                                                            if (curLines[si].toLowerCase().includes(searchTerm.toLowerCase())) {
+                                                                foundAt = si;
+                                                                break;
+                                                            }
+                                                        }
+                                                    }
+                                                    if (foundAt >= 0) {
+                                                        const start = Math.max(0, foundAt - 2);
+                                                        const end = Math.min(curLines.length - 1, foundAt + 100);
+                                                        errMsg += `\n\n[FOUND near line ${foundAt + 1}]:\n${curLines.slice(start, end + 1).join('\n')}\n`;
+                                                        errMsg += isDeleteOp
+                                                            ? `\nDELETE FIX: Copy the EXACT full container from above into <edit_file><find>EXACT</find><replace></replace>.`
+                                                            : `\nEDIT FIX: Copy EXACT text from above into <edit_file><find>EXACT</find><replace>NEW</replace>.`;
+                                                    }
+                                                    else if (nLines <= 400) {
+                                                        errMsg += `\n\nFull file (${nLines} lines):\n${cur}\n\nFIX: Copy EXACT text from above into <find>.`;
+                                                    }
+                                                    else {
+                                                        const safe = searchTerm.replace(/['"<>{}()\[\]]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 35);
+                                                        errMsg += `\n\nFIX: <search_code pattern="${safe}" path="${op.path}"/> → <read_file lines="N-M"/> → copy EXACT text into <find>.`;
+                                                    }
+                                                }
+                                            }
+                                            catch { /* ignore */ }
+                                        }
+                                        fileOpErrors.push(errMsg);
                                     }
                                     if (op.type === 'run' && op.command) {
                                         if (opResult.type === 'run') {
@@ -2805,7 +3201,7 @@ export async function startRepl(cwd) {
                                     : raw;
                     printError(msg);
                     resolve();
-                }, streamAbort.signal);
+                }, streamAbort.signal, useProModel ? PRO_MODEL : FLASH_MODEL);
             });
             // ── Remove streaming key listener ─────────────────────────
             process.stdin.removeListener('data', onStreamKey);

package/dist/services/ai.js

@@ -1,5 +1,7 @@
 const AI_PROXY = 'https://dravix.app/ai-proxy.php';
 const PROMPT_URL = 'https://dravix.app/cli-prompt.php';
+export const FLASH_MODEL = 'deepseek/deepseek-v4-flash'; // fast, cheap — default for all tasks
+export const PRO_MODEL = 'deepseek/deepseek-r1'; // high-reasoning — used after errors/retries
 export async function fetchSystemPrompt(token) {
     try {
         const res = await fetch(`${PROMPT_URL}?token=${encodeURIComponent(token)}`, {
@@ -21,13 +23,14 @@ export async function fetchSystemPrompt(token) {
 const TIMEOUT_MS = 300_000; // 5 min — AI may generate large responses
 const CHUNK_TIMEOUT_MS = 60_000; // 1 min without any chunk = abort
 const MAX_CONTINUATIONS = 5; // auto-continue up to 5 times on length cutoff
+const MAX_429_RETRIES = 3; // retry on rate-limit with exponential backoff
 // Convert history to OpenAI-compatible format:
 // Only the first message can be role:system — everything else must alternate user/assistant.
 // Mid-conversation system messages (file contents, /add files) become role:user.
 // Consecutive user/system-as-user messages are merged to maintain proper alternation.
 function prepareMessages(messages) {
     // Trim context: if total chars exceed ~180k (~45k tokens), drop oldest non-system messages
-    const MAX_CHARS = 80_000;
+    const MAX_CHARS = 150_000;
     let totalChars = messages.reduce((s, m) => s + String(m.content).length, 0);
     const trimmed = [...messages];
     while (totalChars > MAX_CHARS && trimmed.length > 4) {
@@ -51,9 +54,9 @@ function prepareMessages(messages) {
     }
     return merged;
 }
-async function doSingleRequest(messages, token, abort, onChunk) {
+async function doSingleRequest(messages, token, abort, onChunk, model = FLASH_MODEL) {
     const requestTimer = setTimeout(() => abort.abort(), TIMEOUT_MS);
-    try {
+    const attemptFetch = async (attempt) => {
         const res = await fetch(AI_PROXY, {
             method: 'POST',
             signal: abort.signal,
@@ -64,13 +67,22 @@ async function doSingleRequest(messages, token, abort, onChunk) {
             },
             body: JSON.stringify({
                 provider: 'openrouter',
-                model: 'deepseek/deepseek-v4-flash',
+                model,
                 messages: prepareMessages(messages),
                 stream: true,
                 temperature: 0.1,
                 max_tokens: 16384,
             }),
         });
+        // Retry on rate-limit with exponential backoff (2s, 4s, 8s)
+        if (res.status === 429 && attempt < MAX_429_RETRIES - 1) {
+            await new Promise(r => setTimeout(r, 2000 * Math.pow(2, attempt)));
+            return attemptFetch(attempt + 1);
+        }
+        return res;
+    };
+    try {
+        const res = await attemptFetch(0);
         if (!res.ok || !res.body) {
             const text = await res.text().catch(() => '');
             let msg = `HTTP ${res.status}`;
@@ -159,7 +171,7 @@ async function doSingleRequest(messages, token, abort, onChunk) {
         clearTimeout(requestTimer);
     }
 }
-export async function streamChat(messages, token, onChunk, onDone, onError, cancelSignal) {
+export async function streamChat(messages, token, onChunk, onDone, onError, cancelSignal, model = FLASH_MODEL) {
     const abort = new AbortController();
     const forwardCancel = () => abort.abort();
     cancelSignal?.addEventListener('abort', forwardCancel);
@@ -170,7 +182,7 @@ export async function streamChat(messages, token, onChunk, onDone, onError, canc
                 onDone();
                 return;
             }
-            const { finishReason, response } = await doSingleRequest(currentMessages, token, abort, onChunk);
+            const { finishReason, response } = await doSingleRequest(currentMessages, token, abort, onChunk, model);
             if (finishReason === 'length' && attempt < MAX_CONTINUATIONS) {
                 // Token limit hit — auto-continue seamlessly, no visible break to user
                 const tail = response.slice(-400);

package/dist/services/executor.js

@@ -107,39 +107,45 @@ export function computeDiff(oldText, newText) {
 }
 export function parseOps(text) {
     const ops = [];
-    const writeRe = /<write_file\s+path="([^"]+)">([\s\S]*?)<\/write_file>/g;
+    // Q = accept both " and ' for attribute values
+    const Q = `["']`;
+    const AV = (q) => `[^${q}]`;
+    const writeRe = /<write_file\s+path=(["'])([^"']+)\1>([\s\S]*?)<\/write_file>/g;
     let m;
     while ((m = writeRe.exec(text)) !== null) {
-        ops.push({ type: 'write', path: m[1], content: m[2].replace(/^\n/, '') });
+        ops.push({ type: 'write', path: m[2], content: m[3].replace(/^\n/, '') });
     }
-    const editRe = /<edit_file\s+path="([^"]+)">[\s\S]*?<find>([\s\S]*?)<\/find>[\s\S]*?<replace>([\s\S]*?)<\/replace>[\s\S]*?<\/edit_file>/g;
+    const editRe = /<edit_file\s+path=(["'])([^"']+)\1>[\s\S]*?<find>([\s\S]*?)<\/find>[\s\S]*?<replace>([\s\S]*?)<\/replace>[\s\S]*?<\/edit_file>/g;
     while ((m = editRe.exec(text)) !== null) {
-        ops.push({ type: 'edit', path: m[1], find: m[2], replace: m[3] });
+        ops.push({ type: 'edit', path: m[2], find: m[3], replace: m[4] });
     }
-    const mkdirRe = /<create_folder\s+path="([^"]+)"\s*(?:\/>|><\/create_folder>)/g;
+    const mkdirRe = /<create_folder\s+path=(["'])([^"']+)\1\s*(?:\/>|><\/create_folder>)/g;
     while ((m = mkdirRe.exec(text)) !== null) {
-        ops.push({ type: 'mkdir', path: m[1] });
+        ops.push({ type: 'mkdir', path: m[2] });
     }
-    const deleteRe = /<delete_file\s+path="([^"]+)"\s*(?:\/>|><\/delete_file>)/g;
+    const deleteRe = /<delete_file\s+path=(["'])([^"']+)\1\s*(?:\/>|><\/delete_file>)/g;
     while ((m = deleteRe.exec(text)) !== null) {
-        ops.push({ type: 'delete', path: m[1] });
+        ops.push({ type: 'delete', path: m[2] });
     }
-    const runRe = /<run_command(?:\s+cwd="([^"]*)")?>([\s\S]*?)<\/run_command>/g;
+    const runRe = /<run_command(?:\s+cwd=(["'])([^"']*)\2)?>([\s\S]*?)<\/run_command>/g;
     while ((m = runRe.exec(text)) !== null) {
-        ops.push({ type: 'run', command: m[2].trim(), workdir: m[1] || undefined });
+        ops.push({ type: 'run', command: m[3].trim(), workdir: m[2] || undefined });
     }
-    const readRe = /<read_file\s+path="([^"]+)"(?:\s+lines="([^"]+)")?\s*(?:\/>|><\/read_file>)/g;
+    const readRe = /<read_file\s+path=(["'])([^"']+)\1(?:\s+lines=(["'])([^"']+)\3)?\s*(?:\/>|><\/read_file>)/g;
     while ((m = readRe.exec(text)) !== null) {
-        ops.push({ type: 'read_file', path: m[1], lines: m[2] || undefined });
+        ops.push({ type: 'read_file', path: m[2], lines: m[4] || undefined });
     }
-    const readFolderRe = /<read_folder\s+path="([^"]+)"\s*(?:\/>|><\/read_folder>)/g;
+    const readFolderRe = /<read_folder\s+path=(["'])([^"']+)\1\s*(?:\/>|><\/read_folder>)/g;
     while ((m = readFolderRe.exec(text)) !== null) {
-        ops.push({ type: 'read_folder', path: m[1] });
+        ops.push({ type: 'read_folder', path: m[2] });
     }
-    const searchRe = /<search_code\s+pattern="([^"]+)"(?:\s+path="([^"]*)")?\s*(?:\/>|><\/search_code>)/g;
+    const searchRe = /<search_code\s+pattern=(["'])([^"']+)\1(?:\s+path=(["'])([^"']*)\3)?\s*(?:\/>|><\/search_code>)/g;
     while ((m = searchRe.exec(text)) !== null) {
-        ops.push({ type: 'search_code', pattern: m[1], path: m[2] || undefined });
+        ops.push({ type: 'search_code', pattern: m[2], path: m[4] || undefined });
     }
+    // suppress unused-variable warnings for Q / AV helpers used only for readability
+    void Q;
+    void AV;
     return ops;
 }
 export async function executeSingleOp(op, cwd, onStage) {
@@ -194,43 +200,112 @@ export async function executeSingleOp(op, cwd, onStage) {
             }
             stage(`Reading     ${resolvedPath}`);
             const oldContent = fs.readFileSync(fullPath, 'utf-8');
-            // ── Robust match: try exact first, then trimEnd-normalized ──────────────
+            // ── Multi-stage robust match ────────────────────────────────────────────
             let actualFind = op.find;
             if (!oldContent.includes(op.find)) {
-                // Try matching with trailing-whitespace normalization (most common AI copy error)
                 const oldLines = oldContent.split('\n');
-                const findLines = op.find.split('\n').map(l => l.trimEnd());
+                const rawFind = op.find.split('\n');
+                // Try to find findLines inside oldLines — compare with trimEnd per line
+                const tryMatch = (findLines) => {
+                    if (findLines.length === 0 || findLines.length > oldLines.length)
+                        return -1;
+                    outer2: for (let i = 0; i <= oldLines.length - findLines.length; i++) {
+                        for (let j = 0; j < findLines.length; j++) {
+                            if (oldLines[i + j].trimEnd() !== findLines[j].trimEnd())
+                                continue outer2;
+                        }
+                        return i;
+                    }
+                    return -1;
+                };
+                // Strip " 42 │ " / "42: " / "42| " line-number prefixes AI copies from read_file
+                const stripLineNums = (lines) => lines.map(l => l.replace(/^\s*\d+\s*[│|:]\s?/, ''));
+                // Trim leading and trailing blank-only lines
+                const trimBlanks = (lines) => {
+                    let s = 0, e = lines.length - 1;
+                    while (s <= e && !lines[s].trim())
+                        s++;
+                    while (e >= s && !lines[e].trim())
+                        e--;
+                    return s <= e ? lines.slice(s, e + 1) : [];
+                };
                 let matchStart = -1;
-                outer: for (let i = 0; i <= oldLines.length - findLines.length; i++) {
-                    for (let j = 0; j < findLines.length; j++) {
-                        if (oldLines[i + j].trimEnd() !== findLines[j])
-                            continue outer;
+                let matchLen = rawFind.length;
+                // Stage 2: trimEnd normalization
+                matchStart = tryMatch(rawFind);
+                // Stage 3: strip line-number prefixes
+                if (matchStart < 0) {
+                    const stripped = stripLineNums(rawFind);
+                    matchStart = tryMatch(stripped);
+                    if (matchStart >= 0)
+                        matchLen = stripped.length;
+                }
+                // Stage 4: trim surrounding blank lines
+                if (matchStart < 0) {
+                    const trimmed = trimBlanks(rawFind);
+                    if (trimmed.length > 0 && trimmed.length < rawFind.length) {
+                        matchStart = tryMatch(trimmed);
+                        if (matchStart >= 0)
+                            matchLen = trimmed.length;
+                    }
+                }
+                // Stage 5: strip line numbers + trim blanks
+                if (matchStart < 0) {
+                    const trimmed = trimBlanks(stripLineNums(rawFind));
+                    if (trimmed.length > 0) {
+                        matchStart = tryMatch(trimmed);
+                        if (matchStart >= 0)
+                            matchLen = trimmed.length;
                     }
-                    matchStart = i;
-                    break;
                 }
                 if (matchStart >= 0) {
-                    // Rebuild actualFind from the REAL file lines so replaceAll works
-                    actualFind = oldLines.slice(matchStart, matchStart + findLines.length).join('\n');
+                    // Rebuild actualFind from the REAL file lines so replaceAll is exact
+                    actualFind = oldLines.slice(matchStart, matchStart + matchLen).join('\n');
                 }
                 else {
                     // Truly not found — give AI a useful hint
-                    const firstLine = op.find.trim().split('\n')[0].trim().slice(0, 60);
+                    const firstLine = rawFind.map(l => l.replace(/^\s*\d+\s*[│|:]\s?/, '')).find(l => l.trim()) ?? '';
+                    const safePattern = firstLine.replace(/['"<>]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 40);
                     let hintLine = -1;
-                    for (let i = 0; i < oldLines.length; i++) {
-                        if (firstLine.length > 4 && oldLines[i].includes(firstLine.slice(0, Math.min(30, firstLine.length)))) {
-                            hintLine = i + 1;
-                            break;
+                    const searchKey = firstLine.trim().slice(0, Math.min(30, firstLine.trim().length));
+                    if (searchKey.length > 4) {
+                        for (let i = 0; i < oldLines.length; i++) {
+                            if (oldLines[i].includes(searchKey)) {
+                                hintLine = i + 1;
+                                break;
+                            }
                         }
                     }
                     const hint = hintLine > 0
-                        ? ` First line found near line ${hintLine} but block didn't match — use <read_file path="${resolvedPath}" lines="${Math.max(1, hintLine - 2)}-${hintLine + 20}"/> to get EXACT text, then retry.`
-                        : ` Use <search_code pattern="${firstLine.slice(0, 40)}"/> to find the text, then <read_file lines="N-M"/> to read that section.`;
+                        ? ` First line found near line ${hintLine} but block did not match exactly.` +
+                            ` Use <read_file path="${resolvedPath}" lines="${Math.max(1, hintLine - 2)}-${hintLine + 25}"/> to get the EXACT text, then copy it verbatim (no line numbers) into <find>.`
+                        : ` Text not found anywhere in ${resolvedPath}.` +
+                            (safePattern.length > 3 ? ` Try <search_code pattern="${safePattern}" path="${resolvedPath}"/> to locate it.` : '') +
+                            ` Then use <read_file lines="N-M"/> to read that section and copy the EXACT text into <find>.`;
                     return { type: 'error', message: `Text not found in ${resolvedPath}.${hint}` };
                 }
             }
+            // Count occurrences — replaceAll on non-unique text corrupts multiple locations
+            let occurrenceCount = 0;
+            let scanPos = 0;
+            while ((scanPos = oldContent.indexOf(actualFind, scanPos)) !== -1) {
+                occurrenceCount++;
+                scanPos += actualFind.length;
+            }
+            if (occurrenceCount > 1) {
+                const safePattern = actualFind
+                    .split('\n').find(l => l.trim())?.replace(/['"<>{}()\[\]]/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 40) ?? '';
+                return {
+                    type: 'error',
+                    message: `Found ${occurrenceCount} identical occurrences in ${resolvedPath}. ` +
+                        `The <find> text must match EXACTLY ONE location. ` +
+                        `Add more surrounding lines to make it unique, or use ` +
+                        `<read_file path="${resolvedPath}" lines="N-M"/> to get the exact block.` +
+                        (safePattern.length > 4 ? ` (First line: "${safePattern}")` : ''),
+                };
+            }
             stage(`Applying    ${resolvedPath}`);
-            const newContent = oldContent.replaceAll(actualFind, op.replace);
+            const newContent = oldContent.replace(actualFind, op.replace);
             // No actual change — skip write and return skipped
             if (newContent === oldContent)
                 return { type: 'skipped', path: resolvedPath };
@@ -427,9 +502,9 @@ export async function executeSingleOp(op, cwd, onStage) {
             const total = allLines.length;
             // Files under 6000 lines → always return full content so AI has complete context
             const LARGE_FILE_THRESHOLD = 6000;
-            // Only truly huge files (>6000 lines) get paginated — return first 600 lines + hint
+            // Only truly huge files (>6000 lines) get paginated — return first 2000 lines + hint
             if (!op.lines && total > LARGE_FILE_THRESHOLD) {
-                const PAGE = 600;
+                const PAGE = 2000;
                 const preview = allLines.slice(0, PAGE).map((l, i) => `${String(i + 1).padStart(4)} │ ${l}`).join('\n');
                 const pages = Math.ceil(total / PAGE);
                 const output = `[File: ${resolvedPath} — ${total} lines — page 1/${pages}]\n` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taj-special/dravix-code",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "description": "AI-powered coding assistant CLI — Dravix Code",
   "type": "module",
   "bin": {