klyro 0.1.53 → 0.1.55

package/dist/tools/fs/apply-patch.js

@@ -1,112 +1,200 @@
 /**
- * 4.2 — apply_patch: Codex-style unified patch, tolerant hunks
+ * 4.2 — apply_patch: Codex-style unified patch with REAL hunk application.
+ *
+ * Format:
+ *   *** Begin Patch
+ *   *** Update File: <path>     (must contain @@ hunks for existing files)
+ *   *** Add File: <path>        (created from + lines)
+ *   *** End Patch
+ *
+ * Hunks are standard unified diff: `@@ -a,b +c,d @@` headers, ' ' context,
+ * '-' removals, '+' additions. Context/removals must match the file (exact
+ * first, trailing-whitespace-insensitive fallback with ±3 line drift);
+ * otherwise INVALID_PATCH names the file+hunk instead of corrupting it.
+ *
+ * Legacy compat: a file section with NO @@ lines and only + lines is treated
+ * as file creation (the old tolerant behavior) — but never as an edit to an
+ * existing file, where hunk-less appends used to corrupt content.
  */
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { resolveAndFollowSymlinks } from '../../policy/path-guard.js';
-import { safe, TOOL_ERROR_CODES } from '../normalize.js';
+import { safe } from '../normalize.js';
 import { wasRead } from './read-history.js';
 const InputSchema = z.object({
     patch: z.string().min(1).describe('Unified diff patch text'),
 });
+function parseHunks(lines) {
+    const hunks = [];
+    let cur = null;
+    for (const line of lines) {
+        const m = /^@@ -(\d+)(?:,\d+)? \+\d+(?:,\d+)? @@/.exec(line);
+        if (m) {
+            cur = { header: line, oldStart: parseInt(m[1], 10), lines: [] };
+            hunks.push(cur);
+            continue;
+        }
+        if (line.startsWith('--- ') || line.startsWith('+++ '))
+            continue;
+        if (line.startsWith('\\ '))
+            continue; // ""
+        if (!cur)
+            continue; // stray lines outside hunks are ignored
+        if (line.startsWith('+'))
+            cur.lines.push({ kind: 'add', text: line.slice(1) });
+        else if (line.startsWith('-'))
+            cur.lines.push({ kind: 'remove', text: line.slice(1) });
+        else if (line.startsWith(' '))
+            cur.lines.push({ kind: 'context', text: line.slice(1) });
+        else if (line === '')
+            cur.lines.push({ kind: 'context', text: '' });
+        // any other prefix inside a hunk is ignored (tolerant)
+    }
+    return hunks;
+}
+function linesEqual(a, b) {
+    return a === b || a.replace(/[ \t]+$/g, '') === b.replace(/[ \t]+$/g, '');
+}
+/** Match the hunk's old block (context+removals) starting at `at`. */
+function matchAt(fileLines, hunk, at) {
+    let i = at;
+    for (const l of hunk.lines) {
+        if (l.kind === 'add')
+            continue;
+        if (i < 0 || i >= fileLines.length)
+            return false;
+        if (!linesEqual(fileLines[i], l.text))
+            return false;
+        i++;
+    }
+    return true;
+}
+function applyHunks(filePath, fileLines, hunks) {
+    const out = [...fileLines];
+    // Apply last hunk first so earlier line numbers stay valid.
+    const ordered = hunks
+        .map((h, idx) => ({ h, idx }))
+        .sort((a, b) => b.h.oldStart - a.h.oldStart || b.idx - a.idx);
+    for (const { h, idx } of ordered) {
+        const want = Math.max(0, h.oldStart - 1);
+        let at = -1;
+        for (let drift = 0; drift <= 3; drift++) {
+            if (matchAt(out, h, want + drift)) {
+                at = want + drift;
+                break;
+            }
+            if (drift > 0 && matchAt(out, h, want - drift)) {
+                at = want - drift;
+                break;
+            }
+        }
+        if (at === -1) {
+            throw Object.assign(new Error(`hunk ${idx + 1} (${h.header}) does not match ${filePath} — re-read the file and regenerate the patch`), { code: 'HUNK_MISMATCH' });
+        }
+        const replacement = [];
+        for (const l of h.lines) {
+            if (l.kind === 'add' || l.kind === 'context')
+                replacement.push(l.text);
+        }
+        const oldLen = h.lines.filter((l) => l.kind !== 'add').length;
+        out.splice(at, oldLen, ...replacement);
+    }
+    return out;
+}
+async function guardWrite(cwd, relPath, resolved) {
+    try {
+        const existing = await fs.readFile(resolved, 'utf-8');
+        if (!wasRead(relPath, cwd) && existing.length > 200) {
+            throw Object.assign(new Error('File was not read this session and is >200 bytes — re-read before writing (POLICY_DENIED)'), { code: 'POLICY_DENIED' });
+        }
+    }
+    catch (e) {
+        if (e && typeof e === 'object' && e.code === 'POLICY_DENIED')
+            throw e;
+        // missing file → creation path, no guard needed
+    }
+}
 export const applyPatchTool = defineTool({
     name: 'apply_patch',
-    description: 'Apply a unified diff patch (Codex-style). Tolerant hunks, per model config.',
+    description: 'Apply a unified diff patch (Codex-style). Real hunk application with context matching; mismatches fail loudly.',
     inputSchema: InputSchema,
     permission: 'edit',
     isConcurrencySafe: false,
     execute: async (input, ctx) => {
         return safe(async () => {
             const lines = input.patch.split('\n');
-            let currentFile = null;
-            let fileContent = null;
-            let patchedFiles = [];
+            const sections = [];
+            let cur = null;
             for (const line of lines) {
                 if (line.startsWith('*** Begin Patch') || line.startsWith('*** End Patch'))
                     continue;
                 if (line.startsWith('*** Update File:')) {
-                    // Flush previous
-                    if (currentFile && fileContent !== null) {
-                        const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, currentFile);
-                        if (fileContent === null)
-                            throw Object.assign(new Error('fileContent is null — cannot write'), { code: TOOL_ERROR_CODES.INTERNAL });
-                        try {
-                            const existing = await fs.readFile(resolved, 'utf-8');
-                            if (!wasRead(currentFile) && existing.length > 200) {
-                                throw Object.assign(new Error('File was not read this session and is >200 bytes — re-read before writing (POLICY_DENIED)'), { code: 'POLICY_DENIED' });
-                            }
-                        }
-                        catch (e) {
-                            if (e && typeof e === 'object' && e.code === 'POLICY_DENIED')
-                                throw e;
-                        }
-                        await fs.mkdir(path.dirname(resolved), { recursive: true });
-                        await fs.writeFile(resolved, fileContent, 'utf-8');
-                        patchedFiles.push(currentFile);
-                    }
-                    currentFile = line.replace('*** Update File:', '').trim();
-                    if (currentFile) {
-                        try {
-                            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, currentFile);
-                            fileContent = await fs.readFile(resolved, 'utf-8');
-                        }
-                        catch {
-                            fileContent = '';
-                        }
-                    }
+                    cur = { op: 'update', path: line.replace('*** Update File:', '').trim(), body: [] };
+                    sections.push(cur);
                     continue;
                 }
                 if (line.startsWith('*** Add File:')) {
-                    if (currentFile && fileContent !== null) {
-                        const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, currentFile);
-                        if (fileContent === null)
-                            throw Object.assign(new Error('fileContent is null — cannot write'), { code: TOOL_ERROR_CODES.INTERNAL });
-                        try {
-                            const existing = await fs.readFile(resolved, 'utf-8');
-                            if (!wasRead(currentFile) && existing.length > 200) {
-                                throw Object.assign(new Error('File was not read this session and is >200 bytes — re-read before writing (POLICY_DENIED)'), { code: 'POLICY_DENIED' });
-                            }
-                        }
-                        catch (e) {
-                            if (e && typeof e === 'object' && e.code === 'POLICY_DENIED')
-                                throw e;
-                        }
-                        await fs.mkdir(path.dirname(resolved), { recursive: true });
-                        await fs.writeFile(resolved, fileContent, 'utf-8');
-                        patchedFiles.push(currentFile);
-                    }
-                    currentFile = line.replace('*** Add File:', '').trim();
-                    fileContent = '';
+                    cur = { op: 'add', path: line.replace('*** Add File:', '').trim(), body: [] };
+                    sections.push(cur);
                     continue;
                 }
-                if (line.startsWith('+') && currentFile && fileContent !== null) {
-                    // Very tolerant: just append added lines, ignore removals for stub
-                    if (!line.startsWith('+++'))
-                        fileContent += line.slice(1) + '\n';
-                }
-                else if (line.startsWith('@@') || line.startsWith('---') || line.startsWith('+++')) {
+                if (cur)
+                    cur.body.push(line);
+            }
+            if (sections.length === 0) {
+                throw Object.assign(new Error('No files patched — invalid patch format'), { code: 'INVALID_PATCH' });
+            }
+            const patchedFiles = [];
+            for (const sec of sections) {
+                if (!sec.path)
+                    throw Object.assign(new Error('Patch section missing file path'), { code: 'INVALID_PATCH' });
+                const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, sec.path);
+                const hunks = parseHunks(sec.body);
+                if (sec.op === 'add' || hunks.length === 0) {
+                    // Creation path: content from + lines (legacy tolerant format).
+                    // For *** Update File *** this is only valid when the file does NOT
+                    // exist yet — editing an existing file without hunks is rejected
+                    // instead of appending junk at EOF (the old corruption).
+                    let exists = false;
+                    try {
+                        await fs.stat(resolved);
+                        exists = true;
+                    }
+                    catch { /* missing → create */ }
+                    if (exists && sec.op === 'update') {
+                        throw Object.assign(new Error(`No hunks for existing file ${sec.path} — provide @@ hunks (refusing hunk-less edit)`), { code: 'INVALID_PATCH' });
+                    }
+                    const content = sec.body
+                        .filter((l) => l.startsWith('+') && !l.startsWith('+++'))
+                        .map((l) => l.slice(1))
+                        .join('\n');
+                    await guardWrite(ctx.cwd, sec.path, resolved);
+                    await fs.mkdir(path.dirname(resolved), { recursive: true });
+                    await fs.writeFile(resolved, content ? content + '\n' : '', 'utf-8');
+                    patchedFiles.push(sec.path);
                     continue;
                 }
-            }
-            if (currentFile && fileContent !== null) {
-                const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, currentFile);
-                if (fileContent === null)
-                    throw Object.assign(new Error('fileContent is null — cannot write'), { code: TOOL_ERROR_CODES.INTERNAL });
+                // Update path: apply hunks against current content.
+                let current;
                 try {
-                    const existing = await fs.readFile(resolved, 'utf-8');
-                    if (!wasRead(currentFile) && existing.length > 200) {
-                        throw Object.assign(new Error('File was not read this session and is >200 bytes — re-read before writing (POLICY_DENIED)'), { code: 'POLICY_DENIED' });
-                    }
+                    current = await fs.readFile(resolved, 'utf-8');
                 }
-                catch (e) {
-                    if (e && typeof e === 'object' && e.code === 'POLICY_DENIED')
-                        throw e;
+                catch {
+                    throw Object.assign(new Error(`Cannot update missing file ${sec.path} with hunks — use *** Add File ***`), {
+                        code: 'INVALID_PATCH',
+                    });
                 }
+                await guardWrite(ctx.cwd, sec.path, resolved);
+                const hasTrailingNewline = current.endsWith('\n');
+                const fileLines = current.split('\n');
+                if (hasTrailingNewline && fileLines[fileLines.length - 1] === '')
+                    fileLines.pop();
+                const next = applyHunks(sec.path, fileLines, hunks);
                 await fs.mkdir(path.dirname(resolved), { recursive: true });
-                await fs.writeFile(resolved, fileContent, 'utf-8');
-                patchedFiles.push(currentFile);
+                await fs.writeFile(resolved, next.join('\n') + (hasTrailingNewline ? '\n' : ''), 'utf-8');
+                patchedFiles.push(sec.path);
             }
             if (patchedFiles.length === 0)
                 throw Object.assign(new Error('No files patched — invalid patch format'), { code: 'INVALID_PATCH' });

package/dist/tools/fs/edit-file.d.ts

@@ -22,5 +22,18 @@ export declare const editFileTool: import("../types.js").Tool<{
     replace: string;
     replaceAll?: boolean | undefined;
 }, EditFileOutput>;
+export interface FuzzySpan {
+    /** 0-based start line in the ORIGINAL text. */
+    start: number;
+    /** Number of original lines the match covers. */
+    len: number;
+    tier: string;
+}
+/**
+ * Locate fuzzy match spans by line number. The file itself is never
+ * transformed — transforms exist only to find candidate positions, which
+ * map back 1:1 by line because every tier preserves newline positions.
+ */
+export declare function locateFuzzySpans(original: string, find: string): FuzzySpan[];
 export type EditFileInput = z.infer<typeof InputSchema>;
 export {};

package/dist/tools/fs/edit-file.js

@@ -8,6 +8,7 @@ import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { resolveAndFollowSymlinks } from '../../policy/path-guard.js';
 import { safe } from '../normalize.js';
+import { wasRead } from './read-history.js';
 const InputSchema = z.object({
     path: z.string().min(1),
     find: z.string().min(1).describe('Exact substring to match. Not a regex.'),
@@ -50,62 +51,52 @@ export const editFileTool = defineTool({
             if (checkStaleness(resolved, stat.mtimeMs, currentHash)) {
                 throw Object.assign(new Error(`File ${input.path} changed externally since last read — please re-read before editing`), { code: 'STALE' });
             }
-            let original = withoutBOM;
-            let findStr = input.find;
-            let count = countOccurrences(original, findStr);
+            // Read-before-write guard (same policy as write_file/apply_patch).
+            if (!wasRead(input.path, ctx.cwd) && withoutBOM.length > 200) {
+                throw Object.assign(new Error(`File ${input.path} was not read this session and is >200 bytes — re-read before editing (POLICY_DENIED)`), { code: 'POLICY_DENIED' });
+            }
+            const original = withoutBOM;
+            const findStr = input.find;
+            const replaceAll = input.replaceAll === true;
+            const exactCount = countOccurrences(original, findStr);
+            let next;
+            let replacements;
             let fuzzyTier = null;
-            // 4.2 fuzzy tiers (only after exact fails)
-            if (count === 0) {
-                const tiers = [
-                    { name: 'trailing-whitespace', transform: (s) => s.replace(/[ \t]+$/gm, '') },
-                    { name: 'indent-width', transform: (s) => s.replace(/^ {2,}/gm, (m) => '\t'.repeat(m.length / 2)) },
-                    { name: 'unicode-quotes', transform: (s) => s.replace(/[“”]/g, '"').replace(/[‘’]/g, "'").replace(/—/g, '-') },
-                ];
-                for (const tier of tiers) {
-                    const tFind = tier.transform(findStr);
-                    const tOrig = tier.transform(original);
-                    const c = countOccurrences(tOrig, tFind);
-                    if (c > 0) {
-                        findStr = tFind;
-                        original = tOrig;
-                        fuzzyTier = tier.name;
-                        count = c;
-                        break;
-                    }
-                }
-                // Line-window similarity >=0.95
-                if (count === 0) {
-                    const lines = original.split('\n');
-                    let bestScore = 0;
-                    let bestIdx = -1;
-                    for (let i = 0; i < lines.length; i++) {
-                        const line = lines[i] ?? '';
-                        const score = line.length > 0 ? [...findStr].filter((ch, idx) => line[idx] === ch).length / Math.max(line.length, findStr.length) : 0;
-                        if (score > bestScore)
-                            bestScore = score;
-                        if (score >= 0.95) {
-                            bestIdx = i;
-                            break;
-                        }
-                        if (score > bestScore)
-                            bestIdx = i;
-                    }
-                    if (bestScore >= 0.95 && bestIdx >= 0) {
-                        findStr = lines[bestIdx] ?? findStr;
-                        count = 1;
-                        fuzzyTier = 'line-window-0.95';
-                    }
+            // Representative original text for the diff note below.
+            let diffNeedle = findStr;
+            if (exactCount > 0) {
+                if (!replaceAll && exactCount > 1) {
+                    throw Object.assign(new Error(`find substring occurs ${exactCount} times in ${input.path}. Supply more context or pass replaceAll=true.`), { code: 'MATCH_AMBIGUOUS' });
                 }
+                next = replaceAll ? original.split(findStr).join(input.replace) : original.replace(findStr, input.replace);
+                replacements = replaceAll ? exactCount : 1;
             }
-            if (count === 0) {
-                const closest = findClosestMatch(original, input.find);
-                throw Object.assign(new Error(`find substring not present in ${input.path}. Closest match (similarity ${(closest.similarity * 100).toFixed(0)}%): line ${closest.lineRange[0]}-${closest.lineRange[1]} "${closest.snippet.slice(0, 80)}" — re-read and retry with exact context${fuzzyTier ? ` (tried fuzzy: ${fuzzyTier})` : ''}`), { code: 'MATCH_NOT_FOUND', details: closest });
-            }
-            const replaceAll = input.replaceAll === true;
-            if (!replaceAll && count > 1) {
-                throw Object.assign(new Error(`find substring occurs ${count} times in ${input.path}. Supply more context or pass replaceAll=true.`), { code: 'MATCH_AMBIGUOUS' });
+            else {
+                // Match-only fuzzy: locate candidate line spans WITHOUT rewriting the
+                // file for matching (a whole-file transform here used to corrupt
+                // indentation/whitespace/quotes across the entire file). All tiers
+                // preserve newline positions, so a match in transformed text maps
+                // back to original coordinates by line number.
+                const spans = locateFuzzySpans(original, findStr);
+                if (spans.length === 0) {
+                    const closest = findClosestMatch(original, input.find);
+                    throw Object.assign(new Error(`find substring not present in ${input.path}. Closest match (similarity ${(closest.similarity * 100).toFixed(0)}%): line ${closest.lineRange[0]}-${closest.lineRange[1]} "${closest.snippet.slice(0, 80)}" — re-read and retry with exact context`), { code: 'MATCH_NOT_FOUND', details: closest });
+                }
+                if (!replaceAll && spans.length > 1) {
+                    throw Object.assign(new Error(`find substring occurs ${spans.length} times in ${input.path} (fuzzy:${spans[0].tier}). Supply more context or pass replaceAll=true.`), { code: 'MATCH_AMBIGUOUS' });
+                }
+                const targets = replaceAll ? spans : [spans[0]];
+                fuzzyTier = targets[0].tier;
+                const lines = original.split('\n');
+                const repLines = input.replace.split('\n');
+                // Last span first so earlier line numbers stay valid.
+                for (const s of [...targets].sort((a, b) => b.start - a.start)) {
+                    diffNeedle = lines.slice(s.start, s.start + s.len).join('\n');
+                    lines.splice(s.start, s.len, ...repLines);
+                }
+                next = lines.join('\n');
+                replacements = replaceAll ? spans.length : 1;
             }
-            let next = replaceAll ? original.split(findStr).join(input.replace) : original.replace(findStr, input.replace);
             // Preserve EOL: normalize then convert
             if (eol === '\r\n') {
                 next = next.replace(/\r\n/g, '\n').replace(/\n/g, '\r\n');
@@ -145,8 +136,8 @@ export const editFileTool = defineTool({
             const diffNote = fuzzyTier ? ` [fuzzy:${fuzzyTier}]` : '';
             return {
                 path: input.path,
-                replacements: replaceAll ? count : 1,
-                diff: simpleDiff(original, findStr, input.replace, replaceAll ? count : 1) + diffNote,
+                replacements,
+                diff: simpleDiff(original, diffNeedle, input.replace, replacements) + diffNote,
             };
         });
     },
@@ -165,6 +156,57 @@ function countOccurrences(haystack, needle) {
     }
     return count;
 }
+/**
+ * Locate fuzzy match spans by line number. The file itself is never
+ * transformed — transforms exist only to find candidate positions, which
+ * map back 1:1 by line because every tier preserves newline positions.
+ */
+export function locateFuzzySpans(original, find) {
+    const findLineCount = find.split('\n').length;
+    const locate = (tOrig, tFind) => {
+        if (tFind.length === 0)
+            return [];
+        const starts = [];
+        let idx = 0;
+        while (true) {
+            const at = tOrig.indexOf(tFind, idx);
+            if (at === -1)
+                break;
+            starts.push(tOrig.slice(0, at).split('\n').length - 1);
+            idx = at + Math.max(1, tFind.length);
+        }
+        return starts;
+    };
+    const tiers = [
+        { name: 'trailing-whitespace', transform: (s) => s.replace(/[ \t]+$/gm, '') },
+        { name: 'indent-width', transform: (s) => s.replace(/^ {2,}/gm, (m) => '\t'.repeat(m.length / 2)) },
+        { name: 'unicode-quotes', transform: (s) => s.replace(/[“”]/g, '"').replace(/[‘’]/g, "'").replace(/—/g, '-') },
+    ];
+    for (const tier of tiers) {
+        const starts = locate(tier.transform(original), tier.transform(find));
+        if (starts.length > 0) {
+            return starts.map((start) => ({ start, len: findLineCount, tier: tier.name }));
+        }
+    }
+    // Line-window similarity >= 0.95 (single best line only).
+    const lines = original.split('\n');
+    let bestScore = 0;
+    let bestIdx = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        if (line.length === 0)
+            continue;
+        const score = [...find].filter((ch, idx) => line[idx] === ch).length / Math.max(line.length, find.length);
+        if (score > bestScore) {
+            bestScore = score;
+            bestIdx = i;
+        }
+    }
+    if (bestScore >= 0.95 && bestIdx >= 0) {
+        return [{ start: bestIdx, len: 1, tier: 'line-window-0.95' }];
+    }
+    return [];
+}
 function findClosestMatch(text, needle) {
     const lines = text.split('\n');
     let bestIdx = 0;

package/dist/tools/fs/list-dir.d.ts

@@ -8,6 +8,7 @@ declare const InputSchema: z.ZodObject<{
     path: z.ZodDefault<z.ZodString>;
     maxDepth: z.ZodOptional<z.ZodNumber>;
     skip: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    showHidden: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export interface ListEntry {
     name: string;
@@ -22,6 +23,7 @@ export declare const listDirTool: import("../types.js").Tool<{
     path: string;
     maxDepth?: number | undefined;
     skip?: string[] | undefined;
+    showHidden?: boolean | undefined;
 }, {
     readonly ok: false;
     readonly error: {

package/dist/tools/fs/list-dir.js

@@ -14,10 +14,11 @@ const InputSchema = z.object({
     path: z.string().min(1).default('.').describe('Directory path relative to cwd. Defaults to cwd.'),
     maxDepth: z.number().int().min(1).max(5).optional().describe('How deep to recurse (default: 1 = top level only).'),
     skip: z.array(z.string()).optional().describe('Directory names to skip (default: node_modules, .git, etc.)'),
+    showHidden: z.boolean().optional().describe('Include dotfiles (default false — dotfiles are hidden).'),
 });
 export const listDirTool = defineTool({
     name: 'list_directory',
-    description: 'List entries inside a directory. Skips node_modules, .git, and common build dirs by default.',
+    description: 'List entries inside a directory. Skips node_modules, .git, and common build dirs by default. Dotfiles hidden unless showHidden=true.',
     inputSchema: InputSchema,
     execute: async (input, ctx) => {
         return safe(async () => {
@@ -31,18 +32,19 @@ export const listDirTool = defineTool({
             }
             const skip = new Set([...DEFAULT_SKIP, ...(input.skip ?? [])]);
             const maxDepth = input.maxDepth ?? 1;
+            const showHidden = input.showHidden === true;
             const entries = [];
-            await walk(resolved, resolved, 0, maxDepth, skip, entries);
+            await walk(resolved, resolved, 0, maxDepth, skip, showHidden, entries);
             return { path: input.path, entries };
         });
     },
 });
-async function walk(root, dir, depth, maxDepth, skip, out) {
+async function walk(root, dir, depth, maxDepth, skip, showHidden, out) {
     const names = await fs.readdir(dir).catch(() => []);
     for (const name of names) {
         if (skip.has(name))
             continue;
-        if (name.startsWith('.') && name !== '.' && name !== '..')
+        if (!showHidden && name.startsWith('.') && name !== '.' && name !== '..')
             continue;
         const full = path.join(dir, name);
         let entry;
@@ -66,7 +68,7 @@ async function walk(root, dir, depth, maxDepth, skip, out) {
         }
         out.push(entry);
         if (entry.type === 'directory' && depth + 1 < maxDepth) {
-            await walk(root, full, depth + 1, maxDepth, skip, out);
+            await walk(root, full, depth + 1, maxDepth, skip, showHidden, out);
         }
     }
 }

package/dist/tools/fs/multi-edit.js

@@ -2,10 +2,13 @@
  * 4.2 — multi_edit: atomic sequential edits with rollback on failure
  */
 import * as fs from 'node:fs/promises';
+import * as crypto from 'node:crypto';
 import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { resolveAndFollowSymlinks } from '../../policy/path-guard.js';
 import { safe } from '../normalize.js';
+import { wasRead } from './read-history.js';
+import { checkStaleness, recordEditStaleness } from './edit-file.js';
 const EditSchema = z.object({
     find: z.string().min(1),
     replace: z.string(),
@@ -24,8 +27,14 @@ export const multiEditTool = defineTool({
     execute: async (input, ctx) => {
         return safe(async () => {
             const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
+            const stat = await fs.stat(resolved);
             let content = await fs.readFile(resolved, 'utf-8');
-            const original = content;
+            if (checkStaleness(resolved, stat.mtimeMs, crypto.createHash('sha256').update(content, 'utf-8').digest('hex'))) {
+                throw Object.assign(new Error(`File ${input.path} changed externally since last read — please re-read before editing`), { code: 'STALE' });
+            }
+            if (!wasRead(input.path, ctx.cwd) && content.length > 200) {
+                throw Object.assign(new Error(`File ${input.path} was not read this session and is >200 bytes — re-read before editing (POLICY_DENIED)`), { code: 'POLICY_DENIED' });
+            }
             for (let i = 0; i < input.edits.length; i++) {
                 const e = input.edits[i];
                 const count = content.split(e.find).length - 1;
@@ -44,6 +53,8 @@ export const multiEditTool = defineTool({
                 await fs.unlink(tmp).catch(() => undefined);
                 throw err;
             }
+            const newStat = await fs.stat(resolved);
+            recordEditStaleness(resolved, newStat.mtimeMs, crypto.createHash('sha256').update(content, 'utf-8').digest('hex'));
             return { path: input.path, edits: input.edits.length, diff: `multi_edit ${input.edits.length} edits` };
         });
     },

package/dist/tools/fs/read-file.js

@@ -93,7 +93,7 @@ export const readFileTool = defineTool({
                 if (truncatedTokens) {
                     result.hint = 'Truncated to 8k tokens — use startLine/endLine to get more';
                 }
-                markRead(input.path);
+                markRead(input.path, ctx.cwd);
                 // 8.2 lifecycle: store large results, duplicate detection <50 tokens
                 const asStr = outLines.join('\n');
                 if (asStr.length > 2000)

package/dist/tools/fs/read-history.d.ts

@@ -1,3 +1,3 @@
-export declare function markRead(p: string): void;
-export declare function wasRead(p: string): boolean;
+export declare function markRead(p: string, cwd?: string): void;
+export declare function wasRead(p: string, cwd?: string): boolean;
 export declare function clearReadHistory(): void;

package/dist/tools/fs/read-history.js

@@ -1,12 +1,44 @@
-/** Track files read this session for write guard (3.2) */
+/**
+ * Track files read this session for the write guard (3.2).
+ *
+ * Entries are stored normalized (lexical normalize + forward slashes, no
+ * leading ./) in raw AND cwd-resolved absolute form, so `sub/../x`,
+ * `./x`, and absolute-vs-relative spellings of the same file all match.
+ * History is per task-session: hosts call clearReadHistory() when a new
+ * task starts so reads don't leak across sessions in one process.
+ */
+import * as path from 'node:path';
 const sessionReadFiles = new Set();
-export function markRead(p) {
-    sessionReadFiles.add(p);
-    // Also add normalized
-    sessionReadFiles.add(p.replace(/\\/g, '/'));
+function normalize(p) {
+    // Strip the drive letter: on Windows, path.normalize('/x') keeps the
+    // slashes while path.resolve('/x') prepends the cwd drive (A:/x) — without
+    // this, absolute-vs-relative spellings of the same file never match.
+    return path
+        .normalize(p)
+        .replace(/\\/g, '/')
+        .replace(/^\.\//, '')
+        .replace(/^[A-Za-z]:/, '');
 }
-export function wasRead(p) {
-    return sessionReadFiles.has(p) || sessionReadFiles.has(p.replace(/\\/g, '/'));
+export function markRead(p, cwd) {
+    sessionReadFiles.add(normalize(p));
+    if (cwd) {
+        try {
+            sessionReadFiles.add(normalize(path.resolve(cwd, p)));
+        }
+        catch { /* ignore */ }
+    }
+}
+export function wasRead(p, cwd) {
+    if (sessionReadFiles.has(normalize(p)))
+        return true;
+    if (cwd) {
+        try {
+            if (sessionReadFiles.has(normalize(path.resolve(cwd, p))))
+                return true;
+        }
+        catch { /* ignore */ }
+    }
+    return false;
 }
 export function clearReadHistory() {
     sessionReadFiles.clear();