@event4u/agent-config 9.27.0 → 9.29.0

package/src/scripts/routing_doctor.ts

@@ -53,7 +53,7 @@ import {
 import * as hooks_status from "./hooks_status.js";
 import { load_agent_settings } from "./_lib/agent_settings.js";
 import {
-  normalizeHostManifest,
+  probeHostCapabilities,
   type HostCapabilityManifest,
 } from "./_lib/host_capability.js";
 import {
@@ -99,13 +99,25 @@ 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;
+  /**
+   * The host identifier the capability registry was keyed on, and whether it
+   * was OBSERVED (given via `--platform`) or merely ASSUMED (the CLI default).
+   *
+   * The doctor has no host detection: `main()` defaults to `claude`. Once
+   * capability resolution keys on that string, an assumed platform produces a
+   * confident-looking `subagent_spawn` for a host the user may not be on —
+   * so the assumption is reported next to the value it decided, and a reader
+   * can falsify it. Without this pair the misdiagnosis is invisible in the
+   * output, which is worse than the pre-registry bug it replaced.
+   */
+  host_platform: string;
+  host_platform_assumed: boolean;
   /** Verdict of the real activation gate for a canonical delegable probe. */
   activation: { action: string; reason: string };
   cost_budgets: Record<string, unknown>;
@@ -128,22 +140,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 {
@@ -175,7 +184,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)`;
   }
@@ -194,25 +203,46 @@ export interface DoctorReport {
 /**
  * Orchestration-routing state: settings gates, host capability, budget
  * inputs, and (optionally) a dry-run classification for a sample prompt.
- * Read-only — mirrors exactly what the delegation layer would resolve.
+ * Read-only — it mirrors what the delegation layer resolves FOR `platform`.
+ * That qualifier is load-bearing: the hook reads its platform off a real
+ * envelope, this function is told one, and the two agree only when the
+ * caller was told the truth (see `platform_assumed`).
+ *
+ * `platform` is the host identifier the committed capability registry is
+ * keyed on — the same string a hook envelope's `platform` field carries.
+ * It is REQUIRED, not optional: resolving through `normalizeHostManifest`
+ * alone (as this function did until the registry landed) skips the registry
+ * row entirely, so on a fresh clone with no `subagents.host_capabilities`
+ * override the doctor reported `subagent_spawn: false` while
+ * `delegation_nudge_hook` — which does call `resolveHostCapabilities` —
+ * reported `true`. Two readers of one fact disagreeing is worse than either
+ * answer, and the diagnostic is the one a user runs precisely to check the
+ * other. A required parameter makes that regression uncompilable; an
+ * optional one only discourages it in a comment, and a comment has never
+ * failed a build.
+ *
+ * `platform_assumed` says whether the caller OBSERVED the host or guessed
+ * it. It is not decoration: keying the registry on a guessed host is how
+ * this function would trade the bug it fixed for a mirrored one.
  */
 export function collect_orchestration(
   workspace_root: string,
   sample_prompt: string | null,
+  platform: string,
+  platform_assumed: boolean,
 ): 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 = normalizeHostManifest(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,
@@ -221,14 +251,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"] = {};
@@ -254,17 +276,17 @@ export function collect_orchestration(
     };
   }
   return {
-    enabled,
-    auto,
+    halted,
     downshift,
-    budget_routing,
     tier_budgets,
     host_manifest,
+    host_platform: platform,
+    host_platform_assumed: platform_assumed,
     activation: { action: probe.action, reason: probe.reason },
     cost_budgets,
     ledger_present,
     sample,
-    delivery: check_budget_delivery(workspace_root, budget_routing),
+    delivery: check_budget_delivery(workspace_root),
   };
 }
 
@@ -410,6 +432,15 @@ function _freshness(no_freshness: boolean): FreshnessReport {
 
 export function collect_report(options: {
   platform: string;
+  /**
+   * True when `platform` is the CLI's fallback rather than a value the caller
+   * observed or passed. Optional so existing callers keep compiling, and
+   * defaulting to `true` on purpose: a caller that did not say where the
+   * platform came from has not established that it observed one, and the
+   * conservative reading is the one that shows the caveat rather than the one
+   * that hides it.
+   */
+  platform_assumed?: boolean;
   workspace_root: string;
   no_freshness: boolean;
   classify?: string | null;
@@ -440,7 +471,12 @@ export function collect_report(options: {
     chain: chain.map((c) => c.name),
     gates,
     freshness: _freshness(options.no_freshness),
-    orchestration: collect_orchestration(options.workspace_root, options.classify ?? null),
+    orchestration: collect_orchestration(
+      options.workspace_root,
+      options.classify ?? null,
+      options.platform,
+      options.platform_assumed ?? true,
+    ),
     bridge_table,
   };
 }
@@ -465,10 +501,19 @@ function _render(report: DoctorReport): string {
   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"}`,
   );
+  if (o.host_platform_assumed) {
+    // Without this line the reader cannot tell a measured capability from one
+    // the registry produced for a host nobody checked they were on.
+    lines.push(
+      `  ⚠️ host not detected — '${o.host_platform}' is this command's default, ` +
+        `and the capability registry is keyed on it. Pass --platform <host> to check another.`,
+    );
+  }
   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" : "";
@@ -499,7 +544,11 @@ function _render(report: DoctorReport): string {
 
 export function main(argv?: string[]): number {
   const args = argv ?? process.argv.slice(2);
+  // The default is a guess, and since the capability registry is keyed on it
+  // the guess now decides `subagent_spawn`. Track where the value came from so
+  // the report can say so — there is no host detection here to replace it with.
   let platform = "claude";
+  let platform_assumed = true;
   let workspace_root = process.cwd();
   let json = false;
   let strict = false;
@@ -509,6 +558,7 @@ export function main(argv?: string[]): number {
     const a = args[i];
     if (a === "--platform" && args[i + 1]) {
       platform = String(args[(i += 1)]);
+      platform_assumed = false;
     } else if (a === "--workspace" && args[i + 1]) {
       workspace_root = path.resolve(String(args[(i += 1)]));
     } else if (a === "--classify" && args[i + 1]) {
@@ -521,7 +571,13 @@ export function main(argv?: string[]): number {
       no_freshness = true;
     }
   }
-  const report = collect_report({ platform, workspace_root, no_freshness, classify });
+  const report = collect_report({
+    platform,
+    platform_assumed,
+    workspace_root,
+    no_freshness,
+    classify,
+  });
   if (json) {
     process.stdout.write(`${JSON.stringify(report as unknown as JsonValue, null, 2)}\n`);
   } else {

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;