token-pilot 0.30.0 → 0.30.1

package/dist/handlers/read-for-edit.js

@@ -1,121 +1,184 @@
-import { readFile, stat, access } from 'node:fs/promises';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { createHash } from 'node:crypto';
-import { relative, join, extname } from 'node:path';
-import { parseMarkdownSections, findSection, extractSectionContent } from './markdown-sections.js';
-import { parseYamlSections, findYamlSection, extractYamlSectionContent } from './yaml-sections.js';
-import { parseJsonSections, findJsonSection, extractJsonSectionContent } from './json-sections.js';
-import { parseCsvOutline, parseCsvSectionSpec, extractCsvSectionContent } from './csv-sections.js';
-import { estimateTokens } from '../core/token-estimator.js';
-import { resolveSafePath } from '../core/validation.js';
-import { assessConfidence, formatConfidence } from '../core/confidence.js';
+import { readFile, stat, access } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createHash } from "node:crypto";
+import { relative, join, extname } from "node:path";
+import { parseMarkdownSections, findSection, extractSectionContent, } from "./markdown-sections.js";
+import { parseYamlSections, findYamlSection, extractYamlSectionContent, } from "./yaml-sections.js";
+import { parseJsonSections, findJsonSection, extractJsonSectionContent, } from "./json-sections.js";
+import { parseCsvOutline, parseCsvSectionSpec, extractCsvSectionContent, } from "./csv-sections.js";
+import { estimateTokens } from "../core/token-estimator.js";
+import { resolveSafePath } from "../core/validation.js";
+import { markEditPrepared } from "../core/edit-prep-state.js";
+import { assessConfidence, formatConfidence } from "../core/confidence.js";
 const execFileAsync = promisify(execFile);
 const DEFAULT_CONTEXT = 5;
 export async function handleReadForEdit(args, projectRoot, symbolResolver, fileCache, contextRegistry, astIndex, options) {
     const absPath = resolveSafePath(projectRoot, args.path);
+    // Record intent BEFORE any downstream failure: if the agent explicitly
+    // called read_for_edit on this path, they have declared they want to
+    // edit it next. The PreToolUse:Edit hook reads this to decide whether
+    // to allow or deny the follow-up Edit. Best-effort — never throws.
+    markEditPrepared(projectRoot, absPath);
     const ctx = args.context ?? DEFAULT_CONTEXT;
     // Section mode: markdown/YAML section extraction for edit
     if (args.section) {
         const ext = extname(absPath).toLowerCase();
-        const supportedExts = new Set(['.md', '.markdown', '.yaml', '.yml', '.json', '.csv']);
+        const supportedExts = new Set([
+            ".md",
+            ".markdown",
+            ".yaml",
+            ".yml",
+            ".json",
+            ".csv",
+        ]);
         if (!supportedExts.has(ext)) {
             return {
-                content: [{
-                        type: 'text',
+                content: [
+                    {
+                        type: "text",
                         text: `"section" parameter only works with Markdown, YAML, or JSON files. Got: ${ext}. Use "symbol" for code files.`,
-                    }],
+                    },
+                ],
             };
         }
-        const fileContent = await readFile(absPath, 'utf-8');
-        const fileLines = fileContent.split('\n');
+        const fileContent = await readFile(absPath, "utf-8");
+        const fileLines = fileContent.split("\n");
         // Cache file in fileCache for read_diff baseline
         if (!fileCache.get(absPath)) {
             const fileStat = await stat(absPath);
-            const hash = createHash('sha256').update(fileContent).digest('hex');
-            const language = ext === '.csv' ? 'csv' : ext === '.json' ? 'json' : (ext === '.md' || ext === '.markdown') ? 'markdown' : 'yaml';
+            const hash = createHash("sha256").update(fileContent).digest("hex");
+            const language = ext === ".csv"
+                ? "csv"
+                : ext === ".json"
+                    ? "json"
+                    : ext === ".md" || ext === ".markdown"
+                        ? "markdown"
+                        : "yaml";
             fileCache.set(absPath, {
-                structure: { path: absPath, language, meta: { lines: fileLines.length, bytes: fileContent.length, lastModified: fileStat.mtimeMs, contentHash: hash }, imports: [], exports: [], symbols: [] },
-                content: fileContent, lines: fileLines, mtime: fileStat.mtimeMs, hash, lastAccess: Date.now(),
+                structure: {
+                    path: absPath,
+                    language,
+                    meta: {
+                        lines: fileLines.length,
+                        bytes: fileContent.length,
+                        lastModified: fileStat.mtimeMs,
+                        contentHash: hash,
+                    },
+                    imports: [],
+                    exports: [],
+                    symbols: [],
+                },
+                content: fileContent,
+                lines: fileLines,
+                mtime: fileStat.mtimeMs,
+                hash,
+                lastAccess: Date.now(),
             });
         }
         let sectionResult = null;
-        if (ext === '.md' || ext === '.markdown') {
+        if (ext === ".md" || ext === ".markdown") {
             const sections = parseMarkdownSections(fileContent);
             const section = findSection(sections, args.section);
             if (!section) {
-                const available = sections.map(s => s.heading).join(', ');
+                const available = sections.map((s) => s.heading).join(", ");
                 return {
-                    content: [{
-                            type: 'text',
+                    content: [
+                        {
+                            type: "text",
                             text: `Section "${args.section}" not found in ${args.path}.\nAvailable: ${available}`,
-                        }],
+                        },
+                    ],
                 };
             }
-            const hashes = '#'.repeat(section.level);
-            sectionResult = { ...section, rawContent: extractSectionContent(fileLines, section), label: `${hashes} ${section.heading}` };
+            const hashes = "#".repeat(section.level);
+            sectionResult = {
+                ...section,
+                rawContent: extractSectionContent(fileLines, section),
+                label: `${hashes} ${section.heading}`,
+            };
         }
-        else if (ext === '.yaml' || ext === '.yml') {
+        else if (ext === ".yaml" || ext === ".yml") {
             const sections = parseYamlSections(fileContent);
             const section = findYamlSection(sections, args.section);
             if (!section) {
-                const available = sections.map(s => s.heading).join(', ');
+                const available = sections.map((s) => s.heading).join(", ");
                 return {
-                    content: [{
-                            type: 'text',
+                    content: [
+                        {
+                            type: "text",
                             text: `Section "${args.section}" not found in ${args.path}.\nAvailable: ${available}`,
-                        }],
+                        },
+                    ],
                 };
             }
-            sectionResult = { ...section, rawContent: extractYamlSectionContent(fileLines, section), label: section.heading };
+            sectionResult = {
+                ...section,
+                rawContent: extractYamlSectionContent(fileLines, section),
+                label: section.heading,
+            };
         }
-        else if (ext === '.json') {
+        else if (ext === ".json") {
             const sections = parseJsonSections(fileContent);
             const section = findJsonSection(sections, args.section);
             if (!section) {
-                const available = sections.map(s => s.heading).join(', ');
+                const available = sections.map((s) => s.heading).join(", ");
                 return {
-                    content: [{
-                            type: 'text',
+                    content: [
+                        {
+                            type: "text",
                             text: `Section "${args.section}" not found in ${args.path}.\nAvailable: ${available}`,
-                        }],
+                        },
+                    ],
                 };
             }
-            sectionResult = { ...section, rawContent: extractJsonSectionContent(fileLines, section), label: section.heading };
+            sectionResult = {
+                ...section,
+                rawContent: extractJsonSectionContent(fileLines, section),
+                label: section.heading,
+            };
         }
-        else if (ext === '.csv') {
+        else if (ext === ".csv") {
             const outline = parseCsvOutline(fileContent);
             const section = parseCsvSectionSpec(args.section, outline.rowCount);
             if (!section) {
                 return {
-                    content: [{
-                            type: 'text',
+                    content: [
+                        {
+                            type: "text",
                             text: `Invalid section "${args.section}" for CSV. Use: rows:1-50 or row:5\nTotal rows: ${outline.rowCount}`,
-                        }],
+                        },
+                    ],
                 };
             }
-            sectionResult = { ...section, rawContent: extractCsvSectionContent(fileLines, section), label: section.heading };
+            sectionResult = {
+                ...section,
+                rawContent: extractCsvSectionContent(fileLines, section),
+                label: section.heading,
+            };
         }
         if (!sectionResult) {
-            return { content: [{ type: 'text', text: `Unsupported file type: ${ext}` }] };
+            return {
+                content: [{ type: "text", text: `Unsupported file type: ${ext}` }],
+            };
         }
         const outputLines = [
             `FILE: ${args.path}`,
             `EDIT SECTION: ${sectionResult.label} [L${sectionResult.startLine}-${sectionResult.endLine}] (${sectionResult.lineCount} lines)`,
-            '',
+            "",
             sectionResult.rawContent,
-            '',
+            "",
             `AFTER EDIT: Use read_diff("${args.path}") to verify changes (90% cheaper than re-reading).`,
         ];
-        const output = outputLines.join('\n');
+        const output = outputLines.join("\n");
         const tokens = estimateTokens(output);
         contextRegistry.trackLoad(absPath, {
-            type: 'range',
+            type: "range",
             startLine: sectionResult.startLine,
             endLine: sectionResult.endLine,
             tokens,
         });
-        return { content: [{ type: 'text', text: output }] };
+        return { content: [{ type: "text", text: output }] };
     }
     // Get file content — also cache for read_diff baseline
     const cached = fileCache.get(absPath);
@@ -124,16 +187,21 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
         lines = cached.lines;
     }
     else {
-        const content = await readFile(absPath, 'utf-8');
-        lines = content.split('\n');
+        const content = await readFile(absPath, "utf-8");
+        lines = content.split("\n");
         // Cache the full file so read_diff can use it as baseline after edits
         const fileStat = await stat(absPath);
-        const hash = createHash('sha256').update(content).digest('hex');
+        const hash = createHash("sha256").update(content).digest("hex");
         fileCache.set(absPath, {
             structure: {
                 path: absPath,
-                language: 'unknown',
-                meta: { lines: lines.length, bytes: content.length, lastModified: fileStat.mtimeMs, contentHash: hash },
+                language: "unknown",
+                meta: {
+                    lines: lines.length,
+                    bytes: content.length,
+                    lastModified: fileStat.mtimeMs,
+                    contentHash: hash,
+                },
                 imports: [],
                 exports: [],
                 symbols: [],
@@ -149,19 +217,19 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
     if (args.symbols && args.symbols.length > 0) {
         let structure = cached?.structure;
         if (!structure) {
-            structure = await astIndex.outline(absPath) ?? undefined;
+            structure = (await astIndex.outline(absPath)) ?? undefined;
         }
         const sections = [];
         sections.push(`--- EDIT CONTEXT (BATCH: ${args.symbols.length} symbols) ---`);
         sections.push(`FILE: ${args.path}`);
-        sections.push('');
+        sections.push("");
         let resolved_count = 0;
         for (let i = 0; i < args.symbols.length; i++) {
             const symName = args.symbols[i];
             const resolved = await symbolResolver.resolve(symName, structure);
             if (!resolved) {
                 sections.push(`=== SYMBOL ${i + 1}/${args.symbols.length}: ${symName} — NOT FOUND ===`);
-                sections.push('');
+                sections.push("");
                 continue;
             }
             resolved_count++;
@@ -180,22 +248,22 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
             }
             const rangeStart = Math.max(1, effStart - ctx);
             const rangeEnd = Math.min(lines.length, effEnd + ctx);
-            const rawCode = lines.slice(rangeStart - 1, rangeEnd).join('\n');
+            const rawCode = lines.slice(rangeStart - 1, rangeEnd).join("\n");
             sections.push(`=== SYMBOL ${i + 1}/${args.symbols.length}: ${label} ===`);
-            sections.push('');
+            sections.push("");
             sections.push(rawCode);
-            sections.push('');
+            sections.push("");
             // Track each symbol
             contextRegistry.trackLoad(absPath, {
-                type: 'symbol',
+                type: "symbol",
                 symbolName: symName,
                 startLine: rangeStart,
                 endLine: rangeEnd,
                 tokens: estimateTokens(rawCode),
             });
         }
-        sections.push('--- END EDIT CONTEXT ---');
-        sections.push('');
+        sections.push("--- END EDIT CONTEXT ---");
+        sections.push("");
         sections.push(`To edit: use exact text from each section as old_string in Edit tool.`);
         if (resolved_count < args.symbols.length) {
             sections.push(`WARNING: ${args.symbols.length - resolved_count} symbol(s) not found. Use smart_read to see available symbols.`);
@@ -207,8 +275,8 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
             astAvailable: true,
         });
         sections.push(formatConfidence(confidenceMeta));
-        const output = sections.join('\n');
-        return { content: [{ type: 'text', text: output }] };
+        const output = sections.join("\n");
+        return { content: [{ type: "text", text: output }] };
     }
     let startLine;
     let endLine;
@@ -217,15 +285,17 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
         // Resolve symbol via AST
         let structure = cached?.structure;
         if (!structure) {
-            structure = await astIndex.outline(absPath) ?? undefined;
+            structure = (await astIndex.outline(absPath)) ?? undefined;
         }
         const resolved = await symbolResolver.resolve(args.symbol, structure);
         if (!resolved) {
             return {
-                content: [{
-                        type: 'text',
+                content: [
+                    {
+                        type: "text",
                         text: `Symbol "${args.symbol}" not found in ${args.path}.\nHINT: Use smart_read("${args.path}") to see available symbols.`,
-                    }],
+                    },
+                ],
             };
         }
         const symbolLines = resolved.endLine - resolved.startLine + 1;
@@ -243,10 +313,12 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
     else if (args.line) {
         if (args.line < 1 || args.line > lines.length) {
             return {
-                content: [{
-                        type: 'text',
+                content: [
+                    {
+                        type: "text",
                         text: `Line ${args.line} out of range (file has ${lines.length} lines).`,
-                    }],
+                    },
+                ],
             };
         }
         startLine = args.line;
@@ -255,10 +327,12 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
     }
     else {
         return {
-            content: [{
-                    type: 'text',
+            content: [
+                {
+                    type: "text",
                     text: 'Either "symbol" or "line" must be provided.',
-                }],
+                },
+            ],
         };
     }
     // Apply context padding
@@ -266,17 +340,17 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
     const rangeEnd = Math.min(lines.length, endLine + ctx);
     const rangeCount = rangeEnd - rangeStart + 1;
     // Extract RAW code (no line number prefixes — ready for Edit old_string)
-    const rawCode = lines.slice(rangeStart - 1, rangeEnd).join('\n');
+    const rawCode = lines.slice(rangeStart - 1, rangeEnd).join("\n");
     const outputLines = [
         `--- EDIT CONTEXT ---`,
         `FILE: ${args.path}`,
         `TARGET: ${targetLabel}`,
         `SHOWING: L${rangeStart}-${rangeEnd} (${rangeCount} lines)`,
-        '',
+        "",
         rawCode,
-        '',
+        "",
         `--- END EDIT CONTEXT ---`,
-        '',
+        "",
         `To edit: use exact text above as old_string in Edit tool.`,
         `For Read requirement: Read("${args.path}", offset=${rangeStart}, limit=${rangeCount})`,
     ];
@@ -287,17 +361,17 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
             const refs = await astIndex.refs(args.symbol, 10);
             const callers = refs.usages.slice(0, 5);
             if (callers.length > 0) {
-                outputLines.push('');
+                outputLines.push("");
                 outputLines.push(`CALLERS (${callers.length}):`);
                 for (const c of callers) {
                     const relPath = relative(projectRoot, c.path);
-                    const ctx = c.context ? ` — ${c.context.trim().slice(0, 80)}` : '';
+                    const ctx = c.context ? ` — ${c.context.trim().slice(0, 80)}` : "";
                     outputLines.push(`  ${relPath}:${c.line}${ctx}`);
                 }
             }
             else {
-                outputLines.push('');
-                outputLines.push('CALLERS: none found');
+                outputLines.push("");
+                outputLines.push("CALLERS: none found");
             }
         }
         catch {
@@ -307,13 +381,13 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
     // include_tests: find related test file and list test names
     if (args.include_tests) {
         const testSection = await findTestSection(absPath, args.path, projectRoot, astIndex);
-        outputLines.push('');
+        outputLines.push("");
         outputLines.push(...testSection);
     }
     // include_changes: git diff filtered to target region
     if (args.include_changes) {
         const diffSection = await findChangesSection(absPath, projectRoot, rangeStart, rangeEnd);
-        outputLines.push('');
+        outputLines.push("");
         outputLines.push(...diffSection);
     }
     // Confidence metadata
@@ -328,37 +402,37 @@ export async function handleReadForEdit(args, projectRoot, symbolResolver, fileC
     outputLines.push(formatConfidence(confidenceMeta));
     // Add post-edit hint (config-gated)
     if (options?.actionableHints !== false) {
-        outputLines.push('');
+        outputLines.push("");
         outputLines.push(`AFTER EDIT: Use read_diff("${args.path}") to verify changes (90% cheaper than re-reading the file).`);
     }
-    const output = outputLines.join('\n');
+    const output = outputLines.join("\n");
     const tokens = estimateTokens(output);
     // Track in context
     contextRegistry.trackLoad(absPath, {
-        type: 'symbol',
+        type: "symbol",
         symbolName: args.symbol ?? `line:${args.line}`,
         startLine: rangeStart,
         endLine: rangeEnd,
         tokens,
     });
-    return { content: [{ type: 'text', text: output }] };
+    return { content: [{ type: "text", text: output }] };
 }
 // --- Helper: find related test file and extract test names ---
 async function findTestSection(absPath, relPath, projectRoot, astIndex) {
     // Derive test file path from source path using common conventions
     // src/handlers/foo.ts → tests/handlers/foo.test.ts
     // src/core/bar.ts → tests/core/bar.test.ts
-    const srcPrefix = 'src/';
+    const srcPrefix = "src/";
     let testRelPath;
     if (relPath.startsWith(srcPrefix)) {
         const rest = relPath.slice(srcPrefix.length);
-        const ext = rest.match(/\.[^.]+$/)?.[0] ?? '.ts';
-        const base = rest.replace(/\.[^.]+$/, '');
+        const ext = rest.match(/\.[^.]+$/)?.[0] ?? ".ts";
+        const base = rest.replace(/\.[^.]+$/, "");
         testRelPath = `tests/${base}.test${ext}`;
     }
     else {
-        const ext = relPath.match(/\.[^.]+$/)?.[0] ?? '.ts';
-        const base = relPath.replace(/\.[^.]+$/, '');
+        const ext = relPath.match(/\.[^.]+$/)?.[0] ?? ".ts";
+        const base = relPath.replace(/\.[^.]+$/, "");
         testRelPath = `${base}.test${ext}`;
     }
     const testAbsPath = join(projectRoot, testRelPath);
@@ -395,10 +469,10 @@ async function findChangesSection(absPath, projectRoot, rangeStart, rangeEnd) {
     const MAX_DIFF_LINES = 30;
     try {
         // Try unstaged changes first
-        let diffOutput = '';
-        let diffLabel = 'unstaged';
+        let diffOutput = "";
+        let diffLabel = "unstaged";
         try {
-            const { stdout } = await execFileAsync('git', ['diff', 'HEAD', '--', absPath], {
+            const { stdout } = await execFileAsync("git", ["diff", "HEAD", "--", absPath], {
                 cwd: projectRoot,
                 timeout: 5000,
             });
@@ -406,29 +480,29 @@ async function findChangesSection(absPath, projectRoot, rangeStart, rangeEnd) {
         }
         catch {
             // git not available or not a repo
-            return ['RECENT CHANGES: unavailable (not a git repo)'];
+            return ["RECENT CHANGES: unavailable (not a git repo)"];
         }
         // If no unstaged changes, try last commit
         if (!diffOutput.trim()) {
             try {
-                const { stdout } = await execFileAsync('git', ['diff', 'HEAD~1', '--', absPath], {
+                const { stdout } = await execFileAsync("git", ["diff", "HEAD~1", "--", absPath], {
                     cwd: projectRoot,
                     timeout: 5000,
                 });
                 diffOutput = stdout;
-                diffLabel = 'last commit';
+                diffLabel = "last commit";
             }
             catch {
                 // no previous commit
             }
         }
         if (!diffOutput.trim()) {
-            return ['RECENT CHANGES: none (file unchanged)'];
+            return ["RECENT CHANGES: none (file unchanged)"];
         }
         // Filter hunks to those overlapping with target range
         const relevantLines = filterDiffHunks(diffOutput, rangeStart, rangeEnd);
         if (relevantLines.length === 0) {
-            return ['RECENT CHANGES: none in target region'];
+            return ["RECENT CHANGES: none in target region"];
         }
         const lines = [`RECENT CHANGES (${diffLabel}):`];
         const trimmed = relevantLines.slice(0, MAX_DIFF_LINES);
@@ -441,12 +515,12 @@ async function findChangesSection(absPath, projectRoot, rangeStart, rangeEnd) {
         return lines;
     }
     catch {
-        return ['RECENT CHANGES: unavailable'];
+        return ["RECENT CHANGES: unavailable"];
     }
 }
 /** Filter diff output to only hunks overlapping [rangeStart, rangeEnd]. */
 function filterDiffHunks(diff, rangeStart, rangeEnd) {
-    const allLines = diff.split('\n');
+    const allLines = diff.split("\n");
     const result = [];
     let inRelevantHunk = false;
     for (const line of allLines) {
@@ -454,7 +528,7 @@ function filterDiffHunks(diff, rangeStart, rangeEnd) {
         const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
         if (hunkMatch) {
             const hunkStart = parseInt(hunkMatch[1], 10);
-            const hunkLen = parseInt(hunkMatch[2] ?? '1', 10);
+            const hunkLen = parseInt(hunkMatch[2] ?? "1", 10);
             const hunkEnd = hunkStart + hunkLen - 1;
             // Check overlap with target range
             inRelevantHunk = hunkStart <= rangeEnd && hunkEnd >= rangeStart;
@@ -464,10 +538,14 @@ function filterDiffHunks(diff, rangeStart, rangeEnd) {
             continue;
         }
         // Skip diff metadata lines (diff --git, index, ---, +++)
-        if (line.startsWith('diff ') || line.startsWith('index ') || line.startsWith('--- ') || line.startsWith('+++ ')) {
+        if (line.startsWith("diff ") ||
+            line.startsWith("index ") ||
+            line.startsWith("--- ") ||
+            line.startsWith("+++ ")) {
             continue;
         }
-        if (inRelevantHunk && (line.startsWith('+') || line.startsWith('-') || line.startsWith(' '))) {
+        if (inRelevantHunk &&
+            (line.startsWith("+") || line.startsWith("-") || line.startsWith(" "))) {
             result.push(line);
         }
     }

package/dist/hooks/installer.js

@@ -34,6 +34,24 @@ function createHookConfig(options) {
                         },
                     ],
                 },
+                {
+                    matcher: "MultiEdit",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookCommand("hook-edit", options),
+                        },
+                    ],
+                },
+                {
+                    matcher: "Write",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: buildHookCommand("hook-edit", options),
+                        },
+                    ],
+                },
                 {
                     matcher: "Bash",
                     hooks: [

package/dist/hooks/pre-bash.d.ts

@@ -34,6 +34,9 @@ export interface PreBashInput {
 }
 export type PreBashDecision = {
     kind: "allow";
+} | {
+    kind: "advise";
+    reason: string;
 } | {
     kind: "deny";
     reason: string;
@@ -50,6 +53,12 @@ export type PreBashDecision = {
  */
 export declare function extractWrappedCommands(command: string): string[];
 export declare function detectHeavyPattern(command: string): PreBashDecision;
+/**
+ * Detect common test-runner invocations. Returns true for anything we'd
+ * route through `test_summary`. Kept as a pure string test so it's unit-
+ * testable without spinning up child processes.
+ */
+export declare function isTestRunnerCommand(cmd: string): boolean;
 export declare function decidePreBash(input: PreBashInput, mode?: EnforcementMode): PreBashDecision;
 export declare function renderPreBashOutput(decision: PreBashDecision): string | null;
 //# sourceMappingURL=pre-bash.d.ts.map