@event4u/agent-config 16.1.0 → 16.3.0

package/src/scripts/_lib/verify_clause.ts

@@ -0,0 +1,280 @@
+/**
+ * The `verify:` clause — one grammar, one parser, two importers.
+ *
+ * THE DEFECT THIS EXISTS TO NAME. A `verify:` clause names a command and never
+ * names what the command must produce. `verify: `cat notes.md`` is a legal,
+ * green, fully-conforming step field whose oracle cannot say no: the step gets
+ * flipped on a command that was never able to fail. Measured 2026-09-29 across
+ * the 22 active roadmaps: 230 clauses, 93 naming a command, and 6 naming an
+ * expectation — so 59.6% of clauses cannot even be RUN, and 97.4% state no
+ * oracle. The absence is the norm, not an outlier.
+ *
+ * The denominator moves with archival and is not the finding. An earlier
+ * reading the same day over 27 roadmaps gave 264 / 100 / 6; five archived in
+ * between, and the count of EXPECTATIONS did not move. That is why the ratio
+ * carries and the raw totals do not.
+ *
+ * ALL SIX predate this parser, and the split is the interesting part. Three sit
+ * in an unrelated roadmap and were written by an author nobody prompted. The
+ * other three are the verify lines of the roadmap that commissioned this work —
+ * which asserted, in the same document, that ZERO clauses carried an
+ * expectation. It was carrying three of them. This grammar therefore DOCUMENTS
+ * a form already in use; it does not introduce one, and the number here is the
+ * measured one so that it carries its producing command:
+ * `./scripts-run src/scripts/roadmap_verify_share`.
+ *
+ * THE GRAMMAR. The expectation half is OPTIONAL and attaches with the arrow
+ * `exec:` evidence already carries — not a new symbol:
+ *
+ *     verify: `<cmd>` -> 0          the command must exit 0
+ *     verify: `<cmd>` -> 2          … or any declared exit code
+ *     verify: `<cmd>` -> /regex/    the command's output must match
+ *     verify: `<cmd>`               runnable, but the oracle is unstated
+ *     verify: <prose>               MANUAL — a human reads it
+ *
+ * Prose stays legal deliberately. Forbidding it would have silently invalidated
+ * the large majority of lines already in the tree, and a grammar change that
+ * reds every existing producer gets weakened until it finds nothing. What the
+ * three shapes buy instead is that they are TELLABLE APART, which is what lets
+ * `closure_scan` report the unfalsifiable share as a number rather than an
+ * impression.
+ *
+ * WHY ONE PARSER. Two importers read this grammar — the run-continuation hook
+ * (which names the next step and its verify line) and `closure_scan` (which
+ * reports the share that cannot fail). A second copy of the arrow regex is how
+ * those two drift, and a drifted grammar fails silently: an expectation simply
+ * stops being read and the clause reads as unstated. {@link VERIFY_ARROW_SOURCE}
+ * is exported so a duplicate is detectable by a test rather than by a bug
+ * report.
+ */
+
+/** What a clause says the command must produce. */
+export type Expectation =
+    | { readonly kind: 'exit'; readonly code: number }
+    | { readonly kind: 'regex'; readonly source: string };
+
+export interface VerifyClause {
+    /**
+     * The command, or `null` for the prose (MANUAL) form. A clause with no
+     * command cannot be run by anything, which is precisely what makes it
+     * unfalsifiable rather than merely unstated.
+     */
+    readonly command: string | null;
+    /** The `-> 0` / `-> /re/` half, or `null` where the clause carries none. */
+    readonly expect: Expectation | null;
+    /**
+     * The clause body, whitespace-normalised — the clause, never the step.
+     *
+     * For the prose form that is the clause's own paragraph: a detector reading
+     * this must not see text the clause did not write.
+     */
+    readonly raw: string;
+}
+
+/**
+ * The expectation half, as a source string.
+ *
+ * Exported rather than kept private so the "nothing may parse the arrow a
+ * second time" test has something to compare against. Two alternatives only:
+ * a bare exit code, or a slash-delimited regex. A bare word (`-> green`) is
+ * deliberately NOT an expectation — it would read as one while deciding
+ * nothing, which is the defect wearing the fix's clothes.
+ */
+export const VERIFY_ARROW_SOURCE = '(?:->|→)[ \\t]*(\\d+|\\/.+\\/)[ \\t]*$';
+
+/** The arrow alone, anchored at both ends of a clause tail. */
+const ARROW_RE = new RegExp(`^${VERIFY_ARROW_SOURCE}`);
+
+/** A clause body split into its command head and its trailing expectation. */
+const TAIL_RE = new RegExp(`^(.*?)[ \\t]*${VERIFY_ARROW_SOURCE}`);
+
+/** The annotation form. Machine-readable, so it wins when both are present. */
+const HTML_RE = /<!--\s*verify:\s*(.*?)\s*-->/g;
+
+/**
+ * The step's LAST match, not its first.
+ *
+ * A step that DISCUSSES the clause carries the token before the clause that
+ * counts — the roadmap introducing this grammar shows `verify: `<cmd>` -> 0`
+ * in its own prose, two lines above its own verify line. First-match-wins
+ * parsed the illustration and reported its expectation as the step's. The
+ * clause is written last by convention, after the prose, so last wins.
+ */
+function lastMatch(re: RegExp, text: string): RegExpExecArray | null {
+    re.lastIndex = 0;
+    let found: RegExpExecArray | null = null;
+    let m = re.exec(text);
+    while (m !== null) {
+        found = m;
+        if (m.index === re.lastIndex) re.lastIndex += 1;
+        m = re.exec(text);
+    }
+    return found;
+}
+
+/**
+ * The backticked form, plus at most ONE token of expectation after it.
+ *
+ * The label is an ALTERNATION with a lookahead, not two independent optional
+ * backticks. The inherited form — ``` `?verify:`? ``` — let the parser skip the
+ * trailing backtick and use the LABEL's closing backtick to open the command,
+ * so ``` `verify:` stays legal … verify: `cmd` ``` captured the whole
+ * intervening sentence as the command. Nothing failed: a garbage command is
+ * still a string, and the hook printed it into a continuation message as the
+ * step's proof. The alternation alone did not fix it — the bare branch could
+ * start one character later and borrow the same backtick — so the bare branch
+ * carries `(?!`)`: a label followed by a backtick is the delimited form, which
+ * branch one already owns.
+ *
+ * The tail is capped at a single non-space token on purpose. A caller may hand
+ * this parser a whole step BLOCK already joined into one line, so "the rest of
+ * the line" can mean "the rest of the step" — and a step that continues after
+ * its verify clause would then push the expectation away from the end anchor
+ * and lose it silently. The cost is that a regex expectation here may not
+ * contain a space; `/[1-9]/` and `/unfalsifiable-verify/` are the shapes in
+ * use, and a space-bearing expectation loses its arrow loudly (it parses as no
+ * expectation) rather than half-matching.
+ *
+ * THE CAP IS THIS FORM'S, NOT THE GRAMMAR'S — said plainly because an earlier
+ * revision of this comment implied otherwise. The annotation form is
+ * `$`-anchored through {@link VERIFY_ARROW_SOURCE} and DOES keep `-> /a b/`;
+ * this form does not. The two agree on every space-free expectation, which is
+ * every expectation in the tree. Both directions are pinned by test, so closing
+ * the gap is a deliberate act against a failing assertion rather than a silent
+ * drift — which is the failure the WHY ONE PARSER note above exists to prevent,
+ * and it applies to this module's own two readers first.
+ */
+const BACKTICKED_RE = /(?:`verify:`|verify:(?!`))\s*`([^`]+)`[ \t]*((?:->|→)[ \t]*\S+)?/g;
+
+/** Prose after the label. The MANUAL form; the body is bounded separately. */
+const PROSE_RE = /(?:`verify:`|verify:(?!`))[ \t]*/g;
+
+/**
+ * A prose clause runs to the end of its PARAGRAPH — never to the end of the step.
+ *
+ * "To end of line" is too little: a prose clause wraps, and the quantity it
+ * asserts can sit on the wrap. The rest of the step is far too much, and that
+ * was the live defect — a step's evidence block sits under its clause, so a
+ * clause that named no number inherited every number written beneath it, and
+ * `unfalsifiable-verify` reported 46 hits on quantities no clause had written.
+ *
+ * A blank line is the boundary because that is what separates a clause from the
+ * evidence recorded under it in this tree. Input with no newlines at all — a
+ * caller that already joined the block — degrades to the whole string, which is
+ * the previous behaviour and keeps such a caller working rather than silently
+ * truncating it at a boundary that is not there.
+ */
+function proseBody(rest: string): string {
+    const end = rest.search(/\n[ \t]*(?:\r?\n|$)/);
+    return (end === -1 ? rest : rest.slice(0, end)).replace(/\s+/g, ' ').trim();
+}
+
+/** Build an expectation from the already-isolated arrow value. */
+function fromValue(value: string): Expectation | null {
+    if (/^\d+$/.test(value)) return { kind: 'exit', code: Number(value) };
+    const re = /^\/(.+)\/$/.exec(value);
+    if (re === null) return null;
+    const source = re[1] as string;
+    // An expectation that cannot compile is not an oracle — it is a crash
+    // waiting for the first reader that tries to apply it.
+    try {
+        new RegExp(source);
+    } catch {
+        return null;
+    }
+    return { kind: 'regex', source };
+}
+
+/**
+ * Parse an expectation from a clause tail such as `-> 0` or `-> /re/`.
+ *
+ * @returns `null` when the tail carries no arrow, or carries one whose value is
+ * neither an exit code nor a slash-delimited regex.
+ */
+export function parseExpectation(tail: string): Expectation | null {
+    const m = ARROW_RE.exec(tail.trim());
+    return m === null ? null : fromValue(m[1] as string);
+}
+
+/** Split a command-bearing body into its command and its expectation. */
+function splitBody(body: string): { command: string; expect: Expectation | null } {
+    const m = TAIL_RE.exec(body);
+    if (m === null) return { command: body.trim(), expect: null };
+    const expect = fromValue(m[2] as string);
+    // An arrow whose value decides nothing leaves the whole body as the
+    // command, rather than silently truncating it at a `->` that was prose.
+    return expect === null ? { command: body.trim(), expect: null } : { command: (m[1] as string).trim(), expect };
+}
+
+/**
+ * Parse the `verify:` clause carried by `stepText`.
+ *
+ * @param stepText one step block — the line plus its continuation lines, which
+ * is where the tree conventionally writes the clause.
+ * @returns the clause, or `null` when the text carries no `verify:` token.
+ */
+export function parseVerifyClause(stepText: string): VerifyClause | null {
+    const html = lastMatch(HTML_RE, stepText);
+    if (html !== null) {
+        const body = (html[1] as string).trim();
+        // An EMPTY annotation is not a clause and must not mask one. Returning
+        // null here — the inherited behaviour — let `<!-- verify: -->` hide a
+        // real backticked clause further along the same step, and now that two
+        // readers consume this parser it would hide it from the share too.
+        if (body !== '') {
+            const { command, expect } = splitBody(body);
+            return { command: command === '' ? null : command, expect, raw: body };
+        }
+    }
+
+    const backticked = lastMatch(BACKTICKED_RE, stepText);
+    if (backticked !== null) {
+        const command = (backticked[1] as string).trim();
+        if (command !== '') {
+            const tail = (backticked[2] ?? '').trim();
+            return { command, expect: parseExpectation(tail), raw: `\`${command}\`${tail === '' ? '' : ` ${tail}`}` };
+        }
+    }
+
+    const prose = lastMatch(PROSE_RE, stepText);
+    if (prose === null) return null;
+    const body = proseBody(stepText.slice(prose.index + prose[0].length));
+    if (body === '') return null;
+    return { command: null, expect: null, raw: body };
+}
+
+/**
+ * The clause's command half only — `null` where the clause is prose or absent.
+ *
+ * The narrowing the run-continuation hook wants: it renders a command for the
+ * next step, and a prose clause is not one. Kept here rather than at the call
+ * site so the hook imports a decision rather than re-deriving it.
+ */
+export function commandBearing(stepText: string): VerifyClause | null {
+    const clause = parseVerifyClause(stepText);
+    if (clause === null || clause.command === null) return null;
+    return clause;
+}
+
+/** Render an expectation back to its written form, for messages and evidence. */
+export function formatExpectation(expect: Expectation): string {
+    return expect.kind === 'exit' ? `-> ${String(expect.code)}` : `-> /${expect.source}/`;
+}
+
+/**
+ * The clause as a continuation-message line, empty when there is nothing to say.
+ *
+ * The expectation rides along with the command, and that is the point rather
+ * than a formatting nicety: a re-engagement told only the command can run it,
+ * see exit 0, and flip the box regardless — the whole defect the arrow exists
+ * to close. Told the expectation too, it has an oracle.
+ *
+ * Lives beside the grammar rather than at the one call site so that one module
+ * owns how a clause is read AND how it is written back, which is also what
+ * keeps the over-cap hook from paying these lines.
+ */
+export function renderVerifyLine(clause: VerifyClause | null): string {
+    if (clause === null) return '';
+    const expect = clause.expect === null ? '' : ` ${formatExpectation(clause.expect)}`;
+    return `\n  verify: ${clause.command ?? ''}${expect}`;
+}

package/src/scripts/_lib/windsurf_render.ts

@@ -0,0 +1,63 @@
+/**
+ * The windsurf single-file surface, rendered — one renderer, two callers.
+ *
+ * `road-to-a-hook-bundle-with-one-yaml-reader` 3.1. `condense.generate_windsurfrules`
+ * WRITES `.windsurfrules`; the standing-payload census needs the same bytes to
+ * report windsurf's figure without reading that file, because it is an untracked
+ * generated projection and reading it published a number that tracked when the
+ * checkout last ran `task generate-tools` rather than anything about the tree.
+ *
+ * Both callers share THIS function. A second renderer living in the census would
+ * have measured a file nobody receives, which is Risk 3 of that roadmap.
+ *
+ * WHY A SEPARATE MODULE rather than an export from `condense.ts`: that file sits
+ * 1,228 lines over the 1,500-line cap `check_source_size_budget` ratchets, so
+ * every line added there is a new violation. Splitting the renderer out moves
+ * `condense.ts` DOWN. The file is small on purpose and carries only what the
+ * render needs.
+ *
+ * `strip_frontmatter` moved here with it — it is the render's one non-trivial
+ * dependency, it has exactly one caller left inside `condense.ts`, and leaving it
+ * behind would have meant either an import cycle or a second copy.
+ * `condense.ts` re-exports it, so `src/install/emit_host_rules_cli.ts` and every
+ * other importer keeps its path.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+/** Python `str.lstrip("\n")` — strip only leading newlines. Mirrors `condense._lstripNewlines`. */
+function lstripNewlines(s: string): string {
+    return s.replace(/^\n+/, '');
+}
+
+/** Python `str.strip()` with no args — strip leading/trailing Unicode whitespace. Mirrors `condense._strip`. */
+function strip(s: string): string {
+    return s.replace(/^\s+/u, '').replace(/\s+$/u, '');
+}
+
+/** Drop a leading `---` frontmatter block, if the content opens with one. */
+export function strip_frontmatter(content: string): string {
+    if (content.startsWith('---')) {
+        const end = content.indexOf('---', 3);
+        if (end !== -1) {
+            content = lstripNewlines(content.slice(end + 3));
+        }
+    }
+    return content;
+}
+
+/**
+ * The exact bytes `generate_windsurfrules` writes, for a given rule set.
+ *
+ * `rulesSource` is a parameter rather than `condense.MODULE_STATE.RULES_SOURCE`
+ * so a caller can render a tree it names — the census renders the projection
+ * source directly, with no module state to set up.
+ */
+export function render_windsurfrules(rulesSource: string, rules: readonly string[]): string {
+    const parts = ['# Auto-generated from dist/agent-src/rules/ — do not edit directly\n'];
+    for (const rule of rules) {
+        const content = strip_frontmatter(fs.readFileSync(path.join(rulesSource, rule), 'utf-8'));
+        parts.push(`---\n\n${strip(content)}\n`);
+    }
+    return parts.join('\n') + '\n';
+}

package/src/scripts/ai_council/cli_call_budget.ts

@@ -29,15 +29,23 @@ import * as path from 'node:path';
 export const CLI_CALLS_ATTRIBUTION_SUFFIX = '.attribution.json';
 
 /**
- * Who booked a call. Enumerated because the consumer set is closed: exactly two
- * files in the tree construct a `CliClient`.
+ * Who booked a call. Enumerated because the consumer set is closed: exactly
+ * three files in the tree construct a `CliClient`.
  *
- * `unknown` is a FINDING when it appears — it means a third booking path exists
- * that this enumeration does not know about. That is how the test suite was
- * caught spending the operator's live budget.
+ * `unknown` is a FINDING when it appears — it means a booking path exists that
+ * this enumeration does not know about. That is how the test suite was caught
+ * spending the operator's live budget.
  */
 export const CLI_CONSUMER_COUNCIL = 'council';
 export const CLI_CONSUMER_TEAM = 'team';
+/**
+ * The dogfooded self-review gate. Third because `self_review_gate.ts` is
+ * CLI-first since this constant was added: the subscription transport is tried
+ * before the API one, so a local or self-hosted run books here rather than
+ * spending API credit. A hosted CI runner has no vendor CLI on PATH and falls
+ * through to the API transport, which books nothing against this counter.
+ */
+export const CLI_CONSUMER_SELF_REVIEW = 'self-review';
 export const CLI_CONSUMER_UNKNOWN = 'unknown';
 
 /**

package/src/scripts/ai_council/clients.ts

@@ -88,6 +88,7 @@ import * as user_global_paths from '../_lib/user_global_paths.js';
 import { jsonDumpsIndent2 as _jsonDumpsIndent2 } from './_py_json.js';
 import * as budget from './cli_call_budget.js';
 import { appendEvent } from './events_log.js';
+import { OPENAI_CLI_VENDOR_DEFAULT } from './vendor_defaults.js';
 
 export const ANTHROPIC_KEY_FILENAME = 'anthropic.key';
 export const OPENAI_KEY_FILENAME = 'openai.key';
@@ -124,23 +125,12 @@ export const DEFAULT_PERPLEXITY_MODEL = 'sonar-pro';
 // 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.)
-/**
- * Sentinel: let the codex CLI pick its own model, by omitting `--model`.
- *
- * This is not a placeholder for a value nobody looked up. Measured
- * 2026-08-15 against `codex exec --json` on a ChatGPT-account (subscription)
- * transport, every explicitly named candidate was refused with
- * `400 invalid_request_error: The '<model>' model is not supported when using
- * Codex with a ChatGPT account.` — `gpt-4o`, `gpt-5` (this constant's previous
- * value) and `gpt-5.1-codex` alike. Omitting the flag answered normally.
- *
- * So the only value known to work on this transport is "whatever the CLI
- * chooses", and pinning ANY name here would re-break the seat the next time
- * the vendor rotates its lineup. The label is carried into records as-is so a
- * reader can see that no model was pinned, rather than a name being implied
- * that nobody verified.
- */
-export const OPENAI_CLI_VENDOR_DEFAULT = 'codex-default';
+// `OPENAI_CLI_VENDOR_DEFAULT` lives in `vendor_defaults.ts`, re-exported here
+// so every existing importer keeps resolving. It moved because `config.ts`
+// wanted that one string and was charged this whole module for it in the
+// composed hook bundle — 51,523 bytes on every dispatch; the reasoning and the
+// measurement are in that file's header.
+export { OPENAI_CLI_VENDOR_DEFAULT } from './vendor_defaults.js';
 
 /**
  * Models MEASURED to be refused by the codex subscription transport, with the
@@ -1011,6 +1001,7 @@ export const CLI_CALLS_FILENAME = 'cli-calls.json';
 export {
     CLI_CALLS_ATTRIBUTION_SUFFIX,
     CLI_CONSUMER_COUNCIL,
+    CLI_CONSUMER_SELF_REVIEW,
     CLI_CONSUMER_TEAM,
     CLI_CONSUMER_UNKNOWN,
     QUOTA_SOURCE_LOCAL_BUDGET,
@@ -1678,16 +1669,22 @@ export function _foldSystemPrompt(system_prompt: string, user_prompt: string): s
 export class AnthropicCliClient extends CliClient {
     override subscription_label = 'claude-pro';
 
+    // `...opts` rather than a field list, in all five CLI subclasses, and the
+    // spread IS the fix rather than a tidy. Each of these constructors used to
+    // name six option fields explicitly and forward those — so when
+    // `CliClientOptions` grew a seventh, `consumer`, every subclass silently
+    // dropped it. Both construction sites passed it, `CliClient` read
+    // `opts.consumer ?? CLI_CONSUMER_UNKNOWN`, and the sidecar recorded
+    // `unknown` for every CLI call ever booked: measured 2026-10-05 as
+    // `{"anthropic":{"unknown":2},"openai":{"unknown":2}}` after a council
+    // round. A field list can forget a field. A spread cannot, so the eighth
+    // option needs no edit here and cannot repeat this.
+    //
+    // `model` stays explicit because it is the one field each subclass
+    // overrides with its own pinned default; everything else passes through.
     constructor(opts: CliClientOptions = {}) {
         super(
-            {
-                model: opts.model ?? DEFAULT_ANTHROPIC_CLI_MODEL,
-                binary: opts.binary,
-                timeout_seconds: opts.timeout_seconds,
-                max_calls_per_day: opts.max_calls_per_day,
-                warn_at: opts.warn_at,
-                cli_calls_path: opts.cli_calls_path,
-            },
+            { ...opts, model: opts.model ?? DEFAULT_ANTHROPIC_CLI_MODEL },
             { name: 'anthropic', default_binary: 'claude' },
         );
     }
@@ -1817,14 +1814,7 @@ export class OpenAICliClient extends CliClient {
 
     constructor(opts: CliClientOptions = {}) {
         super(
-            {
-                model: opts.model ?? DEFAULT_OPENAI_CLI_MODEL,
-                binary: opts.binary,
-                timeout_seconds: opts.timeout_seconds,
-                max_calls_per_day: opts.max_calls_per_day,
-                warn_at: opts.warn_at,
-                cli_calls_path: opts.cli_calls_path,
-            },
+            { ...opts, model: opts.model ?? DEFAULT_OPENAI_CLI_MODEL },
             { name: 'openai', default_binary: 'codex' },
         );
     }
@@ -2064,14 +2054,7 @@ export class GeminiCliClient extends CliClient {
 
     constructor(opts: CliClientOptions = {}) {
         super(
-            {
-                model: opts.model ?? DEFAULT_GEMINI_CLI_MODEL,
-                binary: opts.binary,
-                timeout_seconds: opts.timeout_seconds,
-                max_calls_per_day: opts.max_calls_per_day,
-                warn_at: opts.warn_at,
-                cli_calls_path: opts.cli_calls_path,
-            },
+            { ...opts, model: opts.model ?? DEFAULT_GEMINI_CLI_MODEL },
             { name: 'gemini', default_binary: 'gemini' },
         );
     }
@@ -2217,14 +2200,7 @@ export class XAICliClient extends CliClient {
 
     constructor(opts: CliClientOptions = {}) {
         super(
-            {
-                model: opts.model ?? DEFAULT_XAI_MODEL,
-                binary: opts.binary,
-                timeout_seconds: opts.timeout_seconds,
-                max_calls_per_day: opts.max_calls_per_day,
-                warn_at: opts.warn_at,
-                cli_calls_path: opts.cli_calls_path,
-            },
+            { ...opts, model: opts.model ?? DEFAULT_XAI_MODEL },
             { name: 'xai', default_binary: 'grok' },
         );
     }
@@ -2289,14 +2265,7 @@ export class PerplexityCliClient extends CliClient {
 
     constructor(opts: CliClientOptions = {}) {
         super(
-            {
-                model: opts.model ?? DEFAULT_PERPLEXITY_MODEL,
-                binary: opts.binary,
-                timeout_seconds: opts.timeout_seconds,
-                max_calls_per_day: opts.max_calls_per_day,
-                warn_at: opts.warn_at,
-                cli_calls_path: opts.cli_calls_path,
-            },
+            { ...opts, model: opts.model ?? DEFAULT_PERPLEXITY_MODEL },
             { name: 'perplexity', default_binary: 'perplexity' },
         );
     }

package/src/scripts/ai_council/config.ts

@@ -82,7 +82,7 @@ import * as budget from './cli_call_budget.js';
 // `import type` and is erased at build, so there is no runtime cycle today.
 // Converting it to a value import — or adding any other runtime import from
 // quorum into config — creates a real ESM cycle in the loader's init path.
-import { OPENAI_CLI_VENDOR_DEFAULT } from './clients.js';
+import { OPENAI_CLI_VENDOR_DEFAULT } from './vendor_defaults.js';
 import { parseSeatFields, type PolicyExclusion } from './seat_policy.js';
 import type { ContentClass } from './content_ceiling.js';
 import { SOLO_FLOOR_MIN_PRESENT } from './quorum.js';

package/src/scripts/ai_council/vendor_defaults.ts

@@ -0,0 +1,45 @@
+/**
+ * Vendor-CLI sentinel values that are DATA, carried in a module with no
+ * dependencies of its own.
+ *
+ * WHY THIS FILE EXISTS, measured rather than argued. `OPENAI_CLI_VENDOR_DEFAULT`
+ * is a single string, and it used to live in `clients.ts` beside the transport
+ * classes that compare against it. `ai_council/config.ts` imports that one
+ * string and nothing else from `clients.ts`; `config.ts` is reachable from
+ * `council-availability`, which is bound on `session_start`. So every hook
+ * dispatch on every slot carried the whole council transport layer —
+ * `clients.ts` and its closure, **51,523 bytes** of the composed
+ * `dist/hooks/dispatch.js` — to compare one string against another. Breaking
+ * that one import edge removes exactly that, with no capability removed
+ * anywhere: every entry point that actually talks to a vendor CLI imports
+ * `clients.ts` directly and still does.
+ *
+ * The bytes are not an abstraction. `src/config/hook-bundle-budget.json` caps
+ * the composed bundle, the cap is a shrink-only ratchet, and on 2026-10-02 the
+ * tree stood 75 bytes under it — a state in which no concern anywhere could add
+ * a line. This module is how `road-to-a-rule-carrier-that-works-outside-the-repo`
+ * Phase 1 paid for its own runtime code instead of asking for a raise.
+ *
+ * WHAT BELONGS HERE: a vendor-facing constant that a CONFIGURATION reader needs
+ * and a TRANSPORT reader also happens to use. Nothing that imports anything.
+ * The moment this file gains an import it stops being the cheap half of the
+ * split and the split stops being worth its own file.
+ */
+
+/**
+ * Sentinel: let the codex CLI pick its own model, by omitting `--model`.
+ *
+ * This is not a placeholder for a value nobody looked up. Measured
+ * 2026-08-15 against `codex exec --json` on a ChatGPT-account (subscription)
+ * transport, every explicitly named candidate was refused with
+ * `400 invalid_request_error: The '<model>' model is not supported when using
+ * Codex with a ChatGPT account.` — `gpt-4o`, `gpt-5` (this constant's previous
+ * value) and `gpt-5.1-codex` alike. Omitting the flag answered normally.
+ *
+ * So the only value known to work on this transport is "whatever the CLI
+ * chooses", and pinning ANY name here would re-break the seat the next time
+ * the vendor rotates its lineup. The label is carried into records as-is so a
+ * reader can see that no model was pinned, rather than a name being implied
+ * that nobody verified.
+ */
+export const OPENAI_CLI_VENDOR_DEFAULT = 'codex-default';

package/src/scripts/ai_team/team_dispatch.ts

@@ -37,6 +37,10 @@
  * shape of an Apache-2.0 upstream — attribution in the repo-root NOTICE file.
  */
 import { spawnSync } from 'node:child_process';
+// read-surface: inter-agent-reply — a teammate's reply arrives through a HOST
+// primitive this package does not own, so no call site here spells the inbound
+// fetch. Declared rather than inferred; the coverage verdict is still read from
+// the import below.
 import { sanitize_text } from '../_lib/retrieval_sanitize.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';