@event4u/agent-config 9.28.0 → 9.30.0

package/src/scripts/session_eol_report.ts

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+/**
+ * session_eol_report — session end-of-life baseline over the local
+ * Claude Code transcript store (road-to-token-economy-recycling Phases
+ * 1.1–1.3). Read-only; prints aggregate numbers, never content.
+ *
+ * Per session file (main chain only): final context size in parsed tokens
+ * (`cc_transcript.billableInputTokens` of the last assistant record), turn
+ * count, and every observed compaction event (`_lib/session_eol.ts`
+ * detector, pinned to the observed `compact_boundary` marker). The
+ * aggregate is the baseline the recycle threshold cites
+ * (`src/config/recycle-threshold-budget.json`), and the reproduce command
+ * for `agents/evidence/analysis/token-economy-recycling-phase1.md`:
+ *
+ *     ./scripts-run src/scripts/session_eol_report            # text
+ *     ./scripts-run src/scripts/session_eol_report -- --json  # machine
+ *
+ * Fallback honesty (Phase 1.2): sessions whose transcript yields NO
+ * parseable assistant usage are counted as `sessions_without_usage`, and
+ * the bytes↔tokens Pearson r over the READABLE set is printed so the
+ * byte-proxy's (un)fitness is a published number, not a vibe.
+ *
+ * Marker-drift alarm (blocker `compaction-marker-shape`): the scanner
+ * counts BOTH observed markers independently; a store-wide divergence
+ * between `compact_boundary` events and `isCompactSummary` records is
+ * reported as drift instead of silently zeroing the metric.
+ */
+
+import * as fs from 'node:fs';
+import process from 'node:process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import * as path from 'node:path';
+
+import { DEFAULT_PROJECTS_ROOT, listTranscriptFiles } from './_lib/cc_transcript.js';
+import { emptyCounters, scanEolSlice, type EolCounters } from './_lib/session_eol.js';
+
+export interface SessionSummary {
+    file: string;
+    bytes: number;
+    counters: EolCounters;
+    last_ts: string | null;
+}
+
+export interface EolReport {
+    schema_version: 1;
+    generated_at: string;
+    root: string;
+    files_scanned: number;
+    sessions: number;
+    sessions_with_usage: number;
+    sessions_without_usage: number;
+    final_context_tokens: Percentiles | null;
+    turns: Percentiles | null;
+    compaction: {
+        sessions_with_compaction: number;
+        events_total: number;
+        events_by_trigger: Record<string, number>;
+        pre_tokens: Percentiles | null;
+        post_tokens: Percentiles | null;
+        /** `isCompactSummary` records store-wide — drift alarm vs `events_total`. */
+        compact_summary_records: number;
+        marker_drift: boolean;
+    };
+    /** Pearson r of file bytes vs final context tokens over the readable set. */
+    bytes_tokens_pearson_r: number | null;
+    threshold_crossings: Record<string, number>;
+}
+
+export interface Percentiles {
+    n: number;
+    min: number;
+    median: number;
+    p90: number;
+    p95: number;
+    max: number;
+}
+
+function percentile(sorted: number[], p: number): number {
+    if (sorted.length === 0) return NaN;
+    const k = (sorted.length - 1) * p;
+    const f = Math.floor(k);
+    const c = Math.min(f + 1, sorted.length - 1);
+    return (sorted[f] as number) + ((sorted[c] as number) - (sorted[f] as number)) * (k - f);
+}
+
+export function percentiles(values: number[]): Percentiles | null {
+    if (values.length === 0) return null;
+    const sorted = [...values].sort((a, b) => a - b);
+    return {
+        n: sorted.length,
+        min: sorted[0] as number,
+        median: percentile(sorted, 0.5),
+        p90: percentile(sorted, 0.9),
+        p95: percentile(sorted, 0.95),
+        max: sorted[sorted.length - 1] as number,
+    };
+}
+
+function pearson(pairs: Array<[number, number]>): number | null {
+    if (pairs.length < 3) return null;
+    const n = pairs.length;
+    const mx = pairs.reduce((s, [x]) => s + x, 0) / n;
+    const my = pairs.reduce((s, [, y]) => s + y, 0) / n;
+    let cov = 0;
+    let sx = 0;
+    let sy = 0;
+    for (const [x, y] of pairs) {
+        cov += (x - mx) * (y - my);
+        sx += (x - mx) ** 2;
+        sy += (y - my) ** 2;
+    }
+    if (sx === 0 || sy === 0) return null;
+    return cov / (Math.sqrt(sx) * Math.sqrt(sy));
+}
+
+/** Scan one transcript file into a session summary. Unreadable file → null. */
+export function scanSessionFile(file: string): SessionSummary | null {
+    let text: string;
+    let bytes: number;
+    try {
+        text = fs.readFileSync(file, 'utf-8');
+        bytes = fs.statSync(file).size;
+    } catch {
+        return null;
+    }
+    const counters = scanEolSlice(text, emptyCounters());
+    let last_ts: string | null = null;
+    // cheap: reuse the final assistant stamp; fall back to null.
+    last_ts = counters.final_context_at;
+    return { file, bytes, counters, last_ts };
+}
+
+export function buildReport(root: string, now: Date = new Date()): EolReport {
+    const files = listTranscriptFiles({ root });
+    const sessions: SessionSummary[] = [];
+    for (const file of files) {
+        const summary = scanSessionFile(file);
+        if (!summary) continue;
+        const c = summary.counters;
+        if (c.assistant_records === 0 && c.turns === 0 && c.compactions.length === 0) continue;
+        sessions.push(summary);
+    }
+
+    const withUsage = sessions.filter((s) => s.counters.final_context_tokens !== null);
+    const finals = withUsage.map((s) => s.counters.final_context_tokens as number);
+    const turns = withUsage.map((s) => s.counters.turns);
+
+    const allEvents = sessions.flatMap((s) => s.counters.compactions);
+    const byTrigger: Record<string, number> = {};
+    for (const e of allEvents) byTrigger[e.trigger] = (byTrigger[e.trigger] ?? 0) + 1;
+    const pre = allEvents.map((e) => e.pre_tokens).filter((v): v is number => v !== null);
+    const post = allEvents.map((e) => e.post_tokens).filter((v): v is number => v !== null);
+    const summaryRecords = sessions.reduce((s, x) => s + x.counters.compact_summaries, 0);
+
+    const crossings: Record<string, number> = {};
+    for (const thr of [200_000, 400_000, 600_000, 800_000]) {
+        crossings[`>=${thr / 1000}k`] = finals.filter((c) => c >= thr).length;
+    }
+
+    return {
+        schema_version: 1,
+        generated_at: now.toISOString(),
+        root,
+        files_scanned: files.length,
+        sessions: sessions.length,
+        sessions_with_usage: withUsage.length,
+        sessions_without_usage: sessions.length - withUsage.length,
+        final_context_tokens: percentiles(finals),
+        turns: percentiles(turns),
+        compaction: {
+            sessions_with_compaction: sessions.filter((s) => s.counters.compactions.length > 0).length,
+            events_total: allEvents.length,
+            events_by_trigger: byTrigger,
+            pre_tokens: percentiles(pre),
+            post_tokens: percentiles(post),
+            compact_summary_records: summaryRecords,
+            marker_drift: summaryRecords !== allEvents.length,
+        },
+        bytes_tokens_pearson_r: pearson(
+            withUsage
+                .filter((s) => (s.counters.final_context_tokens as number) > 1_000)
+                .map((s) => [s.bytes, s.counters.final_context_tokens as number]),
+        ),
+        threshold_crossings: crossings,
+    };
+}
+
+function fmt(n: number): string {
+    return Math.round(n).toLocaleString('en-US');
+}
+
+export function renderText(r: EolReport): string {
+    const lines: string[] = [];
+    lines.push(`session end-of-life baseline — ${r.root}`);
+    lines.push(`files scanned: ${r.files_scanned} · sessions: ${r.sessions}`);
+    lines.push(
+        `  with parseable final usage: ${r.sessions_with_usage} · without (fallback set, 1.2): ${r.sessions_without_usage}`,
+    );
+    if (r.final_context_tokens) {
+        const f = r.final_context_tokens;
+        lines.push(
+            `final context tokens: median=${fmt(f.median)} p90=${fmt(f.p90)} p95=${fmt(f.p95)} max=${fmt(f.max)}`,
+        );
+    }
+    if (r.turns) {
+        lines.push(`turns per session: median=${fmt(r.turns.median)} p90=${fmt(r.turns.p90)} max=${fmt(r.turns.max)}`);
+    }
+    const c = r.compaction;
+    lines.push(
+        `compaction: ${c.sessions_with_compaction} sessions, ${c.events_total} events (${Object.entries(c.events_by_trigger)
+            .map(([k, v]) => `${k}:${v}`)
+            .join(', ') || 'none'})`,
+    );
+    if (c.pre_tokens) {
+        lines.push(
+            `  trigger pre-tokens: min=${fmt(c.pre_tokens.min)} median=${fmt(c.pre_tokens.median)} max=${fmt(c.pre_tokens.max)}`,
+        );
+    }
+    if (c.post_tokens) {
+        lines.push(`  post-tokens median=${fmt(c.post_tokens.median)}`);
+    }
+    lines.push(
+        `  marker drift (${c.events_total} boundary vs ${c.compact_summary_records} summary records): ${c.marker_drift ? 'YES — detector shapes diverge, re-pin the fixture' : 'no'}`,
+    );
+    lines.push(
+        `bytes↔tokens Pearson r (readable set): ${r.bytes_tokens_pearson_r === null ? 'n/a' : r.bytes_tokens_pearson_r.toFixed(3)}`,
+    );
+    for (const [k, v] of Object.entries(r.threshold_crossings)) {
+        lines.push(`sessions ending ${k} tokens: ${v}`);
+    }
+    return lines.join('\n');
+}
+
+export function main(argv: string[] = process.argv.slice(2)): number {
+    const json = argv.includes('--json');
+    const rootFlag = argv.indexOf('--root');
+    const root =
+        rootFlag !== -1 && argv[rootFlag + 1] ? path.resolve(argv[rootFlag + 1] as string) : DEFAULT_PROJECTS_ROOT;
+    const report = buildReport(root);
+    process.stdout.write(json ? `${JSON.stringify(report, null, 2)}\n` : `${renderText(report)}\n`);
+    return 0;
+}
+
+// Bundle-safety: never auto-run when inlined into an esbuild bundle.
+declare const __AGENT_CONFIG_BUNDLE__: boolean | undefined;
+function _isCliEntry(): boolean {
+    if (typeof __AGENT_CONFIG_BUNDLE__ !== 'undefined' && __AGENT_CONFIG_BUNDLE__) return false;
+    if (process.argv[1] === undefined) return false;
+    if (import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href) return true;
+    try {
+        return (
+            fs.realpathSync(fileURLToPath(import.meta.url)) === fs.realpathSync(path.resolve(process.argv[1]))
+        );
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry()) {
+    process.exit(main());
+}

package/src/scripts/team_events_spike.ts

@@ -0,0 +1,271 @@
+#!/usr/bin/env tsx
+/**
+ * Team-event payload shape spike (Phase 5.1, road-to-always-on-orchestration).
+ *
+ * `TaskCreated` / `TaskCompleted` / `TeammateIdle` are documented Claude Code
+ * hook events (agent teams, behind `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS`),
+ * but this repo has never observed a real payload for any of them — the
+ * shapes are documented, not verified. This script is manually startable
+ * ONLY: it is never wired into `hook_manifest.yaml` / `hooks.json`. A
+ * maintainer points a hook command at it (or pipes a captured payload) to
+ * record a SHAPE — field names + JS/JSON types — and never a value.
+ * Privacy by construction: the recursive walk below inspects `typeof` /
+ * `Array.isArray`, nothing else, so there is no code path that could copy a
+ * value into the written report.
+ *
+ * SCOPE OF THE PRIVACY CLAIM (stated honestly, per independent review): the
+ * claim above holds for a payload whose OWN keys are static field names —
+ * true of the three documented envelopes this script targets
+ * (`TaskCreated` / `TaskCompleted` / `TeammateIdle`), where a key is always
+ * a schema name like `task_id` or `teammate_name`. It does NOT hold for a
+ * payload with dynamically-named keys — a map keyed by a file path, a
+ * person's name, or any other runtime value — because `extractShape` walks
+ * `Object.keys()` and records each key verbatim as a "field name". A
+ * dynamic key is not a field name; it is a value wearing a field name's
+ * clothes, and this script would write it into the tracked report exactly
+ * as it would refuse to write a value. Point this script only at the three
+ * documented shapes (or another envelope you have separately confirmed has
+ * static keys) — never at an undocumented payload that might carry a
+ * dynamically-keyed map.
+ *
+ * Usage (only meaningful with the experimental flag set):
+ *
+ *     echo '<payload-json>' | \
+ *       CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 npx tsx src/scripts/team_events_spike.ts [EventName]
+ *
+ * `EventName` is optional; if omitted, the payload's own `hook_event_name` /
+ * `event` / `eventName` / `event_name` / `type` field is read and matched
+ * against the three known `TEAM_EVENT_NAMES` — an unrecognised value falls
+ * back to `unlabeled-event` rather than copying the raw (payload-supplied)
+ * string into the report, which would itself be writing a value under the
+ * cover of a "name".
+ *
+ * Without the flag: clean one-line skip, exit 0, stdin is never touched.
+ *
+ * Output: appends one dated section per capture to
+ * `agents/evidence/analysis/team-event-shapes.md`.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const _HERE = fileURLToPath(import.meta.url);
+const ROOT = path.resolve(path.dirname(_HERE), '..', '..');
+const OUT_FILE = path.join(ROOT, 'agents', 'evidence', 'analysis', 'team-event-shapes.md');
+
+export const FLAG = 'CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS';
+export const TEAM_EVENT_NAMES = ['TaskCreated', 'TaskCompleted', 'TeammateIdle'] as const;
+
+export interface ShapeEntry {
+    path: string;
+    type: string;
+}
+
+/** JS/JSON type of a value. Reads only `typeof` / `Array.isArray` — never the value. */
+function _typeOf(value: unknown): string {
+    if (value === null) return 'null';
+    if (Array.isArray(value)) return 'array';
+    return typeof value; // 'string' | 'number' | 'boolean' | 'object' | 'undefined'
+}
+
+/**
+ * Walk a parsed JSON payload and record field-name + type only.
+ *
+ * This never returns, prints, or embeds a value — recursion is driven
+ * entirely by structural type and object keys.
+ */
+export function extractShape(value: unknown, prefix = ''): ShapeEntry[] {
+    const entries: ShapeEntry[] = [];
+    const t = _typeOf(value);
+    if (prefix !== '') {
+        entries.push({ path: prefix, type: t });
+    }
+    if (t === 'array') {
+        // An event payload's arrays are homogeneous lists, not fixed tuples —
+        // merge every element's shape under one `[]` path (deduped below).
+        for (const item of value as unknown[]) {
+            entries.push(...extractShape(item, `${prefix}[]`));
+        }
+        return entries;
+    }
+    if (t === 'object') {
+        const obj = value as Record<string, unknown>;
+        for (const key of Object.keys(obj).sort()) {
+            entries.push(...extractShape(obj[key], prefix === '' ? key : `${prefix}.${key}`));
+        }
+    }
+    return entries;
+}
+
+/** De-duplicate by path+type — an array's elements repeat the same shape. */
+function _dedupe(entries: ShapeEntry[]): ShapeEntry[] {
+    const seen = new Set<string>();
+    const out: ShapeEntry[] = [];
+    for (const e of entries) {
+        const key = `${e.path}\u0000${e.type}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        out.push(e);
+    }
+    return out;
+}
+
+/**
+ * Best-effort event-name inference from the payload's own envelope.
+ *
+ * m4 fix (independent-review finding): the envelope field this reads
+ * (`hook_event_name` / `event` / `type` / …) carries a payload-SUPPLIED
+ * string — copying it verbatim into the recorded report is exactly the
+ * "copy a value into the report" this script otherwise refuses to do
+ * (see the module header's privacy claim). Matched against the known
+ * `TEAM_EVENT_NAMES` allowlist instead: a recognised name is safe to
+ * record because it is drawn from three publicly documented, stable
+ * literals, never from the untrusted payload string itself; anything
+ * else returns `null` and the caller falls back to the fixed literal
+ * `'unlabeled-event'`.
+ */
+export function inferEventName(payload: unknown): string | null {
+    if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) return null;
+    const obj = payload as Record<string, unknown>;
+    const known = new Set<string>(TEAM_EVENT_NAMES);
+    for (const key of ['hook_event_name', 'event', 'eventName', 'event_name', 'type']) {
+        const v = obj[key];
+        if (typeof v === 'string' && known.has(v)) return v;
+    }
+    return null;
+}
+
+/** Render one capture as a Markdown section — field names + types only. */
+export function renderShapeReport(eventName: string, entries: ShapeEntry[], observedAt: string): string {
+    const deduped = _dedupe(entries);
+    const rows = deduped.map((e) => `| \`${e.path}\` | ${e.type} |`).join('\n');
+    const table = rows === '' ? '_(empty payload — no fields observed)_' : `| Field | Type |\n|---|---|\n${rows}`;
+    return [`## ${eventName} — observed ${observedAt}`, '', table, ''].join('\n');
+}
+
+function _printGuide(): void {
+    process.stdout.write(
+        [
+            'team-event shape spike (manual, not hook-bound)',
+            '',
+            `${FLAG} is set — recording.`,
+            '',
+            `Observed events: ${TEAM_EVENT_NAMES.join(', ')}`,
+            '',
+            'Pipe one captured JSON payload on stdin — values are never written,',
+            'only field names + types:',
+            '',
+            `  echo '<payload-json>' | ${FLAG}=1 npx tsx src/scripts/team_events_spike.ts [EventName]`,
+            '',
+            `Shapes append to ${path.relative(ROOT, OUT_FILE)}.`,
+            '',
+        ].join('\n'),
+    );
+}
+
+async function _readStdin(): Promise<string> {
+    const chunks: Buffer[] = [];
+    // `for await` streams stdin — a synchronous `readFileSync(0)` EAGAINs
+    // past the pipe buffer on a large payload; this has no such ceiling.
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk as Buffer);
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}
+
+export interface RunResult {
+    skipped: boolean;
+    reason?: string;
+    eventName?: string;
+    entryCount?: number;
+    outFile?: string;
+}
+
+export interface RunOptions {
+    argv?: string[];
+    env?: NodeJS.ProcessEnv;
+    readStdin?: () => Promise<string>;
+    writeReport?: (section: string) => void;
+    now?: () => string;
+}
+
+/**
+ * Orchestrates the spike. Every side effect is injectable so tests never
+ * touch the real environment, stdin, or the tracked report file.
+ */
+export async function run(opts?: RunOptions): Promise<RunResult> {
+    const env = opts?.env ?? process.env;
+    const argv = opts?.argv ?? process.argv.slice(2);
+    const readStdin = opts?.readStdin ?? _readStdin;
+    const now = opts?.now ?? (() => new Date().toISOString());
+    const writeReport =
+        opts?.writeReport ??
+        ((section: string) => {
+            fs.mkdirSync(path.dirname(OUT_FILE), { recursive: true });
+            fs.appendFileSync(OUT_FILE, section, 'utf-8');
+        });
+
+    if (!env[FLAG]) {
+        const reason = `${FLAG} is not set — teams are experimental and unavailable; skipping.`;
+        process.stdout.write(`${reason}\n`);
+        return { skipped: true, reason };
+    }
+
+    _printGuide();
+    const raw = (await readStdin()).trim();
+    if (raw === '') {
+        const reason = 'no payload received on stdin — nothing recorded.';
+        process.stdout.write(`${reason}\n`);
+        return { skipped: true, reason };
+    }
+
+    let payload: unknown;
+    try {
+        payload = JSON.parse(raw);
+    } catch (e) {
+        const reason = `invalid JSON on stdin: ${(e as Error).message}`;
+        process.stderr.write(`team_events_spike: ${reason}\n`);
+        return { skipped: true, reason };
+    }
+
+    const eventName = argv[0] ?? inferEventName(payload) ?? 'unlabeled-event';
+    const entries = extractShape(payload);
+    const section = renderShapeReport(eventName, entries, now());
+    writeReport(`\n${section}`);
+    const count = _dedupe(entries).length;
+    process.stdout.write(`recorded ${count} field shape(s) for ${eventName} -> ${path.relative(ROOT, OUT_FILE)}\n`);
+    return { skipped: false, eventName, entryCount: count, outFile: OUT_FILE };
+}
+
+function _isCliEntry(): boolean {
+    if (process.argv[1] === undefined) {
+        return false;
+    }
+    const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+    if (import.meta.url === argvUrl) {
+        return true;
+    }
+    // A symlinked invocation (e.g. via an installed `.augment/` projection)
+    // makes the raw URLs differ; compare realpaths so the entry guard still
+    // fires when run through a symlink.
+    try {
+        const here = fs.realpathSync(fileURLToPath(import.meta.url));
+        const argv = fs.realpathSync(path.resolve(process.argv[1]));
+        return here === argv;
+    } catch {
+        return false;
+    }
+}
+
+if (_isCliEntry() || process.argv[1] === _HERE) {
+    run()
+        .then(() => {
+            // Observational spike, never a gate — always exit 0 on a
+            // completed run (skip or record alike).
+            process.exit(0);
+        })
+        .catch((e: unknown) => {
+            process.stderr.write(`team_events_spike: ${(e as Error).message}\n`);
+            process.exit(1);
+        });
+}

package/src/scripts/team_review_gate_hook.ts

@@ -3,14 +3,36 @@
  * Team Review-Gate governance — `stop` concern (road-to-team-mode Phase 4).
  *
  * Minimal call-site for `src/scripts/ai_team/review_gate.ts`. On Stop it
- * reads the dispatcher envelope, and — ONLY when `ai_team.enabled` AND
- * `ai_team.review_gate.managed` are true — locates the newest stop-gate
- * review job the codex plugin persisted for this session, parses its
- * first-line ALLOW/BLOCK contract, applies the consecutive-BLOCK counter,
- * and prints the circuit-breaker notice (exactly once per trip) to stdout
- * for the dispatch layer to render. With `managed: false` (default) the
- * hook exits 0 without touching anything — byte-identical pre-Phase-4
- * Stop behavior.
+ * reads the dispatcher envelope, and — ONLY when `ai_team.review_gate.managed`
+ * is true — locates the newest stop-gate review job the codex plugin
+ * persisted for this session, parses its first-line ALLOW/BLOCK contract,
+ * applies the consecutive-BLOCK counter, and prints the circuit-breaker
+ * notice (exactly once per trip) to stdout for the dispatch layer to
+ * render. With `managed: false` (default) the hook exits 0 without
+ * touching anything — byte-identical pre-Phase-4 Stop behavior.
+ *
+ * `ai_team.enabled` was DELETED (road-to-always-on-orchestration Phase 1,
+ * Step 1.3) — `managed` was previously double-gated behind it, but the two
+ * keys govern independent things: `managed` governs the codex PLUGIN's own
+ * Stop-hook loop (upstream's mechanism, which does not depend on our codex
+ * CLI availability), while `/team`'s own availability is a separate,
+ * CLI-resolved fact (`src/scripts/ai_team/availability.ts`) that the
+ * conversational `/team` wrappers check, not this passive Stop hook. So the
+ * two keys are decoupled: `managed` stands alone.
+ *
+ * DELIBERATELY NOT GATED ON `emergency.orchestration_halt` (independent
+ * review, road-to-always-on-orchestration): unlike `/team`'s own
+ * conversational surfaces (`assert_delegate_allowed` / `run_team_review` in
+ * `ai_team/team_dispatch.ts`, both of which check `isOrchestrationHalted`
+ * before doing anything), this hook never reads that switch. This is
+ * intentional, not an oversight — `managed` governs the UPSTREAM codex
+ * plugin's OWN Stop-hook loop, a third-party mechanism this hook merely
+ * observes and reports on (parsing an already-persisted job record); it
+ * never itself dispatches, spends, or calls a provider. The always-on-
+ * orchestration incident switch exists to pause OUR dispatch surfaces —
+ * there is no dispatch here to pause. Tripping the halt does not, and
+ * should not, silence this hook's circuit-breaker notice about the
+ * plugin's own loop.
  *
  * Composition point (wired): registered as the `team-review-gate` concern
  * in `src/scripts/hook_manifest.yaml` on the claude `stop` slot, after
@@ -56,7 +78,7 @@ export function main(): number {
         // owns reporting it. Defaults = managed off = strict no-op.
         config = AI_TEAM_DEFAULTS;
     }
-    if (!config.enabled || !config.review_gate.managed) {
+    if (!config.review_gate.managed) {
         return 0;
     }
 

package/src/server/schemas/settings.ts

@@ -331,18 +331,9 @@ export const settingsSchema = z.object({
         }).default({}),
     }).default({}),
     subagents: z.object({
-        enabled: z.boolean().default(true).describe(
-            'Global master switch for the subagent layer. true (default) = available; false = fully disabled (the canonical kill-switch — no auto-dispatch, no routing, everything runs in-session).',
-        ),
-        auto: z.enum(['off', 'ask', 'on']).default('on').describe(
-            'Automatic-dispatch mode. off = subagents only via explicit command. ask = classify the task and ask once before dispatching. on = auto-dispatch delegable tasks (surface the choice in one line). Shipped default is on on subagent-capable hosts (flipped from ask 2026-07-09, ADR-117), off elsewhere; no-op where the host has no subagent primitive.',
-        ),
         downshift: z.boolean().default(true).describe(
             'Route delegable sub-tasks to the lowest-capable model tier (cost + speed via model downshift). false = every subagent runs on the session tier.',
         ),
-        budget_routing: z.enum(['ask', 'auto', 'off']).default('ask').describe(
-            'Budget-aware cheap-request delegation (docs/contracts/budget-routing.md): pick the cheapest classifier-adequate tier WITH available budget (cost.budgets.per_tier); cheap exhausted but strong funded → strong tier; all exhausted → session model + notice. Work is never blocked to save money; the session model is never switched (delegation with a model override). ask = confirm the first budget-motivated downshift per session (default). auto = apply silently with telemetry. off = today\'s behavior (single-flip rollback). Distinct from downshift: that is the quality/cost knob, this is the resource-availability gate.',
-        ),
         quota_arbitrage: z.boolean().default(true).describe(
             'Prefer a separate quota-pool model for delegable sub-tasks where the host manifest reports one. Optional bonus only — identical behaviour (minus the quota win) where unsupported. Never load-bearing.',
         ),
@@ -353,15 +344,15 @@ export const settingsSchema = z.object({
         }).default({}).describe(
             'Per-tier model map for downshift routing. Each empty value uses the tier runtime default (no vendor model baked in).',
         ),
-        host_capabilities: z.object({}).passthrough().default({}).describe(
-            'Optional override of the host-capability manifest (subagent_spawn / parallel_spawn / status_polling / separate_quota_pool). Any field set wins; omitted fields fall back to the all-false safe default. Empty = the agent resolves the manifest from host knowledge.',
-        ),
         implementer_model: z.string().default('').describe(
             'Override the model the orchestrator dispatches to subagents that write code (e.g. claude-sonnet-4, gpt-5). Empty (default) = inherit the session\'s primary model — cheapest and usually right.',
         ),
         judge_model: z.string().default('').describe(
             'Override the model used for review / judge subagents that critique implementer output. Empty (default) = one tier above the implementer model — picks up nuance the implementer missed.',
         ),
+        model_ceiling: z.string().default('').describe(
+            'Session-wide model CEILING for subagents (spend cap). Empty (default) = no ceiling. When set, suite-owned CLI spawn wrappers export CLAUDE_CODE_SUBAGENT_MODEL to the sessions they launch. Class C: a human sets it; the agent never writes or infers one.',
+        ),
         max_parallel: z.number().int().min(1).default(3).describe(
             'Hard cap on subagents running in parallel during /do-in-parallel, /do-competitively, and /judge runs. Raise for faster fan-out, lower if you hit rate limits or want lower token spend.',
         ),
@@ -375,14 +366,11 @@ export const settingsSchema = z.object({
         ),
     }),
     ai_team: z.object({
-        enabled: z.boolean().default(false).describe(
-            'Master switch for the /team cross-model review family (docs/contracts/ai-team-config.md). false (default) = commands are never suggested and every invocation refuses with an enable pointer. true = the family is live; individual gates (allow_delegate) still apply.',
-        ),
         model: z.string().default('auto').describe(
             "Model handed to the codex CLI. 'auto' (default) = pass no --model flag so the CLI's own default applies — tracks the subscription's current strongest model instead of pinning a stale ID. Any other value passes through verbatim as `--model <value>`.",
         ),
         allow_delegate: z.boolean().default(false).describe(
-            'Second opt-in for the only wrapper that delegates write access (/team:delegate). false (default) = delegate refuses even when ai_team.enabled is true. Both keys must be true before delegation is reachable.',
+            'Second opt-in for the only wrapper that delegates write access (/team:delegate). false (default) = delegate refuses even when /team itself is available. Availability (codex CLI installed + authenticated) is necessary but not sufficient — this key must ALSO be true before delegation is reachable.',
         ),
         max_calls_per_day: z.number().int().min(0).default(50).describe(
             'Per-day cap on team calls, read against the EXISTING cli_call_budget openai bucket (~/.event4u/agent-config/cli-calls.json, daily UTC reset) — one subscription, one counter, never a parallel count. 0 = block all team calls.',
@@ -398,7 +386,15 @@ export const settingsSchema = z.object({
                 'Circuit-breaker bound: after this many CONSECUTIVE BLOCK verdicts in one session, a visible notice is injected exactly once and the managed layer stops re-blocking — the user decides, never an infinite Claude↔Codex loop. An ALLOW verdict resets the counter. Positive integer.',
             ),
         }).default({ managed: false, max_consecutive_blocks: 3 }),
-    }).default({ enabled: false, model: 'auto', allow_delegate: false, max_calls_per_day: 50, suppress_setup_hint: false, review_gate: { managed: false, max_consecutive_blocks: 3 } }),
+    }).default({ model: 'auto', allow_delegate: false, max_calls_per_day: 50, suppress_setup_hint: false, review_gate: { managed: false, max_consecutive_blocks: 3 } }),
+    emergency: z.object({
+        orchestration_halt: z.boolean().default(false).describe(
+            'The one audited incident switch over the always-on orchestration stack (subagents, council, team). NOT an activation gate: false (default) = the stack runs normally. true = halted; arming requires no ceremony. Disarming (returning to false) requires orchestration_halt_justification to be a non-empty string. Both transitions emit one telemetry line.',
+        ),
+        orchestration_halt_justification: z.string().default('').describe(
+            'Required non-empty before orchestration_halt may return to false. Ignored while arming the halt.',
+        ),
+    }).default({ orchestration_halt: false, orchestration_halt_justification: '' }),
     onboarding: z.object({
         onboarded: z.boolean().default(false).describe(
             'Set to true once the developer has completed `agent-config setup`. The onboarding-gate rule blocks the first turn of every chat until this is true. Toggle back to false to re-trigger the wizard.',
@@ -524,6 +520,17 @@ export const settingsSchema = z.object({
                 'PreToolUse code-graph nudge (ADR-124 Phase 4). Default off. When on AND a native code-graph cache or a consumer-shipped graph.json/SCIP index is present, warns once per session (never blocks) as the agent is about to Grep/Glob or Read a source file — query the graph first for who-calls/where-used/impact questions (or rebuild if stale, build if absent). Source G’s strict block-first-read mode is deliberately un-ported.',
             ),
         }).default({}),
+        turn_end_gate: z.object({
+            enabled: z.boolean().default(false).describe(
+                'Stop-slot turn-end gate (road-to-conformance-round5 Phase 3). Default off, and it is the only concern that can REFUSE a turn-end rather than a tool call — so it soaks behind an explicit opt-in before it binds. Round 5 measured the reason: both blocking carriers reached zero violations, neither advisory carrier did, and 19 wrong-language replies survived a pin that had fired 26-35 seconds earlier. A refused turn continues in the SAME turn and is never refused twice.',
+            ),
+            promissory: z.boolean().default(true).describe(
+                'Detector A of the turn-end gate: refuse a turn whose closing paragraph promises work not yet performed while asking the user nothing (20 measured occurrences). Inert while hooks.turn_end_gate.enabled is false.',
+            ),
+            language: z.boolean().default(true).describe(
+                'Detector B of the turn-end gate: refuse a turn whose user-visible prose is not in the pinned language, with fenced code, inline code, quoted tool output, tables, URLs, paths and identifiers excluded first (19 measured occurrences). Fires 18.0% of turns on the measured corpus, which is why the master switch is off by default. Inert while hooks.turn_end_gate.enabled is false.',
+            ),
+        }).default({}),
     }),
     decision_engine: z.object({
         surface_traces: z.boolean().default(false).describe(