@event4u/agent-config 14.17.0 → 14.19.0

package/src/config/release-gate-locality.yml

@@ -0,0 +1,141 @@
+# Release-gate locality registry
+#
+# WHY THIS FILE EXISTS
+#
+# `release-validation.yml` is the last gate a release passes and the first one
+# that costs something to fail: by the time it runs, a branch, a pull request
+# and a CI run already exist. Until 2026-09-05 nothing related its jobs to the
+# commands a maintainer can run BEFORE any of that leaves the machine, and the
+# result was a recurring failure shape rather than a one-off — 14.14.0 (PR
+# #1812) on the curated head, 14.17.0 (PR #1856) on the governance-mix
+# response. Both were discoverable locally in under two seconds. Neither was
+# discovered locally, because nothing asked.
+#
+# The registry is the relation the tree was missing. It is read by two
+# consumers, which is what keeps it from rotting into a comment:
+#
+#   1. `tests/scripts/release_gate_locality.test.ts` — every job in the
+#      workflow has a row, every row names a live job, every declared script
+#      exists, and every `local: ~` carries a reason with an approved prefix.
+#      A new release-validation job therefore cannot land without answering
+#      "and how does a maintainer run this before pushing?".
+#   2. `task release:verify` — runs every row marked `verify: true` against the
+#      working tree. That is the command the release pipeline points at, and
+#      the one to run before `task release`.
+#
+# WHAT A ROW MEANS
+#
+#   local:   the shell command that reproduces the job's assertion locally.
+#            `~` (null) means it genuinely cannot run before the PR exists.
+#   reason:  REQUIRED when `local` is null. Must start with one of
+#            NEEDS_PR: / NEEDS_ARTIFACT: / NEEDS_NETWORK: / NEEDS_TOKEN:
+#            so the cause is classified rather than merely narrated.
+#   verify:  whether `task release:verify` runs it. Cheap and deterministic
+#            rows are true; anything that packs or installs is false and stays
+#            opt-in.
+#   network: marks a row that leaves the machine. Excluded from `--cheap`,
+#            which is the set the release pipeline runs on its own, so a
+#            registry outage cannot read as a release defect.
+#   release_branch_only:
+#            the assertion only means anything on a `release/X.Y.Z` head.
+#            Skipped with a printed reason elsewhere — never silently, and
+#            never reported as a pass.
+#   script:  the implementing script, when the assertion lives in one. `~`
+#            marks an assertion that exists only as inline workflow YAML —
+#            which is itself the defect this column makes countable.
+#   guard:   the local guard site that ALSO refuses this, when one exists.
+#            A row with a guard fails before the push, not merely before CI.
+#   partial: REQUIRED when the `local` command reproduces only part of what the
+#            job asserts. Names the uncovered part. A row silently claiming
+#            full coverage it does not have is the defect this file exists to
+#            end, so the gap is written down rather than inferred.
+
+version: 1
+workflow: .github/workflows/release-validation.yml
+
+jobs:
+  release-shape:
+    local: 'git diff --name-only origin/main...HEAD | ./scripts-run src/scripts/check_release_pr_shape --files -'
+    verify: true
+    # The assertion is about a RELEASE PR's diff — every ordinary branch fails
+    # it by construction, so running it off a release branch would teach a
+    # maintainer to ignore this command's red. Skipped with a printed reason
+    # instead, which is the difference between a gate that is not applicable
+    # and one that passed.
+    release_branch_only: true
+    script: src/scripts/check_release_pr_shape.ts
+    guard: ~
+
+  changelog-entry:
+    # The job asserts three things: a heading for the head version, a non-empty
+    # body, and a `Tests: N (+M since PREV)` footer.
+    #
+    # `check_release_highlights` covers the first two — it exits 2 with
+    # "CHANGELOG carries no section for <v>". It does NOT read the footer, and
+    # saying otherwise here would be the exact defect this registry exists to
+    # end: a row asserting a coverage it does not have. The footer half is
+    # covered locally by the guard named below, not by the `local` command, so
+    # `partial` states that rather than leaving a reader to grep for it.
+    local: './scripts-run src/scripts/check_release_highlights --version ${VERSION}'
+    verify: true
+    partial: 'heading + non-empty body only; the `Tests: N` footer half is covered by the guard, not by this command'
+    script: ~
+    guard: guard_release_curation
+
+  surface-equality:
+    local: ~
+    reason: 'NEEDS_PR: compares the live PR body against the CHANGELOG section; there is no PR body before `gh pr create`. The body is DERIVED from that same section (`pr_body_from_section`), so the local half is the section check above.'
+    verify: false
+    script: src/scripts/check_release_surface_equality.ts
+    guard: ~
+
+  highlight-plausibility:
+    # The job that failed 14.17.0. All four sub-checks (authoring instruction,
+    # unrewritten derived marker, `_none_` contradiction, governance-mix
+    # response) run locally from local tags alone — no origin, no HEAD_REF.
+    local: './scripts-run src/scripts/check_release_highlights --version ${VERSION}'
+    verify: true
+    script: src/scripts/check_release_highlights.ts
+    guard: guard_release_branch_push
+
+  version-consistency:
+    local: './scripts-run src/scripts/check_template_pin_drift'
+    verify: true
+    script: src/scripts/check_template_pin_drift.ts
+    guard: ~
+
+  finding-dispositions:
+    local: './scripts-run src/scripts/check_finding_dispositions --release ${VERSION}'
+    verify: false
+    reason: 'NEEDS_PR: the unrecorded-findings half reads live PR review comments. The missing-dispositions half does run locally and is what the `local` command covers.'
+    script: src/scripts/check_finding_dispositions.ts
+    guard: ~
+
+  audit-gate:
+    local: 'npm audit --omit=dev --audit-level=high'
+    verify: true
+    # Reaches the registry, so it is excluded from the `--cheap` set the
+    # release pipeline runs unattended: a registry outage must not read as a
+    # release defect. `task release:verify` (no flag) still runs it.
+    network: true
+    script: ~
+    guard: ~
+
+  release-install-e2e:
+    local: ~
+    reason: 'NEEDS_ARTIFACT: needs a packed tarball plus a BASELINE_TARBALL of the upgrade-from version; runnable by hand as `bash tests/test_release_install_e2e.sh`, too slow for a pre-push gate.'
+    verify: false
+    script: ~
+    guard: ~
+
+  activation-census:
+    # The one row where the local command asserts MORE than the job it mirrors,
+    # not less, so `partial` does not apply: the transcript store the census
+    # reads is keyed on the directory it runs in and does not exist on a runner,
+    # so CI can only re-take an empty reading and check the published figure
+    # against its record. Run locally, the same command reads the real store,
+    # which is the only place the census means anything.
+    local: './scripts-run src/scripts/report_skill_activation && ./scripts-run src/scripts/check_skill_activation_claim'
+    verify: true
+    script: src/scripts/report_skill_activation.ts
+    guard: ~

package/src/scripts/_cli/cmd_doctor.ts

@@ -2881,7 +2881,7 @@ function _run_checks(
         'claude-command-wrappers': _check_claude_command_wrappers,
         'surface-state': _check_surface_state,
         'hook-wiring': _check_hook_wiring,
-        ...(runtime_wiring.wiringRunners({ packageRoot: _package_root(), iterOverrides: () => iter_setting_overrides({ cwd: project_root }) }) as unknown as Record<string, CheckRunner>),
+        ...(runtime_wiring.wiringRunners({ packageRoot: _package_root(), projectRoot: project_root, iterOverrides: () => iter_setting_overrides({ cwd: project_root }) }) as unknown as Record<string, CheckRunner>),
         ...(install_reach.reachRunners({ projectRoot: project_root, resolvableVersion: _current_package_version() }) as unknown as Record<string, CheckRunner>),
         'stale-orphans': _check_stale_orphans,
         overrides: () => _check_overrides(project_root),
@@ -2967,7 +2967,7 @@ function _run_checks_no_manifest(
         'claude-command-wrappers': _check_claude_command_wrappers,
         'surface-state': _check_surface_state,
         'hook-wiring': _check_hook_wiring,
-        ...(runtime_wiring.wiringRunners({ packageRoot: _package_root(), iterOverrides: () => iter_setting_overrides({ cwd: project_root }) }) as unknown as Record<string, CheckRunner>),
+        ...(runtime_wiring.wiringRunners({ packageRoot: _package_root(), projectRoot: project_root, iterOverrides: () => iter_setting_overrides({ cwd: project_root }) }) as unknown as Record<string, CheckRunner>),
         ...(install_reach.reachRunners({ projectRoot: project_root, resolvableVersion: _current_package_version() }) as unknown as Record<string, CheckRunner>),
         'stale-orphans': _check_stale_orphans,
         // BOTH registries need the id. Registering only the first one crashed with

package/src/scripts/_cli/cmd_handoff.ts

@@ -17,7 +17,7 @@
  *                      file (legacy copy-paste mode)
  *   --launch <host>    spawn a fresh interactive host session after
  *                      generating (claude: hook-seeded; codex: handoff as
- *                      initial prompt — no hook surface there)
+ *                      initial prompt — this package binds no hook there)
  *   --llm              narrative-polish seam; v1: clear not-implemented error
  *   --root <path>      repo root override (default: cwd)
  *

package/src/scripts/_cli/cmd_update.ts

@@ -446,7 +446,7 @@ export async function main(argv: string[] | null = null, options: MainOptions =
     const installed_version = options.installed_version || _detect_installed_version();
     const state_path = options.state_path || update_check.DEFAULT_STATE_PATH;
 
-    // AGENT_CONFIG_OFFLINE=1 (set by `install.py --offline`) is honored as an
+    // AGENT_CONFIG_OFFLINE=1 (set by `agent-config install --offline`) is honored as an
     // env-level kill-switch. Mirrors cmd_versions.py.
     const offline = args.offline || process.env['AGENT_CONFIG_OFFLINE'] === '1';
 

package/src/scripts/_cli/cmd_versions.ts

@@ -426,7 +426,7 @@ export function main(argv: string[] | null = null, options: MainOptions = {}): n
     const err = options.err ?? _stderrSink();
     const opts = _parse(argv ?? process.argv.slice(2), out, err);
 
-    // AGENT_CONFIG_OFFLINE=1 (set by `install.py --offline`) is honored as a
+    // AGENT_CONFIG_OFFLINE=1 (set by `agent-config install --offline`) is honored as a
     // global kill-switch even when the per-command --offline flag is absent.
     const offline = opts.offline || process.env['AGENT_CONFIG_OFFLINE'] === '1';
 

package/src/scripts/_lib/adr_frontmatter.ts

@@ -483,3 +483,47 @@ export function readAdrAxisCells(text: string): AdrAxisCells {
                   : `${strength} (${discovery})`,
     };
 }
+
+/**
+ * The one shape this tool decides: a trigger whose condition IS a leading date.
+ *
+ * Deliberately anchored at the start of the string and deliberately narrow. The
+ * boundary is the whole safety property — the moment a trigger is matched on a
+ * date found anywhere in its prose, "reopens when N exceeds M" is one edit away
+ * and the machine-readable grammar two council seats rejected on 2026-08-19 has
+ * been built by increments.
+ */
+export const DATED_TRIGGER_RE = /^\s*(?:expir(?:y|es)\b\s*[:—-]?\s*)?(\d{4})-(\d{2})-(\d{2})(?!\d)/iu;
+
+/**
+ * A trigger that ANNOUNCES itself as dated, whether or not the date parses.
+ *
+ * The gap between this and `DATED_TRIGGER_RE` is the `dated-unparsed` state.
+ * Exactly one ADR in the corpus carries a dated expiry, so a parse tuned to its
+ * phrasing can fail on the second one — and the failure mode is silence,
+ * because the old answer for every trigger was `indeterminate`. This probe is
+ * what turns that silence into a reported defect.
+ */
+export const DATED_TRIGGER_PROBE = /^\s*(?:expir(?:y|es)\b|\d{4}-\d{1,2}-\d{1,2}\b)/iu;
+
+/** The UTC calendar day of an instant, as `YYYY-MM-DD`. */
+export function iso_day(d: Date): string {
+    return d.toISOString().slice(0, 10);
+}
+
+/**
+ * The calendar day a dated trigger names, or null when there is none to read.
+ *
+ * Round-tripping through `Date.UTC` rejects `2026-13-45`, which matches the
+ * shape and is not a date.
+ */
+export function dated_trigger_day(trigger: string): string | null {
+    const m = DATED_TRIGGER_RE.exec(trigger);
+    if (m === null) return null;
+    const [y, mo, d] = [Number(m[1]), Number(m[2]), Number(m[3])];
+    const at = new Date(Date.UTC(y, mo - 1, d));
+    if (at.getUTCFullYear() !== y || at.getUTCMonth() !== mo - 1 || at.getUTCDate() !== d) {
+        return null;
+    }
+    return iso_day(at);
+}

package/src/scripts/_lib/consequence_objects.ts

@@ -0,0 +1,152 @@
+/**
+ * consequence_objects — the consequence vocabulary's prose half.
+ *
+ * Two things live here: the phrase rows that recognise a consequence
+ * authorization, and the extraction of the OBJECT such an authorization names.
+ * An authorization for one table, one environment or one recipient class is not
+ * an authorization for another, and until this existed the ledger could express
+ * the difference for nothing but pull-request numbers.
+ *
+ * IT IS RECOGNITION AND EXTRACTION, NOT MATCHING. Nothing here decides
+ * anything; the one consumer that acts on the vocabulary is `conformance_scan`,
+ * which counts after the fact. Making the object a matching condition is the
+ * ledger item ADR-254 left to the owner.
+ *
+ * It sits beside `git_authorization_hook` rather than inside it because that
+ * file is against the per-file source-size budget, which charges every line
+ * above 1500. The split is along a real seam: the hook owns the machinery —
+ * sentence bounds, negation, fenced-paste handling — and this module owns the
+ * consequence vocabulary that machinery is applied to.
+ */
+import type { GitOp } from "../git_authorization_hook.js";
+
+/**
+ * Prose phrases, German and English, that authorize a consequence operation.
+ *
+ * Spliced into `PHRASES` at its definition, so every row inherits the
+ * interrogative filter, the clause-scoped negation check and the fenced-paste
+ * split rather than reimplementing them.
+ *
+ * Every row REQUIRES ITS OBJECT NOUN, and that is why the patterns are long. A
+ * bare verb cannot tell an authorization from a mention, and for this class the
+ * mention is the common case: "deploy" appears in a hundred sentences that
+ * authorize nothing, while "deploy nach production" appears only when someone
+ * means it.
+ *
+ * German verb endings are `(e|en)?` because the imperative drops its `-e`, and
+ * both word orders are covered — the house style stated above `PHRASES`. The
+ * leading boundary is an explicit character class rather than `\b`: JavaScript's
+ * `\b` is ASCII-only, so a word STARTING with an umlaut ("Ändere") has no
+ * boundary before it and the row silently never fires.
+ */
+export const CONSEQUENCE_PHRASES: ReadonlyArray<{ op: GitOp; re: RegExp }> = [
+  {
+    op: "prod-deploy",
+    re: /(?<![A-Za-z0-9_À-ɏ])(deploy(e|en|t|st)?|ausroll(e|en)?|ship(pe|pen)?|live\s*schalt(e|en)?|rollout)\b[^.\n]{0,30}\b(produktion|production|prod|live|prod-umgebung)\b|\b(produktion|production|prod|live)\b[^.\n]{0,30}\b(deploy(e|en)?|ausrollen|ausroll(e|en)?|live\s*schalten|rollout)\b/i,
+  },
+  {
+    op: "prod-data-destroy",
+    re: /(?<![A-Za-z0-9_À-ɏ])(l(ö|oe)sch(e|en)?|entfern(e|en)?|leer(e|en)?|verwerf(e|en)?|drop|truncate|delete|wipe|purge|zerst(ö|oe)r(e|en)?)\b[^.\n]{0,40}\b(tabelle|tabellen|datenbank|daten|bucket|collection|zeilen|rows|table|database|dataset)\b|\b(tabelle|tabellen|datenbank|daten|bucket|collection|table|database)\b[^.\n]{0,40}\b(l(ö|oe)schen|leeren|verwerfen|droppen|truncaten|entfernen|drop|truncate|delete|wipe|purge)\b/i,
+  },
+  {
+    op: "prod-infra-change",
+    re: /(?<![A-Za-z0-9_À-ɏ])((ver)?(ä|ae)nder(e|n)?|anpass(e|en)?|umbau(e|en)?|apply|destroy|(neu\s*)?provisionier(e|en)?)\b[^.\n]{0,40}\b(infrastruktur|infrastructure|cluster|terraform|iam|dns|netzwerk|network|firewall|policy|policies|security[-\s]group)\b|\b(infrastruktur|infrastructure|cluster|terraform|iam|dns|netzwerk|firewall)\b[^.\n]{0,40}\b((ver)?(ä|ae)ndern|anpassen|umbauen|zerst(ö|oe)ren|apply|destroy)\b/i,
+  },
+  {
+    op: "external-send",
+    re: /(?<![A-Za-z0-9_À-ɏ])(schick(e|en)?|verschick(e|en)?|send(e|en|et)?|mail(e|en)?|raussend(e|en)?|versend(e|en)?|post|publish)\b[^.\n]{0,40}\b(mail|mails|email|e-mail|nachricht|nachrichten|newsletter|webhook|kunden|kundin|kunde|empf(ä|ae)nger|customers?|recipients?|message)\b|\b(mail|email|e-mail|nachricht|newsletter|kunden|customers?)\b[^.\n]{0,40}\b(schicken|verschicken|senden|versenden|rausschicken|send|deliver)\b/i,
+  },
+  {
+    op: "money-movement",
+    re: /(?<![A-Za-z0-9_À-ɏ])(erstatt(e|en)?|r(ü|ue)ckerstatt(e|en)?|zahl(e|en)?|(ü|ue)berweis(e|en)?|abbuch(e|en)?|belast(e|en)?|refund|charge|payout|transfer|bill)\b[^.\n]{0,40}\b(betrag|geld|rechnung|zahlung|euro|dollar|kunde|kunden|karte|konto|invoice|payment|customer|card|account)\b|\b(betrag|geld|rechnung|zahlung|invoice|payment)\b[^.\n]{0,40}\b(erstatten|zur(ü|ue)ckzahlen|(ü|ue)berweisen|abbuchen|belasten|refund|charge|transfer)\b/i,
+  },
+  {
+    op: "trunk-force-push",
+    re: /(?<![A-Za-z0-9_À-ɏ])(force[-\s]?push(e|en|t)?|force[-\s]?pushen|(ü|ue)berschreib(e|en)?)\b[^.\n]{0,40}\b(main|master|trunk|produktions?[-\s]?branch|production|release[-\s]?branch)\b|\b(main|master|trunk|production)\b[^.\n]{0,40}\b(force[-\s]?pushen|force[-\s]?push|(ü|ue)berschreiben)\b/i,
+  },
+  {
+    op: "out-of-scope-destruction",
+    re: /(?<![A-Za-z0-9_À-ɏ])(l(ö|oe)sch(e|en)?|entfern(e|en)?|r(ä|ae)um(e|en)?\s*auf|aufr(ä|ae)um(e|en)?|delete|remove|wipe)\b[^.\n]{0,40}\b(au(ß|ss)erhalb|ausserhalb|unabh(ä|ae)ngig|nicht\s+zur\s+aufgabe|outside\s+(the\s+)?(task|scope)|unrelated|everything\s+else|alles\s+andere)\b|\b(au(ß|ss)erhalb|outside\s+(the\s+)?(task|scope)|unrelated)\b[^.\n]{0,40}\b(l(ö|oe)schen|entfernen|aufr(ä|ae)umen|delete|remove|wipe)\b/i,
+  },
+];
+
+/**
+ * Operations whose authorization is meaningless without its object.
+ *
+ * "Delete the table" is not an authorization to delete a table; it is an
+ * authorization to delete THAT table. The same holds for a recipient class and
+ * for a payment. The other four consequence operations are environment-scoped
+ * rather than object-scoped, so an object is recorded for them when the prose
+ * names one and never required.
+ */
+export const OBJECT_REQUIRED_OPS: ReadonlySet<GitOp> = new Set<GitOp>([
+  "prod-data-destroy",
+  "external-send",
+  "money-movement",
+]);
+
+/**
+ * Words that can follow an object noun and are never the object's NAME.
+ *
+ * "Lösch die Tabelle bitte" names no table; the extractor's next-token rule
+ * captures `bitte` unless something says otherwise. A stop list is the honest
+ * shape for that — the same reviewable-keyword-list discipline the negation and
+ * pasted-output vocabularies above use, and for the same reason: a parser that
+ * guessed here would record a fabricated object, and a fabricated object is
+ * worse than a missing one because the conformance count treats a recorded
+ * object as an authorization the turn actually gave.
+ */
+const OBJECT_STOP_WORDS: ReadonlySet<string> = new Set([
+  "bitte", "doch", "mal", "nicht", "jetzt", "gleich", "auch", "noch", "wieder",
+  "in", "im", "aus", "von", "vom", ": ", "der", "die", "das", "den", "dem",
+  "und", "oder", "mit", "auf", "zu", "komplett", "ganz", "alle", "allen",
+  "please", "now", "again", "too", "also", "from", "and", "or", "the", "a",
+  "an", "there", "here", "completely", "all", "with", "on", "to", "in",
+]);
+
+/** Lower-case, strip surrounding quotes and trailing punctuation. */
+function _normalizeObject(raw: string): string {
+  return raw.trim().replace(/^["'`]+|["'`]+$/g, "").replace(/[.,;:]+$/, "").toLowerCase();
+}
+
+/** Per-operation object patterns, each with the capture group that holds it. */
+const OBJECT_PATTERNS: Readonly<Record<string, readonly RegExp[]>> = {
+  "prod-data-destroy": [
+    /\b(?:tabelle|table|datenbank|database|schema|collection|index)\s+["'`]?([A-Za-z_][\w.$-]*)/gi,
+    /\bs3:\/\/([\w.-]+)/gi,
+    /\b(?:bucket)\s+["'`]?([A-Za-z_][\w.-]*)/gi,
+  ],
+  "external-send": [
+    /([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,})/g,
+    /\bhttps?:\/\/([^\s/"'`]+)/gi,
+    /\b(?:an\s+(?:die|den|alle)|to\s+(?:the|all))\s+([A-Za-z][\w-]*)/gi,
+  ],
+  "money-movement": [
+    /(\d[\d.,]*)\s*(?:€|eur\b|euro\b|\$|usd\b)/gi,
+    /(?:€|\$)\s*(\d[\d.,]*)/g,
+    /\b(?:kunde|kunden|customer|account|konto)\s+["'`]?([A-Za-z0-9][\w.-]*)/gi,
+  ],
+};
+
+/**
+ * The objects a sentence names for one operation.
+ *
+ * Returns `[]` when the prose names none — which is a real answer and the one
+ * `conformance_scan` reads as "the record does not name this object". An empty
+ * list is never widened into a wildcard.
+ */
+export function extractObjects(op: GitOp, text: string): string[] {
+  const patterns = OBJECT_PATTERNS[op];
+  if (!patterns) return [];
+  const out: string[] = [];
+  for (const re of patterns) {
+    const local = new RegExp(re.source, re.flags.includes("g") ? re.flags : `${re.flags}g`);
+    let m: RegExpExecArray | null;
+    while ((m = local.exec(text)) !== null) {
+      const value = _normalizeObject(m[1] ?? "");
+      if (value && !OBJECT_STOP_WORDS.has(value) && !out.includes(value)) out.push(value);
+      if (m.index === local.lastIndex) local.lastIndex++;
+    }
+  }
+  return out;
+}

package/src/scripts/_lib/exec_evidence.ts

@@ -68,6 +68,13 @@ export const ALLOWLIST_PREFIXES: readonly (readonly string[])[] = [
     // a name. Read-only, deterministic, model-free, and already run in CI for its
     // own reasons — the same class as its neighbours here.
     ['check_no_external_sources'],
+    // Compares two COMMITTED files — the skill-activation census record against
+    // the sentence `docs/CLAIMS.md` publishes — so its exit code IS the verdict
+    // for that claim rather than evidence that some report exists. The census
+    // itself is deliberately NOT here: it reads a transcript store under `$HOME`
+    // that is absent on a runner, which would make the verdict an artifact of
+    // where it ran.
+    ['check_skill_activation_claim'],
     ['check_token_regression'],
     ['lint_agent_security'],
     ['measure_lexical_ranking'],

package/src/scripts/_lib/global_deploy_inventory.ts

@@ -356,7 +356,7 @@ function as_posix(p: string): string {
  *
  * `dry_run=true` computes and returns the would-delete set (only paths that
  * currently exist on disk) WITHOUT unlinking anything or pruning empty
- * directories — the preview surface for `install.py --dry-run`. The selection
+ * directories — the preview surface for `agent-config install --dry-run`. The selection
  * logic (orphan diff, containment proof, directory guard) is identical to the
  * live path, so the preview is exact.
  */
@@ -456,7 +456,7 @@ export function reap_stale(
  *
  * `dry_run=true` returns the would-delete set (tagged orphans actually present
  * on disk) WITHOUT unlinking or pruning — the preview surface for
- * `install.py --dry-run`. Selection logic is identical to the live path.
+ * `agent-config install --dry-run`. Selection logic is identical to the live path.
  */
 export function reap_tagged_orphans(
   anchor: string,