@delegance/claude-autopilot 5.0.1 → 5.0.2

package/src/cli/worker.ts

@@ -1,109 +0,0 @@
-import { readLock, writeLock, deleteLock, isWorkerAlive } from '../core/worker/lockfile.ts';
-import { stopWorker, getWorkerStatus } from '../core/worker/client.ts';
-import { startWorkerServer } from '../core/worker/server.ts';
-import { loadConfig } from '../core/config/loader.ts';
-import type { ReviewEngine } from '../adapters/review-engine/types.ts';
-import * as path from 'node:path';
-import * as fs from 'node:fs';
-
-const C = { reset: '\x1b[0m', green: '\x1b[32m', red: '\x1b[31m', yellow: '\x1b[33m', dim: '\x1b[2m', bold: '\x1b[1m' };
-
-export async function runWorker(sub: string | undefined, options: { cwd?: string; configPath?: string } = {}): Promise<number> {
-  const cwd = options.cwd ?? process.cwd();
-  const configPath = options.configPath ?? path.join(cwd, 'guardrail.config.yaml');
-
-  switch (sub) {
-    case 'start':
-      return workerStart(cwd, configPath);
-    case 'stop':
-      return workerStop(cwd);
-    case 'status':
-      return workerStatus(cwd);
-    default:
-      console.error(`${C.red}[worker] Unknown subcommand: "${sub ?? ''}". Use start|stop|status${C.reset}`);
-      return 1;
-  }
-}
-
-async function workerStart(cwd: string, configPath: string): Promise<number> {
-  const existing = readLock(cwd);
-  if (existing && isWorkerAlive(existing)) {
-    console.log(`${C.yellow}[worker] Already running — pid ${existing.pid} port ${existing.port}${C.reset}`);
-    return 0;
-  }
-
-  let config = { configVersion: 1 as const };
-  if (fs.existsSync(configPath)) {
-    const loaded = await loadConfig(configPath);
-    if (loaded) config = loaded;
-  }
-
-  // Lazy import to avoid loading review engine at CLI startup
-  const { loadAdapter } = await import('../adapters/loader.ts');
-  const { runReviewPhase } = await import('../core/pipeline/review-phase.ts');
-
-  const engineRef = (config as { reviewEngine?: unknown }).reviewEngine;
-  const ref = typeof engineRef === 'string' ? engineRef : (engineRef as { adapter?: string })?.adapter ?? 'auto';
-  const engineOptions = typeof engineRef === 'object' && engineRef !== null
-    ? (engineRef as { options?: Record<string, unknown> }).options
-    : undefined;
-
-  const engine = await loadAdapter({
-    point: 'review-engine',
-    ref,
-    options: engineOptions,
-  });
-
-  const server = await startWorkerServer({
-    cwd,
-    onReview: async (files, cfg) => {
-      const result = await runReviewPhase({ touchedFiles: files, config: cfg, engine: engine as unknown as ReviewEngine });
-      return { findings: result.findings, usage: result.costUSD !== undefined ? { costUSD: result.costUSD } : undefined };
-    },
-  });
-
-  writeLock(cwd, { pid: process.pid, port: server.port, startedAt: new Date().toISOString() });
-
-  const cleanup = () => { deleteLock(cwd); server.close().then(() => process.exit(0)); };
-  process.on('SIGTERM', cleanup);
-  process.on('SIGINT', cleanup);
-
-  console.log(`${C.green}[worker] Started — pid ${process.pid} port ${server.port}${C.reset}`);
-  console.log(`${C.dim}  guardrail run --use-worker   # dispatch review chunks to this worker${C.reset}`);
-
-  await new Promise(() => {}); // keep alive
-  return 0;
-}
-
-async function workerStop(cwd: string): Promise<number> {
-  const lock = readLock(cwd);
-  if (!lock) { console.log('[worker] No worker running'); return 0; }
-  if (!isWorkerAlive(lock)) { deleteLock(cwd); console.log('[worker] Stale lockfile removed'); return 0; }
-  await stopWorker(lock);
-  // Give it 3s to exit, then SIGTERM
-  await new Promise(r => setTimeout(r, 1000));
-  if (isWorkerAlive(lock)) {
-    try { process.kill(lock.pid, 'SIGTERM'); } catch { /* already dead */ }
-  }
-  deleteLock(cwd);
-  console.log(`${C.green}[worker] Stopped${C.reset}`);
-  return 0;
-}
-
-async function workerStatus(cwd: string): Promise<number> {
-  const lock = readLock(cwd);
-  if (!lock) { console.log('[worker] Not running'); return 1; }
-  if (!isWorkerAlive(lock)) { console.log(`[worker] Dead (stale lock — pid ${lock.pid})`); return 1; }
-  try {
-    const status = await getWorkerStatus(lock);
-    console.log(`[worker] Running`);
-    console.log(`  pid:            ${status.pid}`);
-    console.log(`  port:           ${status.port}`);
-    console.log(`  jobs processed: ${status.jobsProcessed}`);
-    console.log(`  uptime:         ${Math.round(status.uptimeMs / 1000)}s`);
-    return 0;
-  } catch {
-    console.log(`[worker] Running (pid ${lock.pid} port ${lock.port}) — status endpoint unreachable`);
-    return 0;
-  }
-}

package/src/core/cache/cached-engine.ts

@@ -1,32 +0,0 @@
-import type { ReviewEngine, ReviewInput, ReviewOutput } from '../../adapters/review-engine/types.ts';
-import type { Capabilities } from '../../adapters/base.ts';
-import { ReviewCache, type ReviewCacheOptions } from './review-cache.ts';
-
-/**
- * Wraps any ReviewEngine with file-based response caching.
- * Cache key = SHA-256(adapterName + model + content).
- */
-export function withCache(engine: ReviewEngine, options: ReviewCacheOptions = {}): ReviewEngine {
-  const cache = new ReviewCache(options);
-  const model = (engine as { model?: string }).model ?? engine.name;
-
-  return {
-    name: engine.name,
-    apiVersion: engine.apiVersion,
-    getCapabilities(): Capabilities {
-      return engine.getCapabilities();
-    },
-    estimateTokens(content: string): number {
-      return engine.estimateTokens(content);
-    },
-    async review(input: ReviewInput): Promise<ReviewOutput> {
-      const keyPayload = `${input.content}\x00${input.kind}\x00${input.context?.stack ?? ''}`;
-      const key = ReviewCache.keyFor(engine.name, model, keyPayload);
-      const cached = await cache.get(key);
-      if (cached) return { ...cached, usage: cached.usage ? { ...cached.usage, costUSD: 0 } : undefined };
-      const output = await engine.review(input);
-      await cache.set(key, output);
-      return output;
-    },
-  };
-}

package/src/core/cache/review-cache.ts

@@ -1,70 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { createHash } from 'node:crypto';
-import type { ReviewOutput } from '../../adapters/review-engine/types.ts';
-
-export interface CacheEntry {
-  key: string;
-  output: ReviewOutput;
-  createdAt: string;
-  expiresAt: string;
-}
-
-export interface ReviewCacheOptions {
-  cacheDir?: string;
-  ttlMs?: number;
-}
-
-const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000; // 24h
-// Prefer env override, then ~/.guardrail-cache to survive across cwd changes and container restarts
-const DEFAULT_CACHE_DIR = process.env.AUTOPILOT_CACHE_DIR
-  ? path.join(process.env.AUTOPILOT_CACHE_DIR, 'reviews')
-  : path.join(os.homedir(), '.guardrail-cache', 'reviews');
-
-export class ReviewCache {
-  private readonly cacheDir: string;
-  private readonly ttlMs: number;
-
-  constructor(options: ReviewCacheOptions = {}) {
-    this.cacheDir = options.cacheDir ?? DEFAULT_CACHE_DIR;
-    this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
-  }
-
-  static keyFor(adapterName: string, model: string, content: string): string {
-    return createHash('sha256').update(`${adapterName}:${model}:${content}`).digest('hex');
-  }
-
-  async get(key: string): Promise<ReviewOutput | undefined> {
-    const filePath = this.entryPath(key);
-    try {
-      const raw = await fs.readFile(filePath, 'utf8');
-      const entry: CacheEntry = JSON.parse(raw);
-      if (new Date(entry.expiresAt) < new Date()) {
-        await fs.unlink(filePath).catch(() => undefined);
-        return undefined;
-      }
-      return entry.output;
-    } catch {
-      return undefined;
-    }
-  }
-
-  async set(key: string, output: ReviewOutput): Promise<void> {
-    await fs.mkdir(this.cacheDir, { recursive: true });
-    const entry: CacheEntry = {
-      key,
-      output,
-      createdAt: new Date().toISOString(),
-      expiresAt: new Date(Date.now() + this.ttlMs).toISOString(),
-    };
-    const filePath = this.entryPath(key);
-    const tmp = `${filePath}.tmp`;
-    await fs.writeFile(tmp, JSON.stringify(entry), 'utf8');
-    await fs.rename(tmp, filePath);
-  }
-
-  private entryPath(key: string): string {
-    return path.join(this.cacheDir, `${key}.json`);
-  }
-}

package/src/core/chunking/index.ts

@@ -1,113 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import type { ReviewEngine, ReviewInput } from '../../adapters/review-engine/types.ts';
-import type { GuardrailConfig } from '../config/types.ts';
-import { rankByRisk } from './risk-ranker.ts';
-import { getFileDiffs, formatDiffContent } from '../git/diff-hunks.ts';
-
-export interface ReviewChunk {
-  content: string;
-  kind: ReviewInput['kind'];
-  files: string[];
-}
-
-export interface BuildChunksInput {
-  touchedFiles: string[];
-  strategy: 'auto' | 'single-pass' | 'file-level' | 'diff' | 'auto-diff';
-  chunking?: GuardrailConfig['chunking'];
-  engine: ReviewEngine;
-  cwd?: string;
-  protectedPaths?: string[];
-  base?: string;  // git base ref — required for 'diff'/'auto-diff' strategy
-}
-
-const DEFAULT_SMALL_TIER_TOKENS = 8000;
-const DEFAULT_FILE_TIER_TOKENS = 60000;
-
-export async function buildReviewChunks(input: BuildChunksInput): Promise<ReviewChunk[]> {
-  const smallMax = input.chunking?.smallTierMaxTokens ?? DEFAULT_SMALL_TIER_TOKENS;
-  const fileMax = input.chunking?.perFileMaxTokens ?? DEFAULT_FILE_TIER_TOKENS;
-
-  // Diff strategy: send unified diff hunks instead of full file contents
-  if (input.strategy === 'diff') {
-    return buildDiffChunks(input);
-  }
-
-  // auto-diff: try diff first; fall back to full-file auto if diff is empty
-  // (handles new files, initial commits, or repos with no base ref)
-  if (input.strategy === 'auto-diff') {
-    const diffChunks = buildDiffChunks(input);
-    if (diffChunks.length > 0) return diffChunks;
-    // fall through to auto with full files
-  }
-
-  const ranked = rankByRisk(input.touchedFiles, { protectedPaths: input.protectedPaths });
-  const fileContents = await readFiles(ranked, input.cwd);
-
-  if (input.strategy === 'single-pass') {
-    const combined = formatBatch(fileContents);
-    return [{ content: combined, kind: 'file-batch', files: [...fileContents.keys()] }];
-  }
-
-  if (input.strategy === 'auto') {
-    const combined = formatBatch(fileContents);
-    if (input.engine.estimateTokens(combined) <= smallMax) {
-      return [{ content: combined, kind: 'file-batch', files: [...fileContents.keys()] }];
-    }
-    // fall through to file-level
-  }
-
-  // file-level: one chunk per readable file, truncated to fileMax tokens
-  const chunks: ReviewChunk[] = [];
-  for (const [filePath, content] of fileContents) {
-    const truncated = truncateToTokens(content, fileMax, input.engine);
-    chunks.push({ content: `// File: ${filePath}\n${truncated}`, kind: 'file-batch', files: [filePath] });
-  }
-  return chunks;
-}
-
-function buildDiffChunks(input: BuildChunksInput): ReviewChunk[] {
-  const cwd = input.cwd ?? process.cwd();
-  const base = input.base ?? 'HEAD~1';
-  const ranked = rankByRisk(input.touchedFiles, { protectedPaths: input.protectedPaths });
-  const diffs = getFileDiffs(cwd, base, ranked);
-
-  if (diffs.length === 0) return [];
-
-  // Single chunk — diff content is already compact; truncation handled in formatDiffContent
-  const content = formatDiffContent(diffs);
-  return [{ content, kind: 'file-batch', files: diffs.map(d => d.file) }];
-}
-
-async function readFiles(touchedFiles: string[], cwd?: string): Promise<Map<string, string>> {
-  const result = new Map<string, string>();
-  for (const f of touchedFiles) {
-    const resolved = cwd ? path.resolve(cwd, f) : path.resolve(f);
-    try {
-      result.set(f, await fs.readFile(resolved, 'utf8'));
-    } catch {
-      // deleted or unreadable — skip silently
-    }
-  }
-  return result;
-}
-
-function formatBatch(fileContents: Map<string, string>): string {
-  const parts: string[] = [];
-  for (const [filePath, content] of fileContents) {
-    parts.push(`// File: ${filePath}\n${content}`);
-  }
-  return parts.join('\n\n---\n\n');
-}
-
-function truncateToTokens(content: string, maxTokens: number, engine: ReviewEngine): string {
-  if (engine.estimateTokens(content) <= maxTokens) return content;
-  let lo = 0;
-  let hi = content.length;
-  while (hi - lo > 128) {
-    const mid = (lo + hi) >> 1;
-    if (engine.estimateTokens(content.slice(0, mid)) <= maxTokens) lo = mid;
-    else hi = mid;
-  }
-  return content.slice(0, lo) + '\n// [truncated]';
-}

package/src/core/chunking/risk-ranker.ts

@@ -1,56 +0,0 @@
-import { minimatch } from 'minimatch';
-
-interface RankOptions {
-  protectedPaths?: string[];
-}
-
-const AUTH_PATTERNS = [
-  /auth/i, /login/i, /logout/i, /session/i, /token/i, /jwt/i, /oauth/i,
-  /password/i, /credential/i, /secret/i, /permission/i, /role/i, /acl/i,
-];
-
-const PAYMENT_PATTERNS = [
-  /payment/i, /billing/i, /stripe/i, /checkout/i, /invoice/i, /charge/i,
-  /subscription/i, /wallet/i, /transaction/i, /refund/i,
-];
-
-const CORE_PATTERNS = [
-  /\/services\//i, /\/core\//i, /\/api\//i, /\/routes?\//i,
-  /\/controllers?\//i, /\/models?\//i, /\/middleware\//i, /\/handlers?\//i,
-];
-
-const TEST_EXT = /\.(test|spec)\.[a-z]+$/i;
-const DOC_EXT = /\.(md|txt|rst|adoc)$/i;
-const CONFIG_EXT = /\.(ya?ml|json|toml|ini|env)$/i;
-const CONFIG_NAMES = /(config|settings|env|constants)\./i;
-
-function scoreFile(file: string, protectedPaths: string[]): number {
-  const norm = file.replace(/\\/g, '/');
-
-  // Protected paths are highest risk
-  for (const pattern of protectedPaths) {
-    if (minimatch(norm, pattern, { matchBase: false }) ||
-        minimatch(norm, pattern, { matchBase: true })) {
-      return 100;
-    }
-  }
-
-  if (TEST_EXT.test(norm)) return 10;
-  if (DOC_EXT.test(norm)) return 5;
-
-  if (AUTH_PATTERNS.some(p => p.test(norm))) return 80;
-  if (PAYMENT_PATTERNS.some(p => p.test(norm))) return 70;
-  if (CORE_PATTERNS.some(p => p.test(norm))) return 50;
-  if (CONFIG_EXT.test(norm) || CONFIG_NAMES.test(norm)) return 40;
-
-  return 30;
-}
-
-/**
- * Returns files sorted highest-risk first so LLM sees the most sensitive code
- * at the start of its context window.
- */
-export function rankByRisk(files: string[], options: RankOptions = {}): string[] {
-  const protectedPaths = options.protectedPaths ?? [];
-  return [...files].sort((a, b) => scoreFile(b, protectedPaths) - scoreFile(a, protectedPaths));
-}

package/src/core/config/loader.ts

@@ -1,53 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as yaml from 'js-yaml';
-import Ajv from 'ajv';
-import { GuardrailError } from '../errors.ts';
-import type { GuardrailConfig } from './types.ts';
-import { GUARDRAIL_CONFIG_SCHEMA } from './schema.ts';
-
-const ajv = new Ajv({ allErrors: true, strict: false });
-const validate = ajv.compile(GUARDRAIL_CONFIG_SCHEMA);
-
-export async function loadConfig(path: string): Promise<GuardrailConfig> {
-  let content: string;
-  try {
-    content = await fs.readFile(path, 'utf8');
-  } catch (err) {
-    throw new GuardrailError(`Config file not found: ${path}`, {
-      code: 'user_input',
-      details: { path, cause: err instanceof Error ? err.message : String(err) },
-    });
-  }
-
-  let parsed: unknown;
-  try {
-    parsed = yaml.load(content);
-  } catch (err) {
-    throw new GuardrailError(`Invalid YAML in ${path}`, {
-      code: 'invalid_config',
-      details: { path, cause: err instanceof Error ? err.message : String(err) },
-    });
-  }
-
-  if (!validate(parsed)) {
-    const errors = (validate.errors ?? []).map(e => {
-      const loc = e.instancePath ? e.instancePath.replace(/^\//, '').replace(/\//g, '.') : '<root>';
-      // enum errors: list allowed values
-      if (e.keyword === 'enum' && Array.isArray(e.params?.allowedValues)) {
-        return `${loc}: must be one of ${(e.params.allowedValues as unknown[]).map(v => JSON.stringify(v)).join(', ')}`;
-      }
-      // additionalProperties: name the unexpected key
-      if (e.keyword === 'additionalProperties' && e.params?.additionalProperty) {
-        return `${loc}: unexpected key "${e.params.additionalProperty as string}"`;
-      }
-      return `${loc}: ${e.message ?? 'invalid'}`;
-    });
-    const summary = errors.slice(0, 5).join('\n  ');
-    throw new GuardrailError(
-      `guardrail.config.yaml is invalid:\n  ${summary}${errors.length > 5 ? `\n  …and ${errors.length - 5} more` : ''}`,
-      { code: 'invalid_config', details: { path, errors } },
-    );
-  }
-
-  return parsed as GuardrailConfig;
-}

package/src/core/config/preset-resolver.ts

@@ -1,46 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { loadConfig } from './loader.ts';
-import { GuardrailError } from '../errors.ts';
-import type { GuardrailConfig } from './types.ts';
-
-const PRESET_ROOT = path.resolve(process.cwd(), 'presets');
-
-export interface ResolvedPreset {
-  name: string;
-  config: GuardrailConfig;
-  stack: string;
-}
-
-export async function resolvePreset(name: string): Promise<ResolvedPreset> {
-  const presetDir = path.join(PRESET_ROOT, name);
-  try {
-    await fs.stat(presetDir);
-  } catch {
-    throw new GuardrailError(`Preset not found: ${name}`, {
-      code: 'invalid_config',
-      details: { name, presetDir },
-    });
-  }
-
-  const config = await loadConfig(path.join(presetDir, 'guardrail.config.yaml'));
-  let stack = '';
-  try {
-    stack = await fs.readFile(path.join(presetDir, 'stack.md'), 'utf8');
-  } catch {
-    stack = config.stack ?? '';
-  }
-  return { name, config, stack };
-}
-
-export function mergeConfigs(preset: GuardrailConfig, user: GuardrailConfig): GuardrailConfig {
-  return {
-    ...preset,
-    ...user,
-    // Arrays are concatenated (preset values first) so user additions don't discard preset invariants
-    protectedPaths: [...(preset.protectedPaths ?? []), ...(user.protectedPaths ?? [])],
-    staticRules: [...(preset.staticRules ?? []), ...(user.staticRules ?? [])],
-    thresholds: { ...preset.thresholds, ...user.thresholds },
-    chunking: { ...preset.chunking, ...user.chunking },
-  };
-}

package/src/core/config/schema.ts

@@ -1,181 +0,0 @@
-export const GUARDRAIL_CONFIG_SCHEMA = {
-  $schema: 'http://json-schema.org/draft-07/schema#',
-  type: 'object',
-  required: ['configVersion'],
-  additionalProperties: false,
-  properties: {
-    configVersion: { const: 1 },
-    preset: { type: 'string' },
-    reviewEngine: { $ref: '#/definitions/adapterRef' },
-    vcsHost: { $ref: '#/definitions/adapterRef' },
-    migrationRunner: { $ref: '#/definitions/adapterRef' },
-    reviewBot: { $ref: '#/definitions/adapterRef' },
-    adapterAllowlist: { type: 'array', items: { type: 'string' } },
-    protectedPaths: { type: 'array', items: { type: 'string' } },
-    staticRules: {
-      type: 'array',
-      items: {
-        oneOf: [
-          { type: 'string' },
-          { type: 'object', required: ['adapter'], properties: { adapter: { type: 'string' }, options: { type: 'object' } } },
-        ],
-      },
-    },
-    staticRulesParallel: { type: 'boolean' },
-    stack: { type: 'string' },
-    testCommand: { type: ['string', 'null'] },
-    thresholds: {
-      type: 'object',
-      properties: {
-        bugbotAutoFix: { type: 'number' },
-        bugbotProposePatch: { type: 'number' },
-        maxValidateRetries: { type: 'number' },
-        maxCodexRetries: { type: 'number' },
-        maxBugbotRounds: { type: 'number' },
-      },
-      additionalProperties: false,
-    },
-    ignore: {
-      type: 'array',
-      items: {
-        oneOf: [
-          { type: 'string' },
-          {
-            type: 'object',
-            required: ['path'],
-            properties: {
-              rule: { type: 'string' },
-              path: { type: 'string' },
-            },
-            additionalProperties: false,
-          },
-        ],
-      },
-    },
-    reviewStrategy: { enum: ['auto', 'single-pass', 'file-level', 'diff', 'auto-diff'] },
-    chunking: {
-      type: 'object',
-      properties: {
-        smallTierMaxTokens: { type: 'number' },
-        partialReviewTokens: { type: 'number' },
-        perFileMaxTokens: { type: 'number' },
-        parallelism: { type: 'number' },
-        rateLimitBackoff: { enum: ['exp', 'linear', 'none'] },
-      },
-      additionalProperties: false,
-    },
-    policy: {
-      type: 'object',
-      properties: {
-        failOn: { enum: ['critical', 'warning', 'note', 'none'] },
-        newOnly: { type: 'boolean' },
-        baselinePath: { type: 'string' },
-      },
-      additionalProperties: false,
-    },
-    pipeline: {
-      type: 'object',
-      properties: {
-        runReviewOnStaticFail: { type: 'boolean' },
-        runReviewOnTestFail: { type: 'boolean' },
-      },
-      additionalProperties: false,
-    },
-    cost: {
-      type: 'object',
-      properties: {
-        maxPerRun: { type: 'number' },
-        estimateBeforeRun: { type: 'boolean' },
-        pricing: { type: 'object' },
-      },
-      additionalProperties: false,
-    },
-    brand: {
-      type: 'object',
-      properties: {
-        colorsFrom: { type: 'string' },
-        colors: { type: 'array', items: { type: 'string' } },
-        fonts: { type: 'array', items: { type: 'string' } },
-        componentLibrary: {
-          oneOf: [
-            { type: 'string' },
-            {
-              type: 'object',
-              properties: {
-                tokens: { type: 'string' },
-                guide: { type: 'string' },
-              },
-              additionalProperties: false,
-            },
-          ],
-        },
-      },
-      additionalProperties: false,
-    },
-    'schema-alignment': {
-      type: 'object',
-      properties: {
-        enabled: { type: 'boolean' },
-        migrationGlobs: { type: 'array', items: { type: 'string', minLength: 1 } },
-        layerRoots: {
-          type: 'object',
-          properties: {
-            types: { type: 'array', items: { type: 'string' }, minItems: 1 },
-            api: { type: 'array', items: { type: 'string' }, minItems: 1 },
-            ui: { type: 'array', items: { type: 'string' }, minItems: 1 },
-          },
-          additionalProperties: false,
-        },
-        llmCheck: { type: 'boolean' },
-        severity: { enum: ['warning', 'error'] },
-      },
-      additionalProperties: false,
-    },
-    cache: { type: 'object' },
-    persistence: { type: 'object' },
-    concurrency: { type: 'object' },
-    council: {
-      type: 'object',
-      required: ['models', 'synthesizer'],
-      additionalProperties: false,
-      properties: {
-        models: {
-          type: 'array',
-          minItems: 2,
-          items: {
-            type: 'object',
-            required: ['adapter', 'model', 'label'],
-            additionalProperties: false,
-            properties: {
-              adapter: { type: 'string' },
-              model: { type: 'string' },
-              label: { type: 'string' },
-            },
-          },
-        },
-        synthesizer: {
-          type: 'object',
-          required: ['adapter', 'model', 'label'],
-          additionalProperties: false,
-          properties: {
-            adapter: { type: 'string' },
-            model: { type: 'string' },
-            label: { type: 'string' },
-          },
-        },
-        timeout_ms: { type: 'number' },
-        min_successful_responses: { type: 'number' },
-        parallel_input_max_tokens: { type: 'number' },
-        synthesis_input_max_tokens: { type: 'number' },
-      },
-    },
-  },
-  definitions: {
-    adapterRef: {
-      oneOf: [
-        { type: 'string' },
-        { type: 'object', required: ['adapter'], properties: { adapter: { type: 'string' }, options: { type: 'object' } } },
-      ],
-    },
-  },
-} as const;