@event4u/agent-config 9.13.0 → 9.15.0

package/src/scripts/trigger_coverage.ts

@@ -39,6 +39,8 @@ import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { parse as parseYaml } from 'yaml';
 
+import { keyword_matches_anchored } from './router_telemetry.js';
+
 const _HERE = fileURLToPath(import.meta.url);
 
 // src/scripts/trigger_coverage.ts → parents[2] of the .py file is repo root.
@@ -76,8 +78,17 @@ export function fired_rules(prompt: string, router: Router): Set<string> {
     for (const tier of ['tier_1', 'tier_2'] as const) {
         for (const entry of router[tier] ?? []) {
             for (const trig of entry.triggers ?? []) {
-                if ('keyword' in trig || 'phrase' in trig) {
-                    const needle = String(trig['keyword'] ?? trig['phrase']).toLowerCase();
+                // Single matcher source of truth (road-to-tested-routing
+                // Phase 3): `keyword` is word-boundary anchored via the
+                // shared helper; `phrase` stays unanchored substring.
+                if ('keyword' in trig) {
+                    const needle = String(trig['keyword']).toLowerCase();
+                    if (needle !== '' && keyword_matches_anchored(low, needle)) {
+                        fired.add(entry.id);
+                        break;
+                    }
+                } else if ('phrase' in trig) {
+                    const needle = String(trig['phrase']).toLowerCase();
                     if (needle !== '' && low.includes(needle)) {
                         fired.add(entry.id);
                         break;

package/src/scripts/update_counts.ts

@@ -15,7 +15,7 @@
  *
  * Historical quirks are preserved deliberately — tests and downstream consumers pin the exact behaviour.
  *
- * Source of truth: `.agent-src.uncondensed/`.
+ * Source of truth: `src/`.
  *
  * Target files have explicit regex patterns for each count mention — no fuzzy
  * matching, no risk of touching unrelated numbers.
@@ -26,6 +26,8 @@ import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import { artefact_roots, iter_commands } from './_lib/agent_src.js';
+import { scoped_projection_stats } from './_lib/scoped_projection.js';
+import { canonical_counts } from './check_command_count_messaging.js';
 
 const _HERE = fileURLToPath(import.meta.url);
 // _HERE === <repo>/src/scripts/update_counts.ts ; the retired Python implementation derives
@@ -77,7 +79,48 @@ function _exists(p: string): boolean {
     }
 }
 
+/**
+ * Every `SKILL.md` the canonical `count('skills')` counts, as absolute paths.
+ *
+ * Exported so `count_scoped_projection.ts` partitions the SAME file set the
+ * ledger's total is derived from. That is what makes the published pair
+ * ("N of M skills") coherent by construction: `projected + pruned === M`
+ * cannot drift, because there is one walk, not two.
+ */
+export function* iter_skills(): Generator<string> {
+    const seen = new Set<string>();
+    for (const root of artefact_roots()) {
+        const subdir = path.join(root, 'skills');
+        if (!_exists(subdir)) {
+            continue;
+        }
+        for (const f of _rglob(subdir, (n) => n === 'SKILL.md')) {
+            const rel = path.relative(root, f).split(path.sep).join('/');
+            if (seen.has(rel)) continue;
+            seen.add(rel);
+            yield f;
+        }
+    }
+}
+
 export function count(kind: string): number {
+    if (kind === 'commands_active') {
+        // Commands MINUS deprecation shims — the number the hero badge and the
+        // "Browse all N active commands" line carry, and the one prose
+        // mentions resolve to. Distinct from `commands` (raw file count):
+        // they are equal only while the shim set is empty, so anchoring an
+        // active-count position to `commands` would rewrite it to the wrong
+        // number the moment a command is superseded.
+        const [, , active] = canonical_counts();
+        return active;
+    }
+    if (kind === 'skills_scoped') {
+        // Skills a DEFAULT `projection.mode: scoped` install deploys. Derived
+        // by the installer's own prune predicate over the same walk the
+        // canonical `skills` total uses, so the published pair
+        // ("N of M skills") cannot drift apart. See count_scoped_projection.ts.
+        return scoped_projection_stats(REPO_ROOT, iter_skills()).projected;
+    }
     if (kind === 'router_rules') {
         // Routed rule entries in the compiled router (kernel + tier_1 +
         // tier_2). Read from dist/router.json — the artifact hosts consume —
@@ -119,19 +162,19 @@ export function count(kind: string): number {
         }
         return total;
     }
+    if (kind === 'skills') {
+        // Single walk, shared with count_scoped_projection.ts — see iter_skills.
+        for (const _ of iter_skills()) {
+            total += 1;
+        }
+        return total;
+    }
     for (const root of artefact_roots()) {
         const subdir = path.join(root, kind);
         if (!_exists(subdir)) {
             continue;
         }
-        if (kind === 'skills') {
-            for (const f of _rglob(subdir, (n) => n === 'SKILL.md')) {
-                const rel = path.relative(root, f).split(path.sep).join('/');
-                if (seen.has(rel)) continue;
-                seen.add(rel);
-                total += 1;
-            }
-        } else if (kind === 'personas') {
+        if (kind === 'personas') {
             // personas live as flat .md files, README excluded
             for (const f of _glob(subdir, (n) => n.endsWith('.md'))) {
                 if (path.basename(f) === 'README.md') continue;
@@ -164,6 +207,12 @@ export const TARGETS: ReadonlyArray<[string, ReadonlyArray<[string, string]>]> =
             // badge is owned by check_command_count_messaging.
             ['(/badge/Skills-)(\\d+)(-)', 'skills'],
             ['(/badge/Rules-)(\\d+)(-)', 'rules'],
+            // The Commands badge WAS left to check_command_count_messaging
+            // alone ("avoids double-ownership"). Nothing generated it, so it
+            // drifted to 191 against a canonical 192 and only the checker
+            // noticed — the exact gap this roadmap closes. Generator writes,
+            // checker verifies: that IS the ownership split, not a conflict.
+            ['(/badge/Commands-)(\\d+)(-)', 'commands_active'],
             ['(/badge/Guidelines-)(\\d+)(-)', 'guidelines'],
             ['(/badge/Personas-)(\\d+)(-)', 'personas'],
         ],
@@ -177,8 +226,22 @@ export const TARGETS: ReadonlyArray<[string, ReadonlyArray<[string, string]>]> =
             ['(- claim: )(\\d+)( skills\\.)', 'skills'],
             ['(- claim: )(\\d+)( commands\\.)', 'commands'],
             ['(- claim: )(\\d+)( governed rules\\.)', 'rules'],
+            // The scoped-projection claim: BOTH halves of "N of M skills".
+            // `M` was scanner-checked but generator-blind (a maintainer
+            // hand-edited it on every skill addition); `N` was guarded by
+            // nothing at all and had drifted 2 from the benchmark doc the
+            // claim names as its own method.
+            ['(installs ships )(\\d+)( of )', 'skills_scoped'],
+            ['( of )(\\d+)( skills \\(untagged core)', 'skills'],
+            // "14 of 111 governed rules" — the total was scanner-checked and
+            // generator-blind for the same reason.
+            ['( of )(\\d+)( governed rules \\()', 'rules'],
         ],
     ],
+    [
+        'docs/command-flows.md',
+        [['(\\*\\*)(\\d+)( commands\\*\\*)', 'commands_active']],
+    ],
     [
         'docs/getting-started-by-role.md',
         [
@@ -206,6 +269,11 @@ export const TARGETS: ReadonlyArray<[string, ReadonlyArray<[string, string]>]> =
         'docs/getting-started.md',
         [
             ['(automatically by )(\\d+)( rules)', 'rules'],
+            // Was deliberately unsynced to avoid double-ownership with
+            // check_command_count_messaging; it drifted to 191 as a result.
+            // Now generated from `commands_active` — the SAME canonical the
+            // checker compares against, so the two cannot disagree.
+            ['(Browse all )(\\d+)( active commands)', 'commands_active'],
             // NOTE: the "Browse all N active commands" line here carries the
             // *active* command count and is owned by
             // check_command_count_messaging.py — intentionally not synced
@@ -254,7 +322,16 @@ export function apply_to_text(
     return [new_text, drifts];
 }
 
-const KINDS = ['skills', 'rules', 'commands', 'guidelines', 'personas', 'router_rules'] as const;
+const KINDS = [
+    'skills',
+    'skills_scoped',
+    'rules',
+    'commands',
+    'commands_active',
+    'guidelines',
+    'personas',
+    'router_rules',
+] as const;
 
 function parse_args(argv: readonly string[]): { check: boolean } {
     const args = { check: false };
@@ -282,8 +359,10 @@ export function main(argv: readonly string[] = process.argv.slice(2)): number {
         counts[k] = count(k);
     }
     process.stdout.write(
-        `📊  Truth: skills=${counts['skills']} rules=${counts['rules']} ` +
-            `commands=${counts['commands']} guidelines=${counts['guidelines']} ` +
+        `📊  Truth: skills=${counts['skills']} skills_scoped=${counts['skills_scoped']} ` +
+            `rules=${counts['rules']} commands=${counts['commands']} ` +
+            `commands_active=${counts['commands_active']} ` +
+            `guidelines=${counts['guidelines']} ` +
             `personas=${counts['personas']} router_rules=${counts['router_rules']}\n`,
     );
 

package/src/scripts/validate_telegraph_carveouts.ts

@@ -10,7 +10,7 @@
  * changes — historical quirks preserved (consumers pin the exact behaviour).
  *
  * Given a pre-condensation reply and a post-condensation reply, assert that
- * every carve-out region from `.agent-src.uncondensed/rules/telegraph-speak.md`
+ * every carve-out region from `src/rules/telegraph-speak.md`
  * § Carve-outs survived byte-for-byte:
  *
  *   1. Triple-backtick code blocks (any language).

package/src/scripts/wrapper_freshness_hook.ts

@@ -39,6 +39,9 @@ import {
   needs_refresh,
 } from "./_lib/cli_wrapper.js";
 import { readHookStdin } from "./hooks/hook_stdin.js";
+import { probeRanToday, stampProbeRun } from "./hooks/probe_throttle.js";
+
+const THROTTLE_CONCERN = "wrapper-freshness";
 
 export const EXIT_ALLOW = 0;
 
@@ -202,6 +205,17 @@ export function main(argv?: string[]): number {
   _readStdinIfNotTty();
 
   const root = rootArg !== null ? rootArg : _project_root();
+
+  // Daily throttle (road-to-hook-latency-repair): a wrapper or pre-commit
+  // hook that was fresh this morning is still fresh this afternoon — one
+  // self-heal attempt per local calendar day. Skipped probe re-runs
+  // tomorrow; `agent-config upgrade` / `refresh --project` remain the
+  // immediate recovery paths.
+  if (probeRanToday(root, THROTTLE_CONCERN)) {
+    return EXIT_ALLOW;
+  }
+  stampProbeRun(root, THROTTLE_CONCERN);
+
   let wrapper: string | null;
   try {
     if (_is_source_repo(root)) {

package/src/server/schemas/settings.ts

@@ -53,8 +53,8 @@ export const settingsSchema = z.object({
         rule_workspaces: z.array(z.string()).default([]).describe(
             'Workspace scope for the RULE layer only (road-to-request-scoped-rule-load P1/P1b, opt-in). Absent or empty = legacy-all: every rule projects AND installs. Non-empty = only rules whose workspaces frontmatter intersects this list are projected (condense) and installed (install.sh + global wizard payload). Kernel rules always ship; untagged rules fail safe. The default flip to a scoped value is a HUMAN release gate — do not set this from automation.',
         ),
-        rule_packs: z.array(z.string()).default([]).describe(
-            'Optional second scoping axis for the RULE layer, per pack ids (src/config/discovery/packs.yml). When set, a non-kernel rule also needs a packs frontmatter intersection to ship — e.g. deselecting frontend-design drops ui-audit-gate + design-fidelity. Same opt-in / human-gate semantics as rule_workspaces.',
+        rule_packs: z.union([z.literal('auto'), z.array(z.string())]).default([]).describe(
+            'Optional second scoping axis for the RULE layer, per pack ids (src/config/discovery/packs.yml). When set, a non-kernel rule also needs a packs frontmatter intersection to ship — e.g. deselecting frontend-design drops ui-audit-gate + design-fidelity. Same opt-in / human-gate semantics as rule_workspaces. The literal "auto" derives the id list from the active-pack set (the same set the skill/command prune uses), so a domain safety floor stops shipping into installs that do not have the pack it guards; an explicit list stays supported and wins over the derivation.',
         ),
     }).default({ mode: 'legacy-all' }),
     rule_loading_tier: ruleLoadingTier.default('balanced').describe(
@@ -79,6 +79,17 @@ export const settingsSchema = z.object({
             monthly: z.number().min(0).default(0).describe(
                 'Calendar-month USD ceiling. Pairs with cost.enforcement = hard-stop for a hard cap on agent spend before the next billing cycle. Set 0 to disable.',
             ),
+            per_tier: z.object({
+                cheap: z.number().min(0).nullable().default(null).describe(
+                    'USD ceiling for the cheap model tier under budget-aware delegation (docs/contracts/budget-routing.md). null = no separate tier cap; global ceilings still apply.',
+                ),
+                medium: z.number().min(0).nullable().default(null).describe(
+                    'USD ceiling for the medium model tier. null = no separate tier cap.',
+                ),
+                strong: z.number().min(0).nullable().default(null).describe(
+                    'USD ceiling for the strong model tier. null = no separate tier cap — with cheap exhausted and strong funded, budget routing uses the strong tier rather than blocking work.',
+                ),
+            }).default({ cheap: null, medium: null, strong: null }),
         }),
         enforcement: enforcementMode.default('advisory').describe(
             'What happens when a budget hits 100%. advisory = show a banner, keep working (default — never blocks an active task). hard-stop = refuse further model calls until the budget resets or you raise the ceiling.',
@@ -103,7 +114,7 @@ export const settingsSchema = z.object({
             'Prefer short bullets and tables (true, default) vs verbose prose with rationale (false). Affects every chat reply; flip to false during debugging when you want the agent to think out loud.',
         ),
         canary_name: z.string().default('').describe(
-            'Session canary — the name the agent addresses you with at the start of every new task (e.g. "Alex"). When the greeting silently disappears, the context window is degrading: start a fresh conversation. Also keeps the reply-close markers (end-summary, PR URL as literal last line) alive. Empty = off. See rules/session-canary.md.',
+            'Session canary — the name the agent addresses you with at the start of every new task (e.g. "Alex"). When the greeting silently disappears, the context window is degrading: start a fresh conversation. Also keeps the reply-close markers (end-summary, PR URL as literal last line) alive. Empty = fall back to the user-global canary_name, then to identity.name from the setup wizard; no name anywhere = off. See rules/session-canary.md.',
         ),
         play_by_play: z.boolean().default(false).describe(
             'Narrate intermediate findings between tool calls ("Found it.", "Let me check Y."). Off by default — most users find it noisy. Turn on when you want to follow the agent\'s reasoning step by step.',
@@ -187,8 +198,8 @@ export const settingsSchema = z.object({
         quality_cadence: qualityCadence.default('end_of_roadmap').describe(
             'When the agent runs the full quality / test suite during /roadmap:process-* runs. end_of_roadmap = once, after the last step (fastest, default). per_phase = after each phase boundary. per_step = after every single step (slowest, highest confidence).',
         ),
-        dashboard_regen_cadence: regenCadence.default('per_step').describe(
-            'How often the agent regenerates agents/roadmaps/dashboard.md during a roadmap run. per_step = after every step (default, freshest dashboard). every_5_steps = batch the regen. phase_boundary = only at phase edges.',
+        dashboard_regen_cadence: regenCadence.default('every_5_steps').describe(
+            'How often the agent regenerates agents/roadmaps/dashboard.md during a roadmap run. every_5_steps = batch the regen (default). per_step = after every step (freshest dashboard, highest subprocess overhead). phase_boundary = only at phase edges. A rename, phase add, or archive always regenerates immediately regardless.',
         ),
         horizon_weeks: z.number().int().min(0).default(0).describe(
             'Optional planning horizon (weeks) the agent shows in roadmap framing ("next 4 weeks"). Set 0 to omit the horizon — most teams prefer to ship without a hardcoded window.',
@@ -288,6 +299,9 @@ export const settingsSchema = z.object({
         downshift: z.boolean().default(true).describe(
             'Route delegable sub-tasks to the lowest-capable model tier (cost + speed via model downshift). false = every subagent runs on the session tier.',
         ),
+        budget_routing: z.enum(['ask', 'auto', 'off']).default('ask').describe(
+            'Budget-aware cheap-request delegation (docs/contracts/budget-routing.md): pick the cheapest classifier-adequate tier WITH available budget (cost.budgets.per_tier); cheap exhausted but strong funded → strong tier; all exhausted → session model + notice. Work is never blocked to save money; the session model is never switched (delegation with a model override). ask = confirm the first budget-motivated downshift per session (default). auto = apply silently with telemetry. off = today\'s behavior (single-flip rollback). Distinct from downshift: that is the quality/cost knob, this is the resource-availability gate.',
+        ),
         quota_arbitrage: z.boolean().default(true).describe(
             'Prefer a separate quota-pool model for delegable sub-tasks where the host manifest reports one. Optional bonus only — identical behaviour (minus the quota win) where unsupported. Never load-bearing.',
         ),

package/dist/cli-delegate/chunk-TJIAM5FW.js

@@ -1,133 +0,0 @@
-import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
-import {
-  require_dist
-} from "./chunk-OY53J6II.js";
-import {
-  __toESM
-} from "./chunk-J55WI3RR.js";
-
-// src/install/rule_scope.ts
-import * as fs2 from "node:fs";
-import * as path from "node:path";
-
-// src/install/ruleInScope.ts
-var YAML = __toESM(require_dist(), 1);
-import * as fs from "node:fs";
-function parseYaml(text) {
-  try {
-    const data = YAML.parse(text, { version: "1.1" });
-    return data === void 0 ? null : data;
-  } catch {
-    return null;
-  }
-}
-function strip(s) {
-  return s.replace(/^\s+/u, "").replace(/\s+$/u, "");
-}
-function lstripNewlines(s) {
-  return s.replace(/^\n+/, "");
-}
-function parseFrontmatter(content) {
-  if (!content.startsWith("---")) {
-    return [{}, content];
-  }
-  const end = content.indexOf("\n---", 3);
-  if (end === -1) {
-    return [{}, content];
-  }
-  const raw = strip(content.slice(3, end));
-  const body = lstripNewlines(content.slice(end + 4));
-  let meta = parseYaml(raw);
-  if (meta === null || meta === void 0) {
-    meta = {};
-  }
-  if (typeof meta === "object" && meta !== null && !Array.isArray(meta)) {
-    return [meta, body];
-  }
-  return [{}, body];
-}
-function rule_in_scope(source_path, scope, pack_scope = null, role_scope = null) {
-  if (scope === null && pack_scope === null && role_scope === null) {
-    return true;
-  }
-  const [meta] = parseFrontmatter(fs.readFileSync(source_path, "utf-8"));
-  if (meta["type"] === "always" || meta["alwaysApply"] === true) {
-    return true;
-  }
-  const axis = (key, configured) => {
-    if (configured === null) {
-      return true;
-    }
-    const values = Array.isArray(meta[key]) ? meta[key].map((w) => String(w)) : [];
-    if (values.length === 0) {
-      return true;
-    }
-    return values.some((v) => configured.includes(v));
-  };
-  return axis("workspaces", scope) && axis("packs", pack_scope) && axis("roles", role_scope);
-}
-
-// src/install/rule_scope.ts
-var COMPAT_ALWAYS_EXCLUDED = ["source-of-truth.md"];
-var LEGACY_ALL = { workspaces: null, packs: null };
-function _list(value) {
-  if (Array.isArray(value) && value.length > 0) {
-    return value.map((v) => String(v));
-  }
-  return null;
-}
-function ruleScopeFromSettings(settings) {
-  const proj = settings["projection"];
-  if (typeof proj !== "object" || proj === null || Array.isArray(proj)) {
-    return LEGACY_ALL;
-  }
-  const p = proj;
-  return {
-    workspaces: _list(p["rule_workspaces"]),
-    packs: _list(p["rule_packs"]),
-    roles: _list(p["rule_roles"])
-  };
-}
-function ruleFileArrives(sourcePath, scope) {
-  if (!sourcePath.endsWith(".md")) {
-    return true;
-  }
-  const basename2 = path.basename(sourcePath);
-  if (COMPAT_ALWAYS_EXCLUDED.includes(basename2)) {
-    return false;
-  }
-  return rule_in_scope(sourcePath, scope.workspaces, scope.packs, scope.roles ?? null);
-}
-function excludedRuleBasenames(rulesDir, scope) {
-  let entries;
-  try {
-    entries = fs2.readdirSync(rulesDir).sort();
-  } catch {
-    return [];
-  }
-  const out = [];
-  for (const name of entries) {
-    if (!name.endsWith(".md")) {
-      continue;
-    }
-    const full = path.join(rulesDir, name);
-    try {
-      if (!fs2.statSync(full).isFile()) {
-        continue;
-      }
-    } catch {
-      continue;
-    }
-    if (!ruleFileArrives(full, scope)) {
-      out.push(name);
-    }
-  }
-  return out;
-}
-
-export {
-  LEGACY_ALL,
-  ruleScopeFromSettings,
-  ruleFileArrives,
-  excludedRuleBasenames
-};