@delegance/claude-autopilot 2.4.0 → 5.0.0-alpha.1

package/src/cli/triage.ts

@@ -0,0 +1,137 @@
+import { loadCachedFindings } from '../core/persist/findings-cache.ts';
+import {
+  loadTriage, saveTriage, addTriageEntry, removeTriageEntry, clearExpiredEntries,
+  type TriageState,
+} from '../core/persist/triage.ts';
+
+const C = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  green: '\x1b[32m', yellow: '\x1b[33m', red: '\x1b[31m',
+};
+const fmt = (c: keyof typeof C, t: string) => `${C[c]}${t}${C.reset}`;
+
+export interface TriageCommandOptions {
+  cwd?: string;
+}
+
+function parseTriageArgs(rest: string[]): { reason?: string; expiresInDays?: number; positional: string[] } {
+  let reason: string | undefined;
+  let expiresInDays: number | undefined;
+  const positional: string[] = [];
+  for (let i = 0; i < rest.length; i++) {
+    if (rest[i] === '--reason' && rest[i + 1]) { reason = rest[++i]; }
+    else if (rest[i] === '--expires' && rest[i + 1]) { expiresInDays = parseInt(rest[++i]!, 10); }
+    else if (!rest[i]!.startsWith('--')) { positional.push(rest[i]!); }
+  }
+  return { reason, expiresInDays, positional };
+}
+
+export async function runTriage(
+  subcommand: string | undefined,
+  rest: string[],
+  options: TriageCommandOptions = {},
+): Promise<number> {
+  const cwd = options.cwd ?? process.cwd();
+
+  if (subcommand === 'list' || subcommand === 'show') {
+    return cmdList(cwd);
+  }
+
+  if (subcommand === 'clear') {
+    const { positional } = parseTriageArgs(rest);
+    return cmdClear(cwd, positional, rest.includes('--expired'));
+  }
+
+  // Default: triage <finding-id> <state>
+  const findingId = subcommand;
+  const { reason, expiresInDays, positional } = parseTriageArgs(rest);
+  const stateArg = positional[0];
+
+  if (!findingId || !stateArg) {
+    printUsage();
+    return 1;
+  }
+
+  if (stateArg !== 'accepted-risk' && stateArg !== 'false-positive') {
+    console.error(fmt('red', `[triage] State must be "accepted-risk" or "false-positive", got: "${stateArg}"`));
+    return 1;
+  }
+
+  const findings = loadCachedFindings(cwd);
+  const finding = findings.find(f => f.id === findingId || f.id.startsWith(findingId));
+  if (!finding) {
+    console.error(fmt('red', `[triage] Finding not found: "${findingId}"`));
+    console.error(fmt('dim', '         Run `guardrail run` or `guardrail scan` first, then `guardrail report` to list IDs'));
+    return 1;
+  }
+
+  addTriageEntry(cwd, finding, stateArg as TriageState, { reason, expiresInDays });
+
+  const expNote = expiresInDays !== undefined ? fmt('dim', ` (expires in ${expiresInDays} days)`) : '';
+  console.log(`${fmt('green', '✓')}  ${fmt('bold', stateArg)}  ${finding.file}${finding.line ? `:${finding.line}` : ''} — ${finding.message}${expNote}`);
+  if (reason) console.log(fmt('dim', `   Reason: ${reason}`));
+  console.log(fmt('dim', '   Suppressed from future runs. Commit .guardrail-triage.json to share with team.'));
+  return 0;
+}
+
+function cmdList(cwd: string): number {
+  const store = loadTriage(cwd);
+  const now = new Date().toISOString();
+  const active = store.entries.filter(e => !e.expiresAt || e.expiresAt > now);
+  const expired = store.entries.filter(e => e.expiresAt && e.expiresAt <= now);
+
+  if (store.entries.length === 0) {
+    console.log(fmt('dim', '[triage] No triaged findings.'));
+    return 0;
+  }
+
+  console.log(`\n${fmt('bold', '[guardrail triage]')} ${active.length} active, ${expired.length} expired\n`);
+  for (const e of active) {
+    const tag = e.state === 'false-positive'
+      ? fmt('dim', 'false-positive ')
+      : fmt('yellow', 'accepted-risk  ');
+    const exp = e.expiresAt ? fmt('dim', ` expires ${e.expiresAt.slice(0, 10)}`) : '';
+    console.log(`  [${tag}]  ${fmt('dim', `${e.file}${e.line ? `:${e.line}` : ''}`)} — ${e.id}${exp}`);
+    if (e.reason) console.log(fmt('dim', `             Reason: ${e.reason}`));
+  }
+  if (expired.length > 0) {
+    console.log(fmt('dim', `\n  ${expired.length} expired — run \`guardrail triage clear --expired\` to remove`));
+  }
+  console.log('');
+  return 0;
+}
+
+function cmdClear(cwd: string, ids: string[], expired: boolean): number {
+  if (expired) {
+    const removed = clearExpiredEntries(cwd);
+    console.log(fmt('dim', `[triage] Cleared ${removed} expired entr${removed === 1 ? 'y' : 'ies'}`));
+    return 0;
+  }
+  if (ids.length === 0) {
+    console.error(fmt('red', '[triage] clear requires a finding ID or --expired'));
+    return 1;
+  }
+  const removed = removeTriageEntry(cwd, ids);
+  console.log(fmt('dim', `[triage] Cleared ${removed} entr${removed === 1 ? 'y' : 'ies'}`));
+  return 0;
+}
+
+function printUsage(): void {
+  console.error(`
+${fmt('bold', 'Usage:')}
+  guardrail triage <finding-id> accepted-risk|false-positive [options]
+  guardrail triage list
+  guardrail triage clear <finding-id> [<id>...]
+  guardrail triage clear --expired
+
+${fmt('bold', 'Options:')}
+  --reason <text>    Explain why this finding was triaged
+  --expires <days>   Auto-expire triage after N days
+
+${fmt('bold', 'States:')}
+  accepted-risk      Known issue, risk accepted — suppress without fixing
+  false-positive     Finding is incorrect — suppress permanently (or with expiry)
+
+${fmt('dim', 'Finding IDs come from `guardrail report` or the run output.')}
+`);
+}

package/src/cli/watch.ts

@@ -3,9 +3,9 @@ import * as path from 'node:path';
 import { loadConfig } from '../core/config/loader.ts';
 import { resolvePreset, mergeConfigs } from '../core/config/preset-resolver.ts';
 import { loadAdapter } from '../adapters/loader.ts';
-import { runAutopilot } from '../core/pipeline/run.ts';
+import { runGuardrail } from '../core/pipeline/run.ts';
 import type { ReviewEngine } from '../adapters/review-engine/types.ts';
-import type { AutopilotConfig } from '../core/config/types.ts';
+import type { GuardrailConfig } from '../core/config/types.ts';
 
 const C = {
   reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
@@ -17,7 +17,7 @@ const fmt = (c: keyof typeof C, t: string) => `${C[c]}${t}${C.reset}`;
 export const IGNORED_PATTERNS: readonly RegExp[] = [
   /(^|[/\\])node_modules([/\\]|$)/,
   /(^|[/\\])\.git([/\\]|$)/,
-  /(^|[/\\])\.autopilot-cache([/\\]|$)/,
+  /(^|[/\\])\.guardrail-cache([/\\]|$)/,
   /\.(log|tmp|swp|swo|DS_Store)$/,
   /~$/,
 ];
@@ -29,10 +29,12 @@ export function isIgnored(p: string): boolean {
 /**
  * Pure debounce accumulator — returned functions are the testable core of watch logic.
  * schedule(file) → adds file, starts/resets timer; when debounce fires, calls flush(batch).
+ * onSchedule (optional) is called on every schedule() with the file and current queue size.
  */
 export function makeDebouncer(
   flushFn: (batch: string[]) => void,
   debounceMs: number,
+  onSchedule?: (file: string, queueSize: number) => void,
 ): { schedule: (file: string) => void; pending: () => string[] } {
   const pending = new Set<string>();
   let timer: ReturnType<typeof setTimeout> | null = null;
@@ -46,6 +48,7 @@ export function makeDebouncer(
         timer = null;
         flushFn(batch);
       }, debounceMs);
+      onSchedule?.(file, pending.size);
     },
     pending() { return [...pending]; },
   };
@@ -59,47 +62,55 @@ export interface WatchOptions {
 
 export async function runWatch(options: WatchOptions = {}): Promise<void> {
   const cwd = options.cwd ?? process.cwd();
-  const configPath = options.configPath ?? path.join(cwd, 'autopilot.config.yaml');
+  const configPath = options.configPath ?? path.join(cwd, 'guardrail.config.yaml');
   const debounceMs = options.debounceMs ?? 300;
 
+  // Zero-config fallback — same as `run`
+  let config: GuardrailConfig;
   if (!fs.existsSync(configPath)) {
-    console.error(fmt('red', `[watch] autopilot.config.yaml not found — run: npx autopilot init`));
-    process.exit(1);
+    config = { configVersion: 1, reviewEngine: { adapter: 'auto' }, testCommand: null };
+  } else {
+    try {
+      const userConfig = await loadConfig(configPath);
+      config = userConfig.preset
+        ? mergeConfigs((await resolvePreset(userConfig.preset)).config, userConfig)
+        : userConfig;
+    } catch (err) {
+      console.error(fmt('red', `[watch] Config error: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
+    }
   }
 
-  let config: AutopilotConfig;
-  try {
-    const userConfig = await loadConfig(configPath);
-    config = userConfig.preset
-      ? mergeConfigs((await resolvePreset(userConfig.preset)).config, userConfig)
-      : userConfig;
-  } catch (err) {
-    console.error(fmt('red', `[watch] Config error: ${err instanceof Error ? err.message : String(err)}`));
-    process.exit(1);
-  }
+  const hasAnyKey = !!(process.env.ANTHROPIC_API_KEY || process.env.GEMINI_API_KEY ||
+    process.env.GOOGLE_API_KEY || process.env.OPENAI_API_KEY || process.env.GROQ_API_KEY);
 
   let reviewEngine: ReviewEngine | undefined;
-  if (config.reviewEngine) {
+  if (config.reviewEngine && hasAnyKey) {
     const ref = typeof config.reviewEngine === 'string' ? config.reviewEngine : config.reviewEngine.adapter;
-    if (process.env.OPENAI_API_KEY) {
-      try {
-        reviewEngine = await loadAdapter<ReviewEngine>({
-          point: 'review-engine', ref,
-          options: typeof config.reviewEngine === 'string' ? undefined : config.reviewEngine.options,
-        });
-      } catch { /* skip */ }
-    }
+    try {
+      reviewEngine = await loadAdapter<ReviewEngine>({
+        point: 'review-engine', ref,
+        options: typeof config.reviewEngine === 'string' ? undefined : config.reviewEngine.options,
+      });
+    } catch { /* skip — static rules still run */ }
   }
 
-  console.log(`\n${fmt('bold', '[autopilot watch]')} ${fmt('dim', cwd)}`);
-  console.log(fmt('dim', `  debounce: ${debounceMs}ms  |  Ctrl+C to exit\n`));
+  const keyStatus = hasAnyKey
+    ? fmt('green', '✓ LLM review enabled')
+    : fmt('yellow', '! No API key — static rules only  (set ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, or GROQ_API_KEY)');
+
+  console.log(`\n${fmt('bold', '[guardrail watch]')} ${fmt('dim', cwd)}`);
+  console.log(fmt('dim', `  debounce: ${debounceMs}ms  |  Ctrl+C to exit`));
+  console.log(`  ${keyStatus}\n`);
+  console.log(fmt('dim', '  Watching for changes…\n'));
 
   let running = false;
   const nextPending = new Set<string>();
+  let debounceLineShown = false;
 
   const runBatch = async (batch: string[]) => {
+    debounceLineShown = false;
     if (running) {
-      // Queue these files for the next run after the current one completes
       for (const f of batch) nextPending.add(f);
       return;
     }
@@ -111,7 +122,7 @@ export async function runWatch(options: WatchOptions = {}): Promise<void> {
     console.log(fmt('dim', `  changed: ${rel.slice(0, 4).join(', ')}${rel.length > 4 ? ` +${rel.length - 4} more` : ''}`));
 
     try {
-      const result = await runAutopilot({ touchedFiles: rel, config, reviewEngine, cwd });
+      const result = await runGuardrail({ touchedFiles: rel, config, reviewEngine, cwd });
 
       for (const phase of result.phases) {
         const icon = phase.status === 'pass' ? fmt('green', '✓')
@@ -137,7 +148,8 @@ export async function runWatch(options: WatchOptions = {}): Promise<void> {
     }
 
     running = false;
-    // Flush anything that accumulated while we were running
+    console.log(fmt('dim', '\n  Watching for changes…'));
+
     if (nextPending.size > 0) {
       const queued = [...nextPending];
       nextPending.clear();
@@ -145,7 +157,16 @@ export async function runWatch(options: WatchOptions = {}): Promise<void> {
     }
   };
 
-  const debouncer = makeDebouncer(batch => { runBatch(batch); }, debounceMs);
+  const debouncer = makeDebouncer(
+    batch => { runBatch(batch); },
+    debounceMs,
+    (_file, queueSize) => {
+      if (!debounceLineShown && !running) {
+        process.stdout.write(fmt('dim', `  ⋯ ${queueSize} file(s) queued — reviewing in ${debounceMs}ms…\r`));
+        debounceLineShown = true;
+      }
+    },
+  );
 
   const onEvent = (_event: string, filename: string | null) => {
     if (!filename) return;

package/src/cli/worker.ts

@@ -0,0 +1,109 @@
+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}[guardrail 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/review-cache.ts

@@ -17,10 +17,10 @@ export interface ReviewCacheOptions {
 }
 
 const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000; // 24h
-// Prefer env override, then ~/.autopilot-cache to survive across cwd changes and container restarts
+// 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(), '.autopilot-cache', 'reviews');
+  : path.join(os.homedir(), '.guardrail-cache', 'reviews');
 
 export class ReviewCache {
   private readonly cacheDir: string;

package/src/core/chunking/index.ts

@@ -1,7 +1,7 @@
 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 { AutopilotConfig } from '../config/types.ts';
+import type { GuardrailConfig } from '../config/types.ts';
 import { rankByRisk } from './risk-ranker.ts';
 import { getFileDiffs, formatDiffContent } from '../git/diff-hunks.ts';
 
@@ -14,7 +14,7 @@ export interface ReviewChunk {
 export interface BuildChunksInput {
   touchedFiles: string[];
   strategy: 'auto' | 'single-pass' | 'file-level' | 'diff' | 'auto-diff';
-  chunking?: AutopilotConfig['chunking'];
+  chunking?: GuardrailConfig['chunking'];
   engine: ReviewEngine;
   cwd?: string;
   protectedPaths?: string[];

package/src/core/config/loader.ts

@@ -1,19 +1,19 @@
 import * as fs from 'node:fs/promises';
 import * as yaml from 'js-yaml';
 import Ajv from 'ajv';
-import { AutopilotError } from '../errors.ts';
-import type { AutopilotConfig } from './types.ts';
-import { AUTOPILOT_CONFIG_SCHEMA } from './schema.ts';
+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(AUTOPILOT_CONFIG_SCHEMA);
+const validate = ajv.compile(GUARDRAIL_CONFIG_SCHEMA);
 
-export async function loadConfig(path: string): Promise<AutopilotConfig> {
+export async function loadConfig(path: string): Promise<GuardrailConfig> {
   let content: string;
   try {
     content = await fs.readFile(path, 'utf8');
   } catch (err) {
-    throw new AutopilotError(`Config file not found: ${path}`, {
+    throw new GuardrailError(`Config file not found: ${path}`, {
       code: 'user_input',
       details: { path, cause: err instanceof Error ? err.message : String(err) },
     });
@@ -23,19 +23,31 @@ export async function loadConfig(path: string): Promise<AutopilotConfig> {
   try {
     parsed = yaml.load(content);
   } catch (err) {
-    throw new AutopilotError(`Invalid YAML in ${path}`, {
+    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 => `${e.instancePath || '<root>'}: ${e.message}`);
-    throw new AutopilotError('Config schema validation failed', {
-      code: 'invalid_config',
-      details: { path, errors },
+    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 AutopilotConfig;
+  return parsed as GuardrailConfig;
 }

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

@@ -1,14 +1,14 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { loadConfig } from './loader.ts';
-import { AutopilotError } from '../errors.ts';
-import type { AutopilotConfig } from './types.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: AutopilotConfig;
+  config: GuardrailConfig;
   stack: string;
 }
 
@@ -17,13 +17,13 @@ export async function resolvePreset(name: string): Promise<ResolvedPreset> {
   try {
     await fs.stat(presetDir);
   } catch {
-    throw new AutopilotError(`Preset not found: ${name}`, {
+    throw new GuardrailError(`Preset not found: ${name}`, {
       code: 'invalid_config',
       details: { name, presetDir },
     });
   }
 
-  const config = await loadConfig(path.join(presetDir, 'autopilot.config.yaml'));
+  const config = await loadConfig(path.join(presetDir, 'guardrail.config.yaml'));
   let stack = '';
   try {
     stack = await fs.readFile(path.join(presetDir, 'stack.md'), 'utf8');
@@ -33,7 +33,7 @@ export async function resolvePreset(name: string): Promise<ResolvedPreset> {
   return { name, config, stack };
 }
 
-export function mergeConfigs(preset: AutopilotConfig, user: AutopilotConfig): AutopilotConfig {
+export function mergeConfigs(preset: GuardrailConfig, user: GuardrailConfig): GuardrailConfig {
   return {
     ...preset,
     ...user,