@event4u/agent-config 9.12.0 → 9.14.0

package/src/scripts/hooks/block_no_verify.ts

@@ -33,6 +33,34 @@ const _SHELL_SEPARATORS: ReadonlySet<string> = new Set(['&&', '||', ';', '|']);
 const _NO_VERIFY_FLAGS: ReadonlySet<string> = new Set(['--no-verify']);
 const _NO_VERIFY_SHORT: ReadonlySet<string> = new Set(['-n']);
 const _HOOKS_PATH_RE = /^core\.hooksPath\s*=/i;
+/** Bare key form, as `git config core.hooksPath <value>` spells it. */
+const _HOOKS_PATH_KEY_RE = /^core\.hooksPath$/i;
+/**
+ * `git config` flags that make the invocation a READ or a RESTORE rather than
+ * a write. `--unset` removes the override — the opposite of disabling hooks —
+ * so it stays allowed, or the gate would block its own remediation.
+ */
+/** Global `git` options that consume the following token as their value. */
+const _GIT_GLOBAL_OPTS_WITH_VALUE: ReadonlySet<string> = new Set([
+    '-C',
+    '-c',
+    '--config',
+    '--git-dir',
+    '--work-tree',
+    '--namespace',
+    '--exec-path',
+    '--super-prefix',
+]);
+const _CONFIG_READ_OR_RESTORE: ReadonlySet<string> = new Set([
+    '--get',
+    '--get-all',
+    '--get-regexp',
+    '--get-urlmatch',
+    '--list',
+    '-l',
+    '--unset',
+    '--unset-all',
+]);
 
 type JsonValue = string | number | boolean | null | JsonValue[] | { [k: string]: JsonValue };
 type JsonObject = { [k: string]: JsonValue };
@@ -178,7 +206,80 @@ function _git_base(tokens: string[]): string[] | null {
     return null;
 }
 
+/**
+ * `git config … core.hooksPath <value>` — the subcommand form of the hooksPath
+ * override, distinct from the `-c` / `--config` global-option form handled in
+ * `_is_blocked`.
+ *
+ * Closed by road-to-governance-invariants Phase 1 after the S0.2 spike measured
+ * it: `git-history-discipline` already claimed `core.hooksPath` overrides were
+ * "deterministically blocked", and only the inline `-c` form was. That made
+ * `git config core.hooksPath /dev/null` → `git commit` a two-step sequence
+ * whose every step this gate allowed and whose composition is exactly the
+ * outcome the gate exists to prevent.
+ *
+ * Deliberately narrow, per the 2026-08-02 council cut (option ii — widen only
+ * the exact shapes with no plausible legitimate use):
+ *   - a READ (`--get`, `--list`, or the key with no value) is allowed;
+ *   - `--unset` is allowed — it restores hooks, it does not disable them;
+ *   - non-git ways of disabling a hook (`mv`/`chmod`/`rm` on `.git/hooks/*`)
+ *     are NOT matched here. Recognising them would turn this guard into a
+ *     shell sandbox and those verbs have ordinary legitimate uses. That gap
+ *     is published rather than papered over — see the S0.2 spike.
+ */
+function _is_config_hookspath_write(git_tokens: string[]): [boolean, string] {
+    const rest = git_tokens.slice(1);
+    // The subcommand is the first token that is neither a global option nor
+    // the VALUE of one — `git -C /repo config …` must still resolve to
+    // `config`, not to `/repo`.
+    let subIdx = -1;
+    for (let k = 0; k < rest.length; k += 1) {
+        const tok = rest[k] as string;
+        if (!tok.startsWith('-')) {
+            subIdx = k;
+            break;
+        }
+        if (_GIT_GLOBAL_OPTS_WITH_VALUE.has(tok)) {
+            k += 1; // consume its value
+        }
+    }
+    if (subIdx === -1 || rest[subIdx] !== 'config') {
+        return [false, ''];
+    }
+    const args = rest.slice(subIdx + 1);
+    if (args.some((t) => _CONFIG_READ_OR_RESTORE.has(t))) {
+        return [false, ''];
+    }
+    for (let k = 0; k < args.length; k += 1) {
+        const tok = args[k] as string;
+        // `core.hooksPath=<value>` — one token, always a write.
+        if (_HOOKS_PATH_RE.test(tok)) {
+            return [
+                true,
+                `'git config ${tok}' disables git hooks via hooksPath (git-history-discipline)`,
+            ];
+        }
+        if (!_HOOKS_PATH_KEY_RE.test(tok)) {
+            continue;
+        }
+        // Bare key: a write only when a value follows.
+        const next = args.slice(k + 1).find((t) => !t.startsWith('-'));
+        if (next !== undefined) {
+            return [
+                true,
+                `'git config ${tok} ${next}' disables git hooks via hooksPath (git-history-discipline)`,
+            ];
+        }
+        return [false, ''];
+    }
+    return [false, ''];
+}
+
 function _is_blocked(git_tokens: string[]): [boolean, string] {
+    const [cfgBlocked, cfgReason] = _is_config_hookspath_write(git_tokens);
+    if (cfgBlocked) {
+        return [cfgBlocked, cfgReason];
+    }
     let i = 1; // skip 'git'
     while (i < git_tokens.length) {
         const tok = git_tokens[i] as string;

package/src/scripts/install.ts

@@ -74,6 +74,7 @@ import type * as YamlModule from 'yaml';
 import { build_merge_entries } from './_lib/json_pointers.js';
 import { is_claude_builtin_name } from './_lib/claude_builtin_names.js';
 import * as installed_lock from './_lib/installed_lock.js';
+import * as scoped_projection from './_lib/scoped_projection.js';
 import * as surface_tiers from './_lib/surface_tiers.js';
 import * as global_deploy_inventory from './_lib/global_deploy_inventory.js';
 import * as installed_tools from './_lib/installed_tools.js';
@@ -3344,89 +3345,16 @@ function _prune_lab_modules(
 // `requires` graph). Mirrors the core-only lab prune above — same
 // `_prune_modules_by` mechanics, a different predicate.
 
-/** `workspaces` values whose packs are ALWAYS active under `scoped` mode. */
-const SCOPED_ACTIVE_WORKSPACES: ReadonlySet<string> = new Set(['engineering', 'agent-config-maintainer']);
-
-interface PackRecord {
-    id: string;
-    workspaces: string[];
-    requires: string[];
-}
-
-/**
- * Parse `src/config/discovery/packs.yml` into `{id, workspaces, requires}`
- * records. `requires` falls back to the legacy `requires_hint` field name
- * when `requires` is absent.
- *
- * Deliberately THROWS on a missing file or a parse result that is not a
- * list — an empty active-pack set would be the LEAST safe fallback here
- * (it would prune every tagged artefact, the opposite of the fail-safe
- * contract). The caller wraps this in a try/catch that restores the full
- * tree on any error instead.
- */
-function _load_packs_registry(package_root: string): PackRecord[] {
-    const vocab_path = path.join(package_root, 'src', 'config', 'discovery', 'packs.yml');
-    const data = yamlSafeLoad(readText(vocab_path));
-    if (!Array.isArray(data)) {
-        throw new Error(`packs.yml did not parse to a list: ${vocab_path}`);
-    }
-    const out: PackRecord[] = [];
-    for (const entry of data) {
-        if (!_isPlainObject(entry)) continue;
-        const id = entry['id'];
-        if (typeof id !== 'string' || id === '') continue;
-        const workspaces_raw = entry['workspaces'];
-        const workspaces = Array.isArray(workspaces_raw)
-            ? workspaces_raw.filter((w): w is string => typeof w === 'string')
-            : [];
-        const requires_raw = entry['requires'] ?? entry['requires_hint'];
-        const requires = Array.isArray(requires_raw)
-            ? requires_raw.filter((r): r is string => typeof r === 'string')
-            : [];
-        out.push({ id, workspaces, requires });
-    }
-    return out;
-}
-
-/**
- * Active pack id set for `scoped` mode: every pack whose `workspaces`
- * intersects `SCOPED_ACTIVE_WORKSPACES`, unioned with `runtime_active_packs`,
- * expanded over the `requires` graph (transitive closure).
+/*
+ * The scoped-projection predicate lives in `_lib/scoped_projection.ts` so the
+ * installer and `count_scoped_projection.ts` — which produces the number the
+ * claims ledger publishes — run the SAME code rather than the same rule
+ * written twice. Re-exported under the existing private names to keep the
+ * prune tests' import surface unchanged.
  */
-function _compute_active_pack_ids(
-    packs: readonly PackRecord[],
-    runtime_active_packs: readonly string[],
-): Set<string> {
-    const by_id = new Map<string, PackRecord>();
-    for (const p of packs) by_id.set(p.id, p);
-
-    const active = new Set<string>();
-    for (const p of packs) {
-        if (p.workspaces.some((w) => SCOPED_ACTIVE_WORKSPACES.has(w))) {
-            active.add(p.id);
-        }
-    }
-    for (const id of runtime_active_packs) {
-        active.add(id);
-    }
-
-    let frontier = [...active];
-    while (frontier.length > 0) {
-        const next: string[] = [];
-        for (const id of frontier) {
-            const rec = by_id.get(id);
-            if (rec === undefined) continue;
-            for (const dep of rec.requires) {
-                if (!active.has(dep)) {
-                    active.add(dep);
-                    next.push(dep);
-                }
-            }
-        }
-        frontier = next;
-    }
-    return active;
-}
+type PackRecord = scoped_projection.PackRecord;
+const _load_packs_registry = scoped_projection.load_packs_registry;
+const _compute_active_pack_ids = scoped_projection.compute_active_pack_ids;
 
 /**
  * Read the GLOBAL settings document that governs a global deploy, if one
@@ -3574,14 +3502,9 @@ function _prune_scoped_modules(
     deploy_results: Record<string, DeployResult>,
     active_ids: ReadonlySet<string>,
 ): [number, Record<string, DeployResult>] {
-    return _prune_modules_by(deploy_results, (p) => {
-        const packs = surface_tiers.frontmatter_packs(p);
-        if (packs.size === 0) return false;
-        for (const id of packs) {
-            if (active_ids.has(id)) return false;
-        }
-        return true;
-    });
+    return _prune_modules_by(deploy_results, (p) =>
+        scoped_projection.is_pruned_under_scoped(p, active_ids),
+    );
 }
 
 function install_global(

package/src/scripts/lint_agent_security.ts

@@ -23,10 +23,10 @@
  * Usage:
  *   ./scripts-run src/scripts/lint_agent_security [--sarif artifacts/agent-security.sarif]
  */
-import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { runCountedProbe } from "./_lib/counted_probe.js";
 
 const _HERE = path.dirname(fileURLToPath(import.meta.url));
 
@@ -54,9 +54,10 @@ function _run(script: string): [number, Finding[]] {
   // (capture_output=True, text=True equivalent). Mirrors the retired Python implementation's
   // `subprocess.run([sys.executable, HERE/<child>.py, "--json"])`, now that the
   // children are TypeScript and the `.py` originals are deleted.
-  const proc = spawnSync(tsxBin, [path.join(_HERE, script), "--json"], {
-    encoding: "utf-8",
-  });
+  // Bounded read: a truncated `--json` payload would fail to parse and be
+  // swallowed as zero findings — a security aggregate reporting clean because
+  // it lost the answer. `runCountedProbe` throws on overflow instead.
+  const proc = runCountedProbe(tsxBin, [path.join(_HERE, script), "--json"]);
   let findings: Finding[];
   try {
     const parsed: unknown = JSON.parse((proc.stdout ?? "") || "[]");

package/src/scripts/lint_framework_leakage_allowlist.json

@@ -93,8 +93,8 @@
     {
       "file": "src/skills/supply-chain-intake/SKILL.md",
       "lines": [
-        70,
-        72
+        80,
+        82
       ],
       "reason": "Per-ecosystem check commands in fenced blocks; the pip/composer siblings sit farther apart than the ±10-line window — genuine multi-ecosystem documentation."
     },

package/src/scripts/lint_regression.ts

@@ -64,6 +64,65 @@ const STATUS_ORDER: Record<string, number> = { pass: 0, pass_with_warnings: 1, f
  * baseline worktree-add failure (→ exit 2 in main). */
 class CalledProcessError extends Error {}
 
+/** The baseline ran but produced nothing usable (→ exit 2 in main).
+ *
+ * Distinct from the two DOCUMENTED empty-baseline degradations (no linter file
+ * in the ref; a pre-migration `.py` baseline with no python3). Those are
+ * deliberate. This one is a broken run, and returning an empty baseline for it
+ * silently reclassifies every existing finding as a "new file" — the gate then
+ * fires on an unmodified tree and can never report a real regression, because a
+ * regression needs the file present in both maps. */
+class BaselineCollectionError extends Error {}
+
+/** Give the detached baseline worktree a resolvable module context.
+ *
+ * `git worktree add` checks out tracked files only, so the temp tree has no
+ * `node_modules` and the linter dies on its first bare import. Symlinking the
+ * repo's own install is enough — the baseline runs the ref's linter source
+ * against the ref's artefacts; only the dependency resolution is borrowed. */
+function _link_node_modules(tmpdir: string, repo_root: string): void {
+    const target = path.join(repo_root, 'node_modules');
+    const link = path.join(tmpdir, 'node_modules');
+    if (fs.existsSync(link) || !fs.existsSync(target)) {
+        return;
+    }
+    try {
+        fs.symlinkSync(target, link, 'dir');
+    } catch {
+        // Non-fatal here: a failed link surfaces as a failed baseline run
+        // below, which raises with the real cause rather than degrading.
+    }
+}
+
+/** Re-root the baseline's file keys onto the repo-relative paths the working-tree
+ * run emits.
+ *
+ * The baseline runs with `--repo-root <tmpdir>` and reports absolute paths under
+ * that temp worktree; the working-tree run reports paths relative to the repo.
+ * Left as-is the two maps share no key, so every comparison is vacuous — the
+ * disjoint guard would reject the run outright once the baseline is non-empty. */
+function _relativise(data: LinterJson, tmpdir: string): LinterJson {
+    const roots = new Set<string>([tmpdir]);
+    try {
+        roots.add(fs.realpathSync(tmpdir));
+    } catch {
+        /* the temp dir is about to be removed; the literal prefix still applies */
+    }
+    const strip = (f: string): string => {
+        for (const r of roots) {
+            const prefix = r.endsWith(path.sep) ? r : r + path.sep;
+            if (f.startsWith(prefix)) {
+                return f.slice(prefix.length);
+            }
+        }
+        return f;
+    };
+    return {
+        ...data,
+        results: (data.results ?? []).map((e) => ({ ...e, file: strip(e.file) })),
+    };
+}
+
 /** Run the linter and return parsed JSON. If ref is null, run on working tree.
  *
  * Mirrors `run_linter_json`: for a ref, add a detached temp worktree, run the
@@ -91,6 +150,7 @@ function run_linter_json(ref: string | null, repo_root: string): LinterJson {
             );
         }
         try {
+            _link_node_modules(tmpdir, repo_root);
             // The baseline ref may be pre-migration (`.py`, run via python3) or
             // post-migration (`.ts`, run via tsx). Probe both extensions in both
             // locations and spawn by extension. A historical `.py` ref genuinely
@@ -139,7 +199,17 @@ function run_linter_json(ref: string | null, repo_root: string): LinterJson {
                       encoding: 'utf8',
                   });
             const out = result.stdout ?? '';
-            return out.trim() ? (JSON.parse(out) as LinterJson) : { results: [], summary: {} };
+            if (!out.trim()) {
+                const why =
+                    result.status === 0
+                        ? 'it exited 0 but printed nothing'
+                        : `it exited ${result.status ?? 'null'}`;
+                throw new BaselineCollectionError(
+                    `the baseline linter for '${ref}' produced no output — ${why}.\n` +
+                        `stderr: ${(result.stderr ?? '').trim().split('\n').slice(-6).join('\n')}`,
+                );
+            }
+            return _relativise(JSON.parse(out) as LinterJson, tmpdir);
         } finally {
             spawnSync('git', ['-C', repo_root, 'worktree', 'remove', '--force', tmpdir], {
                 encoding: 'utf8',
@@ -433,6 +503,10 @@ function main(): number {
             );
             return 2;
         }
+        if (e instanceof BaselineCollectionError) {
+            process.stderr.write(`Error: ${e.message}\n`);
+            return 2;
+        }
         throw e;
     }
 
@@ -454,6 +528,22 @@ function main(): number {
         return 2;
     }
 
+    // The same guard's blind spot: an EMPTY baseline against a populated
+    // current tree is not comparable either, and it is the worse failure —
+    // every existing finding is then reported as a "new file", so the gate
+    // fires on an unmodified tree and no real regression can ever surface.
+    // The documented empty-baseline degradations (no linter in the ref; a
+    // pre-migration `.py` baseline with no python3) print their own warning
+    // above and land here on purpose.
+    if (!baseKeys.length && currKeys.length) {
+        process.stderr.write(
+            `Error: the baseline '${args.baseline}' produced no lint results while the ` +
+                `current tree produced ${currKeys.length} — runs are not comparable; ` +
+                'refusing to report. Every finding would be misreported as new.\n',
+        );
+        return 2;
+    }
+
     const delta = compare(baseline_map, current_map);
 
     if (args.format === 'json') {
@@ -528,4 +618,5 @@ export {
     format_text,
     format_markdown,
     main,
+    _relativise,
 };

package/src/scripts/lint_skill_descriptions.ts

@@ -18,11 +18,32 @@
  *                            (em-dash / colon / comma list), no quoted example,
  *                            no imperative-verb lead. A bare topic restatement.
  *
- * (d) is signal-ABSENCE, not a phrase mandate: an imperative house-style
+ * (a)–(d) are signal-ABSENCE checks over every skill: an imperative house-style
  * description ("Writes Laravel PHP — Eloquent, Artisan …") carries routing
  * signal and passes. The farm-generator's name-echo frontmatter is the
  * must-fail specimen.
  *
+ * Two further checks are POSITIVE — they demand something be present — and are
+ * therefore scoped to CLUSTERED skills only (road-to-overlap-truth-and-skill-cut
+ * Phase 5):
+ *
+ *   (e) clustered-no-sibling-routing — the canonical overlap tool pairs this
+ *                            skill with a same-pack sibling at >= the canonical
+ *                            threshold, and the description never names that
+ *                            sibling. Two skills the router cannot tell apart,
+ *                            neither of which says which one loses.
+ *   (f) clustered-no-quoted-phrase — same cluster condition, and the description
+ *                            carries no quoted literal user phrase. In a cluster,
+ *                            the user's own words are the only tie-break the
+ *                            router gets.
+ *
+ * The cluster condition is what keeps these honest. A quoted-phrase mandate
+ * across all ~287 skills is noise, not routing — it would fire on skills with no
+ * neighbour to be confused with. Today the cluster set is EMPTY (the corpus has
+ * no same-pack pair at or above threshold), so (e) and (f) are dormant by
+ * construction and wake up exactly when a new skill lands close to an existing
+ * one. That is the point.
+ *
  * Deterministic, static-config only. Allowlist mirrors lint_skill_originality:
  * `lint_skill_descriptions_allowlist.json`, capped at 20 (autonomous-execution
  * allowlist-growth antipattern — over-cap means the linter is wrong).
@@ -39,6 +60,7 @@ import * as path from 'node:path';
 import process from 'node:process';
 import { fileURLToPath } from 'node:url';
 
+import { OVERLAP_THRESHOLD, _cosine, collect } from './audit_skill_overlap.js';
 import { parse_frontmatter } from './skill_overlap.js';
 
 const _HERE = fileURLToPath(import.meta.url);
@@ -57,10 +79,54 @@ const IMPERATIVE_LEAD_RE =
 
 interface Violation {
     slug: string;
-    code: 'desc-equals-name' | 'duplicated-trigger' | 'triggers-are-name' | 'no-routing-signal';
+    code:
+        | 'desc-equals-name'
+        | 'duplicated-trigger'
+        | 'triggers-are-name'
+        | 'no-routing-signal'
+        | 'clustered-no-sibling-routing'
+        | 'clustered-no-quoted-phrase';
     detail: string;
 }
 
+/** A quoted literal phrase — `'expand this scene'` / `"film-grade scene"`. */
+const QUOTED_PHRASE_RE = /['"`][^'"`]{3,}['"`]/;
+
+/**
+ * Same-pack neighbours at or above the canonical overlap threshold, keyed by
+ * directory slug.
+ *
+ * Uses the canonical instrument, not a second implementation — one metric, one
+ * threshold, one answer. Cross-pack pairs are excluded for the same reason a
+ * cross-pack merge is out of scope: they do not compete for the same install.
+ */
+function computeClusters(root: string, threshold: number = OVERLAP_THRESHOLD): Map<string, string[]> {
+    const clusters = new Map<string, string[]>();
+    const skills = collect(root).map((s) => ({
+        slug: path.basename(path.dirname(s.relpath)),
+        packs: s.packs,
+        vector: s.vector,
+    }));
+    for (let i = 0; i < skills.length; i += 1) {
+        for (let j = i + 1; j < skills.length; j += 1) {
+            const a = skills[i]!;
+            const b = skills[j]!;
+            let sharesPack = false;
+            for (const p of a.packs) {
+                if (b.packs.has(p)) {
+                    sharesPack = true;
+                    break;
+                }
+            }
+            if (!sharesPack) continue;
+            if (_cosine(a.vector, b.vector) < threshold) continue;
+            clusters.set(a.slug, [...(clusters.get(a.slug) ?? []), b.slug]);
+            clusters.set(b.slug, [...(clusters.get(b.slug) ?? []), a.slug]);
+        }
+    }
+    return clusters;
+}
+
 /** A description carries routing signal if it names a condition, leads with an
  * imperative verb, enumerates specifics (em-dash / colon / ≥2 comma segments),
  * or embeds an example query (a quoted phrase). Absence of all four is the defect. */
@@ -89,7 +155,7 @@ function triggerPhrases(desc: string): string[] {
         .filter((p) => p.length >= 3);
 }
 
-function analyseSkill(slug: string, fm: Record<string, string>): Violation[] {
+function analyseSkill(slug: string, fm: Record<string, string>, siblings: readonly string[] = []): Violation[] {
     const out: Violation[] = [];
     const name = fm['name'] ?? slug;
     const desc = (fm['description'] ?? '').trim();
@@ -137,6 +203,25 @@ function analyseSkill(slug: string, fm: Record<string, string>): Violation[] {
         });
     }
 
+    // (e) + (f) fire ONLY for skills the canonical tool put in a cluster.
+    if (siblings.length > 0) {
+        const unrouted = siblings.filter((s) => !desc.includes(s));
+        if (unrouted.length > 0) {
+            out.push({
+                slug,
+                code: 'clustered-no-sibling-routing',
+                detail: `overlaps ${unrouted.map((s) => `\`${s}\``).join(', ')} at or above the canonical threshold, but the description never names ${unrouted.length === 1 ? 'it' : 'them'} — add a sibling-routing clause so the router knows which one loses`,
+            });
+        }
+        if (!QUOTED_PHRASE_RE.test(desc)) {
+            out.push({
+                slug,
+                code: 'clustered-no-quoted-phrase',
+                detail: `clustered with ${siblings.map((s) => `\`${s}\``).join(', ')} but carries no quoted literal user phrase — in a cluster the user's own words are the tie-break`,
+            });
+        }
+    }
+
     return out;
 }
 
@@ -192,13 +277,14 @@ function parseArgs(argv: string[]): Args {
 function main(argv: string[]): number {
     const args = parseArgs(argv);
     const allow = loadAllowlist();
+    const clusters = computeClusters(args.root);
     const violations: Violation[] = [];
     let scanned = 0;
     for (const md of skillMds(args.root)) {
         scanned += 1;
         const slug = path.basename(path.dirname(md));
         const [fm] = parse_frontmatter(fs.readFileSync(md, 'utf-8'));
-        for (const v of analyseSkill(slug, fm)) {
+        for (const v of analyseSkill(slug, fm, clusters.get(slug) ?? [])) {
             if (!allow.has(`${v.slug}::${v.code}`)) violations.push(v);
         }
     }
@@ -216,7 +302,9 @@ function main(argv: string[]): number {
         return 1;
     }
     if (!args.quiet) {
-        process.stdout.write(`✅  lint_skill_descriptions: ${scanned} skill(s) scanned, no description defects.\n`);
+        process.stdout.write(
+            `✅  lint_skill_descriptions: ${scanned} skill(s) scanned (${clusters.size} clustered), no description defects.\n`,
+        );
     }
     return 0;
 }

package/src/scripts/project_thin_rules.ts

@@ -155,8 +155,8 @@ const _TRIGGER_HINT_LIMIT = 6;
 /** A short, comma-joined sample of the rule's trigger keywords/phrases. */
 function _trigger_hint(fm: string): string {
     const hits: string[] = [];
-    // re.finditer(r'^\s*-\s*(?:keyword|phrase|intent):\s*"?(.+?)"?\s*$', fm, re.MULTILINE)
-    const re = /^\s*-\s*(?:keyword|phrase|intent):\s*"?(.+?)"?\s*$/gm;
+    // re.finditer(r'^\s*-\s*(?:keyword|phrase):\s*"?(.+?)"?\s*$', fm, re.MULTILINE)
+    const re = /^\s*-\s*(?:keyword|phrase):\s*"?(.+?)"?\s*$/gm;
     let m: RegExpExecArray | null;
     while ((m = re.exec(fm)) !== null) {
         hits.push((m[1] as string).trim());