@event4u/agent-config 8.9.0 → 8.11.0

package/src/scripts/_cli/cmd_doctor.ts

@@ -28,7 +28,8 @@
  * Health checks (see `CHECK_IDS`):
  * scope · global-binary · claude-plugin · stale-orphans · manifest-integrity ·
  * lockfile-freshness · bridge-drift · mcp-mode · mcp-beta-readiness ·
- * offline-readiness · python-runtime · tier-usage-readiness · council-cli ·
+ * offline-readiness · python-runtime · humanizer-runtime · tier-usage-readiness ·
+ * council-cli ·
  * unsupported-combos · wizard-state.
  * Each emits a structured `{id, status, message, remedy}` record with
  * `status` ∈ `ok` / `warn` / `fail` / `skipped` (rendered
@@ -742,6 +743,7 @@ const CHECK_IDS = [
     'mcp-beta-readiness',
     'offline-readiness',
     'python-runtime',
+    'humanizer-runtime',
     'tier-usage-readiness',
     'council-cli',
     'unsupported-combos',
@@ -762,6 +764,7 @@ const GLOBAL_CHECK_IDS: ReadonlySet<string> = new Set([
     'mcp-beta-readiness',
     'offline-readiness',
     'python-runtime',
+    'humanizer-runtime',
     'tier-usage-readiness',
     'council-cli',
     'wizard-state',
@@ -1505,6 +1508,33 @@ function _check_python_runtime(): Dict {
     };
 }
 
+function _check_humanizer_runtime(): Dict {
+    // Write-engine step 4b (humanize audit) runs `detect_ai_tells.ts` via a
+    // Node/tsx runtime "when available", degrading to a prose-only audit
+    // otherwise. This check surfaces which path a consumer install gets so the
+    // default-on behavior is not a silent surprise. Either state is healthy —
+    // the fallback is graceful by design — so it never fails the run.
+    const node = shutilWhich('node');
+    if (node === null) {
+        return {
+            id: 'humanizer-runtime',
+            status: 'ok',
+            message:
+                'no Node runtime on PATH — write-engine step 4b uses the ' +
+                'prose-only humanize audit (graceful fallback)',
+            remedy:
+                'install Node to enable the mechanical detect_ai_tells.ts pass; ' +
+                'the prose audit runs regardless',
+        };
+    }
+    return {
+        id: 'humanizer-runtime',
+        status: 'ok',
+        message: `Node runtime present (${node}) — step 4b runs the mechanical detect_ai_tells.ts pass`,
+        remedy: '',
+    };
+}
+
 function _check_mcp_beta_readiness(project_root: string): Dict {
     // Maintainer-scoped gate: the six artefacts live in the agent-config
     // SOURCE repo. In a consumer project the paths can never exist, so the
@@ -2130,6 +2160,7 @@ function _run_checks(
         'mcp-beta-readiness': () => _check_mcp_beta_readiness(project_root),
         'offline-readiness': () => _check_offline_readiness(),
         'python-runtime': () => _check_python_runtime(),
+        'humanizer-runtime': () => _check_humanizer_runtime(),
         'tier-usage-readiness': () => _check_tier_usage_readiness(project_root),
         'council-cli': () => _check_council_cli(project_root),
         'unsupported-combos': () => _check_unsupported_combos(manifest),
@@ -2200,6 +2231,7 @@ function _run_checks_no_manifest(
         'mcp-beta-readiness': () => _check_mcp_beta_readiness(project_root),
         'offline-readiness': () => _check_offline_readiness(),
         'python-runtime': () => _check_python_runtime(),
+        'humanizer-runtime': () => _check_humanizer_runtime(),
         'tier-usage-readiness': () => _check_tier_usage_readiness(project_root),
         'council-cli': () => _check_council_cli(project_root),
         'unsupported-combos': () => _skipped_manifest_check('unsupported-combos'),
@@ -2687,6 +2719,7 @@ export {
     _check_offline_readiness,
     _check_stale_orphans,
     _check_python_runtime,
+    _check_humanizer_runtime,
     _check_mcp_beta_readiness,
     _check_tier_usage_readiness,
     _check_council_cli,

package/src/scripts/_lib/auto_dispatch.corpus.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Deterministic `parallelizable:` classifier recall + false-positive measurement
+ * against the orchestration corpus (road-to-orchestration-scope-decision Phase 2
+ * / road-to-subagent-value-realization-followup Phase 1 Step 3).
+ *
+ * The corpus tasks (`internal/bench/orchestration/corpus/*.md`) each document a
+ * "Classification signal" and an expected dispatch mode. This encodes those
+ * documented signals as `TaskSignals` and asserts `classifyTask` (the pure v1
+ * classifier) fires the expected mode — recall on the modes v1 covers
+ * (`do-in-parallel`, `do-in-steps`), FP=0 on the negative control, and the
+ * documented scope gap (v1 has no `do-competitively` / verdict mode).
+ *
+ * This is the durable, reproducible "record actual hit/miss counts" deliverable
+ * + a regression guard for the classifier. Deterministic — no spend, no agents.
+ */
+import { describe, expect, it } from 'vitest';
+
+import { classifyTask, type ActivationInputs, type TaskSignals } from './auto_dispatch.js';
+
+const ON: ActivationInputs = { enabled: true, auto: 'on', subagent_spawn: true };
+
+/** Corpus signals transcribed from each task's documented "Classification signal". */
+const CORPUS: Array<{
+    id: string;
+    signals: TaskSignals;
+    expectMode: 'do-in-parallel' | 'do-in-steps' | null;
+    note: string;
+}> = [
+    {
+        id: 'orch-01',
+        signals: { parallelizable: 'files', independent_slices: 4, size_estimate: 4, ordered_plan: false },
+        expectMode: 'do-in-parallel',
+        note: 'N independent files, same analysis shape',
+    },
+    {
+        id: 'orch-02',
+        signals: { ordered_plan: true, size_estimate: 5, independent_slices: 0 },
+        expectMode: 'do-in-steps',
+        note: 'explicit ordered numbered plan',
+    },
+    {
+        id: 'orch-03',
+        signals: { size_estimate: 3, independent_slices: 0, ordered_plan: false },
+        expectMode: null,
+        note: 'do-competitively — NOT a v1 DispatchMode (documented scope gap)',
+    },
+    {
+        id: 'pv-01',
+        signals: { size_estimate: 2, independent_slices: 0, ordered_plan: false },
+        expectMode: null,
+        note: 'verdict dispatch — out of the v1 parallel/steps scope',
+    },
+    {
+        id: 'pv-02',
+        signals: { size_estimate: 1, independent_slices: 0, ordered_plan: false },
+        expectMode: null,
+        note: 'negative control — a clean one-file task MUST NOT dispatch',
+    },
+];
+
+describe('parallelizable classifier — corpus recall', () => {
+    for (const c of CORPUS) {
+        it(`${c.id}: ${c.note}`, () => {
+            const r = classifyTask(c.signals, ON);
+            expect(r.mode).toBe(c.expectMode);
+        });
+    }
+
+    it('recall on v1-covered modes is 2/2 (orch-01 parallel, orch-02 steps)', () => {
+        const covered = CORPUS.filter((c) => c.expectMode !== null);
+        const hits = covered.filter((c) => classifyTask(c.signals, ON).mode === c.expectMode);
+        expect(covered).toHaveLength(2);
+        expect(hits).toHaveLength(2);
+    });
+
+    it('false-positive rate is 0 — the negative control (pv-02) never dispatches', () => {
+        const pv02 = CORPUS.find((c) => c.id === 'pv-02')!;
+        expect(classifyTask(pv02.signals, ON).action).not.toBe('dispatch');
+    });
+
+    it('documents the v1 scope gap: do-competitively (orch-03) + verdict (pv-01) are not classified', () => {
+        for (const id of ['orch-03', 'pv-01']) {
+            const c = CORPUS.find((x) => x.id === id)!;
+            expect(classifyTask(c.signals, ON).mode).toBeNull();
+        }
+    });
+});

package/src/scripts/_lib/claude_settings_hooks.ts

@@ -108,8 +108,16 @@ export function build_claude_hook_matrix(manifest_path: string): ClaudeHookMatri
         if (!concerns || (Array.isArray(concerns) && concerns.length === 0)) continue;
         const native = ac_to_native[ac_event];
         if (native === undefined) continue;
+        // Hook-resilience shim (road-to-opt-subagent-harvest P1.4):
+        // local binary → PATH fallback → SILENT exit 0 when neither exists
+        // (a hook must never error-spam the loop on an uninstalled repo).
+        // The dispatcher's own exit code PROPAGATES when it runs — a
+        // fail_closed concern (e.g. block-no-verify) still denies; only the
+        // missing-binary case degrades open, which is the honest degrade
+        // (an absent dispatcher cannot evaluate anything).
         matrix[native] =
             'BIN="$CLAUDE_PROJECT_DIR/agent-config"; [ -x "$BIN" ] || BIN=agent-config; ' +
+            'command -v "$BIN" >/dev/null 2>&1 || exit 0; ' +
             `"$BIN" dispatch:hook --platform claude --event ${ac_event} ` +
             `--native-event ${native} --project-dir "$CLAUDE_PROJECT_DIR" ` +
             `--min-version ${String(hook_spec)}`;

package/src/scripts/_lib/knowledge_global.ts

@@ -6,7 +6,9 @@
  * Python→TS migration). The public API and CLI contract mirror the Python
  * original EXACTLY — same exported snake_case names, same semantics, same
  * tier-classification, provenance footer, and config-merge behavior, same
- * exit codes and byte-identical stdout. No behaviour changes.
+ * exit codes and byte-identical stdout. No behaviour changes at port time;
+ * one deliberate post-port change: DEFAULT_ALLOWED_TIERS narrowed to
+ * ['public'] per ADR-119 (2026-07-12).
  *
  * Structure-grounding v2 (ADR-100 / road-to-structure-grounding-v2). Promotes
  * *expensive* (remote) project-local knowledge cards to a per-user, file-first
@@ -51,8 +53,10 @@ export const TIERS: readonly string[] = ['public', 'vendor', 'proprietary'];
 /**
  * Default tiers eligible to auto-cross a project boundary under default-on.
  * `proprietary` is excluded by design — manual-only regardless of `enabled`.
+ * Narrowed to `public` only per ADR-119 (2026-07-12, council-validated
+ * flip): `vendor` is a deliberate opt-in widening, not the shipped default.
  */
-export const DEFAULT_ALLOWED_TIERS: readonly string[] = ['public', 'vendor'];
+export const DEFAULT_ALLOWED_TIERS: readonly string[] = ['public'];
 
 /**
  * Hard defaults applied when the setting block is absent. Default is ON for

package/src/scripts/_lib/knowledge_global_redaction.ts

@@ -7,7 +7,10 @@
  * the tier gate are matched byte-for-byte against the retired Python implementation. The
  * public API and CLI contract mirror Python exactly — same exported
  * snake_case names, same `GateResult` shape + `summary()` text, same exit
- * codes and stdout. No behaviour changes.
+ * codes and stdout. No behaviour changes at port time; one ADDITIVE
+ * hardening landed after the port (2026-07-12, ADR-103 flip validation):
+ * hidden-unicode detection + strip-then-rescan in `redaction_scan` — inputs
+ * without invisible characters are unaffected.
  *
  * Structure-grounding v2, Phase 1 — the privacy crux (ADR-100 /
  * road-to-structure-grounding-v2). Before any project-local card may cross a
@@ -121,11 +124,26 @@ function _compileIgnoreCase(pattern: string): RegExp {
     return new RegExp(pattern, 'i');
 }
 
+// Invisible / control characters usable to smuggle an identifier past the
+// pattern scan (zero-width class, bidi controls, soft hyphen, BOM, Unicode
+// Tag block) — the encoding-smuggling attack class from the ADR-103
+// council re-evaluation (2026-07-11). Presence is itself a violation:
+// a knowledge card has no legitimate need for invisible characters, and
+// halt-and-surface (never silent-rewrite) is this gate's contract.
+const _HIDDEN_UNICODE_RE =
+    /[­​-‏‪-‮⁠-⁤⁦-⁩\u{E0000}-\u{E007F}]/gu;
+
 /**
  * Combined privacy-floor + source-confidentiality scan over `text`.
  *
  * Returns the list of violations (empty = clean). Reused by the Phase-4
  * linter as the CI net that redaction actually fired on committed cards.
+ *
+ * Hidden-unicode hardening (additive, 2026-07-12): invisible characters are
+ * flagged as their own violation class AND the pattern scan runs on the
+ * stripped text, so a zero-width-broken key/email is still caught by its
+ * own category. Inputs without invisible characters behave byte-identically
+ * to the pre-hardening scan.
  */
 export function redaction_scan(
     text: string,
@@ -136,16 +154,36 @@ export function redaction_scan(
         sql_identifiers?: readonly string[];
     } = {},
 ): RedactionViolation[] {
-    const floor = redact_low_impact_entry(text, {
+    const violations: RedactionViolation[] = [];
+    _HIDDEN_UNICODE_RE.lastIndex = 0;
+    const hidden = text.match(_HIDDEN_UNICODE_RE);
+    let scanText = text;
+    if (hidden !== null && hidden.length > 0) {
+        const counts = new Map<string, number>();
+        for (const ch of hidden) {
+            const cp = `U+${(ch.codePointAt(0) as number).toString(16).toUpperCase().padStart(4, '0')}`;
+            counts.set(cp, (counts.get(cp) ?? 0) + 1);
+        }
+        const summary = [...counts.entries()]
+            .map(([cp, n]) => (n > 1 ? `${cp}×${n}` : cp))
+            .join(' ');
+        violations.push({
+            category: 'hidden_unicode',
+            snippet: _pySliceHead(summary, 40),
+            note: 'invisible characters — possible identifier smuggling; pattern scan ran on the stripped text',
+        });
+        scanText = text.replace(_HIDDEN_UNICODE_RE, '');
+    }
+    const floor = redact_low_impact_entry(scanText, {
         repoRoot: options.repo_root ?? null,
         privateDomains: options.private_domains ?? [],
         customerNames: options.customer_names ?? [],
         sqlIdentifiers: options.sql_identifiers ?? [],
     });
-    const violations: RedactionViolation[] = [...floor.violations];
+    violations.push(...floor.violations);
     for (const rx of _load_denylist_patterns()) {
         rx.lastIndex = 0;
-        const m = rx.exec(text);
+        const m = rx.exec(scanText);
         if (m) {
             violations.push({
                 category: 'external_source',

package/src/scripts/_lib/lexical_index.ts

@@ -90,11 +90,20 @@ export class LexicalIndex {
         return Math.max(0, Math.log(1 + (this.n - df + 0.5) / (df + 0.5)));
     }
 
-    /** BM25 score of one document against the tokenised query terms. */
+    /**
+     * BM25 score of one document against the tokenised query terms, weighted by
+     * **term coverage**: the raw BM25 sum is multiplied by `coverage²`, where
+     * `coverage = distinct-query-terms-matched / distinct-query-terms`. This
+     * stops a single generic, high-TF term match from outranking a document that
+     * matches several rarer query terms once each (Phase 1 refinement). A
+     * single-term query has `coverage == 1`, so its score is unchanged — the
+     * weighting only re-orders genuinely multi-term queries.
+     */
     score(queryTerms: readonly string[], docId: string): number {
         const doc = this.docs.get(docId);
         if (doc === undefined || doc.len === 0) return 0;
         let s = 0;
+        const matched = new Set<string>();
         for (const term of queryTerms) {
             const tf = doc.tf.get(term);
             if (tf === undefined) continue;
@@ -102,8 +111,12 @@ export class LexicalIndex {
             if (idf === 0) continue;
             const denom = tf + BM25_K1 * (1 - BM25_B + (BM25_B * doc.len) / (this.avgdl || 1));
             s += (idf * (tf * (BM25_K1 + 1))) / denom;
+            matched.add(term);
         }
-        return s;
+        if (s === 0) return 0;
+        const distinctQuery = new Set(queryTerms).size;
+        const coverage = distinctQuery > 0 ? matched.size / distinctQuery : 1;
+        return s * coverage * coverage;
     }
 
     /**

package/src/scripts/_lib/orchestration_record.ts

@@ -24,6 +24,17 @@ export type TierSource = 'static' | 'inferred' | 'inherit';
 export type Band = 'low' | 'medium' | 'high';
 export type LinePhase = 'refine' | 'memory' | 'analyze' | 'plan' | 'implement' | 'test' | 'verify' | 'report';
 export type LineOutcome = 'success' | 'blocked' | 'skipped' | 'error';
+/** The orchestration form the form-gate selected (road-to-opt-subagent-harvest P2). */
+export type DispatchModeId =
+    | 'do-and-judge'
+    | 'do-and-judge-two-stage'
+    | 'do-in-steps'
+    | 'do-in-parallel'
+    | 'do-competitively'
+    | 'judge-with-debate'
+    | 'do-in-worktrees'
+    | 'do-with-live-app-judge'
+    | 'none';
 
 /** Inputs the agent supplies about one auto-dispatch. */
 export interface RecordInput {
@@ -37,6 +48,8 @@ export interface RecordInput {
     tier_chosen?: TierChosen | null | undefined;
     tier_source?: TierSource | null | undefined;
     task_class?: string | null | undefined;
+    /** Form-gate outcome: which of the seven modes (or 'none') the gate selected. */
+    dispatch_mode?: DispatchModeId | null | undefined;
     task_size_estimate?: number | undefined;
     wall_clock_ms?: number | undefined;
     /** Absolute measured tokens the dispatched slice consumed (feeds the modeled cost-%). */
@@ -45,6 +58,10 @@ export interface RecordInput {
     session_tier?: string | null | undefined;
     dispatch_outcome?: DispatchOutcome | undefined;
     verify_mode?: VerifyMode | undefined;
+    /** QUALITY: subagent return adopted without parent rework. Optional boolean (null = not measured). */
+    first_pass_success?: boolean | undefined;
+    /** QUALITY: slice retried on a higher tier after a verification failure. Optional boolean (null = not measured). */
+    escalated?: boolean | undefined;
     // Audit-log envelope (sensible defaults for a dispatch record)
     phase?: LinePhase | undefined;
     outcome?: LineOutcome | undefined;
@@ -127,6 +144,13 @@ export function buildOrchestrationLine(input: RecordInput): BuiltLine {
     const phase = input.phase ?? 'implement';
     if (!PHASES.includes(phase)) errors.push(`phase must be one of ${PHASES.join(' | ')}`);
 
+    if (input.first_pass_success !== undefined && typeof input.first_pass_success !== 'boolean') {
+        errors.push('first_pass_success must be a boolean (true = return adopted without parent rework) or omitted');
+    }
+    if (input.escalated !== undefined && typeof input.escalated !== 'boolean') {
+        errors.push('escalated must be a boolean (true = retried on a higher tier after verification failure) or omitted');
+    }
+
     if (!input.ts) errors.push('ts (ISO-8601 UTC) is required');
     if (!input.id) errors.push('id (ULID or content hash) is required');
 
@@ -142,10 +166,13 @@ export function buildOrchestrationLine(input: RecordInput): BuiltLine {
         outcome: dOutcome,
         verify_mode: vMode,
         task_class: input.task_class ?? null,
+        dispatch_mode: input.dispatch_mode ?? null,
         tier_chosen: input.tier_chosen ?? null,
         tier_source: input.tier_source ?? null,
         dispatch_tokens: input.dispatch_tokens ?? null,
         session_tier: input.session_tier ?? null,
+        first_pass_success: input.first_pass_success ?? null,
+        escalated: input.escalated ?? null,
     };
 
     const line: Record<string, unknown> = {

package/src/scripts/_lib/orchestration_savings.ts

@@ -39,6 +39,10 @@ export interface OrchestrationRecord {
     dispatch_tokens?: number | null;
     /** The orchestrator's own tier — the baseline the downshift is measured against. */
     session_tier?: string | null;
+    /** QUALITY: subagent return adopted without parent rework. null/absent = pre-extension line / not measured. */
+    first_pass_success?: boolean | null;
+    /** QUALITY: slice retried on a higher tier after a verification failure. null/absent = pre-extension line / not measured. */
+    escalated?: boolean | null;
 }
 
 /** A parsed audit-log-v1 line (only the fields this aggregator touches). */
@@ -65,6 +69,21 @@ export interface ModeledCost {
     weights: TierWeights;
 }
 
+export interface QualityStats {
+    /** Dispatches carrying at least one of the two quality booleans (the n behind the ≥20 pairing gate). */
+    quality_lines: number;
+    /** Dispatches carrying a boolean first_pass_success. */
+    first_pass_lines: number;
+    first_pass_success_count: number;
+    /** first_pass_success_count / first_pass_lines, 0..1; null when no line carries the field. */
+    first_pass_success_rate: number | null;
+    /** Dispatches carrying a boolean escalated. */
+    escalated_lines: number;
+    escalated_count: number;
+    /** escalated_count / escalated_lines, 0..1; null when no line carries the field. */
+    escalation_rate: number | null;
+}
+
 export interface SavingsReport {
     /** Lines carrying an orchestration object with spawn_count > 0. */
     dispatches: number;
@@ -84,6 +103,8 @@ export interface SavingsReport {
     measured_share: number;
     /** Modeled downshift cost-% (tier-weight based). Distinct from the measured token counts. */
     modeled_cost: ModeledCost;
+    /** QUALITY dimension — paired with cost per council verdict; never report savings alone. */
+    quality: QualityStats;
     /** Honest caveats about what the number does and does not mean. */
     notes: string[];
 }
@@ -115,6 +136,15 @@ export function aggregateOrchestrationSavings(
         by_task_class: {},
         measured_share: 0,
         modeled_cost: { covered_dispatches: 0, baseline_cost_units: 0, delegated_cost_units: 0, cost_reduction_pct: null, weights },
+        quality: {
+            quality_lines: 0,
+            first_pass_lines: 0,
+            first_pass_success_count: 0,
+            first_pass_success_rate: null,
+            escalated_lines: 0,
+            escalated_count: 0,
+            escalation_rate: null,
+        },
         notes: [],
     };
 
@@ -154,6 +184,21 @@ export function aggregateOrchestrationSavings(
             report.modeled_cost.baseline_cost_units += dt * wSession;
             report.modeled_cost.delegated_cost_units += dt * wChosen;
         }
+
+        // Quality dimension — only booleans count; null/absent = pre-extension
+        // line / not measured (never a silent false).
+        const q = report.quality;
+        const fps = typeof o.first_pass_success === 'boolean';
+        const esc = typeof o.escalated === 'boolean';
+        if (fps || esc) q.quality_lines += 1;
+        if (fps) {
+            q.first_pass_lines += 1;
+            if (o.first_pass_success === true) q.first_pass_success_count += 1;
+        }
+        if (esc) {
+            q.escalated_lines += 1;
+            if (o.escalated === true) q.escalated_count += 1;
+        }
     }
 
     report.measured_share = report.dispatches === 0 ? 0 : report.by_provenance.measured.dispatches / report.dispatches;
@@ -161,6 +206,10 @@ export function aggregateOrchestrationSavings(
     const mc = report.modeled_cost;
     mc.cost_reduction_pct = mc.baseline_cost_units > 0 ? (mc.baseline_cost_units - mc.delegated_cost_units) / mc.baseline_cost_units : null;
 
+    const q = report.quality;
+    q.first_pass_success_rate = q.first_pass_lines > 0 ? q.first_pass_success_count / q.first_pass_lines : null;
+    q.escalation_rate = q.escalated_lines > 0 ? q.escalated_count / q.escalated_lines : null;
+
     // Honest caveats — always attached so a consumer never over-reads the number.
     if (report.dispatches === 0) {
         report.notes.push('No orchestration telemetry yet (0 dispatches). Data accrues as `subagents.auto: on` delegates real slices (recorded via orchestration_record).');
@@ -174,6 +223,9 @@ export function aggregateOrchestrationSavings(
         } else {
             report.notes.push('MODELED cost-% unavailable: no dispatch yet carries dispatch_tokens + session_tier + tier_chosen. Record those (orchestration_record --dispatch-tokens/--session-tier/--tier-chosen) to populate it.');
         }
+        if (q.quality_lines === 0) {
+            report.notes.push('QUALITY columns empty: no dispatch yet carries first_pass_success / escalated. Record them (orchestration_record --first-pass-success/--escalated) — cost and quality are reported as a PAIR, never savings alone.');
+        }
     }
 
     return report;

package/src/scripts/_lib/trigger_eval_floors.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared trigger-eval precision/recall floors — single source of truth.
+ *
+ * Extracted from `src/cli/commands/recordTriggerEval.ts` so the weekly
+ * canary rotation (`src/scripts/trigger_eval_rotation.ts`, ADR-118 §4) and
+ * the `eval:record` provenance recorder enforce the SAME per-domain floors.
+ * Values are unchanged from the recorder's originals (Phase D council
+ * verdict — tuned to the trigger pattern each skill shows, not a single
+ * global pair): a reference task wants near-perfect precision; a judgment
+ * task tolerates a looser one.
+ */
+
+export interface TriggerEvalFloor {
+    minRecall: number;
+    minPrecision: number;
+}
+
+/** Universal fallback floor when a skill carries no domain-specific entry. */
+export const DEFAULT_FLOOR: TriggerEvalFloor = { minRecall: 1.0, minPrecision: 0.8 };
+
+/** Domain-specific floors; skills absent here fall back to {@link DEFAULT_FLOOR}. */
+export const DOMAIN_FLOORS: Readonly<Record<string, TriggerEvalFloor>> = {
+    'image-generation': { minRecall: 1.0, minPrecision: 0.85 },
+    iconography: { minRecall: 1.0, minPrecision: 0.9 },
+    'brand-strategy': { minRecall: 0.9, minPrecision: 0.7 },
+};
+
+/** Resolve the effective floor for a skill (domain entry, else default). */
+export function floor_for(skill: string | null | undefined): TriggerEvalFloor {
+    return (skill !== null && skill !== undefined && DOMAIN_FLOORS[skill]) || DEFAULT_FLOOR;
+}

package/src/scripts/ai_council/chairman.ts

@@ -0,0 +1,90 @@
+// Chairman selection (road-to-opt-council-deliberation Phase 2).
+//
+// The council's Iron Law argues the host, having framed the artefact, cannot
+// independently judge it — so synthesis by a *non-deliberating* member removes
+// that bias. This module is the pure SELECTION decision (who chairs, and the
+// visible verdict annotation); the billable dispatch of the chairman's synthesis
+// call lives in the CLI run path, gated behind the same config.
+//
+// `auto` policy — decided by the contested-design council pass (anthropic/
+// claude-sonnet-4-5 + openai/gpt-4o, 2-round debate, 2026-07-12):
+// **provider-family difference is primary** — independence from the
+// deliberators' priors is the binding constraint for a judge, and provider
+// diversity is the one structural guarantee available without an LLM call.
+// The **tie-break is the capability signal**: an explicit optional
+// `members.<name>.tier` when present (higher = stronger), else deterministic
+// config order. In this engine each member IS one provider (the
+// one-advisor-per-provider invariant), so every enabled member that did not
+// deliberate is provider-different from every deliberator by construction.
+
+export interface ChairmanCandidate {
+    /** Member name (== provider key in this engine). */
+    name: string;
+    /** Optional capability rank from `members.<name>.tier`; higher = stronger. */
+    tier: number | null;
+}
+
+export interface ChairmanSelection {
+    /** The chosen chairman member name, or `null` → host synthesis (today's path). */
+    member: string | null;
+    /** Visible annotation for the synthesis verdict — never a silent substitution. */
+    annotation: string;
+}
+
+/**
+ * Pure chairman selection.
+ *
+ * @param mode        one of `host` | `member` | `auto` (validated at config load)
+ * @param member      the configured member name when `mode === 'member'`
+ * @param deliberated member names that produced a real (non-error, non-empty) response this session
+ * @param candidates  enabled members in **config order** (the engine's only trusted ordering)
+ */
+export function select_chairman(
+    mode: string,
+    member: string | null,
+    deliberated: ReadonlySet<string>,
+    candidates: readonly ChairmanCandidate[],
+): ChairmanSelection {
+    if (mode === 'host') {
+        return { member: null, annotation: 'Chairman: host' };
+    }
+    const enabledNames = new Set(candidates.map((c) => c.name));
+    if (mode === 'member') {
+        if (member === null || !enabledNames.has(member)) {
+            return {
+                member: null,
+                annotation: `Chairman: host (member ${_q(member)} unavailable — host fallback)`,
+            };
+        }
+        if (deliberated.has(member)) {
+            // A member that argued in the debate cannot independently judge it.
+            return {
+                member: null,
+                annotation: `Chairman: host (member ${_q(member)} deliberated — cannot self-judge, host fallback)`,
+            };
+        }
+        return { member, annotation: `Chairman: ${member}` };
+    }
+    // mode === 'auto' — provider-family difference primary (non-deliberating ⇒
+    // provider-different by construction here); tier tie-break; config-order final.
+    const pool = candidates.filter((c) => !deliberated.has(c.name));
+    if (pool.length === 0) {
+        return {
+            member: null,
+            annotation: 'Chairman: host (no non-panel member available)',
+        };
+    }
+    let best = pool[0] as ChairmanCandidate;
+    for (const c of pool.slice(1)) {
+        const bestTier = best.tier ?? Number.NEGATIVE_INFINITY;
+        const cTier = c.tier ?? Number.NEGATIVE_INFINITY;
+        if (cTier > bestTier) {
+            best = c; // strictly higher tier wins; equal/lower keeps config order
+        }
+    }
+    return { member: best.name, annotation: `Chairman: ${best.name} (auto)` };
+}
+
+function _q(v: string | null): string {
+    return v === null ? 'null' : `'${v}'`;
+}

package/src/scripts/ai_council/clients.ts

@@ -71,6 +71,21 @@ export const DEFAULT_GEMINI_MODEL = 'gemini-2.5-pro';
 export const DEFAULT_XAI_MODEL = 'grok-4';
 export const DEFAULT_PERPLEXITY_MODEL = 'sonar-pro';
 
+// Vendor CLI (subscription transport) default models. Omitting `model` in a
+// CLI client's options pins THESE values — a pin, not "latest"; the vendor
+// CLI's own default may be newer. Bump deliberately; never assume drift.
+//
+// These are SEPARATE from the API-transport `DEFAULT_*_MODEL` constants above
+// because API and CLI defaults can legitimately diverge — openai proves it
+// (API `gpt-4o` vs CLI `gpt-5`). The anthropic/gemini CLI values currently
+// coincide with their API defaults, but stay pinned independently so a future
+// divergence is a one-line change, not a hunt through inline literals.
+// (`xai` / `perplexity` CLI reuse their API constants: their CLIs are
+// community wrappers around the same paid API, so the values do not diverge.)
+export const DEFAULT_OPENAI_CLI_MODEL = 'gpt-5';
+export const DEFAULT_ANTHROPIC_CLI_MODEL = 'claude-sonnet-4-5';
+export const DEFAULT_GEMINI_CLI_MODEL = 'gemini-2.5-pro';
+
 // OpenAI-API-compatible endpoints. xAI and Perplexity both expose the
 // `/v1/chat/completions` shape, so their clients reuse the `openai` SDK with a
 // custom `base_url`. Gemini has its own SDK (`google-genai`).
@@ -1171,7 +1186,7 @@ export class AnthropicCliClient extends CliClient {
 
     constructor(opts: CliClientOptions = {}) {
         super({
-            model: opts.model ?? 'claude-sonnet-4-5',
+            model: opts.model ?? DEFAULT_ANTHROPIC_CLI_MODEL,
             binary: opts.binary,
             timeout_seconds: opts.timeout_seconds,
             max_calls_per_day: opts.max_calls_per_day,
@@ -1271,7 +1286,7 @@ export class OpenAICliClient extends CliClient {
 
     constructor(opts: CliClientOptions = {}) {
         super({
-            model: opts.model ?? 'gpt-5',
+            model: opts.model ?? DEFAULT_OPENAI_CLI_MODEL,
             binary: opts.binary,
             timeout_seconds: opts.timeout_seconds,
             max_calls_per_day: opts.max_calls_per_day,
@@ -1394,7 +1409,7 @@ export class GeminiCliClient extends CliClient {
 
     constructor(opts: CliClientOptions = {}) {
         super({
-            model: opts.model ?? 'gemini-2.5-pro',
+            model: opts.model ?? DEFAULT_GEMINI_CLI_MODEL,
             binary: opts.binary,
             timeout_seconds: opts.timeout_seconds,
             max_calls_per_day: opts.max_calls_per_day,