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

package/src/core/mcp/workspace.ts

@@ -0,0 +1,35 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export function resolveWorkspace(cwd?: string): string {
+  return fs.realpathSync(cwd ?? process.cwd());
+}
+
+export function assertInWorkspace(workspace: string, filePath: string): string {
+  const resolvedWorkspace = fs.realpathSync(workspace);
+  const abs = path.isAbsolute(filePath)
+    ? filePath
+    : path.resolve(resolvedWorkspace, filePath);
+
+  let resolved: string;
+  try {
+    resolved = fs.realpathSync(abs);
+  } catch {
+    // File doesn't exist yet — check the directory
+    const dir = path.dirname(abs);
+    let resolvedDir: string;
+    try {
+      resolvedDir = fs.realpathSync(dir);
+    } catch {
+      // Parent directory doesn't exist — resolve what we can
+      resolvedDir = path.resolve(dir);
+    }
+    resolved = path.join(resolvedDir, path.basename(abs));
+  }
+
+  const root = resolvedWorkspace.endsWith(path.sep) ? resolvedWorkspace : resolvedWorkspace + path.sep;
+  if (!resolved.startsWith(root) && resolved !== resolvedWorkspace) {
+    throw new Error(`Path "${filePath}" is outside workspace "${workspace}"`);
+  }
+  return resolved;
+}

package/src/core/persist/baseline.ts

@@ -0,0 +1,112 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { Finding } from '../findings/types.ts';
+
+const BASELINE_FILE = '.guardrail-baseline.json';
+
+export interface BaselineEntry {
+  id: string;
+  file: string;
+  line?: number;
+  severity: string;
+  message: string;
+  pinnedAt: string;
+  note?: string;
+}
+
+export interface Baseline {
+  version: 1;
+  createdAt: string;
+  updatedAt: string;
+  note?: string;
+  entries: BaselineEntry[];
+}
+
+/** Stable key for matching a finding against a baseline entry. */
+function baselineKey(f: { id: string; file: string; line?: number }): string {
+  return `${f.id}::${f.file}::${f.line ?? ''}`;
+}
+
+export function baselineFilePath(cwd: string, overridePath?: string): string {
+  return overridePath
+    ? path.isAbsolute(overridePath) ? overridePath : path.join(cwd, overridePath)
+    : path.join(cwd, BASELINE_FILE);
+}
+
+export function loadBaseline(cwd: string, overridePath?: string): Baseline | null {
+  const p = baselineFilePath(cwd, overridePath);
+  if (!fs.existsSync(p)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8')) as Baseline;
+  } catch {
+    return null;
+  }
+}
+
+export function saveBaseline(cwd: string, findings: Finding[], options: { note?: string; overridePath?: string } = {}): Baseline {
+  const existing = loadBaseline(cwd, options.overridePath);
+  const now = new Date().toISOString();
+  const baseline: Baseline = {
+    version: 1,
+    createdAt: existing?.createdAt ?? now,
+    updatedAt: now,
+    note: options.note ?? existing?.note,
+    entries: findings.map(f => ({
+      id: f.id,
+      file: f.file,
+      line: f.line,
+      severity: f.severity,
+      message: f.message,
+      pinnedAt: now,
+    })),
+  };
+  const p = baselineFilePath(cwd, options.overridePath);
+  const tmp = p + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(baseline, null, 2), 'utf8');
+  fs.renameSync(tmp, p);
+  return baseline;
+}
+
+export function clearBaseline(cwd: string, overridePath?: string): void {
+  const p = baselineFilePath(cwd, overridePath);
+  if (fs.existsSync(p)) fs.unlinkSync(p);
+}
+
+export interface BaselineFilterResult {
+  newFindings: Finding[];
+  baselinedFindings: Finding[];
+  baselinedCount: number;
+}
+
+/** Returns findings NOT present in the baseline (new findings only). */
+export function filterBaselined(findings: Finding[], baseline: Baseline): BaselineFilterResult {
+  const pinned = new Set(baseline.entries.map(baselineKey));
+  const newFindings: Finding[] = [];
+  const baselinedFindings: Finding[] = [];
+  for (const f of findings) {
+    if (pinned.has(baselineKey(f))) {
+      baselinedFindings.push(f);
+    } else {
+      newFindings.push(f);
+    }
+  }
+  return { newFindings, baselinedFindings, baselinedCount: baselinedFindings.length };
+}
+
+export interface BaselineDiff {
+  added: Finding[];       // in current but not in baseline
+  resolved: BaselineEntry[]; // in baseline but not in current
+  unchanged: Finding[];   // in both
+}
+
+/** Diff current findings against a baseline snapshot. */
+export function diffAgainstBaseline(current: Finding[], baseline: Baseline): BaselineDiff {
+  const currentKeys = new Set(current.map(baselineKey));
+  const baselineKeys = new Set(baseline.entries.map(baselineKey));
+
+  return {
+    added:     current.filter(f => !baselineKeys.has(baselineKey(f))),
+    resolved:  baseline.entries.filter(e => !currentKeys.has(baselineKey(e))),
+    unchanged: current.filter(f => baselineKeys.has(baselineKey(f))),
+  };
+}

package/src/core/persist/cost-log.ts

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 
-const CACHE_DIR = '.autopilot-cache';
+const CACHE_DIR = '.guardrail-cache';
 const LOG_FILE = 'costs.jsonl';
 
 export interface CostLogEntry {

package/src/core/persist/findings-cache.ts

@@ -2,7 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import type { Finding } from '../findings/types.ts';
 
-const CACHE_DIR = '.autopilot-cache';
+const CACHE_DIR = '.guardrail-cache';
 const CACHE_FILE = 'findings.json';
 
 function cacheFilePath(cwd: string): string {

package/src/core/persist/triage.ts

@@ -0,0 +1,112 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { Finding } from '../findings/types.ts';
+
+const TRIAGE_FILE = '.guardrail-triage.json';
+
+export type TriageState = 'accepted-risk' | 'false-positive';
+
+export interface TriageEntry {
+  id: string;
+  file: string;
+  line?: number;
+  state: TriageState;
+  reason?: string;
+  triagedAt: string;
+  expiresAt?: string;
+}
+
+export interface TriageStore {
+  version: 1;
+  entries: TriageEntry[];
+}
+
+function triageFilePath(cwd: string): string {
+  return path.join(cwd, TRIAGE_FILE);
+}
+
+function entryKey(e: { id: string; file: string; line?: number }): string {
+  return `${e.id}::${e.file}::${e.line ?? ''}`;
+}
+
+export function loadTriage(cwd: string): TriageStore {
+  const p = triageFilePath(cwd);
+  if (!fs.existsSync(p)) return { version: 1, entries: [] };
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8')) as TriageStore;
+  } catch {
+    return { version: 1, entries: [] };
+  }
+}
+
+export function saveTriage(cwd: string, store: TriageStore): void {
+  const p = triageFilePath(cwd);
+  const tmp = p + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(store, null, 2), 'utf8');
+  fs.renameSync(tmp, p);
+}
+
+export function addTriageEntry(
+  cwd: string,
+  finding: Finding,
+  state: TriageState,
+  options: { reason?: string; expiresInDays?: number } = {},
+): void {
+  const store = loadTriage(cwd);
+  const key = entryKey(finding);
+  store.entries = store.entries.filter(e => entryKey(e) !== key);
+  const entry: TriageEntry = {
+    id: finding.id,
+    file: finding.file,
+    line: finding.line,
+    state,
+    reason: options.reason,
+    triagedAt: new Date().toISOString(),
+  };
+  if (options.expiresInDays !== undefined) {
+    const exp = new Date();
+    exp.setDate(exp.getDate() + options.expiresInDays);
+    entry.expiresAt = exp.toISOString();
+  }
+  store.entries.push(entry);
+  saveTriage(cwd, store);
+}
+
+export function removeTriageEntry(cwd: string, ids: string[]): number {
+  const store = loadTriage(cwd);
+  const before = store.entries.length;
+  store.entries = store.entries.filter(e => !ids.some(id => e.id === id || e.id.startsWith(id)));
+  saveTriage(cwd, store);
+  return before - store.entries.length;
+}
+
+export function clearExpiredEntries(cwd: string): number {
+  const store = loadTriage(cwd);
+  const now = new Date().toISOString();
+  const before = store.entries.length;
+  store.entries = store.entries.filter(e => !e.expiresAt || e.expiresAt > now);
+  saveTriage(cwd, store);
+  return before - store.entries.length;
+}
+
+export interface TriageFilterResult {
+  active: Finding[];
+  triaged: Finding[];
+  triageCount: number;
+}
+
+export function filterTriaged(findings: Finding[], store: TriageStore): TriageFilterResult {
+  const now = new Date().toISOString();
+  const activeKeys = new Set(
+    store.entries
+      .filter(e => !e.expiresAt || e.expiresAt > now)
+      .map(entryKey),
+  );
+  const active: Finding[] = [];
+  const triaged: Finding[] = [];
+  for (const f of findings) {
+    if (activeKeys.has(entryKey(f))) triaged.push(f);
+    else active.push(f);
+  }
+  return { active, triaged, triageCount: triaged.length };
+}

package/src/core/phases/static-rules.ts

@@ -1,16 +1,20 @@
 import type { Finding, FixAttempt, FixStatus } from '../findings/types.ts';
+import type { GuardrailConfig } from '../config/types.ts';
+import type { ReviewEngine } from '../../adapters/review-engine/types.ts';
 import { dedupFindings, findingContentKey } from '../findings/dedup.ts';
 
 export interface StaticRule {
   name: string;
   severity: 'critical' | 'warning' | 'note';
-  check(touchedFiles: string[]): Promise<Finding[]>;
+  check(touchedFiles: string[], config?: Record<string, unknown>): Promise<Finding[]>;
   autofix?(finding: Finding): Promise<FixStatus>;
 }
 
 export interface StaticRulesPhaseInput {
   touchedFiles: string[];
   rules: StaticRule[];
+  config?: GuardrailConfig;
+  engine?: ReviewEngine;
 }
 
 export interface StaticRulesPhaseResult {
@@ -24,7 +28,7 @@ export interface StaticRulesPhaseResult {
 export async function runStaticRulesPhase(input: StaticRulesPhaseInput): Promise<StaticRulesPhaseResult> {
   const start = Date.now();
 
-  const preFixFindings = dedupFindings(await runAllChecks(input.rules, input.touchedFiles));
+  const preFixFindings = dedupFindings(await runAllChecks(input.rules, input.touchedFiles, input.config, input.engine));
 
   const fixAttempts: FixAttempt[] = [];
   let anyFixApplied = false;
@@ -52,7 +56,7 @@ export async function runStaticRulesPhase(input: StaticRulesPhaseInput): Promise
   // findings always returns preFixFindings so callers have a complete record;
   // fixAttempts + re-check set-difference tells them what was resolved.
   const postFixFindings = anyFixApplied
-    ? dedupFindings(await runAllChecks(input.rules, input.touchedFiles))
+    ? dedupFindings(await runAllChecks(input.rules, input.touchedFiles, input.config, input.engine))
     : preFixFindings;
 
   const postFixKeys = new Set(postFixFindings.map(findingContentKey));
@@ -69,9 +73,18 @@ export async function runStaticRulesPhase(input: StaticRulesPhaseInput): Promise
   return { phase: 'static-rules', status, findings: preFixFindings, fixAttempts, durationMs: Date.now() - start };
 }
 
-async function runAllChecks(rules: StaticRule[], files: string[]): Promise<Finding[]> {
+async function runAllChecks(
+  rules: StaticRule[],
+  files: string[],
+  config?: GuardrailConfig,
+  engine?: ReviewEngine,
+): Promise<Finding[]> {
+  const ruleConfig: Record<string, unknown> = {
+    ...(config ? (config as unknown as Record<string, unknown>) : {}),
+    _engine: engine,
+  };
   const all: Finding[] = [];
-  for (const rule of rules) all.push(...(await rule.check(files)));
+  for (const rule of rules) all.push(...(await rule.check(files, ruleConfig)));
   return all;
 }
 

package/src/core/pipeline/review-phase.ts

@@ -1,12 +1,15 @@
 import type { ReviewEngine } from '../../adapters/review-engine/types.ts';
 import type { Finding } from '../findings/types.ts';
-import type { AutopilotConfig } from '../config/types.ts';
+import type { GuardrailConfig } from '../config/types.ts';
 import { buildReviewChunks, type ReviewChunk } from '../chunking/index.ts';
+import { GuardrailError } from '../errors.ts';
+import { hasFrontendFiles, loadDesignContext } from '../ui/design-context-loader.ts';
 
 export interface ReviewPhaseResult {
   phase: 'review';
   status: 'pass' | 'warn' | 'fail' | 'skip';
   findings: Finding[];
+  rawOutputs?: string[];
   costUSD?: number;
   usage?: { input: number; output: number };
   durationMs: number;
@@ -15,32 +18,55 @@ export interface ReviewPhaseResult {
 export interface ReviewPhaseInput {
   touchedFiles: string[];
   engine: ReviewEngine;
-  config: AutopilotConfig;
+  config: GuardrailConfig;
   cwd?: string;
   gitSummary?: string;
+  designSchema?: string;
   budgetRemainingUSD?: number;
   base?: string;
 }
 
 interface ChunkResult {
   findings: Finding[];
+  rawOutput: string;
   inputTokens: number;
   outputTokens: number;
   costUSD: number;
 }
 
-async function reviewChunk(chunk: ReviewChunk, input: ReviewPhaseInput): Promise<ChunkResult> {
-  const output = await input.engine.review({
-    content: chunk.content,
-    kind: chunk.kind,
-    context: { stack: input.config.stack, cwd: input.cwd, gitSummary: input.gitSummary },
-  });
-  return {
-    findings: output.findings,
-    inputTokens: output.usage?.input ?? 0,
-    outputTokens: output.usage?.output ?? 0,
-    costUSD: output.usage?.costUSD ?? 0,
-  };
+function backoffMs(attempt: number, strategy: 'exp' | 'linear' | 'none'): number {
+  if (strategy === 'none') return 0;
+  if (strategy === 'linear') return attempt * 2000;
+  return Math.min(Math.pow(2, attempt) * 1000, 32000); // exp: 1s, 2s, 4s, 8s … 32s cap
+}
+
+async function reviewChunkWithRetry(chunk: ReviewChunk, input: ReviewPhaseInput): Promise<ChunkResult> {
+  const strategy = input.config.chunking?.rateLimitBackoff ?? 'exp';
+  const maxAttempts = strategy === 'none' ? 1 : 4;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      const output = await input.engine.review({
+        content: chunk.content,
+        kind: chunk.kind,
+        context: { stack: input.config.stack, cwd: input.cwd, gitSummary: input.gitSummary, designSchema: input.designSchema },
+      });
+      return {
+        findings: output.findings,
+        rawOutput: output.rawOutput,
+        inputTokens: output.usage?.input ?? 0,
+        outputTokens: output.usage?.output ?? 0,
+        costUSD: output.usage?.costUSD ?? 0,
+      };
+    } catch (err) {
+      const isRateLimit = err instanceof GuardrailError && err.code === 'rate_limit';
+      const isLast = attempt === maxAttempts - 1;
+      if (!isRateLimit || isLast) throw err;
+      const delay = backoffMs(attempt + 1, strategy);
+      await new Promise(r => setTimeout(r, delay));
+    }
+  }
+  throw new Error('unreachable');
 }
 
 /** Run up to `limit` promises concurrently, preserving result order. */
@@ -71,18 +97,28 @@ export async function runReviewPhase(input: ReviewPhaseInput): Promise<ReviewPha
     return { phase: 'review', status: 'skip', findings: [], durationMs: Date.now() - start };
   }
 
+  let designSchema: string | undefined;
+  if (hasFrontendFiles(input.touchedFiles) && input.config.brand?.componentLibrary) {
+    const loaded = loadDesignContext(
+      input.config.brand.componentLibrary,
+      input.cwd ?? process.cwd(),
+    );
+    if (loaded) designSchema = loaded;
+  }
+  const enrichedInput: ReviewPhaseInput = designSchema ? { ...input, designSchema } : input;
+
   const chunks = await buildReviewChunks({
-    touchedFiles: input.touchedFiles,
-    strategy: input.config.reviewStrategy ?? 'auto',
-    chunking: input.config.chunking,
-    engine: input.engine,
-    cwd: input.cwd,
-    protectedPaths: input.config.protectedPaths,
-    base: input.base,
+    touchedFiles: enrichedInput.touchedFiles,
+    strategy: enrichedInput.config.reviewStrategy ?? 'auto',
+    chunking: enrichedInput.config.chunking,
+    engine: enrichedInput.engine,
+    cwd: enrichedInput.cwd,
+    protectedPaths: enrichedInput.config.protectedPaths,
+    base: enrichedInput.base,
   });
 
-  const parallelism = input.config.chunking?.parallelism ?? 3;
-  const budgetUSD = input.budgetRemainingUSD;
+  const parallelism = enrichedInput.config.chunking?.parallelism ?? 3;
+  const budgetUSD = enrichedInput.budgetRemainingUSD;
 
   // For budget tracking we still need to enforce it — run serially if budget set,
   // parallel otherwise (budget check between serial chunks is the safe path).
@@ -93,7 +129,7 @@ export async function runReviewPhase(input: ReviewPhaseInput): Promise<ReviewPha
     let budgetExceeded = false;
     for (const chunk of chunks) {
       if (spent >= budgetUSD) { budgetExceeded = true; break; }
-      const r = await reviewChunk(chunk, input);
+      const r = await reviewChunkWithRetry(chunk, enrichedInput);
       spent += r.costUSD;
       chunkResults.push(r);
     }
@@ -109,20 +145,22 @@ export async function runReviewPhase(input: ReviewPhaseInput): Promise<ReviewPha
           protectedPath: false,
           createdAt: new Date().toISOString(),
         }],
-        inputTokens: 0, outputTokens: 0, costUSD: 0,
+        rawOutput: '', inputTokens: 0, outputTokens: 0, costUSD: 0,
       });
     }
   } else {
-    chunkResults = await pMap(chunks, chunk => reviewChunk(chunk, input), parallelism);
+    chunkResults = await pMap(chunks, chunk => reviewChunkWithRetry(chunk, enrichedInput), parallelism);
   }
 
   let totalInputTokens = 0;
   let totalOutputTokens = 0;
   let totalCostUSD = 0;
   const allFindings: Finding[] = [];
+  const allRawOutputs: string[] = [];
 
   for (const r of chunkResults) {
     allFindings.push(...r.findings);
+    if (r.rawOutput) allRawOutputs.push(r.rawOutput);
     totalInputTokens += r.inputTokens;
     totalOutputTokens += r.outputTokens;
     totalCostUSD += r.costUSD;
@@ -136,6 +174,7 @@ export async function runReviewPhase(input: ReviewPhaseInput): Promise<ReviewPha
     phase: 'review',
     status,
     findings: allFindings,
+    rawOutputs: allRawOutputs.length > 0 ? allRawOutputs : undefined,
     costUSD: totalCostUSD > 0 ? totalCostUSD : undefined,
     usage: totalInputTokens > 0 ? { input: totalInputTokens, output: totalOutputTokens } : undefined,
     durationMs: Date.now() - start,

package/src/core/pipeline/run.ts

@@ -1,4 +1,4 @@
-import type { AutopilotConfig } from '../config/types.ts';
+import type { GuardrailConfig } from '../config/types.ts';
 import type { StaticRule } from '../phases/static-rules.ts';
 import type { ReviewEngine } from '../../adapters/review-engine/types.ts';
 import type { Finding } from '../findings/types.ts';
@@ -13,12 +13,13 @@ export type PhaseResult = StaticRulesPhaseResult | TestsPhaseResult | ReviewPhas
 
 export interface RunInput {
   touchedFiles: string[];
-  config: AutopilotConfig;
+  config: GuardrailConfig;
   reviewEngine?: ReviewEngine;
   staticRules?: StaticRule[];
   cwd?: string;
   gitSummary?: string;
   base?: string;
+  skipReview?: boolean;
 }
 
 export interface RunResult {
@@ -29,33 +30,64 @@ export interface RunResult {
   durationMs: number;
 }
 
-export async function runAutopilot(input: RunInput): Promise<RunResult> {
+export async function runGuardrail(input: RunInput): Promise<RunResult> {
   const start = Date.now();
   const phases: PhaseResult[] = [];
   let totalCostUSD: number | undefined;
 
-  // Static-rules phase — fail fast on critical
+  const pipelineCfg = input.config.pipeline ?? {};
+  // Default true: when the user wires up a review engine they expect it to actually run.
+  // Skipping LLM review on static-fail is exactly the "silent skip" behavior the v4.0
+  // reviewer flagged — the bugs the LLM is best at often ride alongside one a static
+  // rule already caught.
+  const runReviewOnStaticFail = pipelineCfg.runReviewOnStaticFail !== false;
+  const runReviewOnTestFail = pipelineCfg.runReviewOnTestFail === true;
+
+  // Static-rules phase — tests always run afterward, regardless of status. The
+  // runReviewOnStaticFail flag only gates the LLM review phase (matching its name);
+  // skipping tests on a static-fail would be surprising and asymmetric with
+  // runReviewOnTestFail which only gates the review phase too.
+  let staticFailed = false;
   if (input.staticRules && input.staticRules.length > 0) {
     const result = await runStaticRulesPhase({
       touchedFiles: input.touchedFiles,
       rules: input.staticRules,
+      config: input.config,
+      engine: input.reviewEngine,
     });
     phases.push(result);
-    if (result.status === 'fail') return finalize(phases, start, totalCostUSD);
+    staticFailed = result.status === 'fail';
+  }
+
+  // skipReview short-circuit: skip tests and review phases entirely
+  if (input.skipReview) {
+    const allFindings = phases.flatMap(p => p.findings ?? []);
+    const hasCritical = allFindings.some(f => f.severity === 'critical');
+    return {
+      status: hasCritical ? 'fail' : 'pass',
+      phases,
+      allFindings,
+      totalCostUSD: undefined,
+      durationMs: Date.now() - start,
+    };
   }
 
-  // Tests phase — fail fast on test failure
+  // Tests phase — always runs (unless skipReview above). The runReviewOnTestFail
+  // flag only gates the subsequent review phase.
   const testsResult = await runTestsPhase({
     touchedFiles: input.touchedFiles,
     testCommand: input.config.testCommand,
     cwd: input.cwd,
   });
   phases.push(testsResult);
-  if (testsResult.status === 'fail') return finalize(phases, start, totalCostUSD);
+  const testsFailed = testsResult.status === 'fail';
 
-  // Review phase (optional — only when engine is provided)
-  if (input.reviewEngine) {
-    const budgetUSD = (input.config.cost as { budgetUSD?: number } | undefined)?.budgetUSD;
+  // Review phase (optional — only when engine is provided, not gated off by flags)
+  const skipReviewDueToStatic = staticFailed && !runReviewOnStaticFail;
+  const skipReviewDueToTests = testsFailed && !runReviewOnTestFail;
+  if (input.reviewEngine && !skipReviewDueToStatic && !skipReviewDueToTests) {
+    const costCfg = input.config.cost as { maxPerRun?: number; budgetUSD?: number } | undefined;
+    const budgetUSD = costCfg?.maxPerRun ?? costCfg?.budgetUSD;
     const reviewResult = await runReviewPhase({
       touchedFiles: input.touchedFiles,
       engine: input.reviewEngine,

package/src/core/runtime/lock.ts

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { AutopilotError } from '../errors.ts';
+import { GuardrailError } from '../errors.ts';
 
 export interface LockHandle {
   release(): Promise<void>;
@@ -16,7 +16,7 @@ export function acquireLock(runId: string, lockDir = '.claude'): LockHandle {
       { flag: 'wx' }
     );
   } catch (err) {
-    throw new AutopilotError('Another autopilot run holds the lock', {
+    throw new GuardrailError('Another autopilot run holds the lock', {
       code: 'concurrency_lock',
       details: { lockPath, cause: err instanceof Error ? err.message : String(err) },
     });

package/src/core/runtime/state.ts

@@ -1,6 +1,6 @@
 import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
-import { AutopilotError } from '../errors.ts';
+import { GuardrailError } from '../errors.ts';
 
 export type PipelineStep =
   | 'plan' | 'worktree' | 'implement' | 'migrate' | 'validate'
@@ -72,7 +72,7 @@ export async function loadRunState(runId: string, runsDir?: string): Promise<Run
   try {
     return JSON.parse(await fs.readFile(file, 'utf8')) as RunState;
   } catch (err) {
-    throw new AutopilotError(`Run state not found: ${runId}`, {
+    throw new GuardrailError(`Run state not found: ${runId}`, {
       code: 'user_input',
       details: { runId, file, cause: err instanceof Error ? err.message : String(err) },
     });