klyro 1.0.17 → 1.0.20

package/dist/eval/baseline.js

@@ -0,0 +1,55 @@
+/**
+ * 5.5b — eval baseline writer. Records the environment alongside suite
+ * results so regressions can be attributed (model/node/platform/commit).
+ *
+ * The tracked `evals/results/baseline.json` is refreshed by `klyro eval
+ * --suite <name>` (best-effort; suite failures never fail the write path).
+ */
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { execFileSync } from 'node:child_process';
+/** Best-effort `git rev-parse HEAD` (never throws). Exported for tests. */
+export function gitCommit(cwd = process.cwd()) {
+    try {
+        const out = execFileSync('git', ['rev-parse', 'HEAD'], {
+            cwd,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).toString().trim();
+        return out || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/** Collect the environment half of a baseline record. Exported for tests. */
+export function collectBaselineMetadata(opts = {}) {
+    return {
+        model: opts.model ?? process.env.KLYRO_MODEL ?? 'mock',
+        node: process.version,
+        platform: process.platform,
+        commit: gitCommit(opts.cwd),
+        timestamp: new Date().toISOString(),
+    };
+}
+/** Combine metadata + suite counts into a full baseline record. */
+export function buildEvalBaseline(meta, suite) {
+    return {
+        ...meta,
+        suite: suite.suite,
+        total: suite.total,
+        passed: suite.passed,
+        failed: suite.failed,
+        passRate: suite.total === 0 ? 0 : suite.passed / suite.total,
+        durationMs: suite.durationMs,
+    };
+}
+/**
+ * Write `baseline.json` into `dir` (created if needed). Returns the path.
+ * Never throws for missing dirs — the caller wraps in try/catch anyway.
+ */
+export async function writeEvalBaseline(dir, baseline) {
+    await fsp.mkdir(dir, { recursive: true });
+    const out = path.join(dir, 'baseline.json');
+    await fsp.writeFile(out, JSON.stringify(baseline, null, 2) + '\n');
+    return out;
+}

package/dist/eval/harness.d.ts

@@ -77,10 +77,21 @@ export interface FileFixture {
     script?: StreamEvent[][];
 }
 export declare function loadFileFixture(dir: string): Promise<FileFixture>;
-export declare function runFileFixture(fixture: FileFixture, _opts?: {
+export declare function sanitizedFixtureEnv(base?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/**
+ * 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 declare function assertTmpWorkdir(dir: string, opts?: {
+    allowWorkdirOutsideTmp?: boolean;
+}): void;
+export interface FileFixtureOptions {
     runs?: number;
     parallel?: number;
-}): Promise<TaskResult>;
+    allowWorkdirOutsideTmp?: boolean;
+}
+export declare function runFileFixture(fixture: FileFixture, _opts?: FileFixtureOptions): Promise<TaskResult>;
 /**
  * Agent-driven fixture: seed a tmp repo, run the fixture's canned script
  * through the REAL runtime + tools, then assert outcomes with check.sh
@@ -90,6 +101,7 @@ export declare function runFileFixture(fixture: FileFixture, _opts?: {
 export declare function runAgentFixture(fixture: FileFixture, opts?: {
     judgeAdapter?: ProviderAdapter;
     judgeModel?: string;
+    allowWorkdirOutsideTmp?: boolean;
 }): Promise<TaskResult>;
 /** Hook the harness up to a session + audit log so task runs are durable. */ export declare function runHarnessWithPersistence(tasks: ScriptedTask[], opts: {
     storeDir: string;

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/lsp/diagnostics.d.ts

@@ -49,3 +49,53 @@ export declare const lspGotoDefinitionTool: import("../types.js").Tool<{
     readonly candidates: number;
     readonly note?: undefined;
 }>;
+export declare const lspReferencesTool: import("../types.js").Tool<{
+    path: string;
+    line: number;
+    character?: number | undefined;
+}, {
+    readonly enabled: false;
+    readonly references: readonly [];
+    readonly note: "LSP off via KLYRO_LSP=0";
+} | {
+    readonly enabled: true;
+    readonly references: readonly [];
+    readonly note: `unreadable file: ${string}`;
+} | {
+    readonly enabled: true;
+    readonly references: readonly [];
+    readonly note: "no identifier under cursor";
+} | {
+    readonly enabled: true;
+    readonly references: {
+        file: string;
+        line: number;
+        kind: string;
+        name: string;
+    }[];
+    readonly note?: undefined;
+}>;
+export declare const lspOutlineTool: import("../types.js").Tool<{
+    path: string;
+}, {
+    readonly enabled: false;
+    readonly outline: readonly [];
+    readonly note: "LSP off via KLYRO_LSP=0";
+} | {
+    readonly enabled: true;
+    readonly outline: readonly [];
+    readonly note: `unreadable file: ${string}`;
+} | {
+    readonly enabled: true;
+    readonly outline: {
+        name: string;
+        kind: string;
+        line: number;
+        children: Array<{
+            name: string;
+            kind: string;
+            line: number;
+        }>;
+    }[];
+    readonly note?: undefined;
+}>;

package/dist/tools/lsp/diagnostics.js

@@ -5,8 +5,10 @@
  * project has one and filters the output to the requested path (or returns
  * a capped full-project list). Other languages report "unsupported".
  * `lsp_goto_definition` resolves the identifier under (line, character) to
- * its definition via the regex repo-map symbol index. Set KLYRO_LSP=0 to
- * force both tools off.
+ * its definition via the regex repo-map symbol index.
+ * `lsp_references` finds all references to the identifier under (line, character).
+ * `lsp_outline` returns a hierarchical symbol outline for a file.
+ * Set KLYRO_LSP=0 to force all tools off.
  */
 import { spawnSync } from 'node:child_process';
 import * as fs from 'node:fs/promises';
@@ -15,7 +17,7 @@ import { z } from 'zod';
 import { defineTool } from '../types.js';
 import { safe } from '../normalize.js';
 import { resolveWithinCwd } from '../../policy/path-guard.js';
-import { buildRepoMap } from '../../context/repo-map.js';
+import { buildRepoMap, extractSymbols } from '../../context/repo-map.js';
 function isOff() {
     return process.env.KLYRO_LSP === '0';
 }
@@ -104,3 +106,107 @@ export const lspGotoDefinitionTool = defineTool({
         return { enabled: true, location: best, candidates: hits.length };
     }),
 });
+export const lspReferencesTool = defineTool({
+    name: 'lsp_references',
+    description: 'Find all references to the identifier under (line, character) via the repo symbol index',
+    inputSchema: z.object({ path: z.string().min(1), line: z.number().int().min(1), character: z.number().int().min(0).optional() }),
+    permission: 'read',
+    isConcurrencySafe: true,
+    execute: async (input, ctx) => safe(async () => {
+        if (isOff())
+            return { enabled: false, references: [], note: 'LSP off via KLYRO_LSP=0' };
+        const { resolved } = resolveWithinCwd(ctx.cwd, input.path, ctx.agentAllowedPaths);
+        let content;
+        try {
+            content = await fs.readFile(resolved, 'utf-8');
+        }
+        catch {
+            return { enabled: true, references: [], note: `unreadable file: ${input.path}` };
+        }
+        const lines = content.split('\n');
+        const lineText = lines[input.line - 1] ?? '';
+        const col = Math.min(input.character ?? 0, lineText.length);
+        const wordAt = (() => {
+            const isWord = (c) => /[A-Za-z0-9_$]/.test(c);
+            let s = col;
+            let e = col;
+            while (s > 0 && isWord(lineText[s - 1]))
+                s--;
+            while (e < lineText.length && isWord(lineText[e]))
+                e++;
+            const w = lineText.slice(s, e);
+            return w || null;
+        })();
+        if (!wordAt)
+            return { enabled: true, references: [], note: 'no identifier under cursor' };
+        const files = await buildRepoMap({ cwd: ctx.cwd, maxFiles: 300 });
+        const refs = [];
+        const seen = new Set();
+        for (const f of files) {
+            for (const s of f.symbols) {
+                if (s.name === wordAt) {
+                    const key = `${f.path}:${s.line}:${s.name}`;
+                    if (!seen.has(key)) {
+                        seen.add(key);
+                        refs.push({ file: f.path, line: s.line, kind: s.kind, name: s.name });
+                    }
+                }
+            }
+        }
+        return { enabled: true, references: refs.slice(0, 100) };
+    }),
+});
+export const lspOutlineTool = defineTool({
+    name: 'lsp_outline',
+    description: 'Hierarchical symbol outline for a file via the repo symbol index',
+    inputSchema: z.object({ path: z.string().min(1) }),
+    permission: 'read',
+    isConcurrencySafe: true,
+    execute: async (input, ctx) => safe(async () => {
+        if (isOff())
+            return { enabled: false, outline: [], note: 'LSP off via KLYRO_LSP=0' };
+        const { resolved } = resolveWithinCwd(ctx.cwd, input.path, ctx.agentAllowedPaths);
+        // Symbol-extract this file directly rather than via buildRepoMap: the repo
+        // map is a whole-tree walk capped by maxFiles, so a single-file query can
+        // never be served from it (it would return whichever file the walk reached
+        // first, and the caller's path would usually be absent).
+        let content;
+        try {
+            content = await fs.readFile(resolved, 'utf-8');
+        }
+        catch {
+            return { enabled: true, outline: [], note: `unreadable file: ${input.path}` };
+        }
+        const symbols = extractSymbols(content, path.extname(resolved).toLowerCase());
+        // Build simple hierarchy: classes/interfaces as parents, methods/fields as children
+        const outline = [];
+        for (const sym of symbols) {
+            if (['class', 'interface', 'type'].includes(sym.kind)) {
+                outline.push({ name: sym.name, kind: sym.kind, line: sym.line, children: [] });
+            }
+        }
+        for (const sym of symbols) {
+            if (['method', 'function', 'property', 'field', 'const'].includes(sym.kind)) {
+                // Assign to the nearest preceding class/interface
+                let parentIdx = -1;
+                for (let i = outline.length - 1; i >= 0; i--) {
+                    const parent = outline[i];
+                    if (parent && parent.line < sym.line) {
+                        parentIdx = i;
+                        break;
+                    }
+                }
+                if (parentIdx >= 0) {
+                    const parentEntry = outline[parentIdx];
+                    if (parentEntry) {
+                        parentEntry.children.push({ name: sym.name, kind: sym.kind, line: sym.line });
+                    }
+                }
+                else {
+                    outline.push({ name: sym.name, kind: sym.kind, line: sym.line, children: [] });
+                }
+            }
+        }
+        return { enabled: true, outline };
+    }),
+});

package/dist/tools/registry.js

@@ -16,13 +16,15 @@ 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';
 import { repoMapTool } from './repo-map.js';
 import { importsOfTool, importersOfTool } from './search/imports.js';
 import { findSymbolTool } from './symbols/find-symbol.js';
-import { lspDiagnosticsTool, lspGotoDefinitionTool } from './lsp/diagnostics.js';
+import { lspDiagnosticsTool, lspGotoDefinitionTool, lspReferencesTool, lspOutlineTool } from './lsp/diagnostics.js';
 import { expandResultTool } from './expand-result.js';
 import { memoryWriteTool } from './memory-write.js';
 import { webFetchTool } from './web/web-fetch.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);
@@ -113,6 +117,8 @@ export const builtinRegistry = () => {
     r.register(findSymbolTool);
     r.register(lspDiagnosticsTool);
     r.register(lspGotoDefinitionTool);
+    r.register(lspReferencesTool);
+    r.register(lspOutlineTool);
     r.register(expandResultTool);
     r.register(memoryWriteTool);
     r.register(webFetchTool);