@event4u/agent-config 9.17.0 → 9.18.1

package/dist/cli-delegate/cmd_prune.js

@@ -1,7 +1,7 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
   PROJECT_BRIDGE_MARKERS
-} from "./chunk-IMSXPRVH.js";
+} from "./chunk-ELMFOQPW.js";
 import "./chunk-WR6GTRHJ.js";
 import "./chunk-BKO2AZ7Z.js";
 import {

package/dist/cli-delegate/cmd_route_audit.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env tsx
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  match_prompt
+} from "./chunk-LF2KKJ4Q.js";
+import {
+  read_entries
+} from "./chunk-AIIUU73N.js";
+import "./chunk-XGA2NTU4.js";
+import {
+  load_agent_settings
+} from "./chunk-HJ6DAJHR.js";
+import "./chunk-NDJLNC6Q.js";
+import "./chunk-OY53J6II.js";
+import "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_route_audit.ts
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+var ROUTER_JSON = path.join(REPO_ROOT, "dist", "router.json");
+var RECORDER_REL = "agents/runtime/state/routing-telemetry.jsonl";
+var RULE_TRIPS_REL = "agents/runtime/state/rule-trips.json";
+var RECORD_SCHEMA_VERSION = 1;
+var MEASUREMENT_HEADER = "Measurement level: trigger matching only \u2014 what the host actually invokes is NOT measured here (ADR-126).";
+var PREREG_AUTHORITY_LINE = "Resolver authority: internal/bench/layer1-resolver-PREREG.md \u2014 this corpus feeds its P2 condition as a side effect; nothing here revives a resolver.";
+function recorder_path() {
+  return process.env["AGENT_ROUTING_TELEMETRY_FILE"] ?? path.join(REPO_ROOT, RECORDER_REL);
+}
+function recorder_enabled() {
+  try {
+    const settings = load_agent_settings({ cwd: REPO_ROOT });
+    const t = settings["telemetry"];
+    if (t === null || typeof t !== "object" || Array.isArray(t)) return false;
+    const rr = t["routing_recorder"];
+    if (rr === null || typeof rr !== "object" || Array.isArray(rr)) return false;
+    const enabled = rr["enabled"];
+    return enabled === true || enabled === "true" || enabled === "on" || enabled === "yes";
+  } catch {
+    return false;
+  }
+}
+function _trigger_label(trigger) {
+  for (const kind of ["keyword", "phrase", "command", "path_prefix", "file_pattern"]) {
+    if (kind in trigger) return `${kind}: ${String(trigger[kind])}`;
+  }
+  return JSON.stringify(trigger);
+}
+function audit_prompts(router, prompts) {
+  return prompts.map((prompt) => {
+    const result = match_prompt(router, prompt, "full", null, null);
+    const byRule = /* @__PURE__ */ new Map();
+    for (const mt of result.matched_triggers) {
+      const id = String(mt.rule);
+      const entry = byRule.get(id) ?? { tier: mt.tier.replace("_", "-"), triggers: [] };
+      entry.triggers.push(_trigger_label(mt.trigger));
+      byRule.set(id, entry);
+    }
+    const matched = [...byRule.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([rule, v]) => ({ rule, tier: v.tier, triggers: v.triggers }));
+    return { prompt, matched };
+  });
+}
+function load_user_prompts(last, history_path) {
+  let entries = [];
+  try {
+    entries = read_entries({ path: history_path ?? null });
+  } catch {
+    return [];
+  }
+  const prompts = [];
+  for (const e of entries) {
+    if (e === null || typeof e !== "object") continue;
+    if (e.t !== "user" || typeof e.text !== "string") continue;
+    const text = e.text.trim();
+    if (text === "" || text.startsWith("<") || text.startsWith("Caveat:")) continue;
+    prompts.push(text);
+  }
+  return prompts.slice(-last);
+}
+function _load_trips() {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(REPO_ROOT, RULE_TRIPS_REL), "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function build_records(audits, now_iso) {
+  const trips = _load_trips();
+  return audits.map((a) => {
+    const enforcement_trips = {};
+    for (const m of a.matched) {
+      const concern = trips.concerns?.[m.rule];
+      if (concern) {
+        enforcement_trips[m.rule] = { block: concern.block ?? 0, warn: concern.warn ?? 0 };
+      }
+    }
+    return {
+      schema_version: RECORD_SCHEMA_VERSION,
+      ts: now_iso,
+      prompt_sha16: crypto.createHash("sha256").update(a.prompt).digest("hex").slice(0, 16),
+      matched: a.matched,
+      enforcement_trips
+    };
+  });
+}
+function append_records(records, target) {
+  if (process.env["AGENT_CONFIG_REPLAY"] === "1") return 0;
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  const fd = fs.openSync(target, "a", 420);
+  try {
+    for (const r of records) fs.writeSync(fd, JSON.stringify(r) + "\n");
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  return records.length;
+}
+function render_weekly(target, now) {
+  let lines = [];
+  try {
+    lines = fs.readFileSync(target, "utf-8").split("\n").filter(Boolean);
+  } catch {
+    lines = [];
+  }
+  const cutoff = now.getTime() - 7 * 24 * 60 * 60 * 1e3;
+  const perRule = /* @__PURE__ */ new Map();
+  let inWindow = 0;
+  for (const line of lines) {
+    let rec;
+    try {
+      rec = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const ts = Date.parse(rec.ts ?? "");
+    if (Number.isNaN(ts) || ts < cutoff) continue;
+    inWindow += 1;
+    for (const m of rec.matched ?? []) {
+      perRule.set(m.rule, (perRule.get(m.rule) ?? 0) + 1);
+    }
+  }
+  const out = [MEASUREMENT_HEADER, ""];
+  out.push(`routing recorder \u2014 rolling 7-day window (${inWindow} recorded prompt(s))`);
+  if (inWindow === 0) {
+    out.push("  (no records in the window \u2014 enable telemetry.routing_recorder and run `route:audit --record`)");
+  } else {
+    const rows = [...perRule.entries()].sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1));
+    for (const [rule, n] of rows) out.push(`  ${String(n).padStart(4)} \xD7 ${rule}`);
+  }
+  out.push("");
+  out.push(PREREG_AUTHORITY_LINE);
+  return { text: out.join("\n") + "\n", records: inWindow };
+}
+function main(argv) {
+  const args = [...argv];
+  const as_json = args.includes("--json");
+  const weekly = args.includes("--weekly");
+  const record = args.includes("--record");
+  let last = 10;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--last") last = Number(args[++i] ?? "10") || 10;
+    else if (a.startsWith("--last=")) last = Number(a.slice("--last=".length)) || 10;
+    else if (a === "-h" || a === "--help") {
+      process.stdout.write("usage: agent-config route:audit [--last N] [--record] [--weekly] [--json]\n");
+      return 0;
+    }
+  }
+  if (weekly) {
+    const { text, records } = render_weekly(recorder_path(), /* @__PURE__ */ new Date());
+    process.stdout.write(text);
+    return records === 0 ? 1 : 0;
+  }
+  let router;
+  try {
+    router = JSON.parse(fs.readFileSync(ROUTER_JSON, "utf-8"));
+  } catch (e) {
+    process.stderr.write(`route:audit: cannot read ${ROUTER_JSON}: ${String(e)}
+`);
+    return 2;
+  }
+  const prompts = load_user_prompts(last);
+  if (prompts.length === 0) {
+    process.stdout.write(MEASUREMENT_HEADER + "\n\n");
+    process.stdout.write("no user prompts found in the chat-history log \u2014 nothing to audit\n");
+    return 1;
+  }
+  const audits = audit_prompts(router, prompts);
+  let recorded = 0;
+  let recorder_note = "";
+  if (record) {
+    if (recorder_enabled()) {
+      recorded = append_records(build_records(audits, (/* @__PURE__ */ new Date()).toISOString()), recorder_path());
+      recorder_note = `recorded ${recorded} prompt(s) to ${RECORDER_REL}`;
+    } else {
+      recorder_note = "recorder disabled (telemetry.routing_recorder.enabled is off \u2014 default) \u2014 nothing written";
+    }
+  }
+  if (as_json) {
+    process.stdout.write(
+      JSON.stringify(
+        { measurement_level: MEASUREMENT_HEADER, audited: audits.length, recorded, prompts: audits },
+        null,
+        2
+      ) + "\n"
+    );
+    return 0;
+  }
+  const out = [MEASUREMENT_HEADER, ""];
+  out.push(`audited the last ${audits.length} user prompt(s) \u2014 matched rules per prompt`);
+  out.push("(should-have-matched is the reviewer's judgment over this table, not a computed verdict)");
+  out.push("");
+  audits.forEach((a, i) => {
+    const shown = a.prompt.length > 100 ? a.prompt.slice(0, 97) + "..." : a.prompt;
+    out.push(`${String(i + 1).padStart(3)}. ${JSON.stringify(shown)}`);
+    if (a.matched.length === 0) {
+      out.push("       \u2192 (no trigger matched \u2014 kernel only)");
+    } else {
+      for (const m of a.matched) {
+        out.push(`       \u2192 ${m.rule} [${m.tier}] (${m.triggers.join(" \xB7 ")})`);
+      }
+    }
+  });
+  if (recorder_note) {
+    out.push("");
+    out.push(recorder_note);
+  }
+  process.stdout.write(out.join("\n") + "\n");
+  return 0;
+}
+var _HERE = fileURLToPath(import.meta.url);
+if (process.argv[1] && (import.meta.url === pathToFileURL(process.argv[1]).href || path.resolve(process.argv[1]) === _HERE)) {
+  process.exitCode = main(process.argv.slice(2));
+}
+export {
+  MEASUREMENT_HEADER,
+  PREREG_AUTHORITY_LINE,
+  RECORDER_REL,
+  RECORD_SCHEMA_VERSION,
+  append_records,
+  audit_prompts,
+  build_records,
+  load_user_prompts,
+  main,
+  recorder_enabled,
+  render_weekly
+};

package/dist/cli-delegate/cmd_route_explain.js

@@ -0,0 +1,285 @@
+#!/usr/bin/env tsx
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  _asRuleList,
+  match_prompt
+} from "./chunk-LF2KKJ4Q.js";
+import {
+  load_agent_settings
+} from "./chunk-HJ6DAJHR.js";
+import "./chunk-NDJLNC6Q.js";
+import "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_route_explain.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// src/scripts/_lib/token_count.ts
+import { createRequire } from "node:module";
+var _GPT_CHARS_PER_TOKEN = 4;
+var _CLAUDE_CHARS_PER_TOKEN = 3.6;
+var _TIKTOKEN_ENCODING = "cl100k_base";
+function _loadEncoder() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const mod = require2("js-tiktoken");
+    return mod.getEncoding(_TIKTOKEN_ENCODING);
+  } catch {
+    return null;
+  }
+}
+var _ENCODER = _loadEncoder();
+var TIKTOKEN_AVAILABLE = _ENCODER !== null;
+var TokenCount = class {
+  tokens;
+  exact;
+  constructor(tokens, exact) {
+    this.tokens = tokens;
+    this.exact = exact;
+    Object.freeze(this);
+  }
+};
+function _len(text) {
+  let count = 0;
+  for (const _ch of text) count += 1;
+  return count;
+}
+function _python_round(x) {
+  const floor = Math.floor(x);
+  const diff = x - floor;
+  if (diff > 0.5) return floor + 1;
+  if (diff < 0.5) return floor;
+  return floor % 2 === 0 ? floor : floor + 1;
+}
+function _py_float_repr(x) {
+  return Number.isInteger(x) ? `${x}.0` : `${x}`;
+}
+function gpt_tokens(text) {
+  if (_ENCODER !== null) {
+    return new TokenCount(_ENCODER.encode(text).length, true);
+  }
+  return gpt_tokens_proxy(text);
+}
+function gpt_tokens_proxy(text) {
+  return new TokenCount(_python_round(_len(text) / _GPT_CHARS_PER_TOKEN), false);
+}
+function claude_tokens(text) {
+  return new TokenCount(
+    _python_round(_len(text) / _CLAUDE_CHARS_PER_TOKEN),
+    false
+  );
+}
+function measure(text) {
+  const g = gpt_tokens(text);
+  const c = claude_tokens(text);
+  return {
+    chars: _len(text),
+    tokens_gpt: g.tokens,
+    tokens_gpt_exact: g.exact,
+    tokens_claude: c.tokens,
+    tokens_claude_exact: c.exact
+  };
+}
+function method_note_proxy() {
+  return `tokens_gpt: proxy (chars/${_py_float_repr(_GPT_CHARS_PER_TOKEN)}, tiktoken not installed); tokens_claude: proxy (chars/${_py_float_repr(_CLAUDE_CHARS_PER_TOKEN)})`;
+}
+function method_note() {
+  if (TIKTOKEN_AVAILABLE) {
+    return `tokens_gpt: exact (tiktoken ${_TIKTOKEN_ENCODING}); tokens_claude: proxy (chars/${_py_float_repr(_CLAUDE_CHARS_PER_TOKEN)})`;
+  }
+  return method_note_proxy();
+}
+
+// src/scripts/_cli/cmd_route_explain.ts
+var REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+var ROUTER_JSON = path.join(REPO_ROOT, "dist", "router.json");
+var RULES_DIST_DIR = path.join(REPO_ROOT, "dist", "agent-src", "rules");
+var MEASUREMENT_HEADER = "Measurement level: trigger matching only \u2014 what the host actually invokes is NOT measured here (ADR-126).";
+function _trigger_label(trigger) {
+  for (const kind of ["keyword", "phrase", "command", "path_prefix", "file_pattern"]) {
+    if (kind in trigger) {
+      return `${kind}: ${String(trigger[kind])}`;
+    }
+  }
+  return `trigger: ${JSON.stringify(trigger)}`;
+}
+function _projection_mode() {
+  try {
+    const settings = load_agent_settings({ cwd: REPO_ROOT });
+    const lp = settings["lean_projection"];
+    if (lp !== null && typeof lp === "object" && !Array.isArray(lp)) {
+      const mode = lp["mode"];
+      if (typeof mode === "string" && mode.trim() !== "") {
+        return mode.trim();
+      }
+    }
+  } catch {
+  }
+  return "eager-all";
+}
+function _disposition(tier, projection_mode) {
+  if (tier === "kernel") {
+    return "injected (kernel, always full-bodied)";
+  }
+  return projection_mode === "eager-all" ? `injected at projection time (${tier}, lean_projection.mode: eager-all)` : `router-resolved pointer at projection time (${tier}, lean_projection.mode: ${projection_mode})`;
+}
+function _rule_body_size(rule_id) {
+  const p = path.join(RULES_DIST_DIR, `${rule_id}.md`);
+  try {
+    const text = fs.readFileSync(p, "utf-8");
+    const m = measure(text);
+    return { chars: m.chars, tokens: m.tokens_gpt };
+  } catch {
+    return { chars: 0, tokens: 0 };
+  }
+}
+function build_report(router, prompt, files, profile) {
+  const projection_mode = _projection_mode();
+  const result = match_prompt(router, prompt, profile, files.length > 0 ? files : null, null);
+  const matchedByRule = /* @__PURE__ */ new Map();
+  for (const mt of result.matched_triggers) {
+    const id = String(mt.rule);
+    const entry = matchedByRule.get(id) ?? { tier: mt.tier.replace("_", "-"), labels: [] };
+    entry.labels.push(_trigger_label(mt.trigger));
+    matchedByRule.set(id, entry);
+  }
+  const routesById = /* @__PURE__ */ new Map();
+  for (const tierKey of ["tier_1", "tier_2"]) {
+    for (const rule of _asRuleList(router[tierKey])) {
+      routesById.set(String(rule["id"]), (rule["routes_to"] ?? []).map(String));
+    }
+  }
+  const matches = [...matchedByRule.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([id, { tier, labels }]) => {
+    const size = _rule_body_size(id);
+    return {
+      id,
+      tier,
+      matched: labels,
+      routes_to: routesById.get(id) ?? [],
+      disposition: _disposition(tier, projection_mode),
+      body_chars: size.chars,
+      body_tokens_gpt: size.tokens
+    };
+  });
+  const rejected_no_match = [];
+  for (const tierKey of ["tier_1", "tier_2"]) {
+    if (tierKey === "tier_2" && profile !== "full") continue;
+    for (const rule of _asRuleList(router[tierKey])) {
+      const id = String(rule["id"]);
+      if (!matchedByRule.has(id)) rejected_no_match.push(id);
+    }
+  }
+  rejected_no_match.sort();
+  const rejected = [
+    { reason: "no trigger matched", ids: rejected_no_match }
+  ];
+  if (profile !== "full") {
+    rejected.push({
+      reason: `tier-2 excluded by profile '${profile}' (tier-2 is considered under profile 'full' only)`,
+      ids: _asRuleList(router["tier_2"]).map((r) => String(r["id"])).sort()
+    });
+  }
+  const kernel_always = (Array.isArray(router["kernel"]) ? router["kernel"] : []).map(String);
+  const matched_chars = matches.reduce((s, m) => s + m.body_chars, 0);
+  const matched_tokens = matches.reduce((s, m) => s + m.body_tokens_gpt, 0);
+  return {
+    measurement_level: MEASUREMENT_HEADER,
+    prompt,
+    files,
+    profile,
+    projection_mode,
+    kernel_always,
+    matches,
+    rejected,
+    budget: { matched_chars, matched_tokens_gpt: matched_tokens, method: method_note() }
+  };
+}
+function render_text(report) {
+  const out = [];
+  out.push(report.measurement_level);
+  out.push("");
+  out.push(`prompt: ${JSON.stringify(report.prompt)}`);
+  if (report.files.length > 0) out.push(`files: ${report.files.join(", ")}`);
+  out.push(`profile: ${report.profile} \xB7 projection mode: ${report.projection_mode}`);
+  out.push("");
+  out.push(`kernel (always active, ${report.kernel_always.length}): ${report.kernel_always.join(", ")}`);
+  out.push("");
+  out.push(`matched rules (${report.matches.length}):`);
+  for (const m of report.matches) {
+    out.push(`  \xB7 ${m.id}  [${m.tier}]`);
+    for (const label of m.matched) out.push(`      matched ${label}`);
+    out.push(`      disposition: ${m.disposition}`);
+    if (m.routes_to.length > 0) out.push(`      routes_to: ${m.routes_to.join(", ")}`);
+    out.push(`      body: ${m.body_chars} chars \u2248 ${m.body_tokens_gpt} GPT tokens`);
+  }
+  if (report.matches.length === 0) {
+    out.push("  \xB7 (no trigger matched \u2014 only kernel rules active)");
+  }
+  out.push("");
+  out.push(
+    `budget consumption of matched non-kernel bodies: ${report.budget.matched_chars} chars \u2248 ${report.budget.matched_tokens_gpt} GPT tokens (${report.budget.method})`
+  );
+  for (const r of report.rejected) {
+    out.push(`rejected \u2014 ${r.reason}: ${r.ids.length} rule(s)`);
+  }
+  return out.join("\n") + "\n";
+}
+function main(argv) {
+  const args = [...argv];
+  const as_json = args.includes("--json");
+  let files = [];
+  let profile = "full";
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--json") continue;
+    if (a === "--files") {
+      files = String(args[++i] ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (a.startsWith("--files=")) {
+      files = a.slice("--files=".length).split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (a === "--profile") {
+      profile = String(args[++i] ?? "full");
+    } else if (a.startsWith("--profile=")) {
+      profile = a.slice("--profile=".length);
+    } else if (a === "-h" || a === "--help") {
+      process.stdout.write(
+        'usage: agent-config route:explain "<prompt>" [--files a,b] [--profile full|balanced] [--json]\n'
+      );
+      return 0;
+    } else {
+      positional.push(a);
+    }
+  }
+  const prompt = positional.join(" ").trim();
+  if (!prompt) {
+    process.stderr.write("route:explain: a prompt is required\n");
+    return 2;
+  }
+  let router;
+  try {
+    router = JSON.parse(fs.readFileSync(ROUTER_JSON, "utf-8"));
+  } catch (e) {
+    process.stderr.write(`route:explain: cannot read ${ROUTER_JSON}: ${String(e)}
+`);
+    return 2;
+  }
+  const report = build_report(router, prompt, files, profile);
+  if (as_json) {
+    process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+  } else {
+    process.stdout.write(render_text(report));
+  }
+  return report.matches.length === 0 ? 1 : 0;
+}
+var _HERE = fileURLToPath(import.meta.url);
+if (process.argv[1] && (import.meta.url === pathToFileURL(process.argv[1]).href || path.resolve(process.argv[1]) === _HERE)) {
+  process.exitCode = main(process.argv.slice(2));
+}
+export {
+  MEASUREMENT_HEADER,
+  _projection_mode,
+  build_report,
+  main,
+  render_text
+};

package/dist/cli-delegate/cmd_settings_migrate.js

@@ -3,7 +3,7 @@ import {
   GLOBAL_AGENT_SETTINGS_PATH,
   GLOBAL_USER_SETTINGS_PATH,
   SETTINGS_FILE
-} from "./chunk-IMSXPRVH.js";
+} from "./chunk-ELMFOQPW.js";
 import "./chunk-WR6GTRHJ.js";
 import "./chunk-BKO2AZ7Z.js";
 import "./chunk-63WSP6YZ.js";

package/dist/cli-delegate/cmd_sync.js

@@ -1,7 +1,7 @@
 import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
 import {
   main
-} from "./chunk-IMSXPRVH.js";
+} from "./chunk-ELMFOQPW.js";
 import "./chunk-WR6GTRHJ.js";
 import "./chunk-BKO2AZ7Z.js";
 import {

package/dist/cli-delegate/cmd_uninstall.js

@@ -3,7 +3,7 @@ import {
   PROJECT_BRIDGE_MARKERS,
   USER_SCOPE_PATHS,
   subtract_pointers
-} from "./chunk-IMSXPRVH.js";
+} from "./chunk-ELMFOQPW.js";
 import "./chunk-WR6GTRHJ.js";
 import "./chunk-BKO2AZ7Z.js";
 import {

package/dist/cli-delegate/cmd_validate.js

@@ -3,7 +3,7 @@ import { createRequire as __acCreateRequire } from 'node:module'; const require
 import {
   PROJECT_BRIDGE_MARKERS,
   USER_SCOPE_PATHS
-} from "./chunk-IMSXPRVH.js";
+} from "./chunk-ELMFOQPW.js";
 import "./chunk-WR6GTRHJ.js";
 import "./chunk-BKO2AZ7Z.js";
 import {

package/dist/discovery/deprecation-report.md

@@ -1,6 +1,6 @@
 # Discovery — Deprecation Report
 
-- Generated: `2026-08-04T04:02:42Z`
+- Generated: `2026-08-04T15:34:05Z`
 - Deprecated artefacts: **0**
 
 _None. Tree is clean._