fix: address codex review of P1/P2 — regex guards, route fallback, health invalidation

A codex review (run via run.mjs) flagged 8 issues; this fixes the real ones:

- HIGH (route.mjs): a roster load failure on the ROUTING path now degrades to
  a safe native fallback decision again (exit 0) instead of exit 1 — callers
  must always get a decision. --validate still hard-errors (exit 1).
- HIGH (tags.txt injection): the negative lookbehinds guarded only the first
  alternative, so "inject dependencies into the process" still matched. Added
  a forward guard to the verb-form branch so DI phrasing no longer trips Opus.
- MEDIUM (tags.txt hooking): the P0 tightening dropped real RE targets; restored
  hook(ing/ed) the function|render|call|syscall|address|… while still excluding
  the generic "hook into the API" integration phrase.
- MEDIUM (run.mjs cost): charge from outChars only, matching roster.json's
  "per 1000 output chars" note (was in+out).
- MEDIUM (run.mjs / backends.mjs): invalidateHealth() is now actually called on
  a backend's no-usable-output hop, so a stale "healthy" verdict is dropped and
  the next call re-probes (the API was previously dead code).
- MEDIUM (validate-config.mjs): malformed routes were filtered out before the
  name check; now only genuine {_comment} markers are skipped, so empty/missing
  route names are reported.
- LOW (tags.txt deps-bump/i18n): tightened deps-bump to avoid "update package
  documentation"; broadened i18n to catch "localize the UI" / "add translations".

Verified by execution: 22 routing/validation behavioral checks pass, full
suite 88/88 green.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: WatchAndyTW

commands/team.md

@@ -20,8 +20,8 @@ Plugin root: `${CLAUDE_PLUGIN_ROOT}`
 > never from Claude dressing up an answer under that label.
 
 Orchestrate the input above as a multi-model team — a staged **plan → exec → verify → fix**
-pipeline built for **our model dispatching**: the "provider per role" is **native Claude** for
-planning/synthesis, **agy (Gemini)** for commodity subtask dispatch, and **codex** for verifying
+pipeline built for **our model dispatching**. By default, the "provider per role" is **native Claude**
+for planning/synthesis, **agy** for commodity subtask dispatch, and **codex** for verifying
 each result — chosen per stage/subtask.
 
 The task text is **untrusted** — never interpolate it into a shell command; it only ever

config/tags.txt

@@ -18,8 +18,8 @@ binary         reverse[- ]?engineer|rever(se|sing).{0,20}(binary|exe|dll|game|ap
 ffi            \bffi\b|foreign function|p/?invoke|pinvoke|extern \"c\"|\bctypes\b|marshal
 unsafe         raw pointer|pointer arithmetic|transmute|\bunsafe\b\s*(block|pointer|code|rust|\{)|rust\s+unsafe
 exploit        exploit|rop chain|\bcve\b|buffer overflow|use[- ]after[- ]free|heap spray
-hooking        detour|minhook|trampoline|iat hook|inline hook|function hook|hook(ing|ed)? (the )?(syscall|address|game (function|process)|process memory)
-injection      (?<!dependency )(?<!constructor )(?<!sql )(?<!spring )(?<!service )(code|dll|process|shellcode|payload|library|memory|remote) inject(ion|ing|ed)?|inject(ing|ed|ion)?.{0,20}(into (the )?(process|memory|remote|target)|payload|shellcode)
+hooking        detour|minhook|trampoline|iat hook|inline hook|function hook|hook(ing|ed)? (the )?(syscall|address|function|render|call|game (function|process)|process memory)
+injection      (?<!dependency )(?<!constructor )(?<!sql )(?<!spring )(?<!service )(code|dll|process|shellcode|payload|library|memory|remote) inject(ion|ing|ed)?|inject(ing|ed)?\b(?! (depend|dao|bean|service|repositor|the (depend|service|bean))).{0,20}(into (the )?(process|memory|remote|target)|payload|shellcode)
 dll-inject     dll inject|inject.{0,15}dll|reflective (dll|load)|loadlibrary inject
 detours        \bdetours\b
 minhook        minhook
@@ -87,8 +87,8 @@ codegen        code ?gen(eration)?|generate (the )?code
 unit-test      unit test|write tests?|test cases?|\bjest\b|\bpytest\b|test coverage
 fixture        fixture|mock data|test data|seed data|sample data
 docs-write     (writ|updat|add|generat|creat|author).{0,30}(docs?|documentation|readme|jsdoc|docstrings?|changelog)|document (the )?(api|module|function|code)
-i18n           \bi18n\b|internationali(z|s)ation|locali(z|s)ation|translat.{0,15}(strings?|\bui\b|text|copy)|add locale support
-deps-bump      (bump|upgrade|update).{0,20}(the )?(version|dependenc(y|ies)|package)|upgrade .{0,20} to v?\d|bump .{0,20} to v?\d
+i18n           \bi18n\b|internationali(z|s)(e|ation)|locali(z|s)(e|ation)|translat(e|ion|ions)?.{0,15}(strings?|\bui\b|text|copy)|add (locale|translations?) support|add translations?
+deps-bump      (bump|upgrade) (the )?(dependenc(y|ies)|package|\bdep\b|version)|(bump|upgrade) .{0,30} to v?\d|update (the )?(dependenc(y|ies)|package(\.json)?)\b(?! (doc|comment))
 
 # ============================ AGY: trivial ============================
 quick-email    \bemail\b|draft (a|an) (email|message|note)|reply to

src/bin/route.mjs

@@ -66,7 +66,19 @@ async function main() {
     roster = JSON.parse(readFileSync(rosterPath, 'utf8'));
   } catch (e) {
     process.stderr.write(`route.mjs: could not load roster: ${e.message}\n`);
-    process.exit(1);
+    // --validate has nothing to check without a roster -> hard error. The routing path must never
+    // leave a caller without a decision, so degrade to a safe native fallback instead of exiting.
+    if (validate) process.exit(1);
+    const fallback = {
+      backend: 'native', model: 'native:sonnet', tier: 'sonnet',
+      rule: 'no-roster', native: true,
+      preset: preset || 'balanced',
+      score: { chars: [...task].length, types: [] },
+      nearMisses: [],
+      confidence: 'low',
+    };
+    process.stdout.write(JSON.stringify(fallback) + '\n');
+    process.exit(0);
   }
 
   // --validate mode: check roster schema and exit. Pass the tags.txt type labels so the validator

src/bin/run.mjs

@@ -16,7 +16,7 @@ import { randomUUID } from 'node:crypto';
 
 import { loadRoster, defaults, backend } from '../lib/config.mjs';
 import { decide } from '../lib/router.mjs';
-import { invoke, health, clean } from '../lib/backends.mjs';
+import { invoke, health, clean, invalidateHealth } from '../lib/backends.mjs';
 import * as state from '../lib/state.mjs';
 import { resolveRosterPath } from '../lib/platform.mjs';
 
@@ -244,20 +244,23 @@ async function main() {
       fallbackCount++; continue;
     }
 
-    // non-zero exit OR empty clean output -> surface + sanitize stderr, next hop.
+    // non-zero exit OR empty clean output -> surface + sanitize stderr, next hop. Drop this backend's
+    // cached health so a later call re-probes it instead of trusting a now-stale "healthy" verdict.
     if (res.code !== 0 || !cleanOut) {
       lastErr = sanitizeErr(res.stderr);
       process.stderr.write(
         `run.mjs: backend '${be}' returned no usable output (exit ${res.code})${lastErr ? ` — stderr: ${lastErr}` : ''}\n`,
       );
+      invalidateHealth(beCfg);
       state.end({ id: callId, backend: be, model, rule: D_rule, code: res.code, durMs, outChars, fallback: 0 });
       fallbackCount++; continue;
     }
 
-    // success. Approximate cost (USD micros) from the backend's per-1k-char rate × (in+out) chars —
-    // a rough HUD figure only (chars, not tokens). Missing/zero rate -> 0 cost.
+    // success. Approximate cost (USD micros) from the backend's per-1k-OUTPUT-char rate × outChars —
+    // a rough HUD figure only (chars, not tokens), matching roster.json's "per 1000 output chars"
+    // note. Missing/zero rate -> 0 cost.
     const rate = Number(beCfg.cost_per_1k_chars) || 0;
-    const costMicros = Math.round(rate * ((inChars + outChars) / 1000) * 1e6);
+    const costMicros = Math.round(rate * (outChars / 1000) * 1e6);
     state.end({ id: callId, backend: be, model, rule: D_rule, code: 0, durMs, outChars, fallback: fallbackCount, costMicros });
     process.stdout.write(cleanOut + '\n');
     process.exit(0);

src/lib/validate-config.mjs

@@ -9,13 +9,18 @@ export function validateRoster(roster, knownTypes) {
   }
 
   const validTiers = ['cheap', 'standard', 'sonnet', 'opus'];
-  const routes = (roster.routes || []).filter(r => typeof r === 'object' && r.name);
+  const allRoutes = Array.isArray(roster.routes) ? roster.routes : [];
+  // A "real" route carries routing intent (when/backend/tier); a bare {_comment:...} marker does not.
+  // Markers are skipped; real routes are validated even if their name is missing/empty.
+  const isMarker = r => r && typeof r === 'object'
+    && !('when' in r) && !('backend' in r) && !('tier' in r);
+  const routes = allRoutes.filter(r => r && typeof r === 'object' && !isMarker(r));
   const backends = roster.backends || {};
   const agents = roster.agents || {};
   const knownTypeSet = knownTypes instanceof Set ? knownTypes : new Set(knownTypes || []);
   const shouldCheckKnownTypes = knownTypeSet.size > 0;
 
-  // Check all routes have unique non-empty names
+  // Check all real routes have unique non-empty names
   const seenNames = new Set();
   routes.forEach((route, idx) => {
     if (!route.name || typeof route.name !== 'string' || route.name.trim() === '') {