@event4u/agent-config 9.13.0 → 9.15.0

package/src/scripts/lint_pack_dependencies.ts

@@ -25,10 +25,10 @@ import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { parse as parseYaml } from "yaml";
 import { SRC_AGENT, iter_all_sources } from "./_lib/agent_src.js";
+import { DeadScopeError, assertScanned } from "./_lib/scan_scope.js";
 
 // src/scripts/lint_pack_dependencies.ts → two levels up is the repo root.
 const REPO = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
-const PACKAGES = path.join(REPO, "packages");
 const SRC_DOMAINS = path.join(REPO, "src", "domains");
 const SRC_PACKS = path.join(REPO, "src", "packs");
 const PACKAGE_JSON = path.join(REPO, "package.json");
@@ -102,16 +102,7 @@ function _gpm_read_frontmatter(p: string): YamlObject {
   return isObject(data) ? data : {};
 }
 
-function _gpm_pack_id_from_dir(pkgDir: string): string {
-  const name = path.basename(pkgDir);
-  return name === "core" ? "core" : removePrefix(name, "pack-");
-}
-
-function removePrefix(s: string, prefix: string): string {
-  return s.startsWith(prefix) ? s.slice(prefix.length) : s;
-}
-
-type PackHome = [string, string, "core" | "flat" | "physical"];
+type PackHome = [string, string, "core" | "flat"];
 
 function _gpm_pack_homes(): PackHome[] {
   const homes: PackHome[] = [];
@@ -137,20 +128,6 @@ function _gpm_pack_homes(): PackHome[] {
       seen.add(pid);
     }
   }
-  if (_exists(PACKAGES)) {
-    for (const pkg of sortedDirEntries(PACKAGES)) {
-      const full = path.join(PACKAGES, pkg);
-      if (!_isDir(full)) {
-        continue;
-      }
-      const pid = _gpm_pack_id_from_dir(full);
-      if (seen.has(pid)) {
-        continue;
-      }
-      homes.push([pid, full, "physical"]);
-      seen.add(pid);
-    }
-  }
   return homes;
 }
 
@@ -246,25 +223,6 @@ function asStringList(v: YamlValue | undefined): string[] {
   return v.filter((x): x is string => typeof x === "string");
 }
 
-function _gpm_collect_physical(pkgDir: string): ArtefactRecord[] {
-  const srcRoot = path.join(pkgDir, ".agent-src.uncondensed");
-  if (!_isDir(srcRoot)) {
-    return [];
-  }
-  const items: ArtefactRecord[] = [];
-  for (const p of rglobMd(srcRoot)) {
-    if (!_isFile(p)) {
-      continue;
-    }
-    const fm = _gpm_read_frontmatter(p);
-    if (Object.keys(fm).length === 0) {
-      continue;
-    }
-    items.push(_gpm_artefact_record(p, relPosix(p, srcRoot), fm));
-  }
-  return items;
-}
-
 function _gpm_collect_core(): ArtefactRecord[] {
   const items: ArtefactRecord[] = [];
   const seen = new Set<string>();
@@ -314,15 +272,11 @@ function _gpm_collect_flat(pid: string): ArtefactRecord[] {
 
 function _gpm_collect_artefacts(
   pid: string,
-  homeDir: string,
-  mode: "core" | "flat" | "physical",
+  mode: "core" | "flat",
 ): ArtefactRecord[] {
   if (mode === "core") {
     return _gpm_collect_core();
   }
-  if (mode === "physical") {
-    return _gpm_collect_physical(homeDir);
-  }
   return _gpm_collect_flat(pid);
 }
 
@@ -379,7 +333,7 @@ function _dependency_drift(): string[] {
     if (!_exists(manifest)) {
       continue;
     }
-    const artefacts = _gpm_collect_artefacts(pid, homeDir, mode);
+    const artefacts = _gpm_collect_artefacts(pid, mode);
     const expected = _gpm_build_dependencies(artefacts);
     let onDisk: YamlObject;
     try {
@@ -489,12 +443,23 @@ function _find_cycle(graph: Map<string, Set<string>>): string[] | null {
 }
 
 export function main(): number {
-  // Gate on the resolved home set, not on packages/ existing.
-  if (_gpm_pack_homes().length === 0) {
-    process.stdout.write(
-      "no pack homes (src/packs, src/domains, packages/) — nothing to lint\n",
-    );
-    return 0;
+  // Scope assertion: zero resolved pack homes means both roots moved, not that
+  // every pack is in sync. The previous soft skip printed a green line in
+  // exactly that state — the defect class this gate is being hardened against.
+  const homes = _gpm_pack_homes();
+  try {
+    assertScanned({
+      gate: "lint_pack_dependencies",
+      scanned: homes.length,
+      units: "pack home(s)",
+      roots: ["src/packs", "src/domains"],
+    });
+  } catch (exc) {
+    if (!(exc instanceof DeadScopeError)) {
+      throw exc;
+    }
+    process.stderr.write(`❌  ${exc.message}\n`);
+    return 2;
   }
   const errors = _dependency_drift();
   const cycle = _find_cycle(_pack_requires_graph());
@@ -510,7 +475,9 @@ export function main(): number {
     process.stderr.write(`\n${errors.length} pack-dependency violation(s).\n`);
     return 1;
   }
-  process.stdout.write("✅  pack dependencies in sync; pack-graph is acyclic.\n");
+  process.stdout.write(
+    `✅  pack dependencies in sync; pack-graph is acyclic (${homes.length} pack home(s) scanned).\n`,
+  );
   return 0;
 }
 

package/src/scripts/lint_persona_governance.ts

@@ -9,7 +9,7 @@
  * stderr), exit codes. Historical quirks are preserved deliberately — tests and downstream consumers pin the exact behaviour.
  *
  * Enforces the mechanical checks in
- * `.agent-src.uncondensed/rules/persona-governance.md`:
+ * `src/rules/persona-governance.md`:
  *
  *   1. Per-domain cap (HARD) — ≤ 2 active specialist personas per domain.
  *   2. Skill citation floor (WARN) — every active specialist persona SHOULD

package/src/scripts/lint_role_experiences.ts

@@ -18,14 +18,24 @@ import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { parse as parseYaml } from 'yaml';
 
+import { SRC_SKILLS } from './_lib/agent_src.js';
+import { DeadScopeError, assertScanned } from './_lib/scan_scope.js';
+
 const _HERE = fileURLToPath(import.meta.url);
 
 const ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 const ROLES_DIR = path.join(ROOT, 'agents', 'roles');
-const SKILL_SOURCES = [
-    path.join(ROOT, '.agent-src.uncondensed', 'skills'),
-    path.join(ROOT, 'dist/agent-src', 'skills'),
-];
+/**
+ * Where a referenced skill slug may be resolved, in precedence order.
+ *
+ * The first entry used to be the pre-ADR-051 source container, which has not
+ * existed since the move — so on a checkout with no built `dist/`,
+ * `all_skills()` returned an EMPTY set and every `skills.yml` reference
+ * resolved against nothing. `src/skills` is the source of truth; the `dist/`
+ * projection stays as a second source so the gate also works from an
+ * installed tree.
+ */
+const SKILL_SOURCES = [SRC_SKILLS(), path.join(ROOT, 'dist/agent-src', 'skills')];
 
 const REQUIRED_INDEX_KEYS = new Set([
     'role',
@@ -260,6 +270,23 @@ function main(argv?: readonly string[]): number {
     }
 
     const knownSkills = all_skills();
+    // Scope assertion: an empty skill index is not "no unknown skills" — it
+    // means both sources moved, and every `skills.yml` reference is then
+    // checked against nothing.
+    try {
+        assertScanned({
+            gate: 'lint_role_experiences',
+            scanned: knownSkills.size,
+            units: 'known skill(s)',
+            roots: SKILL_SOURCES.map((s) => path.relative(ROOT, s).split(path.sep).join('/')),
+        });
+    } catch (exc) {
+        if (!(exc instanceof DeadScopeError)) {
+            throw exc;
+        }
+        process.stderr.write(`❌  ${exc.message}\n`);
+        return 2;
+    }
     const failures: string[] = [];
     for (const name of _iterdir(ROLES_DIR).sort()) {
         const roleDir = path.join(ROLES_DIR, name);
@@ -279,7 +306,9 @@ function main(argv?: readonly string[]): number {
         process.stdout.write(`\nlint_role_experiences: ${failures.length} failure(s)\n`);
         return 1;
     }
-    process.stdout.write('✅ lint_role_experiences: all role experiences pass\n');
+    process.stdout.write(
+        `✅ lint_role_experiences: all role experiences pass (${knownSkills.size} known skill(s) indexed)\n`,
+    );
     return 0;
 }
 

package/src/scripts/lint_trigger_precision.ts

@@ -0,0 +1,142 @@
+#!/usr/bin/env tsx
+/**
+ * Trigger-precision budget (road-to-renewal-foundation Phase 3, step 2).
+ *
+ * ## The defect this measures
+ *
+ * Every `keyword` trigger is matched as an UNANCHORED, case-insensitive
+ * substring of the prompt (`router_telemetry.ts::trigger_matches`). A short
+ * keyword therefore fires on words that merely contain it: `AC` fired
+ * `cross-source-consistency` on "black", "back", "contact"; `CAC` fired the
+ * finance floor on "cache". The shorter the keyword, the more of the English
+ * language it claims.
+ *
+ * ## Why a COUNT ratchet and not a rewrite
+ *
+ * The obvious repair — "promote the noisy keywords to `phrase:`" — is a
+ * NO-OP: `keyword` and `phrase` run the same substring comparison
+ * (`router_telemetry.ts` lines for both branches are identical), so the two
+ * kinds differ in documentation only. The other obvious repair — anchoring
+ * `keyword` on word boundaries — is the real fix, but it changes shipped
+ * activation semantics for all 316 single-token keywords at once and belongs
+ * in its own change with its own before/after (recorded as the reopen term in
+ * the Phase 3 pre-registration).
+ *
+ * So this gate does the one thing that is both safe and durable: it fixes the
+ * population in place. Short keywords that exist today are recorded; a NEW one
+ * cannot land. Every removal is a normal commit that lowers the number.
+ *
+ * ## Scope of "short"
+ *
+ * ASCII keywords of ≤ 3 characters. Non-ASCII short keywords are excluded by
+ * construction: the eight emoji triggers on
+ * `no-decorative-emojis-in-git-surfaces` are one code point each and cannot
+ * collide with prose substrings, so counting them would be noise.
+ *
+ * A pure length rule is deliberate. A collision count against a system word
+ * list would be sharper but is not portable (no dictionary on a CI runner),
+ * and an embedded word list is a second source of truth to maintain.
+ *
+ * Exit: 0 within budget · 1 usage/IO error · 2 over budget.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const _HERE = fileURLToPath(import.meta.url);
+const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+const ROUTER = path.join(REPO_ROOT, 'dist', 'router.json');
+
+/**
+ * Ratchet, seeded 2026-08-02 at the measured population after removing the
+ * two provably redundant entries (`AC`, already covered by the
+ * `acceptance criteria` keyword on the same rule; `CAC`, which collided with
+ * "cache" while `LTV` and `payback` already carry the unit-economics signal).
+ * MAY ONLY MOVE DOWN.
+ */
+export const SHORT_KEYWORD_BUDGET = 22;
+
+export interface ShortKeyword {
+    keyword: string;
+    rule: string;
+    tier: string;
+}
+
+interface RouterRule {
+    id: string;
+    triggers?: Array<Record<string, unknown>>;
+}
+
+/** Every ASCII `keyword` trigger of ≤ 3 characters, sorted for stable output. */
+export function short_keywords(router: Record<string, unknown>): ShortKeyword[] {
+    const out: ShortKeyword[] = [];
+    for (const tier of ['tier_1', 'tier_2']) {
+        const entries = router[tier];
+        if (!Array.isArray(entries)) continue;
+        for (const raw of entries) {
+            const rule = raw as RouterRule;
+            for (const trigger of rule.triggers ?? []) {
+                if (!('keyword' in trigger)) continue;
+                const keyword = String(trigger['keyword']);
+                const ascii = [...keyword].every((c) => c.codePointAt(0)! < 128);
+                if (keyword.length <= 3 && ascii) {
+                    out.push({ keyword, rule: rule.id, tier });
+                }
+            }
+        }
+    }
+    out.sort(
+        (a, b) =>
+            (a.keyword < b.keyword ? -1 : a.keyword > b.keyword ? 1 : 0) ||
+            (a.rule < b.rule ? -1 : a.rule > b.rule ? 1 : 0),
+    );
+    return out;
+}
+
+export function main(): number {
+    if (!fs.existsSync(ROUTER)) {
+        process.stderr.write(
+            `error: ${path.relative(REPO_ROOT, ROUTER)} not found — run \`task sync\` first\n`,
+        );
+        return 1;
+    }
+    let router: Record<string, unknown>;
+    try {
+        router = JSON.parse(fs.readFileSync(ROUTER, 'utf-8')) as Record<string, unknown>;
+    } catch (e) {
+        process.stderr.write(`error: cannot parse router.json (${String(e)})\n`);
+        return 1;
+    }
+
+    const found = short_keywords(router);
+    const over = found.length > SHORT_KEYWORD_BUDGET;
+
+    if (over) {
+        process.stdout.write(
+            `❌  trigger precision: ${found.length} short (≤3 char) keyword triggers > budget ${SHORT_KEYWORD_BUDGET}\n`,
+        );
+        for (const s of found) {
+            process.stdout.write(`      ${s.keyword.padEnd(6)} ${s.rule}  [${s.tier}]\n`);
+        }
+        process.stdout.write(
+            '\n    A short keyword is matched as an unanchored substring, so it fires on\n' +
+                '    every word that merely contains it. Lengthen it into an unambiguous\n' +
+                '    string, or drop it when a longer trigger on the same rule already\n' +
+                '    carries the signal. Raising SHORT_KEYWORD_BUDGET is not the fix.\n',
+        );
+        return 2;
+    }
+
+    process.stdout.write(
+        `✅  trigger precision: ${found.length} short (≤3 char) keyword triggers ` +
+            `/ budget ${SHORT_KEYWORD_BUDGET}` +
+            (found.length < SHORT_KEYWORD_BUDGET
+                ? ` — lower the budget to ${found.length} to lock the gain in\n`
+                : '\n'),
+    );
+    return 0;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    process.exit(main());
+}

package/src/scripts/mcp_server/consumer_tool_catalog.json

@@ -30,81 +30,21 @@
       "description": "[stub — implemented on demand] Return the metadata for one catalog entry by id (id, class, name, description, tags, path). Body is returned ONLY when include_body is true. Use after catalog_search to look at a candidate before loading it. Read-only. Activation deferred (see catalog_search).",
       "side_effect": "ro",
       "implemented_on": [],
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "id": {
-            "type": "string",
-            "description": "Catalog id, e.g. `skill:api-design` or `persona:backend-architect`."
-          },
-          "include_body": {
-            "type": "boolean",
-            "default": false,
-            "description": "When true, include the full body. Defaults to false (metadata only)."
-          }
-        },
-        "required": [
-          "id"
-        ],
-        "additionalProperties": false
-      }
+      "input_schema": {}
     },
     {
       "name": "catalog_load",
       "description": "[stub — implemented on demand] Load the full body of one catalog entry by id, wrapped in a neutral reference preamble that subordinates it to the user's request and system instructions. Use to bring a skill/persona/command body into context on demand. Read-only, path-confined to the package root. Never injects or acts — the host decides what to do with the body. Activation deferred (see catalog_search).",
       "side_effect": "ro",
       "implemented_on": [],
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "id": {
-            "type": "string",
-            "description": "Catalog id to load the body for."
-          }
-        },
-        "required": [
-          "id"
-        ],
-        "additionalProperties": false
-      }
+      "input_schema": {}
     },
     {
       "name": "catalog_search",
       "description": "[stub — implemented on demand] Search the package's own artifact catalog (skills, personas, commands) by free-text query and return ranked summaries — name, description, tags, score — WITHOUT loading any body. Use to discover which skill or persona fits a task when the full catalog is not in context. Read-only, deterministic (BM25 over an on-disk index). Activation deferred behind a task-quality A/B (see catalog_tools.ts).",
       "side_effect": "ro",
       "implemented_on": [],
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "query": {
-            "type": "string",
-            "description": "Free-text search query."
-          },
-          "class": {
-            "type": "string",
-            "enum": [
-              "skill",
-              "persona",
-              "command"
-            ],
-            "description": "Optional: restrict to one artifact class."
-          },
-          "pack": {
-            "type": "string",
-            "description": "Optional: restrict to entries tagged with this pack/domain."
-          },
-          "limit": {
-            "type": "integer",
-            "minimum": 1,
-            "default": 8,
-            "description": "Maximum results. Defaults to 8."
-          }
-        },
-        "required": [
-          "query"
-        ],
-        "additionalProperties": false
-      }
+      "input_schema": {}
     },
     {
       "name": "chat_history_append",
@@ -216,17 +156,7 @@
       "description": "[stub — implemented on demand] Regenerate the compiled router (`router.compiled.json`) from the current rule, skill, and command frontmatter, so trigger-based routing reflects the latest artifacts. Use after adding or editing a rule / skill / command's trigger metadata. Shell-bound — wraps `scripts/compile_router.py` — and returns the regenerated router summary. Set `dry_run: true` to compute the result without writing the file.",
       "side_effect": "shell",
       "implemented_on": [],
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "dry_run": {
-            "type": "boolean",
-            "default": false,
-            "description": "When true, compute the router without writing `router.compiled.json` to disk."
-          }
-        },
-        "additionalProperties": false
-      }
+      "input_schema": {}
     },
     {
       "name": "conformance_check",
@@ -502,20 +432,7 @@
       "description": "[stub — implemented on demand] Extract reusable patterns, decisions, and learnings from a single chat-history session, as candidate memory entries. Use to distill a finished session into durable memory before it ages out. Read-only. Returns the mined candidates grouped by kind.",
       "side_effect": "ro",
       "implemented_on": [],
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "session": {
-            "type": "string",
-            "description": "Session id to mine."
-          },
-          "path": {
-            "type": "string",
-            "description": "Optional path to a chat-history JSONL; defaults to the standard location."
-          }
-        },
-        "additionalProperties": false
-      }
+      "input_schema": {}
     },
     {
       "name": "read_resource_body",
@@ -584,16 +501,7 @@
       "description": "[stub — implemented on demand] Run the consumer project's configured quality gate (PHPStan / Rector / ECS or the stack equivalent) and return a structured per-tool result. Use before committing to confirm static-analysis and style gates pass. Shell-bound. Pass `tool` to run a single gate; omit to run all.",
       "side_effect": "shell",
       "implemented_on": [],
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "tool": {
-            "type": "string",
-            "description": "Restrict to a single quality tool by name (e.g. phpstan, rector, ecs)."
-          }
-        },
-        "additionalProperties": false
-      }
+      "input_schema": {}
     },
     {
       "name": "run_tests",
@@ -625,115 +533,35 @@
       "description": "[stub — implemented on demand] Score a user message against the compiled router and return the skills whose triggers match, each with the reason it fired. Use to predict which skills a given message would activate, for debugging trigger coverage. Read-only and deterministic. Returns a ranked list of matching skills with their trigger reasons.",
       "side_effect": "ro",
       "implemented_on": [],
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "message": {
-            "type": "string",
-            "description": "The user message to score against skill triggers."
-          },
-          "context": {
-            "type": "string",
-            "description": "Optional recent-turn context to sharpen the match."
-          },
-          "limit": {
-            "type": "integer",
-            "minimum": 1,
-            "default": 5,
-            "description": "Maximum number of matching skills to return. Defaults to 5."
-          }
-        },
-        "required": [
-          "message"
-        ],
-        "additionalProperties": false
-      }
+      "input_schema": {}
     },
     {
       "name": "suggest_command",
       "description": "[stub — implemented on demand] Run the command-suggestion engine: score the available slash commands against a user message and context, and return a ranked, numbered-options block of the best matches. Use to recommend a command for a free-form request without invoking anything. Read-only and deterministic. Returns the formatted suggestion block plus the scored candidates.",
       "side_effect": "ro",
       "implemented_on": [],
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "message": {
-            "type": "string",
-            "description": "The user message to match commands against."
-          },
-          "context": {
-            "type": "string",
-            "description": "Optional recent-turn context to sharpen the match."
-          }
-        },
-        "required": [
-          "message"
-        ],
-        "additionalProperties": false
-      }
+      "input_schema": {}
     },
     {
       "name": "suggest_skill_for_task",
       "description": "[stub — implemented on demand] Match a free-form task description to the most relevant skills, ranked by their frontmatter triggers. Use to pick a skill for a described task before starting work. Read-only. Returns a ranked list of skills with name, description, and match reason.",
       "side_effect": "ro",
       "implemented_on": [],
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "task": {
-            "type": "string",
-            "description": "Free-form description of the task to find a skill for."
-          },
-          "limit": {
-            "type": "integer",
-            "minimum": 1,
-            "default": 5,
-            "description": "Maximum number of skills to return. Defaults to 5."
-          }
-        },
-        "required": [
-          "task"
-        ],
-        "additionalProperties": false
-      }
+      "input_schema": {}
     },
     {
       "name": "sync_agent_settings",
       "description": "[stub — implemented on demand] Synchronise `.agent-settings.yml` against the current template and active profile — add new sections and keys while preserving existing user values. Use after a package upgrade to pick up newly introduced settings. Edits the settings file and returns the keys that were (or would be) added. Set `dry_run: true` to preview.",
       "side_effect": "fs-write",
       "implemented_on": [],
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "profile": {
-            "type": "string",
-            "description": "Override the profile pinned in the settings file."
-          },
-          "dry_run": {
-            "type": "boolean",
-            "default": false,
-            "description": "When true, return the planned settings changes without writing the file."
-          }
-        },
-        "additionalProperties": false
-      }
+      "input_schema": {}
     },
     {
       "name": "sync_gitignore",
       "description": "[stub — implemented on demand] Synchronise the managed `event4u/agent-config` block in the consumer project's `.gitignore` — add missing canonical entries while preserving user-added lines. Use after upgrading the package or when generated paths are being tracked by mistake. Edits `.gitignore` and returns the added / removed entries. Set `dry_run: true` to preview the changes.",
       "side_effect": "fs-write",
       "implemented_on": [],
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "dry_run": {
-            "type": "boolean",
-            "default": false,
-            "description": "When true, return the planned `.gitignore` changes without writing the file."
-          }
-        },
-        "additionalProperties": false
-      }
+      "input_schema": {}
     },
     {
       "name": "telemetry_report",
@@ -763,24 +591,7 @@
       "description": "[stub — implemented on demand] Synchronise the `messages()` method of a Laravel FormRequest class: add entries for validation rules that lack a custom message, link them to translation keys, and drop stale ones. Use after changing a FormRequest's `rules()`. Edits the class file on disk and returns the planned or applied message changes. Set `dry_run: true` to preview the diff without writing.",
       "side_effect": "fs-write",
       "implemented_on": [],
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "request_class": {
-            "type": "string",
-            "description": "Fully-qualified FormRequest class FQN or repo-relative file path."
-          },
-          "dry_run": {
-            "type": "boolean",
-            "default": false,
-            "description": "When true, return the planned message changes without editing the file."
-          }
-        },
-        "required": [
-          "request_class"
-        ],
-        "additionalProperties": false
-      }
+      "input_schema": {}
     }
   ]
 }

package/src/scripts/mcp_server/tools.ts

@@ -233,7 +233,7 @@ function _chReadEntries(
  *
  * Arguments:
  *   paths: optional list of repo-relative paths to lint. Empty /
- *       missing → lint the full `.agent-src.uncondensed/` tree
+ *       missing → lint the full `src/` tree
  *       via `gather_all_candidate_files`.
  *
  * Never spawns `git` (no `--changed` mode); never writes; mirrors