@event4u/agent-config 9.28.0 → 9.30.0

package/src/scripts/routing_doctor.ts

@@ -35,6 +35,7 @@
  * processes are the two freshness checks, both themselves read-only.
  */
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -53,7 +54,7 @@ import {
 import * as hooks_status from "./hooks_status.js";
 import { load_agent_settings } from "./_lib/agent_settings.js";
 import {
-  resolveHostCapabilities,
+  probeHostCapabilities,
   type HostCapabilityManifest,
 } from "./_lib/host_capability.js";
 import {
@@ -62,6 +63,11 @@ import {
   type ActivationInputs,
 } from "./_lib/auto_dispatch.js";
 import { TIER_ORDER, readCooldowns } from "./_lib/tier_budget_routing.js";
+import {
+  instructionsLoadedRecord,
+  measureStandingDelivery,
+  type StandingDeliveryMeasure,
+} from "./check_standing_rule_delivery.js";
 
 const REPO_ROOT = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
@@ -99,10 +105,9 @@ export interface FreshnessReport {
 }
 
 export interface OrchestrationReport {
-  enabled: boolean;
-  auto: string;
+  /** `emergency.orchestration_halt` — the one audited incident switch. */
+  halted: boolean;
   downshift: boolean;
-  budget_routing: string;
   /** cost.budgets.per_tier ceilings + live cool-down state per tier. */
   tier_budgets: Record<string, { ceiling_usd: number | null; cooldown_until_ms: number }>;
   host_manifest: HostCapabilityManifest;
@@ -141,22 +146,19 @@ export interface OrchestrationReport {
 }
 
 /**
- * Adherence ≠ delivery: budget routing binds via policy prose, so the
- * doctor checks the DELIVERY evidence — orchestration audit lines that
- * carry a tier decision. Eligible dispatches recorded while
- * `budget_routing != off` but 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).
+ * 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).
  */
 export function check_budget_delivery(
   workspace_root: string,
-  budget_routing: string,
 ): OrchestrationReport["delivery"] {
   const out = { eligible_dispatches: 0, budget_evidence_lines: 0, warning: "" };
-  if (budget_routing === "off") {
-    return out;
-  }
   const auditDir = path.join(workspace_root, "agents", "runtime", "state", "audit");
   let files: string[] = [];
   try {
@@ -188,7 +190,7 @@ export function check_budget_delivery(
   }
   if (out.eligible_dispatches > 0 && out.budget_evidence_lines === 0) {
     out.warning =
-      `budget_routing=${budget_routing} is policy-bound but shows no delivery evidence: ` +
+      `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)`;
   }
@@ -201,9 +203,93 @@ export interface DoctorReport {
   gates: GateReport[];
   freshness: FreshnessReport;
   orchestration: OrchestrationReport;
+  standing_delivery: StandingDeliveryMeasure | null;
   bridge_table: string;
 }
 
+/**
+ * Standing-rule-delivery savings for the doctor surface — the measurement is
+ * `check_standing_rule_delivery`'s, reused rather than re-derived, so the gate
+ * and the doctor can never report different numbers for the same layers.
+ * Read-only, like everything else here. `null` = no rule layer installed.
+ */
+export function collect_standing_delivery(
+  workspace_root: string,
+  global_rules_dir: string = path.join(os.homedir(), ".claude", "rules"),
+): StandingDeliveryMeasure | null {
+  return measureStandingDelivery(
+    global_rules_dir,
+    path.join(workspace_root, ".claude", "rules"),
+    instructionsLoadedRecord(workspace_root),
+  );
+}
+
+/**
+ * Render the delivery line in one of its states — scoped-clean (one layer,
+ * nothing duplicated) or both-layers-active (red, pointing at
+ * `install --layer`). Every number printed is one the measurement produced:
+ * the received total, the measured overlap, and the received-minus-overlap
+ * total suppression would leave. No baseline is invented for the layer that
+ * is not installed, so no percentage is derived from one either. The
+ * filesystem-vs-host-confirmed caveat is the gate's own honest-scope
+ * sentence, carried here so the doctor never claims the host confirmed what
+ * only the filesystem projects.
+ */
+export function render_standing_delivery(m: StandingDeliveryMeasure | null): string[] {
+  if (m === null) {
+    return [
+      "Standing delivery: no rule layer installed (neither ~/.claude/rules nor .claude/rules) — nothing delivered, nothing to save.",
+    ];
+  }
+  const lines: string[] = [];
+  if (m.layers.length === 2 && m.overlap_rules > 0) {
+    const scoped = m.received_tokens - m.overlap_tokens;
+    lines.push(
+      `⚠️ Standing delivery: both rule layers active — ${m.overlap_rules} rule(s) delivered twice ` +
+        `(~${m.overlap_tokens} tok). This session's host receives ${m.received_tokens} rule tokens; ` +
+        `scoped delivery would be ~${scoped} — run \`agent-config install --layer=<global|project>\`.`,
+    );
+    if (m.divergent_rules > 0) {
+      // Suppressing a layer whose copies differ drops whichever obligations only
+      // the suppressed copy carried — the same guard `decideLayerAction` applies.
+      lines.push(
+        `  ${m.divergent_rules} of the shared rule(s) differ in body — refresh before suppressing, ` +
+          "or obligations only the suppressed copy carries are lost.",
+      );
+    }
+  } else if (m.layers.length === 2) {
+    lines.push(
+      `Standing delivery: this session's host receives ${m.received_tokens} rule tokens across two ` +
+        "non-overlapping layers — nothing delivered twice, Δ0 to save.",
+    );
+  } else {
+    // One layer = the scoped state, and the honest report of it is the received
+    // total plus the measured fact that nothing is delivered twice.
+    //
+    // This line used to invent an "unscoped both-layers baseline" of
+    // `received × 2` and report the arithmetic consequence — which is always
+    // exactly 50%, for every non-zero input, i.e. a tautology dressed as a
+    // measurement. It also assumed the absent second layer would carry an
+    // identical corpus; the branch directly above exists because two installed
+    // layers can be wholly disjoint, so even with both present the doubling
+    // does not follow. A saving needs a second layer to measure against, and
+    // here there is none.
+    const layer = m.layers[0]?.label ?? "one";
+    lines.push(
+      `Standing delivery: this session's host receives ${m.received_tokens} rule tokens (scoped, ` +
+        `${layer} layer only); 0 tokens delivered twice — one layer is installed, so there is no ` +
+        "second layer to measure a saving against.",
+    );
+  }
+  if (m.input === "filesystem") {
+    lines.push(
+      "  note: filesystem projection, not host-confirmed — no InstructionsLoaded record; a rule " +
+        "projected but never loaded, or loaded from an unprojected layer, is invisible to this input.",
+    );
+  }
+  return lines;
+}
+
 /**
  * Orchestration-routing state: settings gates, host capability, budget
  * inputs, and (optionally) a dry-run classification for a sample prompt.
@@ -237,17 +323,16 @@ export function collect_orchestration(
 ): OrchestrationReport {
   const settings = load_agent_settings({ cwd: workspace_root });
   const sub = (settings["subagents"] ?? {}) as Record<string, unknown>;
-  const enabled = sub["enabled"] !== false;
-  const auto = typeof sub["auto"] === "string" ? (sub["auto"] as string) : "ask";
+  const emergency = (settings["emergency"] ?? {}) as Record<string, unknown>;
+  const halted = emergency["orchestration_halt"] === true;
   const downshift = sub["downshift"] !== false;
-  const host_manifest = resolveHostCapabilities(platform, sub["host_capabilities"]);
+  const host_manifest = probeHostCapabilities(platform);
   const activationInputs: ActivationInputs = {
-    enabled,
-    auto: (auto === "on" || auto === "off" ? auto : "ask") as ActivationInputs["auto"],
+    halted,
     subagent_spawn: host_manifest.subagent_spawn,
   };
   // Canonical delegable probe: the gate verdict shows which activation
-  // layer (settings / host primitive) decides on THIS installation.
+  // layer (emergency halt / host primitive) decides on THIS installation.
   const probe = classifyTask(
     { size_estimate: 5, independent_slices: 3 },
     activationInputs,
@@ -256,14 +341,6 @@ export function collect_orchestration(
   const cost_budgets = (cost["budgets"] ?? {}) as Record<string, unknown>;
   const tracking_dir = path.join(workspace_root, "agents", "cost-tracking");
   const ledger_present = fs.existsSync(path.join(tracking_dir, "sessions.jsonl"));
-  // YAML 1.1 trap: an unquoted `off` parses as boolean false — coerce it
-  // back to the enum string so the check honors the user's intent.
-  const budget_routing =
-    sub["budget_routing"] === false
-      ? "off"
-      : typeof sub["budget_routing"] === "string"
-        ? (sub["budget_routing"] as string)
-        : "ask";
   const per_tier = (cost_budgets["per_tier"] ?? {}) as Record<string, unknown>;
   const cooldowns = readCooldowns(tracking_dir);
   const tier_budgets: OrchestrationReport["tier_budgets"] = {};
@@ -289,10 +366,8 @@ export function collect_orchestration(
     };
   }
   return {
-    enabled,
-    auto,
+    halted,
     downshift,
-    budget_routing,
     tier_budgets,
     host_manifest,
     host_platform: platform,
@@ -301,7 +376,7 @@ export function collect_orchestration(
     cost_budgets,
     ledger_present,
     sample,
-    delivery: check_budget_delivery(workspace_root, budget_routing),
+    delivery: check_budget_delivery(workspace_root),
   };
 }
 
@@ -459,6 +534,8 @@ export function collect_report(options: {
   workspace_root: string;
   no_freshness: boolean;
   classify?: string | null;
+  /** Test seam: fixture global rules dir. Defaults to the real `~/.claude/rules`. */
+  global_rules_dir?: string;
 }): DoctorReport {
   const manifest = _load_yaml(MANIFEST_PATH);
   const chain = resolve_chain(manifest, options.platform);
@@ -492,6 +569,9 @@ export function collect_report(options: {
       options.platform,
       options.platform_assumed ?? true,
     ),
+    standing_delivery: options.global_rules_dir === undefined
+      ? collect_standing_delivery(options.workspace_root)
+      : collect_standing_delivery(options.workspace_root, options.global_rules_dir),
     bridge_table,
   };
 }
@@ -514,10 +594,12 @@ function _render(report: DoctorReport): string {
       ` · dispatch bundle=${report.freshness.dispatch_bundle}`,
   );
   lines.push("");
+  lines.push(...render_standing_delivery(report.standing_delivery));
+  lines.push("");
   const o = report.orchestration;
   lines.push(
-    `Orchestration: enabled=${o.enabled} · auto=${o.auto} · downshift=${o.downshift} · ` +
-      `budget_routing=${o.budget_routing} · subagent_spawn=${o.host_manifest.subagent_spawn} ` +
+    `Orchestration: halted=${o.halted} · downshift=${o.downshift} · ` +
+      `subagent_spawn=${o.host_manifest.subagent_spawn} ` +
       `(host=${o.host_platform}${o.host_platform_assumed ? ", ASSUMED" : ", observed"}) · ` +
       `ledger=${o.ledger_present ? "present" : "absent"}`,
   );

package/src/scripts/score_skill_selection.ts

@@ -19,10 +19,22 @@
  *     pass = (a) >= 0.90  OR  (b) >= 0.95
  *     fail = (a) <  0.80  AND  (b) <  0.80   →  cluster needs `routes_to`
  *
- * NOTE: the .py reads the legacy `.agent-src.uncondensed/skills` literal;
- * this faithful twin replicates it byte-for-byte. When inputs are missing
- * the .py raises an uncaught FileNotFoundError → exit 1; this twin mirrors
- * that by throwing.
+ * REPOINTED 2026-08-09 (P2.2 of road-to-rule-delivery-integrity). The original
+ * read the uncondensed legacy skills tree, faithfully replicating a `.py` twin —
+ * but ADR-051 retired that tree as dead and it does not exist in this checkout.
+ * A scorer pointed at a missing directory does not fail: its glob yields
+ * nothing, every fixture scores against an empty skill set, and the output is a
+ * baseline of silent zeros. That is worse than an error, because a baseline is
+ * exactly what P2.2's pre-registered criteria compare against — the measurement
+ * would have been void and would have looked fine.
+ *
+ * Now reads `SRC_SKILLS()` from the shared resolver. `dist/agent-src/skills`
+ * would be equally valid (ADR-201 makes the projection a byte-exact copy, so
+ * the frontmatter is identical); `src/` is chosen because it is the source of
+ * truth and is present even before a sync.
+ *
+ * When inputs are missing the original raised an uncaught FileNotFoundError →
+ * exit 1; this twin mirrors that by throwing.
  */
 
 import * as fs from 'node:fs';
@@ -30,12 +42,14 @@ import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { parse as parseYaml } from 'yaml';
 
+import { SRC_SKILLS } from './_lib/agent_src.js';
+
 const _HERE = fileURLToPath(import.meta.url);
 // src/scripts/score_skill_selection.ts → parents[2] is the repo root.
 const REPO_ROOT = path.resolve(path.dirname(_HERE), '..', '..');
 const FIXTURES = path.join(REPO_ROOT, 'tests', 'fixtures', 'skill_selection', 'fixtures.yml');
 const CLUSTERS = path.join(REPO_ROOT, 'agents', 'reports', 'skill-collision-clusters.json');
-const SKILLS_DIR = path.join(REPO_ROOT, '.agent-src.uncondensed', 'skills');
+const SKILLS_DIR = SRC_SKILLS();
 const DEFAULT_OUT = path.join(REPO_ROOT, 'agents', 'reports', 'skill-selection-accuracy.json');
 
 const PASS_A = 0.9;