@event4u/agent-config 16.1.0 → 16.3.0

package/src/scripts/_lib/gitignore_block.ts

@@ -0,0 +1,314 @@
+/**
+ * The `.gitignore` managed-block logic, with no CLI entry.
+ *
+ * WHY IT IS NOT IN `sync_gitignore.ts` ANY MORE. That file ends in a
+ * `process.exit(main(...))` behind a CLI-entry guard, and `check_installer_import_purity`
+ * refuses any module-level exit reachable from `install.ts`: esbuild inlines the
+ * whole closure into `dist/install/install.mjs`, where the guard comparing
+ * `import.meta.url` to `process.argv[1]` evaluates TRUE because the bundle IS
+ * argv[1]. A consumer install would then exit after writing its payload.
+ *
+ * So the pure half lives here, with no entry and no exit, and `sync_gitignore.ts`
+ * re-exports every name it used to own — the CLI contract and the ported
+ * pytest suite's snake_case call sites are unchanged.
+ *
+ * Everything below is byte-for-byte the behaviour it had in that file,
+ * including the historical quirks downstream consumers pin.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const SECTION_HEADER = '# event4u/agent-config';
+export const SECTION_FOOTER = '# event4u/agent-config — END';
+export const DEFAULT_GITIGNORE = '.gitignore';
+
+const _HERE = fileURLToPath(import.meta.url);
+// _HERE === <repo>/src/scripts/_lib/gitignore_block.ts, so the repo root is
+// three directories up. The retired Python implementation derived
+// DEFAULT_TEMPLATE = <file>.parent.parent.parent / "src" / "config" /
+// "gitignore-block.txt" from one level higher; the extra `..` here is that
+// same root reached from one level deeper.
+export const DEFAULT_TEMPLATE = path.join(
+    path.dirname(_HERE),
+    '..',
+    '..',
+    '..',
+    'src',
+    'config',
+    'gitignore-block.txt',
+);
+
+// Legacy patterns that lived in older versions of src/config/gitignore-block.txt
+// before runtime artefacts moved under /agents/runtime/ (May 2026). They get
+// stripped wherever they appear in the consumer's .gitignore — inside the
+// managed block or outside (older installers / hand-edits). Current canonical
+// equivalents (e.g. /agents/runtime/.agent-prices.md) come from the template
+// and are NOT affected. Leading-slash variants are matched defensively.
+//
+// Authoritative source: src/config/agents-paths.yml entries with `legacy: true`.
+// Manual sync until the generation step from the manifest is implemented
+// (road-to-agents-dir-and-gitignore-hygiene Phase 3.2 follow-on).
+export const LEGACY_PATTERNS: readonly string[] = [
+    '.agent-chat-history',
+    '.agent-chat-history.bak',
+    '.agent-chat-history.*.bak',
+    '.agent-prices.md',
+    '.council-tmp/',
+    // 2.x intermediate: prices cache lived directly under agents/ before
+    // consolidating under agents/runtime/.
+    'agents/.agent-prices.md',
+    // Budget history JSONLs — previously listed explicitly at project
+    // root or under agents/; now covered by the /agents/runtime/
+    // catch-all in the managed block.
+    '.augment-budget-history.jsonl',
+    '.rule-budget-history.jsonl',
+    'agents/.augment-budget-history.jsonl',
+    'agents/.rule-budget-history.jsonl',
+];
+
+export function _strip(ln: string): string {
+    // Python: ln.rstrip("\n").rstrip() — strip a trailing newline, then strip
+    // all trailing whitespace.
+    return ln.replace(/\n+$/, '').replace(/\s+$/, '');
+}
+
+export function _is_entry(ln: string): boolean {
+    // Non-empty, non-comment line = a path/pattern entry.
+    const s = _strip(ln).replace(/^\s+/, '');
+    return Boolean(s) && !s.startsWith('#');
+}
+
+/** Error raised when the template file is missing (→ exit 2 in main). */
+export class TemplateNotFoundError extends Error {
+    constructor(p: string) {
+        super(`template not found: ${p}`);
+        this.name = 'TemplateNotFoundError';
+    }
+}
+
+export function _isFile(p: string): boolean {
+    try {
+        return fs.statSync(p).isFile();
+    } catch {
+        return false;
+    }
+}
+
+/** Python str.splitlines() — split on universal newlines, no trailing empty. */
+export function _splitlines(text: string): string[] {
+    if (text === '') return [];
+    // str.splitlines() splits on \n, \r, \r\n (and more) and does NOT keep a
+    // trailing empty element. The targets here only ever contain \n / \r\n.
+    const parts = text.split(/\r\n|\r|\n/);
+    if (parts.length > 0 && parts[parts.length - 1] === '') parts.pop();
+    return parts;
+}
+
+export function load_template(p: string): string[] {
+    if (!_isFile(p)) {
+        throw new TemplateNotFoundError(p);
+    }
+    const text = fs.readFileSync(p, 'utf-8');
+    // Keep trailing newlines stripped; we splice explicit newlines.
+    return _splitlines(text).map(_strip);
+}
+
+/**
+ * Locate the managed block; return [start_idx, end_idx_exclusive] or null.
+ *
+ * `start_idx` points at the SECTION_HEADER line.
+ * `end_idx_exclusive` points one past the last line of the block.
+ * Honors explicit SECTION_FOOTER when present; otherwise treats the
+ * block as extending to EOF or to the next non-managed section.
+ */
+export function find_block(lines: readonly string[]): [number, number] | null {
+    for (let i = 0; i < lines.length; i += 1) {
+        if (_strip(lines[i] as string) === SECTION_HEADER) {
+            const start = i;
+            // Explicit footer?
+            for (let j = i + 1; j < lines.length; j += 1) {
+                if (_strip(lines[j] as string) === SECTION_FOOTER) {
+                    return [start, j + 1];
+                }
+            }
+            // Legacy: extend to EOF or next non-managed section break.
+            let end = lines.length;
+            for (let j = i + 1; j < lines.length; j += 1) {
+                const s = _strip(lines[j] as string).replace(/^\s+/, '');
+                if (
+                    s.startsWith('#') &&
+                    !s.startsWith('# Agent config') &&
+                    s !== SECTION_HEADER
+                ) {
+                    end = j;
+                    while (end > i + 1 && _strip(lines[end - 1] as string) === '') {
+                        end -= 1;
+                    }
+                    break;
+                }
+            }
+            return [start, end];
+        }
+    }
+    return null;
+}
+
+/** Return entries (paths/patterns) present in the given block. */
+export function block_entries(block_lines: readonly string[]): string[] {
+    return block_lines
+        .filter((ln) => _is_entry(ln))
+        .map((ln) => _strip(ln).replace(/^\s+/, ''));
+}
+
+export function template_entries(template_lines: readonly string[]): string[] {
+    return template_lines.filter((ln) => _is_entry(ln)).map((ln) => ln.replace(/^\s+/, ''));
+}
+
+/** Return a fresh, fully-managed block with START + body + END. */
+export function build_fresh_block(template_lines: readonly string[]): string[] {
+    return [SECTION_HEADER, ...template_lines, SECTION_FOOTER];
+}
+
+/**
+ * Return [new_lines, added_entries].
+ *
+ * - If block missing: append fresh block (preceded by a blank line if the
+ *   file's last line is not already empty).
+ * - If block present and replace=true: rewrite block in full.
+ * - If block present and replace=false: append any missing managed entries
+ *   before the END marker (adding END if absent). User-added lines inside the
+ *   block are preserved.
+ */
+export function sync_block(
+    existing_lines: readonly string[],
+    template_lines: readonly string[],
+    options: { replace?: boolean } = {},
+): [string[], string[]] {
+    const replace = options.replace ?? false;
+    const loc = find_block(existing_lines);
+    const fresh = build_fresh_block(template_lines);
+
+    // Missing block → append with leading blank if needed.
+    if (loc === null) {
+        const newLines = [...existing_lines];
+        if (newLines.length > 0 && _strip(newLines[newLines.length - 1] as string) !== '') {
+            newLines.push('');
+        }
+        newLines.push(...fresh);
+        return [newLines, template_entries(template_lines)];
+    }
+
+    const [start, end] = loc;
+    const head = existing_lines.slice(0, start);
+    let block = existing_lines.slice(start, end);
+    const tail = existing_lines.slice(end);
+
+    if (replace) {
+        const existing = new Set(block_entries(block));
+        const added = template_entries(template_lines).filter((e) => !existing.has(e));
+        return [[...head, ...fresh, ...tail], added];
+    }
+
+    // Append-only mode.
+    const existing_entries = new Set(block_entries(block));
+    const missing = template_entries(template_lines).filter((e) => !existing_entries.has(e));
+    if (missing.length === 0) {
+        return [[...existing_lines], []];
+    }
+
+    // Ensure block ends with SECTION_FOOTER; insert missing entries right
+    // before it.
+    let insert_at: number;
+    if (block.length > 0 && _strip(block[block.length - 1] as string) === SECTION_FOOTER) {
+        insert_at = block.length - 1;
+    } else {
+        block = [...block, SECTION_FOOTER];
+        insert_at = block.length - 1;
+    }
+    const new_block = [...block.slice(0, insert_at), ...missing, ...block.slice(insert_at)];
+    return [[...head, ...new_block, ...tail], missing];
+}
+
+/**
+ * Strip legacy entries from anywhere in the file.
+ *
+ * A line is legacy when its stripped, leading-whitespace-trimmed content
+ * matches a `LEGACY_PATTERNS` entry — with or without a leading slash.
+ * Comments and blank lines are untouched; current managed entries (e.g.
+ * `/agents/.agent-chat-history`) are not in the legacy set and survive.
+ */
+export function cleanup_legacy(lines: readonly string[]): [string[], string[]] {
+    const legacy = new Set(LEGACY_PATTERNS);
+    const kept: string[] = [];
+    const removed: string[] = [];
+    for (const ln of lines) {
+        const s = _strip(ln).replace(/^\s+/, '');
+        if (legacy.has(s) || (s.startsWith('/') && legacy.has(s.slice(1)))) {
+            removed.push(s);
+            continue;
+        }
+        kept.push(ln);
+    }
+    return [kept, removed];
+}
+
+/** Join lines with newlines and enforce exactly one trailing newline. */
+export function format_file(lines: readonly string[]): string {
+    const text = lines.join('\n');
+    return text.replace(/\n+$/, '') + '\n';
+}
+
+/**
+ * Write the managed block into a project that has no wizard to do it.
+ *
+ * WHY IT EXISTS. The block is normally installed by `refresh --project` /
+ * `sync:gitignore`, which the browser wizard reaches. A `--no-ui` install
+ * reaches neither, so a headless consumer ended up with a package that writes
+ * dispatcher state under `agents/` and a `.gitignore` that says nothing about
+ * it: `git status` fills with untracked runtime files the developer did not
+ * create and cannot place.
+ *
+ * APPEND-ONLY, NEVER `replace`. A line a developer put inside the block is
+ * theirs; this adds the managed entries that are missing and touches nothing
+ * else.
+ *
+ * BEST-EFFORT THROUGHOUT. No `.gitignore` and no git repository, an unreadable
+ * template, an unwritable file — each returns 0 quietly. An installer that
+ * failed because it could not tidy a listing would be worse than the listing.
+ *
+ * Returns the number of entries added (0 when nothing changed), and writes
+ * nothing when `dry_run`. Reporting is the caller's: this module owns no
+ * output convention.
+ */
+export function write_managed_block(project_root: string, dry_run: boolean): number {
+    const target = path.join(project_root, DEFAULT_GITIGNORE);
+    let template: string[];
+    try {
+        template = load_template(DEFAULT_TEMPLATE);
+    } catch {
+        return 0;
+    }
+    let existing: string[] = [];
+    if (_isFile(target)) {
+        existing = _splitlines(fs.readFileSync(target, 'utf-8'));
+    } else if (!_isFile(path.join(project_root, '.git')) && !_isDir(path.join(project_root, '.git'))) {
+        return 0;
+    }
+    const [lines, added] = sync_block(existing, template);
+    if (added.length === 0 || dry_run) return added.length;
+    try {
+        fs.writeFileSync(target, format_file(lines), 'utf-8');
+    } catch {
+        return 0;
+    }
+    return added.length;
+}
+
+function _isDir(p: string): boolean {
+    try {
+        return fs.statSync(p).isDirectory();
+    } catch {
+        return false;
+    }
+}

package/src/scripts/_lib/global_deploy_inventory.ts

@@ -658,6 +658,38 @@ function difference(prev: unknown[], current: Set<string>): unknown[] {
   return out;
 }
 
+/**
+ * The anchor-relative paths a previous deploy of `tool_id` recorded.
+ *
+ * Empty whenever the inventory has no entry, the recorded anchor differs from
+ * `anchor`, or the entry is malformed — the same "not provably ours anymore"
+ * discipline `reap_stale` applies before it deletes anything. Callers use it
+ * to answer "did this package write that file" for a file the CURRENT run did
+ * not write.
+ */
+export function recorded_rel_files(
+  tool_id: string,
+  anchor: string,
+  inventory?: Inventory | null,
+): ReadonlySet<string> {
+  const inv = inventory ?? load_inventory();
+  const tools = (inv["tools"] as Record<string, unknown> | undefined) ?? {};
+  const entry = tools[tool_id];
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    return new Set<string>();
+  }
+  const e = entry as Record<string, unknown>;
+  const recorded_anchor = e["anchor"];
+  const files = e["files"];
+  if (typeof recorded_anchor !== "string" || !Array.isArray(files)) {
+    return new Set<string>();
+  }
+  if (resolve_path(expanduser(recorded_anchor)) !== resolve_path(expanduser(anchor))) {
+    return new Set<string>();
+  }
+  return new Set(files.filter((f): f is string => typeof f === "string"));
+}
+
 /** Sort string members ascending by codepoint (non-strings filtered out). */
 function sorted_strings(items: unknown[]): string[] {
   return items

package/src/scripts/_lib/graph_feeder_record.ts

@@ -0,0 +1,214 @@
+/**
+ * The graph feeder record — detector F's verdict and the code graph's, side by
+ * side, on every stop where a graph existed (`road-to-a-graph-that-feeds-the-gate`
+ * step 3.2).
+ *
+ * WHY A SEPARATE RECORD AND NOT `ShadowRecord` (D3). `ShadowRecord` is written
+ * only on the `stop_hook_active` and `refused_turn` layers and is the Q1
+ * instrument of `road-to-a-stop-that-holds` — a live measurement window with its
+ * own denominator. Folding a second signal into it would contaminate a reading
+ * somebody else is taking, which is a worse failure than a second file.
+ *
+ * WHY IT CHANGES NO VERDICT, AND WHAT THAT CLAIM DOES NOT COVER. Every function
+ * here is wrapped, every failure path returns silently, and no caller branches on
+ * the result, so no in-process path can move an exit code. It is NOT a claim
+ * about latency, and an earlier version of this paragraph said "costs the turn
+ * nothing", which a review correctly read as one: a stop in a repository with a
+ * graph pays a `git status` spawn, a graph open and an `untested` walk. Nothing
+ * measures that, and a host that timed a stop hook out would drop the gate's
+ * refusal — a failure the comparative exit-code test cannot see, because both of
+ * its runs complete. Named rather than implied away. Step 3.4 — promoting the
+ * graph verdict into F — is DEFERRED behind step 3.3's recall measurement and
+ * behind an owner amendment to ADR-277, and nothing here anticipates it.
+ *
+ * WHAT A ROW MAY CONTAIN. The fields are a closed set of enums, counts and
+ * repo-relative source paths. There is no field able to hold a prompt, a file
+ * body, a reply or a command — the same PII-exclusion-by-construction discipline
+ * `domain-safety-pii` § Surface 2 asks of a log line, and the same shape
+ * `ToolCall` already has. Paths are in the set because they are the evidence a
+ * human labeller needs in step 3.3 and because the gate's own refusal text
+ * already quotes them; they are capped so one turn cannot write an unbounded row.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+import { detectSources, type GraphState, NATIVE_CACHE_REL, pickSource } from '../code_graph/detect.js';
+import { loadGraph } from '../code_graph/query.js';
+import { untested } from '../code_graph/verbs.js';
+
+/** At most this many edit paths per row. */
+const MAX_PATHS = 5;
+
+/**
+ * At most this many rows per session file.
+ *
+ * `agents/state/` is local and gitignored, but "local" is not "free": a long
+ * session appends on every turn end, and an instrument that grows without a
+ * bound is the failure the gate's own refusal-state history already records.
+ * Past the cap the writer stops rather than rotating — a truncated tail is a
+ * readable sample, and a rotation would silently drop the earliest rows that a
+ * recall reading most wants.
+ */
+export const MAX_ROWS_PER_SESSION = 200;
+
+/** The graph's half of the verdict. `null` means the graph did not contribute. */
+export type GraphVerdict = 'untested' | 'tested' | 'no-seeds' | null;
+
+/** One stop, as the feeder records it. */
+/**
+ * The stop layer a row came from.
+ *
+ * A closed union rather than `string`. The header below calls these fields "a
+ * closed set of enums", and a review pointed out the types did not enforce it —
+ * the sets lived only in the call sites, so a later caller could widen either
+ * with no type error and the prose would quietly become false.
+ */
+export type FeederLayer = 'live' | 'stop_hook_active' | 'refused_turn';
+
+/** Detector F's evidence class, from the same closed set the detector uses. */
+export type FeederMode = 'transcript' | 'record';
+
+export interface GraphFeederRow {
+    at: string;
+    /** The turn's ordinal — how many genuine user prompts preceded it. */
+    turn: number;
+    /** Which stop layer produced this row: the live verdict, or a retry. */
+    layer: FeederLayer;
+    graph_state: GraphState;
+    /** Did detector F fire on this turn? */
+    f: boolean;
+    /** F's evidence class when it fired — `transcript` or `record`. */
+    f_mode: FeederMode | null;
+    graph: GraphVerdict;
+    /** How many changed symbols the graph found no test edge for. */
+    graph_untested: number;
+    /** How many it did find one for — so the ratio is readable. */
+    graph_tested: number;
+    /** The turn's edit paths, capped at {@link MAX_PATHS}. */
+    paths: string[];
+    /** How many edit paths there were in total, when the list is capped. */
+    path_count: number;
+}
+
+export function feederFile(workspaceRoot: string, sessionKey: string): string {
+    return path.join(workspaceRoot, 'agents', 'state', 'graph-feeder', `${sessionKey}.jsonl`);
+}
+
+/**
+ * Run `untested` over the turn's edit paths.
+ *
+ * Returns `null` — the graph contributed nothing — for every reason there is:
+ * no usable source, a SCIP index with no owned reader, no edit paths, or any
+ * throw at all. A verdict this module cannot stand behind is not a verdict.
+ */
+export function graphUntestedVerdict(
+    root: string,
+    state: GraphState,
+    paths: readonly string[],
+): { verdict: GraphVerdict; untested: number; tested: number } {
+    const none = { verdict: null, untested: 0, tested: 0 } as const;
+    // `behind:N` and `absent` contribute nothing, by the step's own terms: an
+    // answer from an index that predates the change is not evidence about the
+    // change.
+    if (state !== 'fresh' && state !== 'edited') return none;
+    if (paths.length === 0) return none;
+    let picked;
+    try {
+        picked = pickSource(detectSources(root, path.join(root, NATIVE_CACHE_REL)));
+    } catch {
+        return none;
+    }
+    if (!picked || picked.kind === 'scip') return none;
+    let g;
+    try {
+        g = loadGraph(picked.path, `${picked.kind}:${path.relative(root, picked.path)}`);
+    } catch {
+        return none;
+    }
+    try {
+        const r = untested(g, paths, state);
+        if (r.seeds.length === 0) return { verdict: 'no-seeds', untested: 0, tested: 0 };
+        return {
+            verdict: r.untested.length > 0 ? 'untested' : 'tested',
+            untested: r.untested.length,
+            tested: r.tested.length,
+        };
+    } catch {
+        return none;
+    } finally {
+        // The handle owns an open database; a stop hook that leaked one per turn
+        // would hold a descriptor for the life of the session.
+        try {
+            g.close();
+        } catch {
+            /* nothing to do about a failed close */
+        }
+    }
+}
+
+/** Append one row, or do nothing at all. Never throws, never returns a verdict. */
+export function appendFeederRow(workspaceRoot: string, sessionKey: string, row: GraphFeederRow): void {
+    try {
+        const file = feederFile(workspaceRoot, sessionKey);
+        let existing = 0;
+        try {
+            existing = fs
+                .readFileSync(file, 'utf-8')
+                .split('\n')
+                .filter((l) => l.trim() !== '').length;
+        } catch {
+            /* absent is zero */
+        }
+        if (existing >= MAX_ROWS_PER_SESSION) return;
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, `${JSON.stringify(row)}\n`);
+    } catch {
+        // An instrument is never a reason to change what the gate does.
+    }
+}
+
+/** Read a session's rows back, skipping anything unparseable. */
+export function readFeederRows(workspaceRoot: string, sessionKey: string): GraphFeederRow[] {
+    try {
+        return fs
+            .readFileSync(feederFile(workspaceRoot, sessionKey), 'utf-8')
+            .split('\n')
+            .filter((l) => l.trim() !== '')
+            .map((l) => {
+                try {
+                    return JSON.parse(l) as GraphFeederRow;
+                } catch {
+                    return null;
+                }
+            })
+            .filter((r): r is GraphFeederRow => r !== null);
+    } catch {
+        return [];
+    }
+}
+
+/** Build the row. Pure, so the shape can be asserted without a filesystem. */
+export function buildFeederRow(input: {
+    turn: number;
+    layer: FeederLayer;
+    state: GraphState;
+    fFired: boolean;
+    fMode: FeederMode | null;
+    paths: readonly string[];
+    graph: { verdict: GraphVerdict; untested: number; tested: number };
+    at?: string;
+}): GraphFeederRow {
+    return {
+        at: input.at ?? new Date().toISOString(),
+        turn: input.turn,
+        layer: input.layer,
+        graph_state: input.state,
+        f: input.fFired,
+        f_mode: input.fMode,
+        graph: input.graph.verdict,
+        graph_untested: input.graph.untested,
+        graph_tested: input.graph.tested,
+        paths: input.paths.slice(0, MAX_PATHS).map((p) => p),
+        path_count: input.paths.length,
+    };
+}

package/src/scripts/_lib/hook_settings.ts

@@ -78,6 +78,79 @@ export function hookSectionEnabled(root: string, section: string): boolean {
     return false;
 }
 
+/**
+ * Raw scalar at `hooks.<section>.<key>` in `.agent-settings.yml`, or `''`.
+ *
+ * The `hookSectionEnabled` sibling above answers one boolean question and is
+ * the right shape for a default-OFF switch. This one exists because
+ * `hooks.verify_before_complete.touched_file_quality` is a three-valued mode
+ * (`off | shadow | warn`), and collapsing it into a boolean would lose exactly
+ * the distinction the roadmap's Phase 2 turns on — `shadow` records and says
+ * nothing, `warn` records and emits one line.
+ *
+ * It reuses the section scoping of `hookSectionEnabled` verbatim, including the
+ * ACTUAL-indent close that the 4-space-file defect produced: a reader that
+ * closed the section on a fixed depth would read a sibling section's value under
+ * this key's name, which for a mode string is worse than for a flag — the wrong
+ * value is a legal one.
+ *
+ * Interpretation is NOT done here. `''` means "nothing was written", and the
+ * caller decides what that defaults to — the same producer/consumer split
+ * `leanProjectionModeRaw` makes below, and for the same reason.
+ */
+export function hookSectionValue(root: string, section: string, key: string): string {
+    const file = path.join(root, SETTINGS_FILE);
+    let text: string;
+    try {
+        if (!fs.statSync(file).isFile()) return '';
+        text = fs.readFileSync(file, 'utf-8');
+    } catch {
+        return '';
+    }
+
+    const esc = (s: string): string => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const sectionPattern = new RegExp(`^(\\s+)${esc(section)}\\s*:\\s*$`);
+    const keyPattern = new RegExp(`^\\s+${esc(key)}\\s*:\\s*(.+)$`);
+    let inHooks = false;
+    let sectionIndent: number | null = null;
+
+    const indentOf = (line: string): number => line.length - line.replace(/^\s+/, '').length;
+
+    for (const raw of text.split(/\r\n|\r|\n/)) {
+        const line = raw.replace(/\s+$/, '');
+        if (!line || line.replace(/^\s+/, '').startsWith('#')) continue;
+
+        if (!(line.startsWith(' ') || line.startsWith('\t'))) {
+            inHooks = /^hooks\s*:\s*$/.test(line);
+            sectionIndent = null;
+            continue;
+        }
+
+        if (inHooks) {
+            const opened = sectionPattern.exec(line);
+            if (opened) {
+                sectionIndent = opened[1]!.length;
+                continue;
+            }
+            if (sectionIndent !== null && indentOf(line) <= sectionIndent) {
+                sectionIndent = null;
+            }
+        }
+
+        if (sectionIndent !== null) {
+            const m = keyPattern.exec(line);
+            if (m) {
+                return (m[1] ?? '')
+                    .replace(/\s+#.*$/, '')
+                    .trim()
+                    .replace(/^["']|["']$/g, '');
+            }
+        }
+    }
+
+    return '';
+}
+
 /**
  * Raw `lean_projection.mode` string out of `.agent-settings.yml`, or `''`.
  *