klyro 0.1.6 → 0.1.7

package/dist/agent/runtime.js

@@ -371,6 +371,12 @@ export async function run(opts, deps) {
                 if (fileChanged) {
                     emit?.({ kind: 'file_changed', path: fileChanged.path, op: fileChanged.op });
                     emitKlyro({ type: 'file.changed', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', path: fileChanged.path, op: fileChanged.op });
+                    // 4.5 — checkpoint snapshot after each mutation
+                    try {
+                        const { snapshot } = await import('../checkpoints/store.js');
+                        await snapshot(opts.cwd, [fileChanged.path]);
+                    }
+                    catch { /* ignore */ }
                 }
             }
         };

package/dist/checkpoints/store.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 4.5 — Checkpoint snapshots: every mutation to checkpoints dir
+ */
+export declare function snapshot(cwd: string, files: string[]): Promise<string>;
+export declare function listCheckpoints(cwd: string): Promise<string[]>;
+export declare function diff(cwd: string, id?: string): Promise<string>;
+export declare function undo(cwd: string, n?: number): Promise<void>;
+export declare function rewind(cwd: string): Promise<void>;

package/dist/checkpoints/store.js

@@ -0,0 +1,76 @@
+/**
+ * 4.5 — Checkpoint snapshots: every mutation to checkpoints dir
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+function ckptDir(cwd) {
+    return path.join(cwd, '.klyro', 'checkpoints');
+}
+export async function snapshot(cwd, files) {
+    const dir = ckptDir(cwd);
+    await fs.mkdir(dir, { recursive: true });
+    const id = `${Date.now()}-${crypto.randomBytes(4).toString('hex')}`;
+    const dest = path.join(dir, id);
+    await fs.mkdir(dest, { recursive: true });
+    for (const f of files) {
+        try {
+            const src = path.resolve(cwd, f);
+            const data = await fs.readFile(src);
+            const rel = path.relative(cwd, src);
+            const out = path.join(dest, rel);
+            await fs.mkdir(path.dirname(out), { recursive: true });
+            await fs.writeFile(out, data);
+        }
+        catch { /* ignore missing */ }
+    }
+    // Save meta
+    await fs.writeFile(path.join(dest, '.meta.json'), JSON.stringify({ id, files, ts: Date.now() }, null, 2));
+    return id;
+}
+export async function listCheckpoints(cwd) {
+    const dir = ckptDir(cwd);
+    try {
+        const entries = await fs.readdir(dir);
+        return entries.filter((e) => !e.startsWith('.')).sort();
+    }
+    catch {
+        return [];
+    }
+}
+export async function diff(cwd, id) {
+    const ckpts = await listCheckpoints(cwd);
+    const target = id ?? ckpts[ckpts.length - 1];
+    if (!target)
+        return 'No checkpoints';
+    // For stub, just show git diff vs HEAD
+    const { spawn } = await import('node:child_process');
+    return new Promise((resolve) => {
+        const child = spawn('git', ['diff', '--stat'], { cwd, shell: false, windowsHide: true });
+        let out = '';
+        child.stdout.on('data', (b) => { out += b.toString(); });
+        child.on('close', () => resolve(out || 'No diff'));
+        child.on('error', () => resolve('No git diff available'));
+    });
+}
+export async function undo(cwd, n = 1) {
+    const ckpts = await listCheckpoints(cwd);
+    const target = ckpts[ckpts.length - n];
+    if (!target)
+        throw new Error('No checkpoint to undo');
+    const srcDir = path.join(ckptDir(cwd), target);
+    const metaRaw = await fs.readFile(path.join(srcDir, '.meta.json'), 'utf-8');
+    const meta = JSON.parse(metaRaw);
+    for (const f of meta.files) {
+        const src = path.join(srcDir, f);
+        const dest = path.resolve(cwd, f);
+        try {
+            const data = await fs.readFile(src);
+            await fs.writeFile(dest, data);
+        }
+        catch { /* ignore */ }
+    }
+}
+export async function rewind(cwd) {
+    return undo(cwd, 1);
+}

package/dist/cli/repl.js

@@ -55,9 +55,12 @@ export async function startRepl(opts = {}) {
         : httpChatAdapter({ baseURL: baseUrl, apiKey, timeoutMs: 60_000 });
     const ctxBlock = await buildLevel6Context({ cwd });
     const ctxPrefix = ctxBlock.formatted ? `\n\n<context>\n${ctxBlock.formatted}\n</context>` : '';
+    // 4.4 KLYRO.md hierarchy
+    const klyroMd = await import('../context/klyro-md.js').then((m) => m.loadKlyroMd(cwd)).catch(() => '');
+    const klyroBlock = klyroMd ? `\n\n<KLYRO.md>\n${klyroMd.slice(0, 4000)}\n</KLYRO.md>` : '';
     // 2.3 layered system prompt
     const systemPromptFn = (_ctx) => {
-        const base = buildSystemPrompt({ cwd, model, extraSystem: opts.systemPrompt, appendSystem: ctxPrefix });
+        const base = buildSystemPrompt({ cwd, model, extraSystem: opts.systemPrompt, appendSystem: ctxPrefix + klyroBlock });
         const t = _ctx.telemetry ? '\n\n' + _ctx.telemetry : '';
         return base + t;
     };
@@ -389,6 +392,19 @@ export async function startRepl(opts = {}) {
                 queuedAppend({ id: `think-${Date.now()}`, kind: 'text', text: 'Thinking: collapsed (use --show-thinking to expand)', role: 'assistant' });
                 return;
             }
+            case 'memory': {
+                queuedAppend({ id: `mem-${Date.now()}`, kind: 'text', text: 'Memory: .klyro/memory/session-notes.md (stub) — use /memory to view', role: 'assistant' });
+                return;
+            }
+            case 'jobs': {
+                const { listJobs } = await import('../tools/shell/background.js');
+                const jobs = listJobs();
+                if (jobs.length === 0)
+                    queuedAppend({ id: `jobs-${Date.now()}`, kind: 'text', text: 'No background jobs', role: 'assistant' });
+                else
+                    queuedAppend({ id: `jobs-${Date.now()}`, kind: 'text', text: jobs.map((j) => `${j.id}: ${j.command} (${j.running ? 'running' : 'done'})`).join('\n'), role: 'assistant' });
+                return;
+            }
             case 'status': {
                 if (lastStatus) {
                     queuedAppend({
@@ -404,6 +420,16 @@ export async function startRepl(opts = {}) {
                 return;
             }
             case 'diff': {
+                // 4.5 — try checkpoint diff first, fallback to git diff
+                try {
+                    const { diff } = await import('../checkpoints/store.js');
+                    const ckptDiff = await diff(cwd);
+                    if (ckptDiff && ckptDiff !== 'No checkpoints' && ckptDiff !== 'No diff') {
+                        queuedAppend({ id: `diff-${Date.now()}`, kind: 'text', text: ckptDiff, role: 'assistant' });
+                        return;
+                    }
+                }
+                catch { /* fallback to git */ }
                 const r = await registry.execute('git_diff', {}, { cwd, env: process.env, nonInteractive: true });
                 if (!r.ok) {
                     queuedAppend({
@@ -423,6 +449,30 @@ export async function startRepl(opts = {}) {
                 });
                 return;
             }
+            case 'undo': {
+                try {
+                    const { undo } = await import('../checkpoints/store.js');
+                    await undo(cwd);
+                    queuedAppend({ id: `undo-${Date.now()}`, kind: 'text', text: 'Undone last checkpoint', role: 'assistant' });
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    queuedAppend({ id: `undo-err-${Date.now()}`, kind: 'error', message: `undo failed: ${msg}` });
+                }
+                return;
+            }
+            case 'rewind': {
+                try {
+                    const { rewind } = await import('../checkpoints/store.js');
+                    await rewind(cwd);
+                    queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text: 'Rewound to last checkpoint', role: 'assistant' });
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    queuedAppend({ id: `rewind-err-${Date.now()}`, kind: 'error', message: `rewind failed: ${msg}` });
+                }
+                return;
+            }
             case 'compact':
                 queuedAppend({
                     id: `stub-${Date.now()}`,

package/dist/cli/run.d.ts

@@ -65,7 +65,7 @@ export interface RunCliOptions {
     sessionsDir?: string;
 }
 export declare function runOnce(opts: RunCliOptions): Promise<number>;
-/** Wrap a system-prompt fn to inject Level-6 context (project map etc.). */
+/** Wrap a system-prompt fn to inject Level-6 context (project map etc.) + KLYRO.md (4.4). */
 export declare function makeRunSystemPrompt(cwd: string, base: (ctx: {
     cwd: string;
     telemetry?: string;

package/dist/cli/run.js

@@ -244,13 +244,21 @@ function defaultRunSystemPrompt(_ctx) {
     ].join(' ');
     return _ctx.telemetry ? base + '\n\n' + _ctx.telemetry : base;
 }
-/** Wrap a system-prompt fn to inject Level-6 context (project map etc.). */
+/** Wrap a system-prompt fn to inject Level-6 context (project map etc.) + KLYRO.md (4.4). */
 export async function makeRunSystemPrompt(cwd, base) {
     const ctxBlock = await buildLevel6Context({ cwd });
     const prefix = ctxBlock.formatted ? `\n\n<context>\n${ctxBlock.formatted}\n</context>` : '';
+    let klyroBlock = '';
+    try {
+        const { loadKlyroMd } = await import('../context/klyro-md.js');
+        const md = await loadKlyroMd(cwd);
+        if (md)
+            klyroBlock = `\n\n<KLYRO.md>\n${md.slice(0, 4000)}\n</KLYRO.md>`;
+    }
+    catch { /* ignore */ }
     return (ctx) => {
         const t = ctx.telemetry ? '\n\n' + ctx.telemetry : '';
-        return base(ctx) + prefix + t;
+        return base(ctx) + prefix + klyroBlock + t;
     };
 }
 export function loadTranscript(path) {

package/dist/cli/slash/parser.d.ts

@@ -23,6 +23,10 @@ export type SlashCommand = {
     model: string;
 } | {
     kind: 'diff';
+} | {
+    kind: 'undo';
+} | {
+    kind: 'rewind';
 } | {
     kind: 'plan';
 } | {
@@ -41,6 +45,10 @@ export type SlashCommand = {
     kind: 'cost';
 } | {
     kind: 'thinking';
+} | {
+    kind: 'memory';
+} | {
+    kind: 'jobs';
 } | {
     kind: 'prompt';
     text: string;

package/dist/cli/slash/parser.js

@@ -14,7 +14,7 @@
  * Anything not starting with "/" is a regular prompt and yields
  * { kind: 'prompt', text }.
  */
-const KNOWN = ['clear', 'compact', 'model', 'diff', 'plan', 'status', 'quit', 'help', 'config', 'doctor', 'version', 'cost', 'thinking', 'exit', 'clear'];
+const KNOWN = ['clear', 'compact', 'model', 'diff', 'undo', 'rewind', 'plan', 'status', 'quit', 'help', 'config', 'doctor', 'version', 'cost', 'thinking', 'memory', 'jobs', 'exit', 'clear'];
 export function parse(input) {
     const trimmed = input.trim();
     if (!trimmed.startsWith('/')) {
@@ -27,10 +27,14 @@ export function parse(input) {
         case 'clear': return { kind: 'clear' };
         case 'compact': return { kind: 'compact' };
         case 'diff': return { kind: 'diff' };
+        case 'undo': return { kind: 'undo' };
+        case 'rewind': return { kind: 'rewind' };
         case 'plan': return { kind: 'plan' };
         case 'status': return { kind: 'status' };
         case 'cost': return { kind: 'cost' };
         case 'thinking': return { kind: 'thinking' };
+        case 'memory': return { kind: 'memory' };
+        case 'jobs': return { kind: 'jobs' };
         case 'quit':
         case 'exit':
         case 'q': return { kind: 'quit' };

package/dist/context/klyro-md.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 4.4 — KLYRO.md loader: ~/.klyro/KLYRO.md → root → KLYRO.local.md → subdir files lazily
+ */
+export declare function loadKlyroMd(cwd: string): Promise<string>;
+export declare function handleInit(cwd: string): Promise<string>;

package/dist/context/klyro-md.js

@@ -0,0 +1,56 @@
+/**
+ * 4.4 — KLYRO.md loader: ~/.klyro/KLYRO.md → root → KLYRO.local.md → subdir files lazily
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+const CACHE = new Map();
+export async function loadKlyroMd(cwd) {
+    const parts = [];
+    // Global
+    const home = os.homedir();
+    if (home) {
+        for (const p of [path.join(home, '.klyro', 'KLYRO.md'), path.join(home, '.klyro', 'KLYRO.local.md')]) {
+            try {
+                const t = await fs.readFile(p, 'utf-8');
+                parts.push(`# ${p}\n${t}`);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    // Root
+    for (const name of ['KLYRO.md', 'KLYRO.local.md', 'AGENTS.md', 'CLAUDE.md', '.cursorrules']) {
+        const p = path.join(cwd, name);
+        try {
+            const t = await fs.readFile(p, 'utf-8');
+            parts.push(`# ${p}\n${await resolveImports(t, path.dirname(p))}`);
+        }
+        catch { /* ignore */ }
+    }
+    return parts.join('\n\n---\n\n');
+}
+async function resolveImports(text, base, depth = 0) {
+    if (depth > 5)
+        return text;
+    const importRe = /^@import\s+(.+)$/gm;
+    let out = text;
+    let m;
+    while ((m = importRe.exec(text))) {
+        const rel = m[1].trim().replace(/^["']|["']$/g, '');
+        const p = path.resolve(base, rel);
+        try {
+            const t = await fs.readFile(p, 'utf-8');
+            const resolved = await resolveImports(t, path.dirname(p), depth + 1);
+            out = out.replace(m[0], resolved);
+        }
+        catch { /* ignore missing */ }
+    }
+    return out;
+}
+export async function handleInit(cwd) {
+    const md = await loadKlyroMd(cwd);
+    if (md)
+        return `Existing KLYRO.md found. Review and update?`;
+    const draft = `# KLYRO.md\n\nProject: ${path.basename(cwd)}\n\n## Conventions\n- Use edit_file > write_file for existing files\n- Run tests after changes\n`;
+    return draft;
+}

package/dist/tools/fs/apply-patch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 4.2 — apply_patch: Codex-style unified patch, tolerant hunks
+ */
+export declare const applyPatchTool: import("../types.js").Tool<{
+    patch: string;
+}, {
+    readonly patchedFiles: string[];
+    readonly count: number;
+}>;

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

@@ -0,0 +1,79 @@
+/**
+ * 4.2 — apply_patch: Codex-style unified patch, tolerant hunks
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { resolveWithinCwd } from '../../policy/path-guard.js';
+import { safe } from '../normalize.js';
+const InputSchema = z.object({
+    patch: z.string().min(1).describe('Unified diff patch text'),
+});
+export const applyPatchTool = defineTool({
+    name: 'apply_patch',
+    description: 'Apply a unified diff patch (Codex-style). Tolerant hunks, per model config.',
+    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 = [];
+            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 } = resolveWithinCwd(ctx.cwd, currentFile);
+                        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 } = resolveWithinCwd(ctx.cwd, currentFile);
+                            fileContent = await fs.readFile(resolved, 'utf-8');
+                        }
+                        catch {
+                            fileContent = '';
+                        }
+                    }
+                    continue;
+                }
+                if (line.startsWith('*** Add File:')) {
+                    if (currentFile && fileContent !== null) {
+                        const { resolved } = resolveWithinCwd(ctx.cwd, currentFile);
+                        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 = '';
+                    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('+++')) {
+                    continue;
+                }
+            }
+            if (currentFile && fileContent !== null) {
+                const { resolved } = resolveWithinCwd(ctx.cwd, currentFile);
+                await fs.mkdir(path.dirname(resolved), { recursive: true });
+                await fs.writeFile(resolved, fileContent, 'utf-8');
+                patchedFiles.push(currentFile);
+            }
+            if (patchedFiles.length === 0)
+                throw Object.assign(new Error('No files patched — invalid patch format'), { code: 'INVALID_PATCH' });
+            return { patchedFiles, count: patchedFiles.length };
+        });
+    },
+});

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

@@ -14,35 +14,13 @@ export interface EditFileOutput {
     replacements: number;
     diff: string;
 }
+export declare function recordEditStaleness(path: string, mtime: number, hash: string): void;
+export declare function checkStaleness(path: string, currentMtime: number, currentHash: string): boolean;
 export declare const editFileTool: import("../types.js").Tool<{
     path: string;
     find: string;
     replace: string;
     replaceAll?: boolean | undefined;
-}, {
-    readonly ok: false;
-    readonly error: {
-        readonly code: "MATCH_NOT_FOUND";
-        readonly message: `find substring not present in ${string}`;
-    };
-    path?: undefined;
-    replacements?: undefined;
-    diff?: undefined;
-} | {
-    readonly ok: false;
-    readonly error: {
-        readonly code: "MATCH_AMBIGUOUS";
-        readonly message: `find substring occurs ${number} times in ${string}. Supply more context or pass replaceAll=true.`;
-    };
-    path?: undefined;
-    replacements?: undefined;
-    diff?: undefined;
-} | {
-    path: string;
-    replacements: number;
-    diff: string;
-    readonly ok?: undefined;
-    readonly error?: undefined;
-}>;
+}, EditFileOutput>;
 export type EditFileInput = z.infer<typeof InputSchema>;
 export {};

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

@@ -3,6 +3,7 @@
  * Strict: ambiguous matches fail unless replaceAll=true. Missing match fails.
  */
 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';
@@ -13,34 +14,119 @@ const InputSchema = z.object({
     replace: z.string(),
     replaceAll: z.boolean().optional().describe('If true, replace every occurrence.'),
 });
+// Staleness map: path -> { mtime, hash }
+const stalenessMap = new Map();
+export function recordEditStaleness(path, mtime, hash) {
+    stalenessMap.set(path, { mtime, hash });
+}
+export function checkStaleness(path, currentMtime, currentHash) {
+    const prev = stalenessMap.get(path);
+    if (!prev)
+        return false;
+    return prev.mtime !== currentMtime || prev.hash !== currentHash;
+}
 export const editFileTool = defineTool({
     name: 'edit_file',
-    description: 'Replace a substring in a file. Strict: if `find` is missing or ambiguous, the edit fails (unless replaceAll=true).',
+    description: 'Replace a substring in a file. Strict: if `find` is missing or ambiguous, the edit fails (unless replaceAll=true). Preserves EOL/BOM/trailing newline, checks staleness.',
     inputSchema: InputSchema,
+    permission: 'edit',
+    isConcurrencySafe: false,
+    renderCall: (input) => `edit_file ${input.path} find:${input.find.slice(0, 40)}`,
+    renderResult: (output) => `${output.path} ${output.replacements} replacement(s)`,
     execute: async (input, ctx) => {
         return safe(async () => {
             const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
-            const original = await fs.readFile(resolved, 'utf-8');
-            const count = countOccurrences(original, input.find);
+            // 4.1: staleness check via mtime+hash
+            const stat = await fs.stat(resolved);
+            const raw = await fs.readFile(resolved, 'utf-8');
+            // Detect BOM
+            const hasBOM = raw.charCodeAt(0) === 0xfeff;
+            const withoutBOM = hasBOM ? raw.slice(1) : raw;
+            // Detect EOL
+            const eol = withoutBOM.includes('\r\n') ? '\r\n' : '\n';
+            const hasTrailingNewline = withoutBOM.endsWith('\n');
+            // Detect original for staleness
+            const currentHash = crypto.createHash('sha256').update(withoutBOM, 'utf-8').digest('hex');
+            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);
+            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';
+                    }
+                }
+            }
             if (count === 0) {
-                return {
-                    ok: false,
-                    error: { code: 'MATCH_NOT_FOUND', message: `find substring not present in ${input.path}` },
-                };
+                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) {
-                return {
-                    ok: false,
-                    error: {
-                        code: 'MATCH_AMBIGUOUS',
-                        message: `find substring occurs ${count} times in ${input.path}. Supply more context or pass replaceAll=true.`,
-                    },
-                };
+                throw Object.assign(new Error(`find substring occurs ${count} times in ${input.path}. Supply more context or pass replaceAll=true.`), { code: 'MATCH_AMBIGUOUS' });
             }
-            const next = replaceAll ? original.split(input.find).join(input.replace) : original.replace(input.find, input.replace);
-            const tmp = `${resolved}.klyro-edit-${process.pid}-${Date.now()}.tmp`;
+            let next = replaceAll ? original.split(findStr).join(input.replace) : original.replace(findStr, input.replace);
+            // Preserve EOL
+            if (eol === '\r\n')
+                next = next.replace(/\n/g, '\r\n');
+            // Preserve trailing newline
+            if (hasTrailingNewline && !next.endsWith('\n'))
+                next += eol;
+            else if (!hasTrailingNewline && next.endsWith(eol))
+                next = next.slice(0, -eol.length);
+            // Preserve BOM
+            if (hasBOM)
+                next = '\uFEFF' + next;
+            const tmp = `${resolved}.klyro-edit-${process.pid}-${Date.now()}-${crypto.randomBytes(4).toString('hex')}.tmp`;
             await fs.writeFile(tmp, next, 'utf-8');
+            // Ensure fsync before rename (like write_file)
+            const fh = await fs.open(tmp, 'r+');
+            try {
+                await fh.sync();
+            }
+            finally {
+                await fh.close().catch(() => undefined);
+            }
             try {
                 await fs.rename(tmp, resolved);
             }
@@ -48,10 +134,15 @@ export const editFileTool = defineTool({
                 await fs.unlink(tmp).catch(() => undefined);
                 throw err;
             }
+            // Update staleness after successful edit
+            const newStat = await fs.stat(resolved);
+            const newHash = crypto.createHash('sha256').update(next.replace(/^\uFEFF/, ''), 'utf-8').digest('hex');
+            recordEditStaleness(resolved, newStat.mtimeMs, newHash);
+            const diffNote = fuzzyTier ? ` [fuzzy:${fuzzyTier}]` : '';
             return {
                 path: input.path,
                 replacements: replaceAll ? count : 1,
-                diff: simpleDiff(original, input.find, input.replace, replaceAll ? count : 1),
+                diff: simpleDiff(original, findStr, input.replace, replaceAll ? count : 1) + diffNote,
             };
         });
     },
@@ -70,6 +161,35 @@ function countOccurrences(haystack, needle) {
     }
     return count;
 }
+function findClosestMatch(text, needle) {
+    const lines = text.split('\n');
+    let bestIdx = 0;
+    let bestScore = -1;
+    let bestSnippet = '';
+    // Simple similarity: longest common substring ratio
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        // Compute similarity as shared chars / max length (very rough)
+        let score = 0;
+        const minLen = Math.min(line.length, needle.length);
+        for (let k = 0; k < minLen; k++)
+            if (line[k] === needle[k])
+                score++;
+        score = minLen > 0 ? score / Math.max(line.length, needle.length) : 0;
+        // Also check if needle substring inside line
+        if (line.includes(needle.slice(0, Math.min(10, needle.length))))
+            score += 0.3;
+        if (score > bestScore) {
+            bestScore = score;
+            bestIdx = i;
+            bestSnippet = line;
+        }
+    }
+    const start = Math.max(0, bestIdx - 2);
+    const end = Math.min(lines.length - 1, bestIdx + 2);
+    const snippet = lines.slice(start, end + 1).join('\n');
+    return { snippet, lineRange: [start + 1, end + 1], similarity: Math.min(1, bestScore) };
+}
 function simpleDiff(original, find, replace, count) {
     const firstIdx = original.indexOf(find);
     if (firstIdx < 0)

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

@@ -0,0 +1,15 @@
+/**
+ * 4.2 — multi_edit: atomic sequential edits with rollback on failure
+ */
+export declare const multiEditTool: import("../types.js").Tool<{
+    path: string;
+    edits: {
+        find: string;
+        replace: string;
+        replaceAll?: boolean | undefined;
+    }[];
+}, {
+    readonly path: string;
+    readonly edits: number;
+    readonly diff: `multi_edit ${number} edits`;
+}>;

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

@@ -0,0 +1,50 @@
+/**
+ * 4.2 — multi_edit: atomic sequential edits with rollback on failure
+ */
+import * as fs from 'node:fs/promises';
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { resolveAndFollowSymlinks } from '../../policy/path-guard.js';
+import { safe } from '../normalize.js';
+const EditSchema = z.object({
+    find: z.string().min(1),
+    replace: z.string(),
+    replaceAll: z.boolean().optional(),
+});
+const InputSchema = z.object({
+    path: z.string().min(1),
+    edits: z.array(EditSchema).min(1).max(20),
+});
+export const multiEditTool = defineTool({
+    name: 'multi_edit',
+    description: 'Apply multiple sequential edits atomically to a file. Fails fast with rollback if any edit fails.',
+    inputSchema: InputSchema,
+    permission: 'edit',
+    isConcurrencySafe: false,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const { resolved } = await resolveAndFollowSymlinks(ctx.cwd, input.path);
+            let content = await fs.readFile(resolved, 'utf-8');
+            const original = content;
+            for (let i = 0; i < input.edits.length; i++) {
+                const e = input.edits[i];
+                const count = content.split(e.find).length - 1;
+                if (count === 0)
+                    throw Object.assign(new Error(`edit ${i}: find not found`), { code: 'MATCH_NOT_FOUND' });
+                if (!e.replaceAll && count > 1)
+                    throw Object.assign(new Error(`edit ${i}: ambiguous (${count} matches)`), { code: 'MATCH_AMBIGUOUS' });
+                content = e.replaceAll ? content.split(e.find).join(e.replace) : content.replace(e.find, e.replace);
+            }
+            const tmp = `${resolved}.klyro-multi-${Date.now()}.tmp`;
+            await fs.writeFile(tmp, content, 'utf-8');
+            try {
+                await fs.rename(tmp, resolved);
+            }
+            catch (err) {
+                await fs.unlink(tmp).catch(() => undefined);
+                throw err;
+            }
+            return { path: input.path, edits: input.edits.length, diff: `multi_edit ${input.edits.length} edits` };
+        });
+    },
+});

package/dist/tools/git/git-log.d.ts

@@ -0,0 +1,6 @@
+export declare const gitLogTool: import("../types.js").Tool<{
+    limit?: number | undefined;
+    path?: string | undefined;
+}, {
+    readonly log: string;
+}>;

package/dist/tools/git/git-log.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { safe } from '../normalize.js';
+import { spawn } from 'node:child_process';
+const InputSchema = z.object({
+    limit: z.number().int().min(1).max(100).optional().describe('Number of commits'),
+    path: z.string().optional().describe('Filter by path'),
+});
+export const gitLogTool = defineTool({
+    name: 'git_log',
+    description: 'Show git log (read-only)',
+    inputSchema: InputSchema,
+    permission: 'read',
+    isConcurrencySafe: true,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const args = ['log', '--oneline', `-${input.limit ?? 20}`];
+            if (input.path)
+                args.push('--', input.path);
+            const out = await runGit(args, ctx.cwd);
+            return { log: out };
+        });
+    },
+});
+function runGit(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, { cwd, shell: false, windowsHide: true });
+        let out = '';
+        let err = '';
+        child.stdout.on('data', (b) => { out += b.toString(); });
+        child.stderr.on('data', (b) => { err += b.toString(); });
+        child.on('error', reject);
+        child.on('close', (code) => {
+            if (code === 0)
+                resolve(out);
+            else
+                reject(new Error(err || `git ${args[0]} failed`));
+        });
+    });
+}

package/dist/tools/registry.js

@@ -4,6 +4,8 @@
 import { readFileTool } from './fs/read-file.js';
 import { writeFileTool } from './fs/write-file.js';
 import { editFileTool } from './fs/edit-file.js';
+import { multiEditTool } from './fs/multi-edit.js';
+import { applyPatchTool } from './fs/apply-patch.js';
 import { listDirTool } from './fs/list-dir.js';
 import { globTool } from './search/glob.js';
 import { grepTool } from './search/grep.js';
@@ -13,6 +15,7 @@ import { dependenciesTool } from './search/dependencies.js';
 import { shellExecTool } from './shell/shell-exec.js';
 import { gitStatusTool } from './git/git-status.js';
 import { gitDiffTool } from './git/git-diff.js';
+import { gitLogTool } from './git/git-log.js';
 import { runVerifyTool } from './verify/run-verify.js';
 import { zodToJsonSchema } from './schema.js';
 export class ToolRegistry {
@@ -73,6 +76,8 @@ export const builtinRegistry = () => {
     r.register(readFileTool);
     r.register(writeFileTool);
     r.register(editFileTool);
+    r.register(multiEditTool);
+    r.register(applyPatchTool);
     r.register(listDirTool);
     r.register(globTool);
     r.register(grepTool);
@@ -82,6 +87,7 @@ export const builtinRegistry = () => {
     r.register(shellExecTool);
     r.register(gitStatusTool);
     r.register(gitDiffTool);
+    r.register(gitLogTool);
     r.register(runVerifyTool);
     return r;
 };

package/dist/tools/shell/background.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 4.3 — Background shell: shell(run_in_background), bash_output, kill_shell, /jobs
+ */
+export declare function startBackground(command: string, cwd: string): string;
+export declare function getOutput(id: string, filter?: string): string;
+export declare function killJob(id: string): void;
+export declare function listJobs(): Array<{
+    id: string;
+    command: string;
+    cwd: string;
+    running: boolean;
+}>;

package/dist/tools/shell/background.js

@@ -0,0 +1,39 @@
+/**
+ * 4.3 — Background shell: shell(run_in_background), bash_output, kill_shell, /jobs
+ */
+import { spawn } from 'node:child_process';
+const jobs = new Map();
+let counter = 0;
+export function startBackground(command, cwd) {
+    const id = `job-${++counter}-${Date.now().toString(36)}`;
+    const proc = spawn(command, { cwd, shell: true, windowsHide: true });
+    const job = { id, command, cwd, proc, output: '', start: Date.now() };
+    jobs.set(id, job);
+    proc.stdout?.on('data', (b) => { job.output += b.toString(); if (job.output.length > 1_000_000)
+        job.output = job.output.slice(-1_000_000); });
+    proc.stderr?.on('data', (b) => { job.output += b.toString(); if (job.output.length > 1_000_000)
+        job.output = job.output.slice(-1_000_000); });
+    proc.on('close', () => { });
+    return id;
+}
+export function getOutput(id, filter) {
+    const job = jobs.get(id);
+    if (!job)
+        throw new Error(`No job ${id}`);
+    if (filter)
+        return job.output.split('\n').filter((l) => l.includes(filter)).join('\n');
+    return job.output.slice(-5000);
+}
+export function killJob(id) {
+    const job = jobs.get(id);
+    if (!job)
+        throw new Error(`No job ${id}`);
+    try {
+        job.proc.kill('SIGKILL');
+    }
+    catch { /* ignore */ }
+    jobs.delete(id);
+}
+export function listJobs() {
+    return [...jobs.values()].map((j) => ({ id: j.id, command: j.command, cwd: j.cwd, running: j.proc.exitCode === null }));
+}

package/dist/tui/app.js

@@ -237,6 +237,41 @@ export function App(props) {
                 setInput('');
                 return;
             }
+            // 4.4 — handle @path and !cmd and # note without model call
+            if (trimmedOuter.startsWith('@')) {
+                const atPath = trimmedOuter.slice(1).trim().split(' ')[0] ?? '';
+                setInput('');
+                append({ id: nextId('text'), kind: 'text', text: `Attached @${atPath} (fuzzy completion stub)`, role: 'assistant' });
+                // Still send to model as context, but mark as @ reference
+                const atText = `Reference file: ${atPath}`;
+                void props.onPrompt(atText);
+                return;
+            }
+            if (trimmedOuter.startsWith('!')) {
+                const cmdText = trimmedOuter.slice(1).trim();
+                setInput('');
+                // Run shell without model call, attach output
+                import('../tools/shell/shell-exec.js').then(async ({ shellExecTool }) => {
+                    const { builtinRegistry } = await import('../tools/registry.js');
+                    const reg = builtinRegistry();
+                    const r = await reg.execute('shell_exec', { command: cmdText }, { cwd: props.cwd, env: process.env, nonInteractive: true });
+                    const out = r.ok ? JSON.stringify(r.value).slice(0, 500) : String(r.error.message);
+                    append({ id: nextId('text'), kind: 'text', text: `!${cmdText}\n${out}`, role: 'assistant' });
+                });
+                return;
+            }
+            if (trimmedOuter.startsWith('# ')) {
+                const note = trimmedOuter.slice(2).trim();
+                // Append to .klyro/memory/session-notes.md
+                import('node:fs/promises').then(async (fs) => {
+                    const p = (await import('node:path')).join(props.cwd, '.klyro', 'memory', 'session-notes.md');
+                    await fs.mkdir((await import('node:path')).dirname(p), { recursive: true });
+                    await fs.appendFile(p, `- ${note}\n`, 'utf-8');
+                });
+                setInput('');
+                append({ id: nextId('text'), kind: 'text', text: `Note saved: ${note}`, role: 'assistant' });
+                return;
+            }
             // Check for Ctrl+C double at empty prompt handled below, but here handle submit
             setInput('');
             historyIndexRef.current = -1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klyro",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Klyro — autonomous coding harness CLI that streams from any OpenAI-compatible or Anthropic LLM endpoint.",
   "type": "module",
   "main": "dist/index.js",