@delegance/claude-autopilot 2.5.0 → 5.0.0-alpha.2

package/src/adapters/review-engine/claude.ts

@@ -1,8 +1,9 @@
 import Anthropic from '@anthropic-ai/sdk';
-import { AutopilotError } from '../../core/errors.ts';
+import { GuardrailError } from '../../core/errors.ts';
 import type { Capabilities } from '../base.ts';
 import type { ReviewEngine, ReviewInput, ReviewOutput } from './types.ts';
 import { parseReviewOutput } from './parse-output.ts';
+import { buildSystemPrompt, classifyError } from './prompt-builder.ts';
 
 const DEFAULT_MODEL = 'claude-opus-4-7';
 const MAX_OUTPUT_TOKENS = 4096;
@@ -14,7 +15,7 @@ const COST_PER_M_OUTPUT = 75.0;
 const SYSTEM_PROMPT_TEMPLATE = `You are a senior software architect reviewing code changes for quality, security, and correctness.
 
 The codebase context:
-{STACK}{GIT_CONTEXT}
+{STACK}{GIT_CONTEXT}{DESIGN_SCHEMA}
 
 Provide structured feedback in exactly this format:
 
@@ -51,13 +52,11 @@ export const claudeAdapter: ReviewEngine = {
   async review(input: ReviewInput): Promise<ReviewOutput> {
     const apiKey = process.env.ANTHROPIC_API_KEY;
     if (!apiKey) {
-      throw new AutopilotError('ANTHROPIC_API_KEY not set', { code: 'auth', provider: 'claude' });
+      throw new GuardrailError('ANTHROPIC_API_KEY not set', { code: 'auth', provider: 'claude' });
     }
 
     const model = (input.context as Record<string, unknown> | undefined)?.['model'] as string | undefined ?? DEFAULT_MODEL;
-    const stack = input.context?.stack ?? 'A web application — stack details unspecified.';
-    const gitCtx = input.context?.gitSummary ? `\n\nChange context: ${input.context.gitSummary}` : '';
-    const systemPrompt = SYSTEM_PROMPT_TEMPLATE.replace('{STACK}', stack).replace('{GIT_CONTEXT}', gitCtx);
+    const systemPrompt = buildSystemPrompt(input, SYSTEM_PROMPT_TEMPLATE);
 
     const client = new Anthropic({ apiKey });
     let response: Anthropic.Message;
@@ -70,12 +69,11 @@ export const claudeAdapter: ReviewEngine = {
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      const isRateLimit = /rate.limit|429|overloaded/i.test(message);
-      const isAuth = /unauthorized|401|invalid.api.key|authentication/i.test(message);
-      throw new AutopilotError(`Claude review call failed: ${message}`, {
-        code: isAuth ? 'auth' : isRateLimit ? 'rate_limit' : 'transient_network',
+      const code = classifyError(message);
+      throw new GuardrailError(`Claude review call failed: ${message}`, {
+        code,
         provider: 'claude',
-        retryable: isRateLimit,
+        retryable: code === 'rate_limit',
       });
     }
 

package/src/adapters/review-engine/codex.ts

@@ -1,8 +1,9 @@
 import OpenAI from 'openai';
 import { parseReviewOutput } from './parse-output.ts';
-import { AutopilotError } from '../../core/errors.ts';
+import { GuardrailError } from '../../core/errors.ts';
 import type { Capabilities } from '../base.ts';
 import type { ReviewEngine, ReviewInput, ReviewOutput } from './types.ts';
+import { buildSystemPrompt, classifyError } from './prompt-builder.ts';
 
 const DEFAULT_MODEL = process.env.CODEX_MODEL ?? 'gpt-5.3-codex';
 const MAX_OUTPUT_TOKENS = 4096;
@@ -10,7 +11,7 @@ const MAX_OUTPUT_TOKENS = 4096;
 const SYSTEM_PROMPT_TEMPLATE = `You are a senior software architect providing feedback on designs, proposals, and ideas.
 
 The codebase context:
-{STACK}{GIT_CONTEXT}
+{STACK}{GIT_CONTEXT}{DESIGN_SCHEMA}
 
 Provide structured feedback in exactly this format:
 
@@ -46,11 +47,9 @@ export const codexAdapter: ReviewEngine = {
   async review(input: ReviewInput): Promise<ReviewOutput> {
     const apiKey = process.env.OPENAI_API_KEY;
     if (!apiKey) {
-      throw new AutopilotError('OPENAI_API_KEY not set', { code: 'auth', provider: 'codex' });
+      throw new GuardrailError('OPENAI_API_KEY not set', { code: 'auth', provider: 'codex' });
     }
-    const stack = input.context?.stack ?? 'A web application — stack details unspecified.';
-    const gitCtx = input.context?.gitSummary ? `\n\nChange context: ${input.context.gitSummary}` : '';
-    const systemPrompt = SYSTEM_PROMPT_TEMPLATE.replace('{STACK}', stack).replace('{GIT_CONTEXT}', gitCtx);
+    const systemPrompt = buildSystemPrompt(input, SYSTEM_PROMPT_TEMPLATE);
 
     const client = new OpenAI({ apiKey });
     let response;
@@ -63,12 +62,11 @@ export const codexAdapter: ReviewEngine = {
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      const isRateLimit = /rate.limit|429/i.test(message);
-      const isAuth = /unauthorized|401|invalid.api.key/i.test(message);
-      throw new AutopilotError(`Codex review call failed: ${message}`, {
-        code: isAuth ? 'auth' : isRateLimit ? 'rate_limit' : 'transient_network',
+      const code = classifyError(message);
+      throw new GuardrailError(`Codex review call failed: ${message}`, {
+        code,
         provider: 'codex',
-        retryable: isRateLimit,
+        retryable: code === 'rate_limit',
       });
     }
 

package/src/adapters/review-engine/gemini.ts

@@ -1,8 +1,9 @@
 import { GoogleGenerativeAI } from '@google/generative-ai';
 import { parseReviewOutput } from './parse-output.ts';
-import { AutopilotError } from '../../core/errors.ts';
+import { GuardrailError } from '../../core/errors.ts';
 import type { Capabilities } from '../base.ts';
 import type { ReviewEngine, ReviewInput, ReviewOutput } from './types.ts';
+import { buildSystemPrompt, classifyError } from './prompt-builder.ts';
 
 const DEFAULT_MODEL = 'gemini-2.5-pro-preview-05-06';
 const MAX_OUTPUT_TOKENS = 4096;
@@ -14,7 +15,7 @@ const COST_PER_M_OUTPUT = 10.0;
 const PROMPT_TEMPLATE = `You are a senior software architect reviewing code changes for quality, security, and correctness.
 
 The codebase context:
-{STACK}{GIT_CONTEXT}
+{STACK}{GIT_CONTEXT}{DESIGN_SCHEMA}
 
 Please review the following:
 
@@ -59,13 +60,11 @@ export const geminiAdapter: ReviewEngine = {
   async review(input: ReviewInput): Promise<ReviewOutput> {
     const apiKey = process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
     if (!apiKey) {
-      throw new AutopilotError('GEMINI_API_KEY (or GOOGLE_API_KEY) not set', { code: 'auth', provider: 'gemini' });
+      throw new GuardrailError('GEMINI_API_KEY (or GOOGLE_API_KEY) not set', { code: 'auth', provider: 'gemini' });
     }
 
     const model = (input.context as Record<string, unknown> | undefined)?.['model'] as string | undefined ?? DEFAULT_MODEL;
-    const stack = input.context?.stack ?? 'A web application — stack details unspecified.';
-    const gitCtx = input.context?.gitSummary ? `\n\nChange context: ${input.context.gitSummary}` : '';
-    const prompt = PROMPT_TEMPLATE.replace('{STACK}', stack).replace('{GIT_CONTEXT}', gitCtx).replace('{CONTENT}', input.content);
+    const prompt = buildSystemPrompt(input, PROMPT_TEMPLATE).replace('{CONTENT}', input.content);
 
     const genAI = new GoogleGenerativeAI(apiKey);
     const genModel = genAI.getGenerativeModel({
@@ -78,12 +77,11 @@ export const geminiAdapter: ReviewEngine = {
       result = await genModel.generateContent(prompt);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      const isRateLimit = /rate.limit|429|quota/i.test(message);
-      const isAuth = /api.key|unauthorized|403/i.test(message);
-      throw new AutopilotError(`Gemini review call failed: ${message}`, {
-        code: isAuth ? 'auth' : isRateLimit ? 'rate_limit' : 'transient_network',
+      const code = classifyError(message);
+      throw new GuardrailError(`Gemini review call failed: ${message}`, {
+        code,
         provider: 'gemini',
-        retryable: isRateLimit,
+        retryable: code === 'rate_limit',
       });
     }
 

package/src/adapters/review-engine/openai-compatible.ts

@@ -1,15 +1,16 @@
 import OpenAI from 'openai';
 import { parseReviewOutput } from './parse-output.ts';
-import { AutopilotError } from '../../core/errors.ts';
+import { GuardrailError } from '../../core/errors.ts';
 import type { Capabilities } from '../base.ts';
 import type { ReviewEngine, ReviewInput, ReviewOutput } from './types.ts';
+import { buildSystemPrompt, classifyError } from './prompt-builder.ts';
 
 const MAX_OUTPUT_TOKENS = 4096;
 
 const SYSTEM_PROMPT_TEMPLATE = `You are a senior software architect reviewing code changes for quality, security, and correctness.
 
 The codebase context:
-{STACK}{GIT_CONTEXT}
+{STACK}{GIT_CONTEXT}{DESIGN_SCHEMA}
 
 Provide structured feedback in exactly this format:
 
@@ -56,15 +57,13 @@ export const openaiCompatibleAdapter: ReviewEngine = {
 
     const model = opts['model'] as string | undefined;
     if (!model) {
-      throw new AutopilotError(
-        'openai-compatible adapter requires options.model to be set in autopilot.config.yaml',
+      throw new GuardrailError(
+        'openai-compatible adapter requires options.model to be set in guardrail.config.yaml',
         { code: 'invalid_config', provider: 'openai-compatible' },
       );
     }
 
-    const stack = input.context?.stack ?? 'A web application — stack details unspecified.';
-    const gitCtx = input.context?.gitSummary ? `\n\nChange context: ${input.context.gitSummary}` : '';
-    const systemPrompt = SYSTEM_PROMPT_TEMPLATE.replace('{STACK}', stack).replace('{GIT_CONTEXT}', gitCtx);
+    const systemPrompt = buildSystemPrompt(input, SYSTEM_PROMPT_TEMPLATE);
     const client = new OpenAI({ apiKey, ...(baseURL ? { baseURL } : {}) });
 
     let response: OpenAI.Chat.ChatCompletion;
@@ -79,12 +78,11 @@ export const openaiCompatibleAdapter: ReviewEngine = {
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      const isRateLimit = /rate.limit|429/i.test(message);
-      const isAuth = /unauthorized|401|invalid.api.key/i.test(message);
-      throw new AutopilotError(`openai-compatible review call failed: ${message}`, {
-        code: isAuth ? 'auth' : isRateLimit ? 'rate_limit' : 'transient_network',
+      const code = classifyError(message);
+      throw new GuardrailError(`openai-compatible review call failed: ${message}`, {
+        code,
         provider: 'openai-compatible',
-        retryable: isRateLimit,
+        retryable: code === 'rate_limit',
       });
     }
 

package/src/adapters/review-engine/parse-output.ts

@@ -15,16 +15,29 @@ function extractFileRef(text: string): { file: string; line?: number } {
   return { file: raw, line };
 }
 
+// Accepts any of: `### [CRITICAL] title`, `### CRITICAL title`, `### **CRITICAL** title`,
+// `### **[CRITICAL]** title`. Severity capture works across variants.
+const FINDING_REGEX =
+  /### (?:\*\*)?\[?(CRITICAL|WARNING|NOTE)\]?(?:\*\*)?\s*(.+?)(?=\n### (?:\*\*)?\[?(?:CRITICAL|WARNING|NOTE)\]?|## Review Summary|$)/gs;
+
+// "Substantive" output = enough non-whitespace chars to be a real LLM response, not
+// an empty/placeholder string. Anything past this with zero parsed findings is likely
+// format drift we should warn about.
+const NONTRIVIAL_OUTPUT_THRESHOLD = 40;
+
 /**
- * Parses the structured [CRITICAL|WARNING|NOTE] markdown format
- * produced by all review engine adapters. Extracts file:line references
- * from the finding body when present.
+ * Parses the structured CRITICAL|WARNING|NOTE markdown format produced by all review
+ * engine adapters. Extracts file:line references from the finding body when present.
+ *
+ * Tolerates common LLM format drift (missing brackets, bold wrappers) because the prompt
+ * alone doesn't guarantee literal `### [CRITICAL]` — models routinely emit
+ * `### CRITICAL` or `### **CRITICAL**`. A strict parser silently returns zero findings
+ * on otherwise-valid output, which is exactly the silent-failure mode this file exists to
+ * prevent.
  */
 export function parseReviewOutput(output: string, idPrefix: string): Finding[] {
   const findings: Finding[] = [];
-  const regex = /### \[(CRITICAL|WARNING|NOTE)\]\s*(.+?)(?=\n### \[|## Review Summary|$)/gs;
-  let match: RegExpExecArray | null;
-  while ((match = regex.exec(output)) !== null) {
+  for (const match of output.matchAll(FINDING_REGEX)) {
     const severity = match[1]!.toLowerCase() as Finding['severity'];
     const body = match[2]!.trim();
     const titleEnd = body.indexOf('\n');
@@ -44,5 +57,18 @@ export function parseReviewOutput(output: string, idPrefix: string): Finding[] {
       createdAt: new Date().toISOString(),
     });
   }
+
+  if (findings.length === 0) {
+    const nonWhitespace = output.replace(/\s/g, '').length;
+    if (nonWhitespace >= NONTRIVIAL_OUTPUT_THRESHOLD) {
+      const preview = output.slice(0, 200).replace(/\s+/g, ' ').trim();
+      // eslint-disable-next-line no-console
+      console.warn(
+        `[parseReviewOutput] LLM returned ${output.length} chars but no findings parsed. ` +
+        `Expected '### [CRITICAL|WARNING|NOTE] …'. Preview: ${preview}${output.length > 200 ? '…' : ''}`,
+      );
+    }
+  }
+
   return findings;
 }

package/src/adapters/review-engine/prompt-builder.ts

@@ -0,0 +1,19 @@
+import type { ReviewInput } from './types.ts';
+
+const DEFAULT_STACK = 'A web application — stack details unspecified.';
+
+export function buildSystemPrompt(input: ReviewInput, template: string): string {
+  const stack = input.context?.stack ?? DEFAULT_STACK;
+  const gitCtx = input.context?.gitSummary ? `\n\nChange context: ${input.context.gitSummary}` : '';
+  const designBlock = input.context?.designSchema ? `\n\n${input.context.designSchema}` : '';
+  return template
+    .replace('{STACK}', stack)
+    .replace('{GIT_CONTEXT}', gitCtx)
+    .replace('{DESIGN_SCHEMA}', designBlock);
+}
+
+export function classifyError(message: string): 'auth' | 'rate_limit' | 'transient_network' {
+  if (/unauthorized|401|invalid.api.key|authentication|api.key|403/i.test(message)) return 'auth';
+  if (/rate.limit|429|overloaded|quota/i.test(message)) return 'rate_limit';
+  return 'transient_network';
+}

package/src/adapters/review-engine/types.ts

@@ -4,7 +4,7 @@ import type { Finding } from '../../core/findings/types.ts';
 export interface ReviewInput {
   content: string;
   kind: 'spec' | 'pr-diff' | 'file-batch';
-  context?: { spec?: string; plan?: string; stack?: string; cwd?: string; gitSummary?: string };
+  context?: { spec?: string; plan?: string; stack?: string; cwd?: string; gitSummary?: string; designSchema?: string };
 }
 
 export interface ReviewOutput {

package/src/adapters/vcs-host/commit-status.ts

@@ -0,0 +1,39 @@
+import { runSafe } from '../../core/shell.ts';
+
+export type CommitState = 'pending' | 'success' | 'failure' | 'error';
+
+export interface CommitStatusOptions {
+  sha: string;
+  state: CommitState;
+  description?: string;
+  context?: string;
+  targetUrl?: string;
+  cwd?: string;
+}
+
+function getCurrentSha(cwd: string): string | null {
+  return runSafe('git', ['rev-parse', 'HEAD'], { cwd })?.trim() ?? null;
+}
+
+export function resolveCommitSha(cwd: string, envSha?: string): string | null {
+  return envSha
+    ?? process.env.GITHUB_SHA
+    ?? getCurrentSha(cwd);
+}
+
+export function postCommitStatus(opts: CommitStatusOptions): boolean {
+  const payload = JSON.stringify({
+    state: opts.state,
+    description: (opts.description ?? '').slice(0, 140),
+    context: opts.context ?? 'guardrail',
+    ...(opts.targetUrl ? { target_url: opts.targetUrl } : {}),
+  });
+
+  const result = runSafe('gh', [
+    'api', `repos/{owner}/{repo}/statuses/${opts.sha}`,
+    '--method', 'POST',
+    '--input', '-',
+  ], { cwd: opts.cwd, input: payload });
+
+  return result !== null;
+}

package/src/adapters/vcs-host/github.ts

@@ -1,5 +1,5 @@
 import { runSafe, runThrowing } from '../../core/shell.ts';
-import { AutopilotError } from '../../core/errors.ts';
+import { GuardrailError } from '../../core/errors.ts';
 import type { Capabilities } from '../base.ts';
 import type { VcsHost, GenericComment, PrMetadata, CreatePrOptions, CreatePrResult } from './types.ts';
 
@@ -13,7 +13,7 @@ export const githubAdapter: VcsHost = {
 
   async getPrDiff(pr: number | string): Promise<string> {
     const result = runSafe('gh', ['pr', 'diff', String(pr)]);
-    if (result === null) throw new AutopilotError(`Failed to get diff for PR ${pr}`, { code: 'transient_network' });
+    if (result === null) throw new GuardrailError(`Failed to get diff for PR ${pr}`, { code: 'transient_network' });
     return result;
   },
 

package/src/cli/baseline.ts

@@ -0,0 +1,125 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import {
+  loadBaseline, saveBaseline, clearBaseline, diffAgainstBaseline,
+  baselineFilePath,
+} from '../core/persist/baseline.ts';
+import { loadCachedFindings } from '../core/persist/findings-cache.ts';
+
+const C = {
+  reset: '\x1b[0m', bold: '\x1b[1m', dim: '\x1b[2m',
+  green: '\x1b[32m', yellow: '\x1b[33m', red: '\x1b[31m', cyan: '\x1b[36m',
+};
+const fmt = (c: keyof typeof C, t: string) => `${C[c]}${t}${C.reset}`;
+
+export interface BaselineCommandOptions {
+  cwd?: string;
+  note?: string;
+  baselinePath?: string;
+}
+
+export async function runBaseline(sub: string, options: BaselineCommandOptions = {}): Promise<number> {
+  const cwd = options.cwd ?? process.cwd();
+  const bPath = baselineFilePath(cwd, options.baselinePath);
+  const relPath = path.relative(cwd, bPath);
+
+  switch (sub) {
+    case 'create': {
+      if (fs.existsSync(bPath)) {
+        console.log(fmt('yellow', `[baseline] ${relPath} already exists — use \`guardrail baseline update\` to refresh, or \`guardrail baseline clear\` to reset`));
+        return 1;
+      }
+      return createOrUpdate(cwd, bPath, relPath, options.note, 'Created');
+    }
+
+    case 'update': {
+      return createOrUpdate(cwd, bPath, relPath, options.note, 'Updated');
+    }
+
+    case 'show': {
+      const baseline = loadBaseline(cwd, options.baselinePath);
+      if (!baseline) {
+        console.log(fmt('yellow', `[baseline] No baseline found at ${relPath}`));
+        console.log(fmt('dim', '  Run: guardrail baseline create'));
+        return 0;
+      }
+      console.log(`\n${fmt('bold', '[guardrail baseline]')} ${fmt('dim', relPath)}`);
+      console.log(fmt('dim', `  Created: ${baseline.createdAt}  Updated: ${baseline.updatedAt}`));
+      if (baseline.note) console.log(fmt('dim', `  Note: ${baseline.note}`));
+      console.log(`  ${baseline.entries.length} pinned finding${baseline.entries.length !== 1 ? 's' : ''}\n`);
+      for (const e of baseline.entries) {
+        const sev = e.severity === 'critical' ? fmt('red', 'CRIT') : e.severity === 'warning' ? fmt('yellow', 'WARN') : fmt('dim', 'NOTE');
+        console.log(`  [${sev}] ${fmt('dim', `${e.file}${e.line ? `:${e.line}` : ''}`)} ${e.message.slice(0, 70)}`);
+      }
+      console.log('');
+      return 0;
+    }
+
+    case 'diff': {
+      const baseline = loadBaseline(cwd, options.baselinePath);
+      if (!baseline) {
+        console.log(fmt('yellow', `[baseline] No baseline found — run: guardrail baseline create`));
+        return 1;
+      }
+      const current = loadCachedFindings(cwd);
+      if (current.length === 0) {
+        console.log(fmt('yellow', '[baseline] No cached findings — run `guardrail run` or `guardrail scan` first'));
+        return 1;
+      }
+      const diff = diffAgainstBaseline(current, baseline);
+      console.log(`\n${fmt('bold', '[guardrail baseline diff]')} vs ${fmt('dim', relPath)}\n`);
+
+      if (diff.added.length > 0) {
+        console.log(fmt('red', `  ${diff.added.length} new finding${diff.added.length !== 1 ? 's' : ''} (not in baseline):`));
+        for (const f of diff.added) {
+          const sev = f.severity === 'critical' ? fmt('red', 'CRIT') : f.severity === 'warning' ? fmt('yellow', 'WARN') : fmt('dim', 'NOTE');
+          console.log(`    [${sev}] ${fmt('dim', `${f.file}${f.line ? `:${f.line}` : ''}`)} ${f.message.slice(0, 70)}`);
+        }
+        console.log('');
+      }
+      if (diff.resolved.length > 0) {
+        console.log(fmt('green', `  ${diff.resolved.length} resolved (in baseline but not in current):`));
+        for (const e of diff.resolved) {
+          console.log(`    ${fmt('dim', `${e.file}${e.line ? `:${e.line}` : ''}`)} ${e.message.slice(0, 70)}`);
+        }
+        console.log('');
+      }
+      if (diff.added.length === 0 && diff.resolved.length === 0) {
+        console.log(fmt('green', `  ✓ No changes vs baseline (${diff.unchanged.length} pinned findings unchanged)\n`));
+      } else {
+        console.log(fmt('dim', `  ${diff.unchanged.length} unchanged · run \`guardrail baseline update\` to pin new state\n`));
+      }
+      return diff.added.some(f => f.severity === 'critical') ? 1 : 0;
+    }
+
+    case 'clear': {
+      if (!fs.existsSync(bPath)) {
+        console.log(fmt('dim', `[baseline] No baseline at ${relPath} — nothing to clear`));
+        return 0;
+      }
+      clearBaseline(cwd, options.baselinePath);
+      console.log(fmt('green', `[baseline] Cleared ${relPath}`));
+      return 0;
+    }
+
+    default:
+      console.error(fmt('red', `[baseline] Unknown subcommand: "${sub}"`));
+      console.error(fmt('dim', '  Usage: guardrail baseline <create|update|show|diff|clear> [--note "..."]'));
+      return 1;
+  }
+}
+
+function createOrUpdate(cwd: string, bPath: string, relPath: string, note: string | undefined, verb: string): number {
+  const findings = loadCachedFindings(cwd);
+  if (findings.length === 0) {
+    console.log(fmt('yellow', '[baseline] No cached findings to snapshot — run `guardrail run` or `guardrail scan` first'));
+    return 1;
+  }
+  const baseline = saveBaseline(cwd, findings, { note, overridePath: bPath === path.join(cwd, '.guardrail-baseline.json') ? undefined : bPath });
+  console.log(`\n${fmt('green', `[baseline] ${verb}`)} ${fmt('dim', relPath)}`);
+  console.log(`  ${baseline.entries.length} finding${baseline.entries.length !== 1 ? 's' : ''} pinned as accepted baseline`);
+  if (note) console.log(`  Note: ${note}`);
+  console.log(fmt('dim', `\n  Commit this file to share the baseline with your team:`));
+  console.log(fmt('cyan', `    git add ${relPath} && git commit -m "chore: update guardrail baseline"\n`));
+  return 0;
+}

package/src/cli/ci.ts

@@ -8,18 +8,19 @@ export interface CiCommandOptions {
   sarifOutput?: string;
   diff?: boolean;
   inlineComments?: boolean;
+  newOnly?: boolean;
+  failOn?: 'critical' | 'warning' | 'note' | 'none';
 }
 
 /**
- * `autopilot ci` — opinionated single-command CI entrypoint.
- *
- * Equivalent to:
- *   autopilot run --base <ref> --post-comments --format sarif --output <path>
+ * `guardrail ci` — opinionated single-command CI entrypoint.
  *
  * Defaults:
- *   base       GITHUB_BASE_REF → HEAD~1
- *   output     autopilot.sarif
- *   post-comments  true (skip if no PR detected — run.ts handles gracefully)
+ *   base          GITHUB_BASE_REF → HEAD~1
+ *   output        guardrail.sarif
+ *   post-comments true
+ *   fail-on       critical (or policy.failOn from config)
+ *   new-only      false (or policy.newOnly from config)
  */
 export async function runCi(options: CiCommandOptions = {}): Promise<number> {
   const base = options.base
@@ -27,7 +28,7 @@ export async function runCi(options: CiCommandOptions = {}): Promise<number> {
     ?? process.env.CI_MERGE_REQUEST_TARGET_BRANCH_NAME  // GitLab
     ?? 'HEAD~1';
 
-  const sarifOutput = options.sarifOutput ?? 'autopilot.sarif';
+  const sarifOutput = options.sarifOutput ?? 'guardrail.sarif';
 
   return runCommand({
     cwd: options.cwd,
@@ -38,5 +39,7 @@ export async function runCi(options: CiCommandOptions = {}): Promise<number> {
     outputPath: sarifOutput,
     diff: options.diff,
     inlineComments: options.inlineComments ?? true,
+    newOnly: options.newOnly,
+    failOn: options.failOn,
   });
 }

package/src/cli/costs.ts

@@ -26,7 +26,7 @@ export async function runCosts(cwd = process.cwd()): Promise<number> {
   const log = readCostLog(cwd);
 
   if (log.length === 0) {
-    console.log(fmt('yellow', '[costs] No run history found — run `autopilot run` first.'));
+    console.log(fmt('yellow', '[costs] No run history found — run `guardrail run` first.'));
     return 0;
   }
 
@@ -40,7 +40,7 @@ export async function runCosts(cwd = process.cwd()): Promise<number> {
   const totalOutput = log.reduce((s, e) => s + e.outputTokens, 0);
   const recentCost = recent.reduce((s, e) => s + e.costUSD, 0);
 
-  console.log(`\n${fmt('bold', '[autopilot costs]')}\n`);
+  console.log(`\n${fmt('bold', '[guardrail costs]')}\n`);
 
   // Summary row
   console.log(fmt('bold', 'Summary'));

package/src/cli/council.ts

@@ -0,0 +1,96 @@
+// src/cli/council.ts
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { loadConfig } from '../core/config/loader.ts';
+import { parseCouncilConfig } from '../core/council/config.ts';
+import { runCouncil } from '../core/council/runner.ts';
+import { makeClaudeCouncilAdapter } from '../adapters/council/claude.ts';
+import { makeOpenAICouncilAdapter } from '../adapters/council/openai.ts';
+import type { CouncilAdapter } from '../adapters/council/types.ts';
+import type { CouncilModelEntry } from '../core/council/types.ts';
+import { GuardrailError } from '../core/errors.ts';
+
+function makeAdapter(entry: CouncilModelEntry): CouncilAdapter {
+  switch (entry.adapter) {
+    case 'claude': return makeClaudeCouncilAdapter(entry.model, entry.label);
+    case 'openai': return makeOpenAICouncilAdapter(entry.model, entry.label);
+  }
+}
+
+export async function runCouncilCmd(opts: {
+  prompt?: string;
+  contextFile?: string;
+  configPath?: string;
+  dryRun?: boolean;
+  noSynthesize?: boolean;
+}): Promise<number> {
+  const cwd = process.cwd();
+  const configPath = opts.configPath ?? path.join(cwd, 'guardrail.config.yaml');
+
+  let config;
+  try {
+    config = await loadConfig(configPath);
+  } catch (err) {
+    console.error(err instanceof GuardrailError ? err.message : String(err));
+    return 1;
+  }
+
+  if (!config.council) {
+    console.error('[council] No "council" section in guardrail.config.yaml — add council.models and council.synthesizer');
+    return 1;
+  }
+
+  let councilConfig;
+  try {
+    councilConfig = parseCouncilConfig(config.council as Record<string, unknown>);
+  } catch (err) {
+    console.error(err instanceof GuardrailError ? err.message : String(err));
+    return 1;
+  }
+
+  if (opts.dryRun) {
+    process.stdout.write(JSON.stringify({ schema_version: 1, status: 'dry_run', config: councilConfig }, null, 2) + '\n');
+    return 0;
+  }
+
+  if (!opts.prompt) {
+    console.error('[council] --prompt is required');
+    return 1;
+  }
+  if (!opts.contextFile) {
+    console.error('[council] --context-file is required');
+    return 1;
+  }
+
+  let contextDoc: string;
+  try {
+    contextDoc = fs.readFileSync(opts.contextFile, 'utf8');
+  } catch {
+    console.error(`[council] Cannot read context file: ${opts.contextFile}`);
+    return 1;
+  }
+
+  const adapters = councilConfig.models.map(makeAdapter);
+  const synthesizer = opts.noSynthesize
+    ? { label: 'none', consult: async () => '' } as CouncilAdapter
+    : makeAdapter(councilConfig.synthesizer);
+
+  const result = await runCouncil(
+    councilConfig,
+    adapters,
+    synthesizer,
+    opts.prompt,
+    contextDoc,
+  );
+
+  // When no-synthesize, clear the empty synthesis object
+  if (opts.noSynthesize && result.synthesis?.text === '') {
+    delete (result as unknown as Record<string, unknown>)['synthesis'];
+  }
+
+  process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+
+  if (result.status === 'failed') return 2;
+  if (result.status === 'partial') return 1;
+  return 0;
+}