klyro 1.0.17 → 1.0.18

package/dist/eval/harness.js

@@ -177,10 +177,46 @@ export async function loadFileFixture(dir) {
     catch { /* no script → static fixture */ }
     return { dir, task: task.trim(), checkSh, meta, ...(repo ? { repo } : {}), ...(script ? { script } : {}) };
 }
+/**
+ * 5.4b — sanitized env for `check.sh`: PATH + home/locale + temp vars
+ * (+ Windows shell vars so the shell can spawn). Everything else —
+ * secrets, `KLYRO_*` config, caller sentinels — is dropped. Exported for tests.
+ */
+const FIXTURE_ENV_ALLOW = new Set([
+    'PATH', 'PATHEXT', 'HOME', 'LANG', 'LC_ALL', 'TMPDIR', 'TEMP', 'TMP',
+    'SYSTEMROOT', 'SYSTEMDRIVE', 'COMSPEC',
+]);
+export function sanitizedFixtureEnv(base = process.env) {
+    const out = {};
+    for (const k of FIXTURE_ENV_ALLOW) {
+        const v = base[k];
+        if (v !== undefined)
+            out[k] = v;
+    }
+    return out;
+}
+/**
+ * 5.4b — guard: fixture workdirs must stay inside `os.tmpdir()` (the
+ * harness relies on that isolation). Throws otherwise unless the caller
+ * explicitly passes `allowWorkdirOutsideTmp`. Exported for tests.
+ */
+export function assertTmpWorkdir(dir, opts = {}) {
+    if (opts.allowWorkdirOutsideTmp)
+        return;
+    const root = path.resolve(os.tmpdir());
+    const resolved = path.resolve(dir);
+    if (resolved !== root && !resolved.startsWith(root + path.sep)) {
+        throw new Error(`fixture workdir escapes os.tmpdir(): ${resolved} (pass allowWorkdirOutsideTmp to override)`);
+    }
+}
 export async function runFileFixture(fixture, _opts = {}) {
     const start = Date.now();
     const tmp = path.join(os.tmpdir(), 'klyro-eval-file-' + Math.random().toString(36).slice(2));
+    assertTmpWorkdir(tmp, _opts);
     await fs.mkdir(tmp, { recursive: true });
+    // Restrictive creation (umask-style): the tmp workdir is owner-only.
+    // Best-effort — chmod is a no-op for ACLs on Windows but harmless.
+    await fs.chmod(tmp, 0o700).catch(() => undefined);
     // Copy repo if exists
     if (fixture.repo) {
         const src = path.isAbsolute(fixture.repo) ? fixture.repo : path.join(fixture.dir, fixture.repo);
@@ -192,7 +228,7 @@ export async function runFileFixture(fixture, _opts = {}) {
     // Run check.sh via shell
     const { spawn } = await import('node:child_process');
     const result = await new Promise((resolve) => {
-        const child = spawn('bash', ['-c', fixture.checkSh], { cwd: tmp, shell: false });
+        const child = spawn('bash', ['-c', fixture.checkSh], { cwd: tmp, shell: false, env: sanitizedFixtureEnv() });
         const sink = cappedOutput(MAX_CHECK_BYTES);
         child.stdout?.on('data', (b) => sink.push(b));
         child.stderr?.on('data', (b) => sink.push(b));
@@ -226,7 +262,9 @@ export async function runAgentFixture(fixture, opts = {}) {
         return { id, status: 'fail', details: 'agent fixture needs script.json', durationMs: Date.now() - start };
     }
     const tmp = path.join(os.tmpdir(), 'klyro-eval-agent-' + Math.random().toString(36).slice(2));
+    assertTmpWorkdir(tmp, opts);
     await fs.mkdir(tmp, { recursive: true });
+    await fs.chmod(tmp, 0o700).catch(() => undefined);
     try {
         if (fixture.repo) {
             const src = path.isAbsolute(fixture.repo) ? fixture.repo : path.join(fixture.dir, fixture.repo);
@@ -250,7 +288,7 @@ export async function runAgentFixture(fixture, opts = {}) {
         // Structural pass — now assert real filesystem outcomes.
         const { spawn } = await import('node:child_process');
         const out = await new Promise((resolve) => {
-            const child = spawn('bash', ['-c', fixture.checkSh], { cwd: tmp, shell: false });
+            const child = spawn('bash', ['-c', fixture.checkSh], { cwd: tmp, shell: false, env: sanitizedFixtureEnv() });
             const sink = cappedOutput(MAX_CHECK_BYTES);
             child.stdout?.on('data', (b) => sink.push(b));
             child.stderr?.on('data', (b) => sink.push(b));

package/dist/index.js

@@ -350,6 +350,7 @@ async function main() {
         .option('--agent <name>', 'Run under an orchestrator context enabling spawn_agent/task_list/task_get (explorer|implementer|tester|reviewer)')
         .option('--max-depth <n>', 'Max spawn depth for child agents (default 1)', (v) => parsePositiveInt('--max-depth', v))
         .option('--bare', 'Deterministic runs: skip MCP, hooks, memory/KLYRO.md/context, persistence')
+        .option('--auto-answer <text>', 'Headless answer for ask_user prompts (sets KLYRO_AUTO_ANSWER)')
         .action(async (prompt, opts) => {
         const model = opts.model ?? process.env.KLYRO_MODEL;
         if (!model) {
@@ -410,6 +411,7 @@ async function main() {
                 agent: opts.agent,
                 maxDepth: opts.maxDepth,
                 bare: !!opts.bare,
+                autoAnswer: opts.autoAnswer,
             });
             process.exit(code);
         }
@@ -443,17 +445,18 @@ async function main() {
         .option('--model <id>', 'Model for eval')
         .option('--judge-model <id>', 'Live model id for grading judge.rubric (needs endpoint + key)')
         .option('--cwd <path>', 'Shared scenario workdir (default: isolated tmp per scenario)')
+        .option('--auto-answer <text>', 'Headless answer for ask_user prompts (sets KLYRO_AUTO_ANSWER)')
         .action(async (input, opts) => {
         const output = (opts.output ?? 'human');
         if (opts.suite) {
-            const code = await runEval({ inputPath: input ?? '-', output, suite: opts.suite, filter: opts.filter, runs: opts.runs, parallel: opts.parallel, model: opts.model, judgeModel: opts.judgeModel });
+            const code = await runEval({ inputPath: input ?? '-', output, suite: opts.suite, filter: opts.filter, runs: opts.runs, parallel: opts.parallel, model: opts.model, judgeModel: opts.judgeModel, cwd: opts.cwd, autoAnswer: opts.autoAnswer });
             process.exit(code);
         }
         if (!input) {
             process.stderr.write('klyro eval: missing input (provide <input> or --suite)\n');
             process.exit(2);
         }
-        const code = await runEval({ inputPath: input, output, suite: opts.suite, filter: opts.filter, runs: opts.runs, parallel: opts.parallel, model: opts.model, judgeModel: opts.judgeModel, cwd: opts.cwd });
+        const code = await runEval({ inputPath: input, output, suite: opts.suite, filter: opts.filter, runs: opts.runs, parallel: opts.parallel, model: opts.model, judgeModel: opts.judgeModel, cwd: opts.cwd, autoAnswer: opts.autoAnswer });
         process.exit(code);
     });
     program

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

@@ -0,0 +1,5 @@
+export declare const gitBlameTool: import("../types.js").Tool<{
+    path: string;
+}, {
+    readonly blame: string;
+}>;

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { safe } from '../normalize.js';
+import { runGit } from './run-git.js';
+const InputSchema = z.object({
+    path: z.string().min(1).describe('File path to blame'),
+});
+export const gitBlameTool = defineTool({
+    name: 'git_blame',
+    description: 'Show git blame for a file, line by line. Read-only.',
+    inputSchema: InputSchema,
+    permission: 'read',
+    isConcurrencySafe: true,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const res = await runGit(['blame', '--', input.path], ctx.cwd);
+            if (res.code !== 0)
+                throw new Error(res.err || `git blame failed`);
+            return { blame: res.out };
+        });
+    },
+});

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

@@ -2,31 +2,14 @@
  * git_diff — show unstaged (`git diff`) or staged (`git diff --cached`)
  * changes plus a compact per-file stat. Read-only.
  */
-import { spawn } from 'node:child_process';
 import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { safe, TOOL_ERROR_CODES } from '../normalize.js';
+import { runGit } from './run-git.js';
 const InputSchema = z.object({
     staged: z.boolean().optional().describe('Show staged changes instead of unstaged (default false)'),
     path: z.string().optional().describe('Limit to a specific path'),
 });
-function run(args, cwd, timeoutMs = 15_000) {
-    return new Promise((resolve) => {
-        const child = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: false });
-        const out = [];
-        const err = [];
-        const timer = setTimeout(() => { try {
-            child.kill('SIGKILL');
-        }
-        catch { /* noop */ } }, timeoutMs);
-        child.stdout.on('data', (b) => out.push(b));
-        child.stderr.on('data', (b) => err.push(b));
-        child.on('close', (code) => {
-            clearTimeout(timer);
-            resolve({ code: code ?? 1, out: Buffer.concat(out).toString('utf-8'), err: Buffer.concat(err).toString('utf-8') });
-        });
-    });
-}
 export const gitDiffTool = defineTool({
     name: 'git_diff',
     description: 'Show the unified diff of working-tree changes (unstaged by default) or staged changes. Read-only. Returns the diff text, a per-file stat, and the list of changed file paths.',
@@ -37,7 +20,7 @@ export const gitDiffTool = defineTool({
             const args = [...base, '--no-color'];
             if (input.path)
                 args.push('--', input.path);
-            const diff = await run(args, ctx.cwd);
+            const diff = await runGit(args, ctx.cwd);
             if (diff.code !== 0) {
                 return {
                     ok: false,
@@ -47,7 +30,7 @@ export const gitDiffTool = defineTool({
             const statArgs = [...base, '--stat', '--no-color'];
             if (input.path)
                 statArgs.push('--', input.path);
-            const stat = await run(statArgs, ctx.cwd);
+            const stat = await runGit(statArgs, ctx.cwd);
             // Parse changed file paths from `diff --git a/... b/...` lines.
             const patchedFiles = [];
             const newline = /\r?\n/;

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { safe } from '../normalize.js';
-import { spawn } from 'node:child_process';
+import { runGit } from './run-git.js';
 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'),
@@ -17,24 +17,10 @@ export const gitLogTool = defineTool({
             const args = ['log', '--oneline', `-${input.limit ?? 20}`];
             if (input.path)
                 args.push('--', input.path);
-            const out = await runGit(args, ctx.cwd);
-            return { log: out };
+            const res = await runGit(args, ctx.cwd);
+            if (res.code !== 0)
+                throw new Error(res.err || `git log failed`);
+            return { log: res.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/git/git-show.d.ts

@@ -0,0 +1,5 @@
+export declare const gitShowTool: import("../types.js").Tool<{
+    target: string;
+}, {
+    readonly content: string;
+}>;

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { defineTool } from '../types.js';
+import { safe } from '../normalize.js';
+import { runGit } from './run-git.js';
+const InputSchema = z.object({
+    target: z.string().min(1).describe('Commit hash, branch name, or tag to show'),
+});
+export const gitShowTool = defineTool({
+    name: 'git_show',
+    description: 'Show the patch/content of a specific commit. Read-only.',
+    inputSchema: InputSchema,
+    permission: 'read',
+    isConcurrencySafe: true,
+    execute: async (input, ctx) => {
+        return safe(async () => {
+            const res = await runGit(['show', '--no-color', input.target], ctx.cwd);
+            if (res.code !== 0)
+                throw new Error(res.err || `git show failed`);
+            return { content: res.out };
+        });
+    },
+});

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

@@ -4,37 +4,20 @@
  *   - `git log -n 10 --oneline` for recent history
  * The agent needs working-tree state AND recent history to plan edits.
  */
-import { spawn } from 'node:child_process';
 import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { safe } from '../normalize.js';
+import { runGit } from './run-git.js';
 const InputSchema = z.object({
     showLog: z.boolean().optional().describe('Also include the last 10 commit messages (default true)'),
 });
-function run(args, cwd, timeoutMs = 15_000) {
-    return new Promise((resolve) => {
-        const child = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: false });
-        const out = [];
-        const err = [];
-        const timer = setTimeout(() => { try {
-            child.kill('SIGKILL');
-        }
-        catch { /* noop */ } }, timeoutMs);
-        child.stdout.on('data', (b) => out.push(b));
-        child.stderr.on('data', (b) => err.push(b));
-        child.on('close', (code) => {
-            clearTimeout(timer);
-            resolve({ code: code ?? 1, out: Buffer.concat(out).toString('utf-8'), err: Buffer.concat(err).toString('utf-8') });
-        });
-    });
-}
 export const gitStatusTool = defineTool({
     name: 'git_status',
     description: 'Show working-tree status (porcelain) and, optionally, the last 10 commit messages and current branch. Read-only.',
     inputSchema: InputSchema,
     execute: async (input, ctx) => {
         return safe(async () => {
-            const status = await run(['status', '--porcelain', '--untracked-files=all'], ctx.cwd);
+            const status = await runGit(['status', '--porcelain', '--untracked-files=all'], ctx.cwd);
             if (status.code !== 0) {
                 // Not a git repo or git unavailable
                 return {
@@ -43,11 +26,11 @@ export const gitStatusTool = defineTool({
                 };
             }
             const result = { porcelain: status.out || '(clean)' };
-            const branch = await run(['branch', '--show-current'], ctx.cwd);
+            const branch = await runGit(['branch', '--show-current'], ctx.cwd);
             if (branch.code === 0 && branch.out.trim())
                 result.branch = branch.out.trim();
             if (input.showLog !== false) {
-                const log = await run(['log', '-n', '10', '--oneline', '--no-show-signature'], ctx.cwd);
+                const log = await runGit(['log', '-n', '10', '--oneline', '--no-show-signature'], ctx.cwd);
                 if (log.code === 0 && log.out.trim())
                     result.recentCommits = log.out.trim();
             }

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

@@ -0,0 +1,5 @@
+export declare function runGit(args: string[], cwd: string, timeoutMs?: number): Promise<{
+    code: number;
+    out: string;
+    err: string;
+}>;

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

@@ -0,0 +1,18 @@
+import { spawn } from 'node:child_process';
+export function runGit(args, cwd, timeoutMs = 15_000) {
+    return new Promise((resolve) => {
+        const child = spawn('git', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true, shell: false });
+        const out = [];
+        const err = [];
+        const timer = setTimeout(() => { try {
+            child.kill('SIGKILL');
+        }
+        catch { /* noop */ } }, timeoutMs);
+        child.stdout.on('data', (b) => out.push(b));
+        child.stderr.on('data', (b) => err.push(b));
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            resolve({ code: code ?? 1, out: Buffer.concat(out).toString('utf-8'), err: Buffer.concat(err).toString('utf-8') });
+        });
+    });
+}

package/dist/tools/registry.js

@@ -16,6 +16,8 @@ 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 { gitBlameTool } from './git/git-blame.js';
+import { gitShowTool } from './git/git-show.js';
 import { runVerifyTool } from './verify/run-verify.js';
 import { todoWriteTool } from './plan/todo-write.js';
 import { askUserTool } from './plan/ask-user.js';
@@ -104,6 +106,8 @@ export const builtinRegistry = () => {
     r.register(gitStatusTool);
     r.register(gitDiffTool);
     r.register(gitLogTool);
+    r.register(gitBlameTool);
+    r.register(gitShowTool);
     r.register(runVerifyTool);
     r.register(todoWriteTool);
     r.register(askUserTool);

package/dist/tools/search/glob.js

@@ -7,6 +7,7 @@ import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { resolveWithinCwd } from '../../policy/path-guard.js';
 import { safe } from '../normalize.js';
+import { IgnoreFilter } from './ignore.js';
 const InputSchema = z.object({
     pattern: z.string().min(1).describe('Glob pattern, e.g. "**/*.ts" or "src/**/*.json"'),
     cwd: z.string().optional().describe('Base directory; defaults to workspace cwd'),
@@ -25,7 +26,8 @@ export const globTool = defineTool({
             const max = input.maxResults ?? DEFAULT_MAX;
             const matches = [];
             let truncated = false;
-            await walk(base, base, matcher, max + 1, matches, () => (truncated = true));
+            const ignore = await IgnoreFilter.load(ctx.cwd);
+            await walk(base, base, matcher, max + 1, matches, () => (truncated = true), ignore, ctx.cwd);
             // Normalize to relative, forward-slash paths from ctx.cwd (so
             // tool inputs/outputs are stable across Windows and POSIX).
             const rel = matches.slice(0, max).map((m) => path.relative(ctx.cwd, m).split(path.sep).join('/'));
@@ -50,7 +52,7 @@ export function globToRegex(pattern) {
         .replace(/::DOUBLESTAR::/g, '.*');
     return new RegExp(`${anchor}${escaped}$`);
 }
-async function walk(root, dir, matcher, cap, out, onCap) {
+async function walk(root, dir, matcher, cap, out, onCap, ignore, cwd) {
     if (out.length >= cap)
         return;
     let names;
@@ -66,6 +68,9 @@ async function walk(root, dir, matcher, cap, out, onCap) {
         if (SKIP_DIRS.has(name))
             continue;
         const full = path.join(dir, name);
+        const relToCwd = path.relative(cwd, full);
+        if (ignore.ignores(relToCwd))
+            continue;
         let isDir = false;
         try {
             const s = await fs.lstat(full);
@@ -83,6 +88,6 @@ async function walk(root, dir, matcher, cap, out, onCap) {
                 onCap();
         }
         if (isDir)
-            await walk(root, full, matcher, cap, out, onCap);
+            await walk(root, full, matcher, cap, out, onCap, ignore, cwd);
     }
 }

package/dist/tools/search/grep.js

@@ -7,6 +7,7 @@ import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { resolveWithinCwd } from '../../policy/path-guard.js';
 import { safe, TOOL_ERROR_CODES } from '../normalize.js';
+import { IgnoreFilter } from './ignore.js';
 const InputSchema = z.object({
     pattern: z.string().min(1).describe('JavaScript regular expression (not ripgrep syntax)'),
     cwd: z.string().optional(),
@@ -48,6 +49,7 @@ export const grepTool = defineTool({
             const hits = [];
             let searched = 0;
             let truncated = false;
+            const ignore = await IgnoreFilter.load(ctx.cwd);
             await walk(base, async (file) => {
                 if (hits.length >= max) {
                     truncated = true;
@@ -88,7 +90,7 @@ export const grepTool = defineTool({
                         hits.push(hit);
                     }
                 }
-            });
+            }, ignore, ctx.cwd);
             return { pattern: input.pattern, hits, truncated, searchedFiles: searched };
         });
     },
@@ -102,7 +104,7 @@ function globToRegex(g) {
         .replace(/::DS::/g, '.*');
     return new RegExp(`^${escaped}$`);
 }
-async function walk(dir, visit) {
+async function walk(dir, visit, ignore, cwd) {
     let names;
     try {
         names = await fs.readdir(dir);
@@ -114,6 +116,11 @@ async function walk(dir, visit) {
         if (SKIP_DIRS.has(name))
             continue;
         const full = path.join(dir, name);
+        if (ignore && cwd) {
+            const relToCwd = path.relative(cwd, full);
+            if (ignore.ignores(relToCwd))
+                continue;
+        }
         let isDir = false;
         try {
             const s = await fs.lstat(full);
@@ -125,7 +132,7 @@ async function walk(dir, visit) {
             continue;
         }
         if (isDir)
-            await walk(full, visit);
+            await walk(full, visit, ignore, cwd);
         else
             await visit(full);
     }

package/dist/tools/search/ignore.d.ts

@@ -0,0 +1,8 @@
+/** Converts a .gitignore rule to a regex. Assumes no negative (!) rules for now. */
+export declare function ignoreRuleToRegex(rule: string): RegExp | null;
+export declare class IgnoreFilter {
+    private rules;
+    static load(cwd: string): Promise<IgnoreFilter>;
+    /** Accepts a relative path (posix or windows) and returns true if it should be ignored. */
+    ignores(relPath: string): boolean;
+}

package/dist/tools/search/ignore.js

@@ -0,0 +1,49 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+/** Converts a .gitignore rule to a regex. Assumes no negative (!) rules for now. */
+export function ignoreRuleToRegex(rule) {
+    let p = rule.trim();
+    if (!p || p.startsWith('#') || p.startsWith('!'))
+        return null;
+    // Strip trailing slashes
+    if (p.endsWith('/'))
+        p = p.slice(0, -1);
+    // If it starts with /, anchor to root; else it can match anywhere
+    const anchorStart = p.startsWith('/') ? '^' : '(?:^|/)';
+    if (p.startsWith('/'))
+        p = p.slice(1);
+    const escaped = p
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '::DS::')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/::DS::/g, '.*');
+    return new RegExp(`${anchorStart}${escaped}(?:/|$)`);
+}
+export class IgnoreFilter {
+    rules = [];
+    static async load(cwd) {
+        const filter = new IgnoreFilter();
+        for (const name of ['.gitignore', '.klyroignore']) {
+            try {
+                const content = await fs.readFile(path.join(cwd, name), 'utf-8');
+                for (const line of content.split('\n')) {
+                    const re = ignoreRuleToRegex(line);
+                    if (re)
+                        filter.rules.push(re);
+                }
+            }
+            catch { /* missing/unreadable */ }
+        }
+        return filter;
+    }
+    /** Accepts a relative path (posix or windows) and returns true if it should be ignored. */
+    ignores(relPath) {
+        const normalized = relPath.replace(/\\/g, '/');
+        for (const re of this.rules) {
+            if (re.test(normalized))
+                return true;
+        }
+        return false;
+    }
+}

package/dist/tools/search/search-files.js

@@ -16,6 +16,7 @@ import { defineTool } from '../types.js';
 import { resolveWithinCwd } from '../../policy/path-guard.js';
 import { safe } from '../normalize.js';
 import { globToRegex } from './glob.js';
+import { IgnoreFilter } from './ignore.js';
 const InputSchema = z.object({
     query: z.string().optional().describe('Substring or regex to match against file paths (case-insensitive)'),
     glob: z.string().optional().describe('Glob pattern to constrain candidates, e.g. "src/**/*.ts"'),
@@ -29,7 +30,7 @@ function queryToRegex(query) {
     const escaped = query.replace(/[.+^${}()|[\]\\]/g, '\\$&');
     return new RegExp(escaped, 'i');
 }
-async function walk(root, dir, onFile) {
+async function walk(root, dir, onFile, ignore, cwd) {
     let names;
     try {
         names = await fs.readdir(dir);
@@ -41,6 +42,11 @@ async function walk(root, dir, onFile) {
         if (SKIP_DIRS.has(name))
             continue;
         const full = path.join(dir, name);
+        if (ignore && cwd) {
+            const relToCwd = path.relative(cwd, full);
+            if (ignore.ignores(relToCwd))
+                continue;
+        }
         let isDir = false;
         try {
             const s = await fs.lstat(full);
@@ -52,7 +58,7 @@ async function walk(root, dir, onFile) {
             continue;
         }
         if (isDir)
-            await walk(root, full, onFile);
+            await walk(root, full, onFile, ignore, cwd);
         else
             await onFile(full);
     }
@@ -69,6 +75,7 @@ export const searchFilesTool = defineTool({
             const globRe = input.glob ? globToRegex(input.glob) : null;
             const candidates = [];
             const now = Date.now();
+            const ignore = await IgnoreFilter.load(ctx.cwd);
             await walk(base, base, async (full) => {
                 const rel = path.relative(ctx.cwd, full).split(path.sep).join('/');
                 if (globRe && !globRe.test(rel))
@@ -101,7 +108,7 @@ export const searchFilesTool = defineTool({
                 // Recency: 0..30 points, 0 days = 30, 30+ days = 0
                 score += Math.max(0, 30 - ageDays);
                 candidates.push({ path: rel, score, mtimeMs, firstParty });
-            });
+            }, ignore, ctx.cwd);
             candidates.sort((a, b) => b.score - a.score);
             const truncated = candidates.length > max;
             return { matches: candidates.slice(0, max), truncated };

package/dist/tui/app.js

@@ -7,6 +7,8 @@ import React, { useState, useEffect, useRef, useCallback, useMemo } from 'react'
 import { Box, Text, useInput, useStdout } from 'ink';
 import Spinner from 'ink-spinner';
 import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import * as path from 'node:path';
 import { TuiApprovalBridge, ApprovalModal } from './approval.js';
 import { parse as parseSlash, suggestCommands } from '../cli/slash/parser.js';
 import { loadCustomCommands, listCompletableFiles } from '../cli/slash/custom.js';
@@ -33,6 +35,40 @@ function Header({ cwd, model, version, width }) {
     const showLinks = width >= 120;
     return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, flexShrink: 0, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { bold: true, color: tokens.colors.accent, children: ["KLYRO  v", version] }), showLinks ? _jsx(Text, { color: tokens.colors.dim, children: "\u2502  /help   /config   /clear   /exit" }) : null] }), _jsxs(Text, { color: tokens.colors.dim, children: [model, "  \u00B7  ", cwd] }), branch ? _jsxs(Text, { color: tokens.colors.dim, children: ["\u2387  ", branch] }) : null] }));
 }
+/**
+ * 5.5c — compact todo checklist. Live `plan` state (`todo_write` →
+ * `plan_update` events → `updatePlan`) wins; when it is empty, best-effort
+ * read of `.klyro/plans/todos.json` so a reloaded TUI still shows the list.
+ */
+const TODO_STATUSES = ['pending', 'in_progress', 'done', 'failed', 'skipped'];
+function loadTodosFromDisk(cwd) {
+    try {
+        const raw = readFileSync(path.join(cwd, '.klyro', 'plans', 'todos.json'), 'utf-8');
+        const arr = JSON.parse(raw);
+        if (!Array.isArray(arr))
+            return [];
+        return arr
+            .filter((t) => typeof t.title === 'string' && t.title.length > 0)
+            .map((t, i) => ({
+            id: typeof t.id === 'string' ? t.id : `disk-${i}`,
+            title: t.title,
+            status: TODO_STATUSES.includes(t.status)
+                ? t.status
+                : 'pending',
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function TodoChecklist({ plan, cwd }) {
+    // Disk fallback only when live state is empty (never masks live updates).
+    const disk = useMemo(() => (plan.length > 0 ? [] : loadTodosFromDisk(cwd)), [plan.length, cwd]);
+    const items = plan.length > 0 ? plan : disk;
+    if (items.length === 0)
+        return null;
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginTop: 0, marginBottom: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { bold: true, children: [g('todoPlan'), " Plan  ", items.filter((p) => p.status === 'done').length, "/", items.length] })] }), items.slice(0, 8).map((p, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: p.status === 'done' ? tokens.colors.ok : p.status === 'in_progress' ? tokens.colors.accent : tokens.colors.dim, children: [p.status === 'done' ? g('todoDone') : p.status === 'in_progress' ? g('todoActive') : g('todoPending'), " ", i + 1, ". ", redact(p.title)] })] }, p.id)))] }));
+}
 function verbForTool(name) {
     if (name === 'read_file')
         return 'Read';
@@ -1287,5 +1323,5 @@ export function App(props) {
                                 if (it.kind === 'diff')
                                     return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, color: tokens.colors.soft, children: it.summary ?? 'Diff' }), it.hunks.map((h, i) => (_jsxs(Box, { flexDirection: "column", marginTop: 0, children: [_jsx(Text, { color: tokens.colors.soft, children: h.path }), h.lines.map((l, j) => (_jsxs(Text, { wrap: "wrap", color: l.kind === 'add' ? tokens.colors.ok : l.kind === 'remove' ? tokens.colors.err : tokens.colors.dim, children: [l.kind === 'add' ? '+ ' : l.kind === 'remove' ? '- ' : '  ', redact(l.text)] }, j)))] }, i)))] }, it.id));
                                 return null;
-                            }) : null, showThinking && status.status === 'running' && !streamingIdRef.current ? (_jsxs(Box, { paddingLeft: 2, marginBottom: 1, children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: tokens.colors.accent, children: [_jsx(Spinner, { type: "dots" }), " "] }), _jsx(Text, { color: tokens.colors.dim, children: "Thinking... (esc \u00D72 to cancel)" }), _jsxs(Text, { color: tokens.colors.dim, children: ["  ", (elapsed / 1000).toFixed(1), "s"] })] })) : null, showPlan && plan.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginTop: 0, marginBottom: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { bold: true, children: [g('todoPlan'), " Plan  ", plan.filter((p) => p.status === 'done').length, "/", plan.length] })] }), plan.slice(0, 8).map((p, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: p.status === 'done' ? tokens.colors.ok : p.status === 'in_progress' ? tokens.colors.accent : tokens.colors.dim, children: [p.status === 'done' ? g('todoDone') : p.status === 'in_progress' ? g('todoActive') : g('todoPending'), " ", i + 1, ". ", redact(p.title)] })] }, p.id)))] })) : null, showQueued && queuedInputs.length > 0 ? (_jsx(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: queuedInputs.map((q, i) => (_jsxs(Text, { color: tokens.colors.dim, children: ["queued: ", redact(q.slice(0, 60)), i === 0 ? '  esc to drop' : ''] }, i))) })) : null] }), isFullscreen && !atBottom ? (_jsx(Box, { flexDirection: "column", width: 1, marginLeft: 1, children: Array.from({ length: trackH }).map((_, i) => (_jsx(Text, { color: i === thumbPos ? tokens.colors.accent : tokens.colors.guide, children: i === thumbPos ? '●' : '│' }, i))) })) : null] }), pinned && badgeLabel(atBottom, pendingNew, status.status !== 'running') ? (_jsx(Box, { justifyContent: "center", flexShrink: 0, children: _jsxs(Text, { backgroundColor: tokens.colors.accentSoft, color: tokens.colors.accent, bold: true, children: [' ', badgeLabel(atBottom, pendingNew, status.status !== 'running'), ' '] }) })) : null, slashSuggest.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, flexShrink: 0, children: [slashSuggest.map((s, i) => (_jsxs(Text, { color: i === 0 ? tokens.colors.accent : tokens.colors.dim, children: [i === 0 ? '▸' : ' ', " /", s.name, "  \u2014 ", s.hint] }, s.name))), _jsx(Text, { color: tokens.colors.dim, children: "  tab to complete" })] })) : null, slashSuggest.length === 0 && pathSuggest.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, flexShrink: 0, children: [pathSuggest.map((s, i) => (_jsxs(Text, { color: i === 0 ? tokens.colors.accent : tokens.colors.dim, children: [i === 0 ? '▸' : ' ', " ", s.name] }, s.name))), _jsx(Text, { color: tokens.colors.dim, children: "  tab to complete" })] })) : null, _jsx(ApprovalModal, { bridge: bridge }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) }), _jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.accent, bold: true, children: [g('prompt'), " "] }), vimMode === 'normal' ? _jsx(Text, { color: tokens.colors.warn, bold: true, children: "--NORMAL-- " }) : null, _jsx(InputWithCursor, { input: input, cursor: vimCursor })] }), _jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) })] }), _jsxs(Box, { justifyContent: "space-between", flexShrink: 0, children: [_jsxs(Text, { color: tokens.colors.dim, children: [status.status === 'running' ? (_jsxs(Text, { color: tokens.colors.accent, children: [_jsx(Spinner, { type: "dots" }), " working  \u00B7  "] })) : null, baseHints, maxTop > 0 && isFullscreen ? '  ·  PgUp/Dn scroll' : ''] }), _jsxs(Text, { color: tokens.colors.dim, children: [maxTop > 0 && isFullscreen ? `⇅ ${topRow}/${maxTop} · ` : '', cost > 0 ? `$${cost.toFixed(2)} · ` : '', ctxPct, "% ctx \u00B7 ", status.model, status.status === 'running' ? ' ●' : ''] })] })] }));
+                            }) : null, showThinking && status.status === 'running' && !streamingIdRef.current ? (_jsxs(Box, { paddingLeft: 2, marginBottom: 1, children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: tokens.colors.accent, children: [_jsx(Spinner, { type: "dots" }), " "] }), _jsx(Text, { color: tokens.colors.dim, children: "Thinking... (esc \u00D72 to cancel)" }), _jsxs(Text, { color: tokens.colors.dim, children: ["  ", (elapsed / 1000).toFixed(1), "s"] })] })) : null, showPlan ? _jsx(TodoChecklist, { plan: plan, cwd: props.cwd }) : null, showQueued && queuedInputs.length > 0 ? (_jsx(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: queuedInputs.map((q, i) => (_jsxs(Text, { color: tokens.colors.dim, children: ["queued: ", redact(q.slice(0, 60)), i === 0 ? '  esc to drop' : ''] }, i))) })) : null] }), isFullscreen && !atBottom ? (_jsx(Box, { flexDirection: "column", width: 1, marginLeft: 1, children: Array.from({ length: trackH }).map((_, i) => (_jsx(Text, { color: i === thumbPos ? tokens.colors.accent : tokens.colors.guide, children: i === thumbPos ? '●' : '│' }, i))) })) : null] }), pinned && badgeLabel(atBottom, pendingNew, status.status !== 'running') ? (_jsx(Box, { justifyContent: "center", flexShrink: 0, children: _jsxs(Text, { backgroundColor: tokens.colors.accentSoft, color: tokens.colors.accent, bold: true, children: [' ', badgeLabel(atBottom, pendingNew, status.status !== 'running'), ' '] }) })) : null, slashSuggest.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, flexShrink: 0, children: [slashSuggest.map((s, i) => (_jsxs(Text, { color: i === 0 ? tokens.colors.accent : tokens.colors.dim, children: [i === 0 ? '▸' : ' ', " /", s.name, "  \u2014 ", s.hint] }, s.name))), _jsx(Text, { color: tokens.colors.dim, children: "  tab to complete" })] })) : null, slashSuggest.length === 0 && pathSuggest.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, flexShrink: 0, children: [pathSuggest.map((s, i) => (_jsxs(Text, { color: i === 0 ? tokens.colors.accent : tokens.colors.dim, children: [i === 0 ? '▸' : ' ', " ", s.name] }, s.name))), _jsx(Text, { color: tokens.colors.dim, children: "  tab to complete" })] })) : null, _jsx(ApprovalModal, { bridge: bridge }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) }), _jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.accent, bold: true, children: [g('prompt'), " "] }), vimMode === 'normal' ? _jsx(Text, { color: tokens.colors.warn, bold: true, children: "--NORMAL-- " }) : null, _jsx(InputWithCursor, { input: input, cursor: vimCursor })] }), _jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) })] }), _jsxs(Box, { justifyContent: "space-between", flexShrink: 0, children: [_jsxs(Text, { color: tokens.colors.dim, children: [status.status === 'running' ? (_jsxs(Text, { color: tokens.colors.accent, children: [_jsx(Spinner, { type: "dots" }), " working  \u00B7  "] })) : null, baseHints, maxTop > 0 && isFullscreen ? '  ·  PgUp/Dn scroll' : ''] }), _jsxs(Text, { color: tokens.colors.dim, children: [maxTop > 0 && isFullscreen ? `⇅ ${topRow}/${maxTop} · ` : '', cost > 0 ? `$${cost.toFixed(2)} · ` : '', ctxPct, "% ctx \u00B7 ", status.model, status.status === 'running' ? ' ●' : ''] })] })] }));
 }