graph-indexer 3.0.1 → 3.1.1

package/src/cli/hook.mjs

@@ -32,7 +32,8 @@ import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { findRepoRoot, dataDir, DATA_DIR_NAME, readRepoFile } from '../util/paths.mjs';
-import { specForPath } from '../parse/languages.mjs';
+import { gitSync } from '../util/git.mjs';
+import { codeSpecForPath as specForPath } from '../parse/languages.mjs'; // hooks report on code files only
 
 const MAX_CONTEXT = 1500;
 const EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit', 'edit', 'write', 'apply_patch', 'replace', 'write_file']);
@@ -103,15 +104,63 @@ function sessionState(input) {
     };
 }
 
+/**
+ * The commands of a shell line, split at `;`, `&&`, `||` and newlines outside quotes, with heredoc
+ * bodies dropped and `cd DIR` steps left out (agents write `cd repo; sed -n …; grep …`).
+ */
+export function shellSegments(command) {
+    return splitShell(command).filter(x => !/^cd\s+\S+$/.test(x));
+}
+
+function splitShell(command) {
+    const src = String(command ?? '');
+    const out = [];
+    let cur = '', q = null;
+    const lines = src.split('\n');
+    for (let li = 0; li < lines.length; li++) {
+        const line = lines[li];
+        for (let i = 0; i < line.length; i++) {
+            const ch = line[i];
+            if (q) { cur += ch; if (ch === q) q = null; else if (ch === '\\' && q === '"' && i + 1 < line.length) cur += line[++i]; continue; }
+            if (ch === '"' || ch === "'") { q = ch; cur += ch; continue; }
+            if (ch === '\\' && i + 1 < line.length) { cur += ch + line[++i]; continue; }
+            if (ch === ';' || (ch === '&' && line[i + 1] === '&') || (ch === '|' && line[i + 1] === '|')) {
+                out.push(cur); cur = '';
+                if (ch !== ';') i++;
+                continue;
+            }
+            cur += ch;
+        }
+        if (q) { cur += '\n'; continue; } // a quoted string spanning lines
+        // a heredoc (`<<'EOF'`): skip its body up to the delimiter
+        const hd = /<<-?\s*['"]?(\w+)['"]?/.exec(cur);
+        out.push(cur); cur = '';
+        if (hd) while (li + 1 < lines.length && lines[li + 1].trim() !== hd[1]) li++;
+        if (hd) li++;
+    }
+    if (cur) out.push(cur);
+    return out.map(x => x.trim()).filter(Boolean);
+}
+
 /** A file read through the shell: [file, from, to] for `sed -n 'a,bp' f`, `head -n N f`, `cat f`, `nl -ba f | sed -n …`. */
 export function shellRead(command) {
-    const c = String(command ?? '').replace(/^\s*cd\s+\S+\s*&&\s*/, '');
-    let m;
-    if ((m = /^(?:nl\s+-ba\s+|cat\s+-n\s+)(\S+)\s*\|\s*sed\s+-n\s+['"]?(\d+),(\d+)p['"]?\s*$/.exec(c))) return [m[1], +m[2], +m[3]];
-    if ((m = /^sed\s+-n\s+['"]?(\d+),(\d+)p['"]?\s+(\S+)\s*$/.exec(c))) return [m[3], +m[1], +m[2]];
-    if ((m = /^head\s+-(?:n\s*)?(\d+)\s+(\S+)\s*$/.exec(c))) return [m[2], 1, +m[1]];
-    if ((m = /^cat\s+(?:-n\s+)?(\S+\.\w+)\s*$/.exec(c))) return [m[1], 1, 2000];
-    return null;
+    return shellReads(command)[0] ?? null;
+}
+
+/** Every file read in a shell line (`cd repo; sed -n 10,40p a.py; sed -n 5,9p b.py`), relative paths resolved against a `cd` before them. */
+export function shellReads(command) {
+    const out = [];
+    let dir = null;
+    const at = (f) => (dir && !path.isAbsolute(f) ? path.join(dir, f) : f);
+    for (const c of splitShell(command)) {
+        let m;
+        if ((m = /^cd\s+(['"]?)(\S+)\1$/.exec(c))) { dir = path.isAbsolute(m[2]) ? m[2] : path.join(dir ?? '', m[2]); continue; }
+        if ((m = /^(?:nl\s+-ba\s+|cat\s+-n\s+)(\S+)\s*\|\s*sed\s+-n\s+['"]?(\d+),(\d+)p['"]?\s*$/.exec(c))) out.push([at(m[1]), +m[2], +m[3]]);
+        else if ((m = /^sed\s+-n\s+['"]?(\d+),(\d+)p['"]?\s+(\S+)\s*$/.exec(c))) out.push([at(m[3]), +m[1], +m[2]]);
+        else if ((m = /^head\s+-(?:n\s*)?(\d+)\s+(\S+)\s*$/.exec(c))) out.push([at(m[2]), 1, +m[1]]);
+        else if ((m = /^cat\s+(?:-n\s+)?(\S+\.\w+)\s*$/.exec(c))) out.push([at(m[1]), 1, 2000]);
+    }
+    return out;
 }
 
 /** Minimal shell-words split (quotes and escapes) for extracting a grep pattern. */
@@ -158,17 +207,20 @@ function localIndex(root) {
     };
 }
 
-async function afterEdit(root, input, acquire) {
-    const file = input.tool_input?.file_path ?? input.tool_input?.notebook_path ?? input.tool_input?.path ?? null;
-    if (!file) return null;
-    const rel = path.isAbsolute(file) ? path.relative(root, file).split(path.sep).join('/') : file;
-    if (rel.startsWith('..') || !specForPath(rel)) return null;
+async function afterEdit(root, input, acquire, files = null) {
+    if (!files) {
+        const file = input.tool_input?.file_path ?? input.tool_input?.notebook_path ?? input.tool_input?.path ?? null;
+        if (!file) return null;
+        files = [path.isAbsolute(file) ? path.relative(root, file).split(path.sep).join('/') : file];
+    }
+    files = files.filter(rel => !rel.startsWith('..') && specForPath(rel)).slice(0, 6);
+    if (!files.length) return null;
     const ix = await acquire();
     if (!ix) return null;
     const { intel } = ix;
     try {
         const { checkChanges } = await import('../query/check.mjs');
-        const r = await checkChanges(intel, { files: [rel], tests: false });
+        const r = await checkChanges(intel, { files, tests: false });
         if (r.error) return null;
         const lines = [];
         for (const e of r.syntax.slice(0, 3)) lines.push(`${e.path}:${e.line} has a syntax error introduced since the last commit (${e.missing ? `missing ${e.missing}` : 'unexpected code'}): ${e.text.slice(0, 100)}`);
@@ -235,46 +287,69 @@ async function afterGrep(root, input, crawling, acquire) {
  * silent when there is none; and while the agent is crawling, where the names the lines use are defined.
  */
 async function afterRead(root, input, state, crawling, acquire) {
-    let file = null, from = 1, to = 2000;
+    let reads = [];
     if (READ_TOOLS.has(input.tool_name)) {
-        file = input.tool_input?.file_path ?? input.tool_input?.path ?? input.tool_input?.absolute_path ?? null;
+        const file = input.tool_input?.file_path ?? input.tool_input?.path ?? input.tool_input?.absolute_path ?? null;
+        let from = 1, to = 2000;
         const off = Number(input.tool_input?.offset ?? 0), lim = Number(input.tool_input?.limit ?? 0);
         if (off > 0) from = off;
         if (lim > 0) to = from + lim - 1;
-    } else {
-        const r = shellRead(input.tool_input?.command);
-        if (!r) return null;
-        [file, from, to] = r;
-    }
-    if (!file) return null;
+        if (file) reads = [[file, from, to]];
+    } else reads = shellReads(input.tool_input?.command);
     const cwd = input.cwd || root;
-    const abs = path.isAbsolute(file) ? file : path.join(cwd, file);
-    const rel = path.relative(root, abs).split(path.sep).join('/');
-    if (rel.startsWith('..') || !specForPath(rel)) return null;
+    const ranges = reads.map(([file, from, to]) => {
+        const abs = path.isAbsolute(file) ? file : path.join(cwd, file);
+        return { rel: path.relative(root, abs).split(path.sep).join('/'), from, to };
+    }).filter(r => !r.rel.startsWith('..') && specForPath(r.rel)).slice(0, 4);
+    if (!ranges.length) return null;
     const ix = await acquire();
     if (!ix) return null;
     const { intel } = ix;
     try {
-        await intel.revalidate([rel]); // a long-lived index may not have seen the file change yet
-        const out = [];
+        await intel.revalidate([...new Set(ranges.map(r => r.rel))]); // a long-lived index may not have seen the file change yet
+        const facts = [], defs = [];
         const { factsForRange, renderFacts } = await import('../query/facts.mjs');
+        const { definitionsUsed } = await import('../query/read.mjs');
         state.st.facts ??= [];
-        const facts = factsForRange(intel, rel, from, to, { max: 4, shown: new Set(state.st.facts) });
-        if (facts.length) {
-            for (const f of facts) state.st.facts.push(f.key);
-            out.push(`graph-indexer, resolved for these lines:\n${renderFacts(facts).map(l => `  ${l}`).join('\n')}`);
-        }
-        if (crawling) {
-            const { definitionsUsed } = await import('../query/read.mjs');
-            const n = Math.max(1, to - from + 1);
-            const { rows } = definitionsUsed(intel, rel, from, to, { max: Math.min(12, Math.max(4, Math.round(n / 15))), skipIds: new Set(state.st.shown) });
-            for (const r of rows) state.st.shown.push(r.id);
-            if (rows.length) out.push(`graph-indexer: where names used in these lines are defined (read them directly instead of searching):\n${rows.map(r => `  ${r.qname} → ${r.path}:${r.start_line}  ${String(r.sig || r.kind).replace(/\s+/g, ' ').replace(/\s+#.*$/, '').slice(0, 100)}`).join('\n')}`);
+        for (const { rel, from, to } of ranges) {
+            const fs1 = factsForRange(intel, rel, from, to, { max: Math.max(1, 4 - facts.length), shown: new Set(state.st.facts) });
+            for (const f of fs1) { state.st.facts.push(f.key); facts.push(f); }
+            if (crawling) {
+                const n = Math.max(1, to - from + 1);
+                const { rows } = definitionsUsed(intel, rel, from, to, { max: Math.min(12, Math.max(4, Math.round(n / 15))), skipIds: new Set(state.st.shown) });
+                for (const r of rows) { state.st.shown.push(r.id); if (defs.length < 12) defs.push(r); }
+            }
         }
+        const out = [];
+        if (facts.length) out.push(`graph-indexer, resolved for these lines:\n${renderFacts(facts).map(l => `  ${l}`).join('\n')}`);
+        if (defs.length) out.push(`graph-indexer: where names used in these lines are defined (read them directly instead of searching):\n${defs.map(r => `  ${r.qname} → ${r.path}:${r.start_line}  ${String(r.sig || r.kind).replace(/\s+/g, ' ').replace(/\s+#.*$/, '').slice(0, 100)}`).join('\n')}`);
         return out.length ? out.join('\n') : null;
     } finally { ix.release(); }
 }
 
+/**
+ * Source files a shell command changed (`sed -i`, a Python heredoc that rewrites a file, a patch):
+ * the working tree's modified and new files whose modification time moved since the hook last
+ * looked, so the edit checker also follows edits made without the edit tool.
+ */
+function shellEdits(root, state) {
+    let r;
+    // hardened (gitSync): a repository's core.fsmonitor or filters would otherwise run
+    try { r = gitSync(root, ['status', '--porcelain', '--untracked-files=all', '-z'], { timeout: 1500 }); } catch { return []; }
+    if (r.status !== 0 || typeof r.stdout !== 'string') return [];
+    const seen = state.st.mtimes ??= {};
+    const changed = [];
+    for (const e of r.stdout.split('\0')) {
+        if (e.length < 4 || e.startsWith('D') || e[1] === 'D') continue;
+        const rel = e.slice(3);
+        if (!specForPath(rel) || rel.startsWith(DATA_DIR_NAME + '/')) continue;
+        let m;
+        try { m = fs.statSync(path.join(root, rel)).mtimeMs; } catch { continue; }
+        if (seen[rel] !== m) { seen[rel] = m; changed.push(rel); }
+    }
+    return changed;
+}
+
 // the lookup rules, for sessions and subagents whose instruction files do not carry them
 const RULES = `How to look code up in this repository (graph-indexer):
 - Several things at once: several tool calls in one message, or one search with alternatives — not one search per turn.
@@ -288,7 +363,7 @@ async function sessionLine(root, { rules = false, acquire }) {
     const { intel } = ix;
     try {
         const st = intel.stats();
-        const line = `graph-indexer has a live index of this repository (${st.files} files, ${st.symbols} symbols). Its MCP tools answer with exact locations: find_references (exact uses, even when other code shares the name), change_impact (what a change affects and which tests to run), check_changes (what an edit broke, and the closest tests), call_graph, read_code (symbols or ranges by name, with where each name they use is defined), search_text, search_code and outline.`;
+        const line = `graph-indexer has a live index of this repository (${st.files} files, ${st.symbols} symbols). Its MCP tools answer with exact locations: explore (the code relevant to a task, its callers, the definitions it uses and its tests, in one call), find_references (exact uses, even when other code shares the name), change_impact (what a change affects and which tests to run), check_changes (what an edit broke, and the closest tests), call_graph, read_code (symbols or ranges by name, with where each name they use is defined), search_text, search_code and outline.`;
         // the managed block of `init` already carries the rules; otherwise add them
         const carried = ['CLAUDE.md', 'AGENTS.md'].some(f => (readRepoFile(root, f) ?? '').includes('<!-- graph-indexer:start -->'));
         return rules || !carried ? `${line}\n${RULES}` : line;
@@ -308,6 +383,7 @@ export async function handleHook(event, input, { root, acquire }) {
         const state = sessionState(input);
         if (EDIT_TOOLS.has(tool)) {
             state.st.nav = 0;
+            shellEdits(root, state); // so a later shell command does not report this edit again
             state.save();
             text = await afterEdit(root, input, acquire);
         } else if (GREP_TOOLS.has(tool) || (SHELL_TOOLS.has(tool) && grepPattern(command))) {
@@ -318,6 +394,12 @@ export async function handleHook(event, input, { root, acquire }) {
             state.st.nav++;
             text = await afterRead(root, input, state, state.st.nav >= CRAWL, acquire);
             state.save();
+        } else if (SHELL_TOOLS.has(tool)) {
+            // any other command may have edited files (`sed -i`, a script): check what it changed
+            const changed = shellEdits(root, state);
+            if (changed.length) state.st.nav = 0;
+            state.save();
+            if (changed.length) text = await afterEdit(root, input, acquire, changed);
         }
     } else if (event === 'session-start' || event === 'subagent-start') {
         name ??= event === 'session-start' ? 'SessionStart' : 'SubagentStart';
@@ -351,7 +433,9 @@ export async function runHook(event, { repo = null, version = null } = {}) {
     const timer = setTimeout(() => process.exit(0), deadlineMs); // fail open: never hold the agent up
     try {
         const input = await readStdin();
-        const root = findRepoRoot(input.cwd || repo || process.cwd());
+        // an explicit --repo wins over the session's directory (a session started elsewhere, with
+        // the repository added to it)
+        const root = findRepoRoot(repo || input.cwd || process.cwd());
         const { askResident, residentRequired } = await import('./resident.mjs');
         const reply = await askResident(root, { op: 'hook', event, input }, { version, totalMs: 2000 });
         let out = null;

package/src/cli/init.mjs

@@ -26,6 +26,8 @@ const SNIPPET = `${BLOCK_START}
 - Check once: run the tests that cover your change when you are done; do not re-run a check nothing has changed.
 
 The \`graph-indexer\` MCP server answers what a text search cannot answer exactly:
+- Fixing an issue or bug report: make your first call \`explore\` with the names and terms the issue uses (or its text as written). It ranks the code where the names the issue uses meet (usually what you will change) and shows it with its callers, the definitions it uses and the tests to run; read further only what it leaves out.
+- Starting on any other task in code you have not read: \`explore\` with the task in words.
 - Uses of a function, method or class that other code shares a name with: \`find_references\` (exact call sites, says when the list is complete; kind \`inherit\` for subclasses and implementations). Callers of callers: \`call_graph\`.
 - Before changing a signature other code relies on: \`change_impact\`; after: \`check_changes\`.
 ${BLOCK_END}`;
@@ -56,13 +58,23 @@ function readJson(p) {
 // (code the repository ships) instead of the published package
 const NPX_ARGS = ['-y', '--prefix', '/', 'graph-indexer@3'];
 
+/**
+ * npx, by absolute path on Windows: there a bare `npx` is looked up in the working directory (the
+ * repository) before PATH, so an `npx.cmd`/`npx.exe` the repository ships would run instead.
+ */
+function npxCommand() {
+    if (process.platform !== 'win32') return 'npx';
+    const f = path.join(path.dirname(process.execPath), 'npx.cmd');
+    return fs.existsSync(f) ? f : 'npx';
+}
+
 function serverEntry(agent, { local }) {
     const here = path.dirname(fileURLToPath(import.meta.url));
     const bin = path.resolve(here, '../../bin/graph-indexer.mjs');
     const repoArgs = agent.workspaceVar ? ['--repo', agent.workspaceVar] : [];
     const base = local
         ? { command: process.execPath, args: [bin, 'serve', ...repoArgs] }
-        : { command: 'npx', args: [...NPX_ARGS, 'serve', ...repoArgs] };
+        : { command: npxCommand(), args: [...NPX_ARGS, 'serve', ...repoArgs] };
     if (agent.opencode) return { type: 'local', command: [base.command, ...base.args], enabled: true };
     if (agent.zed) return { ...base, env: {} };
     return agent.vscode ? { type: 'stdio', ...base } : base;
@@ -108,7 +120,9 @@ function upsertBlock(repo, file, dryRun) {
 /** An installed `graph-indexer` executable on PATH, if any (hooks start in ~0.1 s instead of npx's ~1 s). */
 function installedBin() {
     for (const dir of (process.env.PATH ?? '').split(path.delimiter)) {
-        if (!dir) continue;
+        // only absolute entries, never a project's own bin directory: a PATH with `.` or
+        // `node_modules/.bin` would otherwise find a graph-indexer the repository ships
+        if (!dir || !path.isAbsolute(dir) || /(^|[\\/])node_modules[\\/]\.bin[\\/]?$/.test(dir)) continue;
         const f = path.join(dir, process.platform === 'win32' ? 'graph-indexer.cmd' : 'graph-indexer');
         try { if (fs.statSync(f).isFile()) return f; } catch { /* not here */ }
     }
@@ -121,7 +135,7 @@ function cliCommand(local) {
     const bin = path.resolve(here, '../../bin/graph-indexer.mjs');
     if (local) return `${JSON.stringify(process.execPath)} ${JSON.stringify(bin)}`;
     const installed = installedBin();
-    return installed ? JSON.stringify(installed) : ['npx', ...NPX_ARGS].join(' ');
+    return installed ? JSON.stringify(installed) : [npxCommand() === 'npx' ? 'npx' : JSON.stringify(npxCommand()), ...NPX_ARGS].join(' ');
 }
 
 /** The command that starts graph-indexer, as an argv array (for the OpenCode/Kilo Code plugin). */
@@ -129,7 +143,7 @@ function cliArgv(local) {
     const here = path.dirname(fileURLToPath(import.meta.url));
     if (local) return [process.execPath, path.resolve(here, '../../bin/graph-indexer.mjs')];
     const installed = installedBin();
-    return installed ? [installed] : ['npx', ...NPX_ARGS];
+    return installed ? [installed] : [npxCommand(), ...NPX_ARGS];
 }
 
 /**
@@ -209,6 +223,7 @@ export async function runInit({ opt, flag, repo: repoArg = null }) {
     const hooks = flag('--hooks');
     const noInstructions = flag('--no-instructions');
     const noHelper = flag('--no-helper');
+    const noDemo = flag('--no-demo');
     const all = flag('--all');
     const agentList = opt('--agents');
     let chosen;
@@ -267,6 +282,18 @@ export async function runInit({ opt, flag, repo: repoArg = null }) {
     }
     process.stdout.write(`graph-indexer init ${dryRun ? '(dry run) ' : ''}in ${repo}\n  ${report.join('\n  ')}\n\n` +
         `Other agents (Claude Desktop, JetBrains AI Assistant, Cline): add an MCP server with command "npx" and args ${JSON.stringify([...NPX_ARGS, 'serve', '--repo', repo])}.\n` +
-        `Build the index now with: npx ${NPX_ARGS.join(' ')} index   (the server also builds it on first start)\n` +
+        (dryRun || noDemo ? `Build the index now with: npx ${NPX_ARGS.join(' ')} index   (the server also builds it on first start)\n` : '') +
         (hooks ? '' : `Optional: graph-indexer init --hooks adds Claude Code hooks (edit check after each edit, grep disambiguation).\n`));
+    if (dryRun || noDemo) return;
+    // build the index now (the server would on first start) and show what it answers here
+    const { CodeIntel } = await import('../query/intel.mjs');
+    const { showcaseText } = await import('../query/showcase.mjs');
+    const intel = new CodeIntel({ root: repo });
+    try {
+        let last = 0;
+        await intel.open({ onProgress: (d, n) => { const now = Date.now(); if (now - last > 1000 || d === n) { last = now; process.stderr.write(`\r[graph-indexer] indexing ${d}/${n} files`); if (d === n) process.stderr.write('\n'); } } });
+        process.stdout.write(`\n${await showcaseText(intel)}\n`);
+    } catch (e) {
+        process.stdout.write(`\nThe index could not be built now (${e.message}); the server builds it on first start.\n`);
+    } finally { intel.close(); }
 }

package/src/cli/resident.mjs

@@ -16,7 +16,7 @@
  *   { v, version, op: 'hook', event, input }     → { ok, out }   out: what the hook prints, or null
  *   { v, version, op: 'tool', calls }            → { ok, out }   out: the CLI's output text
  * A request from another graph-indexer version gets { ok: false } and the client falls back, except
- * from thin clients that only relay hooks (`any: true`, integrations/claude-code/hooks/gi-hook.mjs).
+ * from thin clients that only relay hooks (`any: true`, integrations/claude-code-local/hooks/gi-hook.mjs).
  *
  * The socket is only reachable by its owner: inside the repository's .graph-indexer/ directory,
  * or, when that path is too long for a Unix socket, in a per-user directory with mode 0700 that
@@ -37,7 +37,13 @@ const WIN = process.platform === 'win32';
 export function socketPath(root) {
     const abs = path.resolve(root);
     const hash = crypto.createHash('sha256').update(abs).digest('hex').slice(0, 16);
-    if (WIN) return `\\\\.\\pipe\\graph-indexer-${hash}`;
+    // a pipe name anyone could compute would let another user of the machine create it first and
+    // answer as the resident: the name carries a random id kept in the private data directory
+    if (WIN) {
+        let id = '';
+        try { id = fs.readFileSync(path.join(abs, '.graph-indexer', 'resident.pipe-id'), 'utf8').trim(); } catch { /* no resident yet */ }
+        return /^[0-9a-f]{32}$/.test(id) ? `\\\\.\\pipe\\graph-indexer-${hash}-${id}` : null;
+    }
     const inRepo = path.join(abs, DATA_DIR_NAME, 'resident.sock');
     // Unix socket paths are limited to 104–108 bytes
     if (Buffer.byteLength(inRepo) <= 100) return inRepo;
@@ -74,7 +80,7 @@ export const residentRequired = () => process.env.GRAPH_INDEXER_RESIDENT === 're
 export function askResident(root, request, { version, connectMs = 250, totalMs = 5000 } = {}) {
     if (disabled()) return Promise.resolve(null);
     const file = socketPath(root);
-    if (!WIN && (!ownSocket(file) || !privateDir(path.dirname(file), root))) return Promise.resolve(null);
+    if (!file || (!WIN && (!ownSocket(file) || !privateDir(path.dirname(file), root)))) return Promise.resolve(null);
     return new Promise((resolve) => {
         let done = false, connected = false, buf = '';
         const sock = net.createConnection(file);
@@ -114,7 +120,7 @@ export function askResident(root, request, { version, connectMs = 250, totalMs =
  */
 export async function startResident({ root, version, handle, log = () => {}, idleMs = 0, onIdle = null, wanted = () => true }) {
     if (disabled()) return null;
-    const file = socketPath(root);
+    let file = socketPath(root);
     if (!WIN) {
         const dir = path.dirname(file);
         try { fs.mkdirSync(dir, { recursive: true, mode: 0o700 }); } catch { /* checked below */ }
@@ -123,6 +129,15 @@ export async function startResident({ root, version, handle, log = () => {}, idl
     // another resident may serve this repository already; a dead one leaves its socket file behind
     if (await askResident(root, { op: 'ping' }, { version, connectMs: 300, totalMs: 1500 })) return null;
     if (!WIN) { try { fs.unlinkSync(file); } catch { /* none */ } }
+    else {
+        // a fresh pipe id for this resident (see socketPath)
+        const idFile = path.join(path.resolve(root), DATA_DIR_NAME, 'resident.pipe-id');
+        try {
+            fs.mkdirSync(path.dirname(idFile), { recursive: true });
+            fs.writeFileSync(idFile, crypto.randomBytes(16).toString('hex'), { mode: 0o600 });
+        } catch (e) { log(`resident: cannot write ${idFile} (${e.message}); not listening`); return null; }
+        file = socketPath(root);
+    }
 
     let last = Date.now();
     const server = net.createServer((sock) => {

package/src/index/discover.mjs

@@ -7,6 +7,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { gitSync } from '../util/git.mjs';
+import { readRepoFile, withinRoot } from '../util/paths.mjs';
 import { specForPath } from '../parse/languages.mjs';
 
 export const MAX_FILE_BYTES = 1_500_000;
@@ -34,26 +35,56 @@ function gitListFiles(root) {
     return r.stdout.split('\0').filter(Boolean);
 }
 
+/**
+ * A .gitignore pattern as a matcher that cannot backtrack: `*` (within a name), `?`, `**` (across
+ * names), anything else literal. A regular expression of many stars (`*a*a*a*a*a*b`) takes seconds
+ * per long path; this keeps the set of positions reachable after each token, so a match costs
+ * pattern length × path length. Unanchored, it may start at any name; it must end at the end of
+ * the path or at a `/` (a directory and everything under it).
+ */
+function globMatcher(glob, anchored) {
+    const tokens = [];
+    for (let i = 0; i < glob.length; i++) {
+        if (glob[i] === '*') {
+            let j = i; while (glob[j + 1] === '*') j++;
+            tokens.push(j > i ? '**' : '*'); i = j;
+        } else tokens.push(glob[i] === '?' ? '?' : { c: glob[i] });
+    }
+    return (s) => {
+        const n = s.length;
+        let cur = new Uint8Array(n + 1);
+        cur[0] = 1;
+        if (!anchored) for (let k = 0; k < n; k++) if (s[k] === '/') cur[k + 1] = 1;
+        for (const t of tokens) {
+            const next = new Uint8Array(n + 1);
+            let any = false;
+            if (t === '**') { let on = 0; for (let p = 0; p <= n; p++) { on |= cur[p]; next[p] = on; any ||= !!on; } }
+            else if (t === '*') { let on = 0; for (let p = 0; p <= n; p++) { on |= cur[p]; next[p] = on; any ||= !!on; if (s[p] === '/') on = 0; } }
+            else if (t === '?') { for (let p = 0; p < n; p++) if (cur[p] && s[p] !== '/') { next[p + 1] = 1; any = true; } }
+            else { for (let p = 0; p < n; p++) if (cur[p] && s[p] === t.c) { next[p + 1] = 1; any = true; } }
+            if (!any) return false;
+            cur = next;
+        }
+        for (let p = 0; p <= n; p++) if (cur[p] && (p === n || s[p] === '/')) return true;
+        return false;
+    };
+}
+
 /** Minimal .gitignore → predicate (used only outside git repos). */
 function loadGitignore(root) {
     const rules = [];
-    try {
-        for (let line of fs.readFileSync(path.join(root, '.gitignore'), 'utf8').split(/\r?\n/)) {
-            line = line.trim();
-            if (!line || line.startsWith('#')) continue;
-            const neg = line.startsWith('!');
-            if (neg) line = line.slice(1);
-            const dirOnly = line.endsWith('/');
-            if (dirOnly) line = line.slice(0, -1);
-            const anchored = line.startsWith('/') || line.includes('/');
-            line = line.replace(/^\//, '');
-            const re = line.split('**').map(seg => seg.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '[^/]*').replace(/\?/g, '[^/]')).join('.*');
-            rules.push({ neg, re: new RegExp(anchored ? `^${re}(/|$)` : `(^|/)${re}(/|$)`) });
-        }
-    } catch { /* no .gitignore */ }
+    for (let line of (readRepoFile(root, '.gitignore') ?? '').split(/\r?\n/)) {
+        line = line.trim();
+        if (!line || line.startsWith('#')) continue;
+        const neg = line.startsWith('!');
+        if (neg) line = line.slice(1);
+        if (line.endsWith('/')) line = line.slice(0, -1);
+        const anchored = line.startsWith('/') || line.includes('/');
+        rules.push({ neg, test: globMatcher(line.replace(/^\//, ''), anchored) });
+    }
     return (rel) => {
         let ignored = false;
-        for (const r of rules) if (r.re.test(rel)) ignored = !r.neg;
+        for (const r of rules) if (r.test(rel)) ignored = !r.neg;
         return ignored;
     };
 }
@@ -95,28 +126,19 @@ export function discoverFiles(root, opts = {}) {
         viaGit = rels !== null;
     }
     if (!rels) rels = walk(root, loadGitignore(root));
-    const files = rels.map(r => r.replace(/\\/g, '/')).filter(r => isIndexablePath(r, opts) && (!viaGit || insideRoot(root, r)));
+    const files = rels.map(r => r.replace(/\\/g, '/')).filter(r => isIndexablePath(r, opts) && insideRoot(root, r));
     files.sort();
     return { files, viaGit };
 }
 
-const realRoots = new Map();
-
 /**
- * A tracked file must resolve inside the repository: symlinks are followed only when their target
- * stays under the root, so a link to /etc/… or ~/.ssh/… is never read, indexed or served.
+ * A tracked file must resolve inside the repository: every component of its path is resolved, so
+ * neither a link to /etc/… or ~/.ssh/… nor a file under a linked directory (`link/secret.ts` with
+ * `link` → elsewhere, which git lists from its index without looking) is read, indexed or served.
  */
 export function insideRoot(root, rel) {
-    const abs = path.join(root, rel);
-    let st;
-    try { st = fs.lstatSync(abs); } catch { return true; } // vanished: the caller handles deletion
-    if (!st.isSymbolicLink()) return true;
-    let realRoot = realRoots.get(root);
-    if (!realRoot) { try { realRoot = fs.realpathSync(root); } catch { realRoot = root; } realRoots.set(root, realRoot); }
-    try {
-        const target = fs.realpathSync(abs);
-        return target === realRoot || target.startsWith(realRoot + path.sep);
-    } catch { return false; } // dangling link
+    try { fs.lstatSync(path.join(root, rel)); } catch { return true; } // vanished: the caller handles deletion
+    return withinRoot(root, rel);
 }
 
 /** Heuristic: minified / generated content that slipped past the name filters. */