@event4u/agent-config 14.20.0 → 14.22.0

package/src/scripts/_lib/subagent_capsule.ts

@@ -143,10 +143,68 @@ export const CAPSULE_SCHEMA_VERSION = 4;
  */
 export const ACCEPTED_CAPSULE_VERSIONS: readonly number[] = [3, 4];
 
-/** The two CHECKPOINT variants sharing this schema. */
-export const CAPSULE_VARIANTS = ['worker', 'main_session'] as const;
+/** The three CHECKPOINT variants sharing this schema. */
+export const CAPSULE_VARIANTS = ['worker', 'main_session', 'continuity_record'] as const;
 export type CapsuleVariant = (typeof CAPSULE_VARIANTS)[number];
 
+/**
+ * `continuity_record` — the DETERMINISTIC main-session variant.
+ *
+ * Why a variant and not a relaxed `main_session`. `main_session` requires
+ * `failed_approaches` and `successful_approaches` with at least one entry each,
+ * and requires the explicit token `none` when nothing failed or worked — the
+ * whole point of those fields being that silence and "nothing was abandoned"
+ * stay distinguishable. A writer that runs without model spend cannot know
+ * either. It could only write `none`, which asserts a judgement nobody made.
+ *
+ * The AI council of 2026-09-07 ruled exactly this: add a variant rather than
+ * stuffing absence markers into `main_session`, because explicit absence
+ * markers "misrepresent unavailable model judgments as values". This constant
+ * set is that ruling in code.
+ *
+ * The fields below are FORBIDDEN on this variant rather than optional, and the
+ * distinction is load-bearing. Optional would leave the door open for a later
+ * writer to fill one with a guess and for a reader to be unable to tell a
+ * derived record from a judged one. Forbidden makes the variant's meaning
+ * checkable: everything a `continuity_record` carries was computed from disk.
+ *
+ * Nothing here is invented — every name is an existing key of this same schema.
+ * The council's constraint was explicit: the required fields "must be derived
+ * from the existing validated envelope contract; this ruling does not authorize
+ * inventing parallel identity or directive fields."
+ *
+ * Version compatibility is unchanged and envelope-wide: a `continuity_record`
+ * declares the same `capsule_version`, and a reader that does not know the
+ * variant refuses it by name (see `validateRecycleEnvelope`) rather than
+ * guessing at its required set.
+ */
+export const CONTINUITY_RECORD_FORBIDDEN_KEYS: ReadonlySet<string> = new Set([
+    'decisions',
+    'constraints',
+    'do_not_touch',
+    'assumptions',
+    'failed_approaches',
+    'successful_approaches',
+    'open_questions',
+    'not_carried_forward',
+    'status_summary',
+    'suggested_skills',
+    'open_worker_envelopes',
+]);
+
+/** Required on a `continuity_record` — each one computable from on-disk state. */
+export const CONTINUITY_RECORD_REQUIRED_KEYS: readonly string[] = [
+    'capsule_version',
+    'variant',
+    'summary',
+    'task',
+    'workspace',
+    'written_at',
+    'acceptance_criteria',
+    'remaining',
+    'predecessor',
+];
+
 /** A single-line token no longer than `max` chars. Rejects any body-shaped value. */
 function isShortLine(value: unknown, max: number): value is string {
     return typeof value === 'string' && value.length > 0 && value.length <= max && !value.includes('\n');
@@ -757,6 +815,31 @@ export function validateRecycleEnvelope(input: unknown): string[] {
         }
     }
 
+    // VARIANT FIRST, then version. The order is the contract, not a style
+    // choice. Required fields are variant-specific, so a reader that does not
+    // recognise the variant cannot know what to demand — and a reader that
+    // reports twenty field violations against a variant it never understood has
+    // told the operator nothing useful and, worse, has implied the record was
+    // malformed when the truth is that the reader is old. One refusal naming
+    // the variant is the honest output, and it is what makes an old reader
+    // meeting a new record a legible event rather than a pile of noise.
+    const variant = e['variant'];
+    if (typeof variant !== 'string' || !(CAPSULE_VARIANTS as readonly string[]).includes(variant)) {
+        return [
+            `unknown variant ${JSON.stringify(variant)} — this reader knows ` +
+                `${CAPSULE_VARIANTS.join(' | ')}. A reader that does not know a variant must not ` +
+                'guess at its required fields, so no further field checks were run.',
+        ];
+    }
+    if (variant === 'worker') {
+        return [
+            "variant 'worker' is a subagent generation handover and is validated by the worker " +
+                'path, not by the main-session recycle validator — routing it here would apply ' +
+                'the wrong required set to a well-formed record.',
+        ];
+    }
+    const isDerived = variant === 'continuity_record';
+
     const version = e['capsule_version'];
     if (typeof version !== 'number' || !ACCEPTED_CAPSULE_VERSIONS.includes(version)) {
         errors.push(`capsule_version must be one of ${ACCEPTED_CAPSULE_VERSIONS.join(' | ')}`);
@@ -766,9 +849,35 @@ export function validateRecycleEnvelope(input: unknown): string[] {
     // Demanding the new fields of an already-written record would be a
     // retroactive requirement, which is the one thing the recorded schema lock
     // forbids ("add fields or variants, never repurpose or remove one").
-    const atV4 = version === 4;
-    if (e['variant'] !== 'main_session') {
-        errors.push("variant must be 'main_session'");
+    //
+    // A `continuity_record` is exempt from the two v4 judgement fields for the
+    // opposite reason: it is forbidden from carrying them at all (below), so
+    // requiring them would make the variant unsatisfiable.
+    const atV4 = version === 4 && !isDerived;
+
+    if (isDerived) {
+        // Forbidden, not merely absent: a derived record that carries a
+        // judgement field is either a `main_session` mislabelled, or a
+        // deterministic writer that invented a value. Both are worth refusing
+        // loudly, and neither is distinguishable after the fact.
+        for (const key of Object.keys(e)) {
+            if (CONTINUITY_RECORD_FORBIDDEN_KEYS.has(key)) {
+                errors.push(
+                    `field "${key}" is forbidden on variant 'continuity_record' — it carries a ` +
+                        'model judgement, and a record written without model spend cannot have made ' +
+                        "one. Use variant 'main_session' for a judged record.",
+                );
+            }
+        }
+        for (const key of CONTINUITY_RECORD_REQUIRED_KEYS) {
+            if (e[key] === undefined) {
+                errors.push(
+                    `field "${key}" is required on variant 'continuity_record' — it is computable ` +
+                        'from on-disk state, so its absence is a writer defect rather than an ' +
+                        'unavailable judgement.',
+                );
+            }
+        }
     }
     if (!isShortLine(e['summary'], MAX_LINE_CHARS)) {
         errors.push(`summary must be a single line of 1–${MAX_LINE_CHARS} chars`);
@@ -789,7 +898,7 @@ export function validateRecycleEnvelope(input: unknown): string[] {
         errors.push('acceptance_criteria must carry at least one entry — the successor cannot know "done" without it');
     }
     checkList(errors, 'remaining', e['remaining'], MAX_LINE_CHARS, true);
-    checkList(errors, 'not_carried_forward', e['not_carried_forward'], MAX_LINE_CHARS, true);
+    checkList(errors, 'not_carried_forward', e['not_carried_forward'], MAX_LINE_CHARS, !isDerived);
     checkList(errors, 'decisions', e['decisions'], MAX_LINE_CHARS, false);
     errors.push(...decisionTagErrors(e['decisions']));
     checkList(errors, 'constraints', e['constraints'], MAX_LINE_CHARS, false);
@@ -809,7 +918,7 @@ export function validateRecycleEnvelope(input: unknown): string[] {
 
     // Required with ≥ 1 entry (Phase 2.3): a session that abandoned nothing
     // writes `none`. Absence must never be readable as "nothing failed".
-    checkList(errors, 'failed_approaches', e['failed_approaches'], MAX_LINE_CHARS, true);
+    checkList(errors, 'failed_approaches', e['failed_approaches'], MAX_LINE_CHARS, !isDerived);
     if (Array.isArray(e['failed_approaches']) && e['failed_approaches'].length === 0) {
         errors.push(
             'failed_approaches must carry at least one entry — write "none" explicitly, so ' +
@@ -835,7 +944,7 @@ export function validateRecycleEnvelope(input: unknown): string[] {
     // is a reader waiting for something that will not arrive.
     const predecessor = e['predecessor'];
     if (predecessor === undefined) {
-        if (atV4) {
+        if (atV4 || isDerived) {
             errors.push(
                 'predecessor is required — name the session this one continues, or write "none" ' +
                     'explicitly for the first session in a workspace',

package/src/scripts/_lib/tty_prompt.ts

@@ -0,0 +1,76 @@
+/**
+ * Synchronous terminal prompting for the release pipeline.
+ *
+ * Its own module because `release.ts` sits 371 lines over the 1500-line source
+ * ratchet, where every added line is one unit of excess — and because a SECOND
+ * caller now needs these: `guard_release_curation` in `release_publication.ts`
+ * collects the governance answer it used to only refuse over.
+ *
+ * Extracted verbatim from `release.ts`, where the `/dev/tty` discipline below
+ * was established against a reproduced failure. Do not "simplify" it back to
+ * `readSync(0)`; the comment on `promptLine` says what that costs.
+ */
+import * as fs from 'node:fs';
+import process from 'node:process';
+
+/** Can we prompt at all — is fd 0 a TTY, or is a controlling terminal openable? */
+export function canPrompt(): boolean {
+    if (process.env.CI) return false; // CI is non-interactive by contract → require --yes
+    if (process.stdin.isTTY) return true;
+    try {
+        const fd = fs.openSync('/dev/tty', 'r');
+        fs.closeSync(fd);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Mirror of Python `input(prompt)` — write the prompt, read one line from the
+ * controlling terminal. Returns `null` when no terminal is reachable.
+ *
+ * The answer is ALWAYS read from a freshly opened, blocking `/dev/tty`
+ * (`openSync(..., 'rs')`), NEVER from fd 0. `task release` / `./scripts-run`
+ * run this under go-task's `interactive: true`, which leaves fd 0 a TTY
+ * (`process.stdin.isTTY === true`) but one Node treats as NON-blocking — so a
+ * bare `readSync(0)` throws `EAGAIN`, the catch swallows it, and the `[y/N]`
+ * prompt "auto-aborts" without ever waiting (the exact failure this fixes;
+ * reproduced with `isTTY === true`). A fresh blocking `/dev/tty` descriptor
+ * blocks for real input regardless of how the script was invoked — the proven
+ * synchronous-prompt pattern.
+ */
+export function promptLine(prompt: string): string | null {
+    process.stdout.write(prompt);
+    let fd: number;
+    try {
+        // 'rs' → O_RDONLY | O_SYNC: a fresh, blocking descriptor on the
+        // controlling terminal, unaffected by Node's non-blocking fd 0.
+        fd = fs.openSync('/dev/tty', 'rs');
+    } catch {
+        return null; // no controlling terminal (true non-interactive)
+    }
+    try {
+        const buf = Buffer.alloc(1);
+        const chars: number[] = [];
+        for (;;) {
+            let bytesRead: number;
+            try {
+                bytesRead = fs.readSync(fd, buf, 0, 1, null);
+            } catch (e) {
+                const code = (e as NodeJS.ErrnoException).code;
+                // A blocking /dev/tty should not yield these, but inherited
+                // descriptor flags can — retry rather than abort the prompt.
+                if (code === 'EAGAIN' || code === 'EINTR') continue;
+                break; // EOF / EIO → EOFError analogue; return what we have.
+            }
+            if (bytesRead === 0) break;
+            const b = buf[0] as number;
+            if (b === 0x0a) break; // newline terminates the line (stripped, like input()).
+            chars.push(b);
+        }
+        return Buffer.from(chars).toString('utf-8');
+    } finally {
+        fs.closeSync(fd);
+    }
+}

package/src/scripts/ai_council/api_transport.ts

@@ -0,0 +1,168 @@
+/**
+ * The council's synchronous HTTP transport, and the per-provider shims that
+ * turn it into the SDK-shaped callables `clients.ts::ask()` reads.
+ *
+ * Extracted from `clients.ts` (road-to-admissible-council-seats 1.1). Two
+ * reasons, and only the first is about tidiness:
+ *
+ * 1. `clients.ts` is ~1,370 lines past the 1,500-line ceiling
+ *    `check_source_size_budget` ratchets, so every line added there costs one
+ *    excess line. The three shims below are new code; putting them in a file
+ *    UNDER the ceiling is what lets 1.1 land without raising a baseline.
+ * 2. Before 1.1 exactly one provider (OpenAI) had a live transport and the
+ *    other four constructors threw `… package not installed. pip install …`
+ *    after the api-key check — so `mode: api` was dead for gemini, xai and
+ *    perplexity. A shared shim module is the honest home for "how this
+ *    package actually reaches a provider over HTTP", rather than four
+ *    copies of the same curl call inside four constructors.
+ *
+ * The injectable seam. Every shim takes a `JsonPost` rather than calling `curlJsonPost` directly.
+ * A test can then construct a REAL client with a REAL api_key — exercising
+ * the shim-building path a mock `client:` object skips entirely — and still
+ * make no network call. That is the difference between testing the transport
+ * and testing around it.
+ */
+
+import { spawnSync } from 'node:child_process';
+
+/** The one network primitive. Swappable so tests never reach the network. */
+export type JsonPost = (url: string, extraHeaders: string[], body: unknown) => unknown;
+
+export const GEMINI_BASE_URL = 'https://generativelanguage.googleapis.com/v1beta';
+
+/**
+ * Synchronous JSON POST via `curl` (no Node SDK, no Python). Matches the
+ * council's `spawnSync` transport model so the live-call clients stay
+ * synchronous. Returns the parsed response JSON (the provider HTTP APIs return
+ * exactly the SDK response shape `ask()` reads). Throws on transport failure or
+ * a non-2xx status so `ask()`'s catch surfaces it as a member error.
+ */
+export function curlJsonPost(url: string, extraHeaders: string[], body: unknown): unknown {
+    const args = ['-sS', '-X', 'POST', url, '-H', 'content-type: application/json'];
+    for (const h of extraHeaders) {
+        args.push('-H', h);
+    }
+    // `--connect-timeout` fast-fails a dead host; `--max-time` lets curl abort
+    // itself cleanly (surfacing a real `curl exited` error with stderr) ~10s
+    // before the `spawnSync` timeout would kill it with an opaque ETIMEDOUT.
+    // A full 16k-token generation legitimately runs several minutes, so the
+    // ceiling is 300s, not 120s (the old value timed out long Anthropic calls).
+    // Both ceilings are PER CALL, never a run total. Members are iterated
+    // serially, so a run's worst case is members x passes x 290s, and nothing
+    // cancels a call mid-flight: `spawnSync` takes no signal, which is the
+    // synchronous contract the module docblock states. The only run-level bound
+    // is the USD cap, and it is checked AFTER a call returns.
+    args.push('--connect-timeout', '30', '--max-time', '290');
+    args.push('-w', '\n%{http_code}', '--data-binary', '@-');
+    const r = spawnSync('curl', args, {
+        input: JSON.stringify(body),
+        encoding: 'utf8',
+        maxBuffer: 64 * 1024 * 1024,
+        timeout: 300_000,
+    });
+    if (r.error) {
+        throw new Error(`curl spawn failed: ${(r.error as Error).message}`);
+    }
+    if (r.status !== 0) {
+        throw new Error(
+            `curl exited ${r.status ?? 'null'}: ${(r.stderr ?? '').toString().slice(0, 500)}`,
+        );
+    }
+    const out = (r.stdout ?? '').toString();
+    const nl = out.lastIndexOf('\n');
+    const httpCode = (nl >= 0 ? out.slice(nl + 1) : out).trim();
+    const bodyText = nl >= 0 ? out.slice(0, nl) : out;
+    if (!/^2\d\d$/.test(httpCode)) {
+        throw new Error(`HTTP ${httpCode}: ${bodyText.slice(0, 500)}`);
+    }
+    return JSON.parse(bodyText);
+}
+
+/**
+ * `chat.completions.create` over any OpenAI-compatible `/v1/chat/completions`.
+ * Used by OpenAI itself and by the two OpenAI-compatible vendors (xAI,
+ * Perplexity), whose only difference is the base URL.
+ *
+ * `baseUrl` is passed rather than read off `this.base_url`: a subclass field
+ * initializer (`override base_url = XAI_BASE_URL`) runs AFTER the base
+ * constructor, so reading the field during construction would silently build
+ * every compatible client against the empty string.
+ */
+export function openAiCompatibleClient(
+    baseUrl: string,
+    apiKey: string,
+    post: JsonPost = curlJsonPost,
+): unknown {
+    const url = `${baseUrl.replace(/\/+$/, '')}/chat/completions`;
+    return {
+        chat: {
+            completions: {
+                create: (kwargs: Record<string, unknown>): unknown =>
+                    post(url, [`authorization: Bearer ${apiKey}`], kwargs),
+            },
+        },
+    };
+}
+
+/**
+ * `models.generate_content` over the Gemini REST API, normalised to the
+ * `google-genai` SDK response shape `GeminiClient.ask()` reads.
+ *
+ * The normalisation is the whole point and is not cosmetic: REST answers with
+ * `candidates[0].content.parts[*].text` and `usageMetadata.promptTokenCount`,
+ * while `ask()` reads `.text`, `.model_version` and
+ * `.usage_metadata.{prompt_token_count, candidates_token_count}`. Rewriting
+ * `ask()` to read REST instead would break every injected SDK-shaped mock in
+ * the existing tests, so the adapter lives here, at the transport boundary,
+ * where a shape mismatch is a transport concern.
+ */
+export function geminiRestClient(
+    apiKey: string,
+    post: JsonPost = curlJsonPost,
+    baseUrl: string = GEMINI_BASE_URL,
+): unknown {
+    return {
+        models: {
+            generate_content: (kwargs: Record<string, unknown>): unknown => {
+                const model = String(kwargs['model'] ?? '');
+                const cfg = (kwargs['config'] ?? {}) as Record<string, unknown>;
+                const url = `${baseUrl.replace(/\/+$/, '')}/models/${model}:generateContent`;
+                const raw = post(
+                    url,
+                    [`x-goog-api-key: ${apiKey}`],
+                    {
+                        contents: [{ role: 'user', parts: [{ text: String(kwargs['contents'] ?? '') }] }],
+                        generationConfig: { maxOutputTokens: cfg['max_output_tokens'] ?? null },
+                    },
+                );
+                return normaliseGeminiRest(raw);
+            },
+        },
+    };
+}
+
+/** REST envelope → the `google-genai` SDK response shape. Exported for tests. */
+export function normaliseGeminiRest(raw: unknown): {
+    text: string;
+    model_version: string;
+    usage_metadata: { prompt_token_count: number; candidates_token_count: number };
+} {
+    const env = (raw ?? {}) as Record<string, unknown>;
+    const candidates = Array.isArray(env['candidates']) ? (env['candidates'] as unknown[]) : [];
+    const first = (candidates[0] ?? {}) as Record<string, unknown>;
+    const content = (first['content'] ?? {}) as Record<string, unknown>;
+    const parts = Array.isArray(content['parts']) ? (content['parts'] as unknown[]) : [];
+    const text = parts
+        .map((p) => String(((p ?? {}) as Record<string, unknown>)['text'] ?? ''))
+        .join('');
+    const usage = (env['usageMetadata'] ?? {}) as Record<string, unknown>;
+    const num = (v: unknown): number => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
+    return {
+        text,
+        model_version: String(env['modelVersion'] ?? ''),
+        usage_metadata: {
+            prompt_token_count: num(usage['promptTokenCount']),
+            candidates_token_count: num(usage['candidatesTokenCount']),
+        },
+    };
+}

package/src/scripts/ai_council/clients.ts

@@ -47,6 +47,12 @@ import * as path from 'node:path';
 
 import { hardenedSpawnEnv } from '../_lib/spawn_env.js';
 import { boundFor } from './cli_agency_bounds.js';
+import {
+    curlJsonPost as _curlJsonPost,
+    geminiRestClient,
+    openAiCompatibleClient,
+    type JsonPost,
+} from './api_transport.js';
 import { SESSION_ROLE_ENV } from '../_lib/session_role.js';
 import { load_agent_settings } from '../_lib/agent_settings.js';
 
@@ -163,9 +169,8 @@ export const DEFAULT_OPENAI_CLI_MODEL = OPENAI_CLI_VENDOR_DEFAULT;
 export const DEFAULT_ANTHROPIC_CLI_MODEL = 'sonnet';
 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`).
+// OpenAI-API-compatible endpoints — xAI and Perplexity both expose the
+// `/v1/chat/completions` shape, reached by one curl shim in `api_transport.ts`.
 export const XAI_BASE_URL = 'https://api.x.ai/v1';
 export const PERPLEXITY_BASE_URL = 'https://api.perplexity.ai';
 
@@ -461,6 +466,12 @@ interface ApiClientOptions {
     // Phase 4). Default '5m' when omitted — see `DEFAULT_PROMPT_CACHE_TTL`.
     // Only meaningful when `enable_prompt_cache` is true.
     prompt_cache_ttl?: PromptCacheTtl | undefined;
+    /**
+     * HTTP seam. Omitted → the live `curl` post. A test passes a double
+     * TOGETHER with a real `api_key`, which exercises the shim-building
+     * path that an injected `client:` object skips entirely.
+     */
+    transport?: JsonPost | undefined;
 }
 
 /** Shared ctor-options shape for the CLI clients. */
@@ -479,47 +490,6 @@ interface CliClientOptions {
     consumer?: string | undefined;
 }
 
-/**
- * Synchronous JSON POST via `curl` (no Node SDK, no Python). Matches the
- * council's `spawnSync` transport model so the live-call clients stay
- * synchronous. Returns the parsed response JSON (the provider HTTP APIs return
- * exactly the SDK response shape `ask()` reads). Throws on transport failure or
- * a non-2xx status so `ask()`'s catch surfaces it as a member error.
- */
-function _curlJsonPost(url: string, extraHeaders: string[], body: unknown): unknown {
-    const args = ['-sS', '-X', 'POST', url, '-H', 'content-type: application/json'];
-    for (const h of extraHeaders) {
-        args.push('-H', h);
-    }
-    // `--connect-timeout` fast-fails a dead host; `--max-time` lets curl abort
-    // itself cleanly (surfacing a real `curl exited` error with stderr) ~10s
-    // before the `spawnSync` timeout would kill it with an opaque ETIMEDOUT.
-    // A full 16k-token generation legitimately runs several minutes, so the
-    // ceiling is 300s, not 120s (the old value timed out long Anthropic calls).
-    args.push('--connect-timeout', '30', '--max-time', '290');
-    args.push('-w', '\n%{http_code}', '--data-binary', '@-');
-    const r = spawnSync('curl', args, {
-        input: JSON.stringify(body),
-        encoding: 'utf8',
-        maxBuffer: 64 * 1024 * 1024,
-        timeout: 300_000,
-    });
-    if (r.error) {
-        throw new Error(`curl spawn failed: ${(r.error as Error).message}`);
-    }
-    if (r.status !== 0) {
-        throw new Error(`curl exited ${r.status ?? 'null'}: ${(r.stderr ?? '').toString().slice(0, 500)}`);
-    }
-    const out = (r.stdout ?? '').toString();
-    const nl = out.lastIndexOf('\n');
-    const httpCode = (nl >= 0 ? out.slice(nl + 1) : out).trim();
-    const bodyText = nl >= 0 ? out.slice(0, nl) : out;
-    if (!/^2\d\d$/.test(httpCode)) {
-        throw new Error(`HTTP ${httpCode}: ${bodyText.slice(0, 500)}`);
-    }
-    return JSON.parse(bodyText);
-}
-
 export class AnthropicClient extends ExternalAIClient {
     override name = 'anthropic';
     override billable = true;
@@ -824,13 +794,12 @@ export class OpenAIClient extends ExternalAIClient {
 // ── Gemini / xAI / Perplexity (Phase 0 — Step 6) ─────────────────────
 
 /**
- * Google Gemini via the `google-genai` SDK.
- *
- * Lazy-imports `google.genai` on first `ask()` so disabled members do not
- * require the SDK to be installed. Tests inject a mock client shaped like
- * `genai.Client(api_key=...)` — `self._client.models.generate_content(...)`
- * returns an object with `.text` and
- * `.usage_metadata.{prompt_token_count, candidates_token_count}`.
+ * Google Gemini over the REST API (1.1 — there is no SDK dependency; the old
+ * `google-genai` lazy-import never existed in the TS port and the constructor
+ * simply threw). `ask()` still reads the SDK RESPONSE shape — `.text`,
+ * `.model_version`, `.usage_metadata.{prompt_token_count,
+ * candidates_token_count}` — which `geminiRestClient` normalises to, so every
+ * injected-mock test is unaffected.
  */
 export class GeminiClient extends ExternalAIClient {
     override name = 'gemini';
@@ -851,7 +820,12 @@ export class GeminiClient extends ExternalAIClient {
                     'Use `api_key_ref: env:GEMINI_API_KEY` in ~/.event4u/agent-config/settings/.ai-council.yml.',
             );
         }
-        throw new Error('google-genai package not installed. `pip install google-genai`.');
+        // Live transport (1.1). Was an unconditional `pip install google-genai`
+        // throw, which made `mode: api` dead for this provider however the key
+        // was configured. `geminiRestClient` normalises the REST envelope into
+        // the SDK shape `ask()` below already reads, so `ask()` is untouched
+        // and every existing injected-mock test keeps passing.
+        this._client = geminiRestClient(api_key, opts.transport ?? _curlJsonPost);
     }
 
     override ask(
@@ -901,19 +875,26 @@ export class GeminiClient extends ExternalAIClient {
 }
 
 /**
- * Shared shape for OpenAI-API-compatible providers (xAI, Perplexity).
- *
- * Both vendors implement `/v1/chat/completions` and accept the `openai` Python
- * SDK with a custom `base_url`. The reasoning-model branch from `OpenAIClient`
- * is intentionally omitted — neither xAI nor Perplexity ships a reasoning model
- * that requires `max_completion_tokens` as of 2026-05-14.
+ * Shared shape for OpenAI-API-compatible providers (xAI, Perplexity): both
+ * implement `/v1/chat/completions`, so 1.1 reaches them with one curl shim and
+ * a base URL. The reasoning-model branch from `OpenAIClient` is intentionally
+ * omitted — neither ships a reasoning model that requires
+ * `max_completion_tokens` as of 2026-05-14.
  */
 export class _OpenAICompatibleClient extends ExternalAIClient {
     override billable = true;
     base_url = '';
     protected _client: unknown;
 
-    constructor(opts: { model: string; client?: unknown; api_key?: string | null | undefined }) {
+    constructor(opts: {
+        model: string;
+        client?: unknown;
+        api_key?: string | null | undefined;
+        transport?: JsonPost | undefined;
+        // Passed, never read off `this.base_url`: a subclass field initializer
+        // runs AFTER this constructor, so the field is still '' right here.
+        base_url: string;
+    }) {
         super();
         this.model = opts.model;
         if (opts.client !== undefined && opts.client !== null) {
@@ -926,7 +907,13 @@ export class _OpenAICompatibleClient extends ExternalAIClient {
                 `${this.constructor.name} requires explicit api_key or injected client.`,
             );
         }
-        throw new Error('openai package not installed. `pip install openai`.');
+        // Live transport (1.1) — replaces an unconditional `pip install openai`
+        // throw that made `mode: api` dead for xai and perplexity.
+        this._client = openAiCompatibleClient(
+            opts.base_url,
+            api_key,
+            opts.transport ?? _curlJsonPost,
+        );
     }
 
     override ask(
@@ -989,7 +976,13 @@ export class XAIClient extends _OpenAICompatibleClient {
     override base_url = XAI_BASE_URL;
 
     constructor(opts: ApiClientOptions = {}) {
-        super({ model: opts.model ?? DEFAULT_XAI_MODEL, client: opts.client, api_key: opts.api_key });
+        super({
+            model: opts.model ?? DEFAULT_XAI_MODEL,
+            client: opts.client,
+            api_key: opts.api_key,
+            transport: opts.transport,
+            base_url: XAI_BASE_URL,
+        });
     }
 }
 
@@ -1003,6 +996,8 @@ export class PerplexityClient extends _OpenAICompatibleClient {
             model: opts.model ?? DEFAULT_PERPLEXITY_MODEL,
             client: opts.client,
             api_key: opts.api_key,
+            transport: opts.transport,
+            base_url: PERPLEXITY_BASE_URL,
         });
     }
 }
@@ -1028,8 +1023,8 @@ export {
 //
 // Raised 120 → 300 (2026-08-13) to match the API transport, which has carried
 // `--max-time 290` / `timeout: 300_000` since the 2026-06-24 repair of the same
-// symptom. That repair landed in `_curlJsonPost` only, so when a member resolves
-// to `cli · subscription` the old cap was still live — and a deep design run
+// symptom. That repair landed in `api_transport.ts::curlJsonPost` only, so with
+// a member on `cli · subscription` the old cap was still live — a deep run
 // reproduced it exactly: both members returned `error: timeout` at
 // `latency_ms: 122921` with `timeout_seconds: 120`, and the run reported
 // `0/2 present — INCONCLUSIVE`.

package/src/scripts/ai_council/config.ts

@@ -83,6 +83,8 @@ import * as budget from './cli_call_budget.js';
 // 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 { parseSeatFields, type PolicyExclusion } from './seat_policy.js';
+import type { ContentClass } from './content_ceiling.js';
 import { SOLO_FLOOR_MIN_PRESENT } from './quorum.js';
 
 const _VALID_PROVIDERS: ReadonlySet<string> = new Set([
@@ -330,6 +332,12 @@ export interface MemberConfig {
      * demanding a date nobody would refresh.
      */
     readonly verified_at: string | null;
+    /** Seat policy — parsed and documented by `seat_policy.ts::parseSeatFields`.
+     *  All three are NOTES or REFUSALS: none can make a seat available that was
+     *  not already available. */
+    readonly disabled_reason: string | null;
+    readonly policy_exclusion: PolicyExclusion | null;
+    readonly content_ceiling: ContentClass;
 }
 
 /**
@@ -1875,6 +1883,10 @@ function _build_member(
         }
         verified_at = coerced;
     }
+    const seat = parseSeatFields(name, cfg as Record<string, unknown>);
+    if ('error' in seat) {
+        throw new CouncilConfigError(seat.error);
+    }
     const prompt_cache_raw = _get(cfg, 'prompt_cache', null);
     let prompt_cache_ttl: '5m' | '1h' = '5m';
     if (prompt_cache_raw !== null && prompt_cache_raw !== undefined && !_isBool(prompt_cache_raw)) {
@@ -1907,6 +1919,7 @@ function _build_member(
         tier,
         prompt_cache_ttl,
         verified_at,
+        ...seat.fields,
     };
 }