@event4u/agent-config 12.1.0 → 13.0.0

package/src/scripts/release.ts

@@ -879,14 +879,14 @@ function watch_pr_checks(branch: string): void {
  *
  * git's wording for this is stable across versions: the hint is `fetch first`
  * / `Updates were rejected`, and the ref line carries `[rejected]` with
- * `non-fast-forward` or `fetch first`.
+ * `non-fast-forward` or `fetch first`. A stale lease is a SECOND wording —
+ * `[remote rejected]` + `cannot lock ref … but expected`; pinned in the tests.
  */
 export function _is_non_fast_forward(stderr: string, stdout: string): boolean {
     const text = `${stderr}\n${stdout}`;
-    return (
-        /\[rejected\]/i.test(text) &&
-        /(non-fast-forward|fetch first|behind its remote counterpart)/i.test(text)
-    );
+    if (!/\[(?:remote )?rejected\]/i.test(text)) return false;
+    if (/cannot lock ref[^\n]*but expected/i.test(text)) return true;
+    return /(non-fast-forward|fetch first|behind its remote counterpart)/i.test(text);
 }
 
 function push_release_branch(branch: string): void {

package/src/scripts/routing_doctor.ts

@@ -63,7 +63,7 @@ import {
   classifyTask,
   type ActivationInputs,
 } from "./_lib/auto_dispatch.js";
-import { TIER_ORDER, readCooldowns } from "./_lib/tier_budget_routing.js";
+import { COOLDOWN_FILE, TIER_ORDER, readCooldowns } from "./_lib/tier_budget_routing.js";
 import {
   instructionsLoadedRecord,
   measureStandingDelivery,
@@ -111,6 +111,13 @@ export interface OrchestrationReport {
   downshift: boolean;
   /** cost.budgets.per_tier ceilings + live cool-down state per tier. */
   tier_budgets: Record<string, { ceiling_usd: number | null; cooldown_until_ms: number }>;
+  /**
+   * Whether the cool-down store exists on disk. `readCooldowns` returns all
+   * zeros both when no tier is cooling AND when nothing has ever written the
+   * file, so a bare zero cannot distinguish "measured: live" from "no reading
+   * exists". This flag is what separates them.
+   */
+  cooldown_store_present: boolean;
   host_manifest: HostCapabilityManifest;
   /**
    * The host identifier the capability registry was keyed on, and whether it
@@ -158,14 +165,23 @@ export interface OrchestrationReport {
 }
 
 /**
- * Adherence ≠ delivery: budget-aware tier routing has no on/off setting any
- * more (always-on orchestration removed `subagents.budget_routing`), so the
- * doctor always checks the DELIVERY evidence — orchestration audit lines
- * that carry a tier decision. Dispatches recorded with ZERO tier-carrying
- * lines → WARN with the exact reason. Read-only over
- * agents/runtime/state/audit/*.jsonl; no new state. This closes the same
- * blind-spot class the session-canary incident exposed (policy present,
- * delivery silently absent).
+ * Tier-decision coverage in the orchestration record.
+ *
+ * REPOINTED 2026-08-16. This used to check "delivery evidence" for budget-aware
+ * tier routing, on the reasoning that policy can be present while delivery is
+ * silently absent — the session-canary blind-spot class. That layer is now
+ * ARCHIVED (`docs/contracts/budget-routing.md`), so the old rationale no longer
+ * holds and the old warning would have been permanently true and un-actionable:
+ * nothing dispatches through a tier decision by design, so telling the operator
+ * "the relation may not be running" is a dead advisory of exactly the shape this
+ * repository keeps removing elsewhere.
+ *
+ * What it measures now is narrower and still worth having: how many recorded
+ * dispatches carry a `tier` at all. That is the SAME field the archived layer's
+ * revisit-if depends on — a saving can only be computed once both the chosen and
+ * the realized tier are recorded — so this is the instrument that would show the
+ * reopen condition arriving. It reports coverage rather than warning about it.
+ * Read-only over agents/runtime/state/audit/*.jsonl; no new state.
  */
 export function check_budget_delivery(
   workspace_root: string,
@@ -202,9 +218,10 @@ export function check_budget_delivery(
   }
   if (out.eligible_dispatches > 0 && out.budget_evidence_lines === 0) {
     out.warning =
-      `budget-aware tier routing shows no delivery evidence: ` +
-      `${out.eligible_dispatches} orchestration dispatch(es) recorded, 0 carry a tier decision — ` +
-      `the relation may not be running (adherence != delivery)`;
+      `tier-decision coverage is 0 of ${out.eligible_dispatches} recorded dispatch(es) — ` +
+      `expected while budget routing stays archived (docs/contracts/budget-routing.md). ` +
+      `This is the counter its revisit-if reads: a non-zero value here is the signal ` +
+      `that per-tier dispatch has reappeared and the decision can be reopened`;
   }
   return out;
 }
@@ -356,6 +373,7 @@ export function collect_orchestration(
   const ledger_present = fs.existsSync(path.join(tracking_dir, "sessions.jsonl"));
   const per_tier = (cost_budgets["per_tier"] ?? {}) as Record<string, unknown>;
   const cooldowns = readCooldowns(tracking_dir);
+  const cooldown_store_present = fs.existsSync(path.join(tracking_dir, COOLDOWN_FILE));
   const tier_budgets: OrchestrationReport["tier_budgets"] = {};
   for (const t of TIER_ORDER) {
     const v = per_tier[t];
@@ -382,6 +400,7 @@ export function collect_orchestration(
     halted,
     downshift,
     tier_budgets,
+    cooldown_store_present,
     host_manifest,
     host_platform: platform,
     host_platform_assumed: platform_assumed,
@@ -636,10 +655,28 @@ function _render(report: DoctorReport): string {
   );
   const tierBits = Object.entries(o.tier_budgets).map(([t, s]) => {
     const cap = s.ceiling_usd === null ? "no cap" : `$${s.ceiling_usd}`;
-    const cool = s.cooldown_until_ms > 0 ? " COOLING" : "";
+    // `> Date.now()`, not `> 0`. The purger went with the archived permit
+    // lifecycle (`tripCooldown` rewrote the map on every write), so a stale
+    // entry now has nothing to clear it and `> 0` would render COOLING for
+    // ever. Latent rather than live — there is no writer either — but the
+    // comparison should be the one that stays correct if a writer returns.
+    const cool = s.cooldown_until_ms > Date.now() ? " COOLING" : "";
     return `${t}=${cap}${cool}`;
   });
   lines.push(`  tier budgets (rolling-24h): ${tierBits.join(" · ")}`);
+  // `readCooldowns` returns all zeros both when no tier is cooling and when
+  // nothing has ever written the store, so a missing COOLING marker alone
+  // cannot be read as a measured "this tier is live". Report which of the two
+  // it is — the same unavailable-vs-false distinction the capability-
+  // provenance line above makes two lines earlier. Derived from the store's
+  // existence rather than from a caller count, so it stays true if the
+  // cool-down producer is ever wired.
+  if (!o.cooldown_store_present) {
+    lines.push(
+      `  cool-down state: no reading on disk (${COOLDOWN_FILE} absent) — ` +
+        `absence of COOLING above is not evidence of a live tier`,
+    );
+  }
   if (o.delivery.warning) {
     lines.push(`  ⚠️ ${o.delivery.warning}`);
   } else if (o.delivery.eligible_dispatches > 0) {

package/src/scripts/schemas/command.schema.json

@@ -254,7 +254,7 @@
     },
     "requires_confirmation": {
       "type": "boolean",
-      "description": "Optional, additive: the command's action STAGES rather than executes, so an irreversible step waits for an explicit human confirmation naming the exact object (non-destructive-by-default § Never act while asking). Twin of the same key in skill.schema.json's execution block; commands carry no execution block, so it sits top-level. A declaration only — it names the action class, never the object, which exists at stage time and not in frontmatter. Mechanism: stageAction/confirmOnce in work_engine/hooks/builtin/staged_confirmation.ts; enumerate with `agent-config gates --pending`. Nothing BINDS on it yet (blocker confirmation-degraded-host-semantics: 5 of 8 hosts have no pre_tool_use slot)."
+      "description": "Optional, additive: the command's action STAGES rather than executes, so an irreversible step waits for an explicit human confirmation naming the exact object (non-destructive-by-default § Never act while asking). Twin of the same key in skill.schema.json's execution block; commands carry no execution block, so it sits top-level. A declaration only — it names the action class, never the object, which exists at stage time and not in frontmatter. Mechanism: stageAction/confirmOnce in work_engine/hooks/builtin/staged_confirmation.ts; enumerate with `agent-config gates --pending`. Nothing BINDS on it yet (blocker confirmation-degraded-host-semantics: only claude both binds pre_tool_use and honours a deny — docs/contracts/hook-architecture-v1.md, section Which hosts carry pre_tool_use)."
     },
     "auto_detect": {
       "type": "boolean",

package/src/scripts/schemas/skill.schema.json

@@ -276,7 +276,7 @@
         },
         "requires_confirmation": {
           "type": "boolean",
-          "description": "Optional, additive: the skill's action STAGES rather than executes, so an irreversible step waits for an explicit human confirmation naming the exact object (non-destructive-by-default § Never act while asking). A declaration only — it names the action class, never the object, which exists at stage time and not in frontmatter. The mechanism is stageAction/confirmOnce in work_engine/hooks/builtin/staged_confirmation.ts; enumerate what is pending with `agent-config gates --pending`. Nothing BINDS on this flag yet: on 5 of 8 hosts there is no pre_tool_use slot, so a guard would degrade to prose while the flag reads like a control — that decision is deferred behind blocker confirmation-degraded-host-semantics."
+          "description": "Optional, additive: the skill's action STAGES rather than executes, so an irreversible step waits for an explicit human confirmation naming the exact object (non-destructive-by-default § Never act while asking). A declaration only — it names the action class, never the object, which exists at stage time and not in frontmatter. The mechanism is stageAction/confirmOnce in work_engine/hooks/builtin/staged_confirmation.ts; enumerate what is pending with `agent-config gates --pending`. Nothing BINDS on this flag yet: only claude both binds pre_tool_use and honours a deny (docs/contracts/hook-architecture-v1.md, section Which hosts carry pre_tool_use — 2 further hosts bind it and ignore the verdict, 3 alias it unbound, 2 have no pre-tool surface), so a guard would degrade to prose on 7 of 8 hosts while the flag reads like a control — that decision is deferred behind blocker confirmation-degraded-host-semantics."
         },
         "command": {
           "type": "array",
@@ -287,6 +287,23 @@
         }
       }
     },
+    "triggers": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "keyword": {"type": "string", "minLength": 1},
+          "phrase": {"type": "string", "minLength": 1},
+          "file_pattern": {"type": "string", "minLength": 1},
+          "path_prefix": {"type": "string", "minLength": 1},
+          "command": {"type": "string", "minLength": 1},
+          "reason": {"type": "string"}
+        }
+      },
+      "description": "Activation triggers for the SKILL catalogue, shaped after the rule-side field so the two stay legible together — same five match keys (keyword, phrase, file_pattern, path_prefix, command), same additionalProperties:false, and deliberately no `intent` key, which was removed rule-side for giving authors false confidence that an activation path existed. OPTIONAL and empty of adopters on the day it ships: the capability becomes declarable before anything declares it, so a seeded tranche is measurable against the router corpus before it is written. Read by scripts/trigger_coverage.ts --scope skill through the same router_match.ts matcher the rule scope uses — not a fork. Schema: docs/contracts/rule-router.md."
+    },
     "workspaces": {
       "type": "array",
       "minItems": 1,

package/src/scripts/trigger_coverage.ts

@@ -40,6 +40,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { parse as parseYaml } from 'yaml';
 
 import { keyword_matches_anchored } from './router_telemetry.js';
+import { match_prompt, type Router as MatchRouter } from './_lib/router_match.js';
 
 const _HERE = fileURLToPath(import.meta.url);
 
@@ -48,6 +49,11 @@ export const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 export const ROUTER = path.join(REPO_ROOT, 'dist', 'router.json');
 export const CORPUS = path.join(REPO_ROOT, 'tests', 'eval', 'trigger-coverage.yaml');
 
+/** Skill tree the `skill` scope reads `triggers:` frontmatter from. */
+export const SKILLS_DIR = path.join(REPO_ROOT, 'src', 'skills');
+/** The matrix corpus the unintended-activation census is defined over. */
+export const MATRIX_DIR = path.join(REPO_ROOT, 'tests', 'eval', 'routing-matrix');
+
 type Router = {
     kernel?: string[];
     tier_1?: Array<{ id: string; triggers?: Array<Record<string, string>> }>;
@@ -100,6 +106,168 @@ export function fired_rules(prompt: string, router: Router): Set<string> {
     return fired;
 }
 
+/* ------------------------------------------------------------------ *
+ * The SKILL scope.
+ *
+ * It reuses `match_prompt` from `_lib/router_match.ts` — the same matcher the
+ * rule scope's census runs on — by handing it a router-SHAPED view of the
+ * skill catalogue. Forking the matcher would let the two scopes disagree about
+ * what "fires" means, which is the exact drift the shared helper exists to
+ * prevent.
+ *
+ * WHAT THIS SCOPE CANNOT REGRESS, stated because the roadmap's own risk
+ * register assumed otherwise. Risk 2 reads "the corpus counts activations
+ * across the whole router, so a skill-side tranche can regress a rule-side
+ * number". Verified against the tree: `compile_router.ts` contains zero
+ * references to skills, and `dist/router.json` carries exactly
+ * `kernel` + `tier_1` + `tier_2` rule entries. Skill triggers are compiled
+ * into nothing and are matched here over a SEPARATE catalogue, so the rule-side
+ * 433 census is structurally untouched by any skill tranche. The risk it names
+ * is real for a shared router and does not exist in this one — which makes the
+ * skill-side count below a NEW number needing its own ceiling, not a threat to
+ * the old one.
+ * ------------------------------------------------------------------ */
+
+/** One skill that declares activation triggers. */
+export interface SkillTriggerEntry {
+    id: string;
+    triggers: Array<Record<string, string>>;
+}
+
+/** `triggers:` list items from a SKILL.md frontmatter block. */
+function _parseTriggerBlock(frontmatter: string): Array<Record<string, string>> {
+    const out: Array<Record<string, string>> = [];
+    const lines = frontmatter.split('\n');
+    let inside = false;
+    for (const line of lines) {
+        if (/^triggers:\s*$/.test(line)) {
+            inside = true;
+            continue;
+        }
+        if (inside && /^\S/.test(line)) break; // next top-level key ends the block
+        if (!inside) continue;
+        const item = /^\s*-\s*(keyword|phrase|file_pattern|path_prefix|command):\s*(.+?)\s*$/.exec(line);
+        if (item) {
+            out.push({ [item[1]!]: item[2]!.replace(/^["']|["']$/g, '') });
+        }
+    }
+    return out;
+}
+
+/** Every skill under `skillsDir` that declares a non-empty `triggers:` list. */
+export function loadSkillTriggers(skillsDir: string): SkillTriggerEntry[] {
+    let names: string[];
+    try {
+        names = fs.readdirSync(skillsDir);
+    } catch {
+        return [];
+    }
+    const out: SkillTriggerEntry[] = [];
+    for (const name of names.sort()) {
+        const file = path.join(skillsDir, name, 'SKILL.md');
+        let content: string;
+        try {
+            content = fs.readFileSync(file, 'utf-8');
+        } catch {
+            continue;
+        }
+        if (!content.startsWith('---')) continue;
+        const end = content.indexOf('\n---', 3);
+        if (end === -1) continue;
+        const triggers = _parseTriggerBlock(content.slice(3, end));
+        if (triggers.length > 0) out.push({ id: name, triggers });
+    }
+    return out;
+}
+
+/**
+ * Every prompt in the matrix corpus, positives and near-misses alike.
+ *
+ * Parsed with the YAML reader this module already imports, not with a
+ * line regex. A regex anchored on `- prompt: "…"` silently drops any entry
+ * written unquoted or in single quotes, and a corpus that shrinks without
+ * saying so moves every rate computed against it — the denominator would
+ * change while the number kept its old name.
+ */
+export function loadMatrixPrompts(matrixDir: string): string[] {
+    let files: string[];
+    try {
+        files = fs.readdirSync(matrixDir).filter((n) => n.endsWith('.yaml')).sort();
+    } catch {
+        return [];
+    }
+    const out: string[] = [];
+    for (const f of files) {
+        let doc: unknown;
+        try {
+            doc = parseYaml(fs.readFileSync(path.join(matrixDir, f), 'utf-8'), { version: '1.1' });
+        } catch {
+            continue; // an unparseable corpus file is skipped, never guessed at
+        }
+        if (typeof doc !== 'object' || doc === null) continue;
+        const record = doc as Record<string, unknown>;
+        for (const section of ['positives', 'near_misses']) {
+            const entries = record[section];
+            if (!Array.isArray(entries)) continue;
+            for (const raw of entries) {
+                const prompt = (raw as Record<string, unknown> | null)?.['prompt'];
+                if (typeof prompt === 'string' && prompt.trim() !== '') out.push(prompt);
+            }
+        }
+    }
+    return out;
+}
+
+export interface SkillScopeReport {
+    /** Skills declaring at least one trigger. Zero on the day the schema ships. */
+    skills_with_triggers: number;
+    prompts: number;
+    /** Total (prompt, skill) activations — the skill-side census. */
+    activations: number;
+    /** Prompts that activated at least one skill. */
+    prompts_activating: number;
+    /** Per-skill activation counts, descending then by id. */
+    histogram: Array<[string, number]>;
+}
+
+/**
+ * Run the skill catalogue over the matrix corpus with the shared matcher.
+ *
+ * `tier_2` is the carrier for the router-shaped view purely because
+ * `match_prompt` reads its rule lists from `tier_1`/`tier_2`; skills have no
+ * tier and none is implied by the placement.
+ */
+export function runSkillScope(
+    entries: readonly SkillTriggerEntry[],
+    prompts: readonly string[],
+): SkillScopeReport {
+    // `kernel: []` is load-bearing: `match_prompt` appends every kernel id to
+    // `activated_rules` unconditionally, so a non-empty kernel here would count
+    // rule activations as skill ones on every prompt.
+    const view = { kernel: [], tier_1: [], tier_2: entries } as unknown as MatchRouter;
+    const histogram: Record<string, number> = {};
+    let activations = 0;
+    let promptsActivating = 0;
+    for (const prompt of prompts) {
+        const result = match_prompt(view, prompt, 'full', null, null);
+        const ids = result.activated_rules.map((a) => String(a.rule));
+        if (ids.length > 0) promptsActivating += 1;
+        for (const id of ids) {
+            histogram[id] = (histogram[id] ?? 0) + 1;
+            activations += 1;
+        }
+    }
+    return {
+        skills_with_triggers: entries.length,
+        prompts: prompts.length,
+        activations,
+        prompts_activating: promptsActivating,
+        histogram: Object.entries(histogram).sort((a, b) =>
+            b[1] !== a[1] ? b[1] - a[1] : a[0] < b[0] ? -1 : 1,
+        ),
+    };
+}
+
 export function run(corpus: Case[], router: Router): [CaseResult[], number] {
     const results: CaseResult[] = [];
     let misses = 0;
@@ -168,23 +336,76 @@ function _jsonDumps(obj: unknown): string {
 
 interface ParsedArgs {
     json: boolean;
+    /** `rule` keeps the pinned byte-identical contract; `skill` is additive. */
+    scope: 'rule' | 'skill';
 }
 
 function parse_args(argv: string[]): ParsedArgs {
-    const out: ParsedArgs = { json: false };
-    for (const a of argv) {
+    const out: ParsedArgs = { json: false, scope: 'rule' };
+    for (let i = 0; i < argv.length; i += 1) {
+        const a = argv[i]!;
         if (a === '--json') {
             out.json = true;
+        } else if (a === '--scope') {
+            const v = argv[i + 1];
+            if (v !== 'rule' && v !== 'skill') {
+                process.stderr.write(`error: --scope must be rule or skill, got: ${v ?? '(missing)'}\n`);
+                process.exit(2);
+            }
+            out.scope = v;
+            i += 1;
         } else if (a === '-h' || a === '--help') {
-            process.stdout.write('usage: trigger_coverage [-h] [--json]\n');
+            process.stdout.write('usage: trigger_coverage [-h] [--json] [--scope rule|skill]\n');
             process.exit(0);
         }
     }
     return out;
 }
 
+/**
+ * `--scope skill` — report only, never a gate.
+ *
+ * Exit 0 regardless of the count: no ceiling is committed here. The skill-side
+ * census is a NEW number (see the scope's header note on why the rule-side 433
+ * is structurally out of reach), and this package does not commit a threshold
+ * before it has a reading. A tranche is judged against a published baseline in
+ * its own change, not against a number invented on the day the instrument
+ * shipped.
+ */
+function runSkillScopeCli(json: boolean): number {
+    const report = runSkillScope(loadSkillTriggers(SKILLS_DIR), loadMatrixPrompts(MATRIX_DIR));
+    if (json) {
+        process.stdout.write(_jsonDumps(report) + '\n');
+        return 0;
+    }
+    process.stdout.write(
+        `skill trigger coverage over ${report.prompts} matrix prompts\n` +
+            `  skills declaring triggers: ${report.skills_with_triggers}\n` +
+            `  activations:               ${report.activations}\n` +
+            `  prompts activating ≥1:     ${report.prompts_activating}\n`,
+    );
+    if (report.skills_with_triggers === 0) {
+        process.stdout.write(
+            '\nNo skill declares a trigger yet. That is the schema landing empty of\n' +
+                'adopters, not a failure: the capability is declarable before anything\n' +
+                'declares it, so a seeded tranche is measurable before it is written.\n',
+        );
+        return 0;
+    }
+    process.stdout.write('\nper skill:\n');
+    for (const [id, n] of report.histogram) {
+        process.stdout.write(`  ${String(n).padStart(4)}  ${id}\n`);
+    }
+    process.stdout.write(
+        '\nReport only — no ceiling is enforced here. The rule-side 433 census is a\n' +
+            'different catalogue and cannot move from this scope.\n',
+    );
+    return 0;
+}
+
 export function main(argv: string[] | null = null): number {
     const args = parse_args(argv ?? process.argv.slice(2));
+    if (args.scope === 'skill') return runSkillScopeCli(args.json);
 
     let isFile = false;
     try {

package/src/server/schemas/settings.ts

@@ -80,13 +80,13 @@ export const settingsSchema = z.object({
             ),
             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.',
+                    'USD ceiling for the cheap model tier. Budget-aware delegation was ARCHIVED 2026-08-16 (docs/contracts/budget-routing.md), so no code routes on this today; the cap is still summed and reported by `budget.mjs tier`. 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.',
+                    'USD ceiling for the strong model tier. null = no separate tier cap. The never-block-to-save-money relation this used to describe went with the archived budget-routing layer (docs/contracts/budget-routing.md); nothing routes between tiers today.',
                 ),
             }).default({ cheap: null, medium: null, strong: null }),
         }),

package/src/config/budget-routing.json

@@ -1,7 +0,0 @@
-{
-  "$comment": "Single source of truth for the budget-routing reserve lifecycle (docs/contracts/budget-routing.md). Read by BOTH reserve readers — src/scripts/_lib/tier_budget_routing.ts (acquireBudgetPermit) and src/scripts/cost/budget.mjs (tier subcommand) — so the reserve window can never diverge between them. reserve_ttl_ms: reserves are RACE PROTECTION, not spend accounting — a pending entry older than this is dead and is dropped at the next compaction. lock_break_ms: an .lock file older than this is a crash leftover and is broken (unlink + one retry).",
-  "owner": "maintainer",
-  "review_by": "2027-08-03",
-  "reserve_ttl_ms": 600000,
-  "lock_break_ms": 30000
-}