@delegance/claude-autopilot 5.0.0 → 5.0.2

package/dist/presets/go/rules/go-sql-injection.d.ts

@@ -0,0 +1,4 @@
+import type { StaticRule } from '../../../src/core/phases/static-rules.ts';
+export declare const goSqlInjectionRule: StaticRule;
+export default goSqlInjectionRule;
+//# sourceMappingURL=go-sql-injection.d.ts.map

package/dist/presets/nextjs-supabase/rules/supabase-rls-bypass.d.ts

@@ -0,0 +1,4 @@
+import type { StaticRule } from '../../../src/core/phases/static-rules.ts';
+export declare const supabaseRlsBypassRule: StaticRule;
+export default supabaseRlsBypassRule;
+//# sourceMappingURL=supabase-rls-bypass.d.ts.map

package/dist/presets/python-fastapi/rules/fastapi-missing-auth.d.ts

@@ -0,0 +1,4 @@
+import type { StaticRule } from '../../../src/core/phases/static-rules.ts';
+export declare const fastapiMissingAuthRule: StaticRule;
+export default fastapiMissingAuthRule;
+//# sourceMappingURL=fastapi-missing-auth.d.ts.map

package/dist/presets/rails-postgres/rules/rails-sql-injection.d.ts

@@ -0,0 +1,4 @@
+import type { StaticRule } from '../../../src/core/phases/static-rules.ts';
+export declare const railsSqlInjectionRule: StaticRule;
+export default railsSqlInjectionRule;
+//# sourceMappingURL=rails-sql-injection.d.ts.map

package/dist/presets/t3/rules/t3-server-only.d.ts

@@ -0,0 +1,4 @@
+import type { StaticRule } from '../../../src/core/phases/static-rules.ts';
+export declare const t3ServerOnlyRule: StaticRule;
+export default t3ServerOnlyRule;
+//# sourceMappingURL=t3-server-only.d.ts.map

package/dist/src/adapters/base.d.ts

@@ -0,0 +1,11 @@
+export interface AdapterBase {
+    name: string;
+    apiVersion: string;
+    getCapabilities(): Capabilities;
+}
+export interface Capabilities {
+    [feature: string]: boolean | number | string;
+}
+export declare const CORE_ADAPTER_API_VERSION_MAJOR = 1;
+export declare function checkApiVersionCompatibility(adapterApiVersion: string): boolean;
+//# sourceMappingURL=base.d.ts.map

package/dist/src/adapters/council/claude.d.ts

@@ -0,0 +1,3 @@
+import type { CouncilAdapter } from './types.ts';
+export declare function makeClaudeCouncilAdapter(model: string, label: string): CouncilAdapter;
+//# sourceMappingURL=claude.d.ts.map

package/dist/src/adapters/council/openai.d.ts

@@ -0,0 +1,3 @@
+import type { CouncilAdapter } from './types.ts';
+export declare function makeOpenAICouncilAdapter(model: string, label: string): CouncilAdapter;
+//# sourceMappingURL=openai.d.ts.map

package/dist/src/adapters/council/types.d.ts

@@ -0,0 +1,5 @@
+export interface CouncilAdapter {
+    readonly label: string;
+    consult(prompt: string, context: string): Promise<string>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/loader.d.ts

@@ -0,0 +1,11 @@
+import { type AdapterBase } from './base.ts';
+export type IntegrationPoint = 'review-engine' | 'vcs-host' | 'migration-runner' | 'review-bot-parser';
+export interface LoadAdapterOptions {
+    point: IntegrationPoint;
+    ref: string;
+    options?: Record<string, unknown>;
+    /** Allow loading adapters from arbitrary local paths. Off by default for security. */
+    unsafeAllowLocalAdapters?: boolean;
+}
+export declare function loadAdapter<T extends AdapterBase>(options: LoadAdapterOptions): Promise<T>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/src/adapters/migration-runner/supabase.d.ts

@@ -0,0 +1,4 @@
+import type { MigrationRunner } from './types.ts';
+export declare const supabaseAdapter: MigrationRunner;
+export default supabaseAdapter;
+//# sourceMappingURL=supabase.d.ts.map

package/dist/src/adapters/migration-runner/types.d.ts

@@ -0,0 +1,31 @@
+import type { AdapterBase } from '../base.ts';
+export type MigrationEnv = 'dev' | 'qa' | 'prod';
+export interface Migration {
+    name: string;
+    path: string;
+    content?: string;
+}
+export interface DryRunResult {
+    ok: boolean;
+    errors?: string[];
+    warnings?: string[];
+}
+export interface ApplyResult {
+    ok: boolean;
+    appliedSha?: string;
+    durationMs?: number;
+    errors?: string[];
+}
+export interface LedgerEntry {
+    name: string;
+    appliedAt: string;
+    sha?: string;
+}
+export interface MigrationRunner extends AdapterBase {
+    discover(touchedFiles: string[]): Migration[];
+    dryRun(migration: Migration): Promise<DryRunResult>;
+    apply(migration: Migration, env: MigrationEnv): Promise<ApplyResult>;
+    ledger(env: MigrationEnv): Promise<LedgerEntry[]>;
+    alreadyApplied(migration: Migration, env: MigrationEnv): Promise<boolean>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/review-bot-parser/cursor.d.ts

@@ -0,0 +1,3 @@
+export declare const cursorAdapter: import("./types.ts").ReviewBotParser;
+export default cursorAdapter;
+//# sourceMappingURL=cursor.d.ts.map

package/dist/src/adapters/review-bot-parser/declarative-base.d.ts

@@ -0,0 +1,13 @@
+import type { ReviewBotParser } from './types.ts';
+export interface DeclarativeParserConfig {
+    name: string;
+    author: string | RegExp;
+    severityMap: {
+        critical?: RegExp;
+        warning?: RegExp;
+        note?: RegExp;
+    };
+    dismissalKeywords: string[];
+}
+export declare function makeDeclarativeParser(config: DeclarativeParserConfig): ReviewBotParser;
+//# sourceMappingURL=declarative-base.d.ts.map

package/{src/adapters/review-bot-parser/types.ts → dist/src/adapters/review-bot-parser/types.d.ts}

@@ -1,9 +1,9 @@
 import type { AdapterBase } from '../base.ts';
 import type { Finding } from '../../core/findings/types.ts';
 import type { GenericComment, VcsHost } from '../vcs-host/types.ts';
-
 export interface ReviewBotParser extends AdapterBase {
-  detect(comment: GenericComment): boolean;
-  fetchFindings(vcs: VcsHost, pr: number | string): Promise<Finding[]>;
-  detectDismissal(reply: string): boolean;
+    detect(comment: GenericComment): boolean;
+    fetchFindings(vcs: VcsHost, pr: number | string): Promise<Finding[]>;
+    detectDismissal(reply: string): boolean;
 }
+//# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/review-engine/auto.d.ts

@@ -0,0 +1,4 @@
+import type { ReviewEngine } from './types.ts';
+export declare const autoAdapter: ReviewEngine;
+export default autoAdapter;
+//# sourceMappingURL=auto.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { ReviewEngine } from './types.ts';
+export declare const claudeAdapter: ReviewEngine;
+export default claudeAdapter;
+//# sourceMappingURL=claude.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { ReviewEngine } from './types.ts';
+export declare const codexAdapter: ReviewEngine;
+export default codexAdapter;
+//# sourceMappingURL=codex.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { ReviewEngine } from './types.ts';
+export declare const geminiAdapter: ReviewEngine;
+export default geminiAdapter;
+//# sourceMappingURL=gemini.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { ReviewEngine } from './types.ts';
+export declare const openaiCompatibleAdapter: ReviewEngine;
+export default openaiCompatibleAdapter;
+//# sourceMappingURL=openai-compatible.d.ts.map

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

@@ -0,0 +1,13 @@
+import type { Finding } from '../../core/findings/types.ts';
+/**
+ * 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 declare function parseReviewOutput(output: string, idPrefix: string): Finding[];
+//# sourceMappingURL=parse-output.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { ReviewInput } from './types.ts';
+export declare function buildSystemPrompt(input: ReviewInput, template: string): string;
+export declare function classifyError(message: string): 'auth' | 'rate_limit' | 'transient_network';
+//# sourceMappingURL=prompt-builder.d.ts.map

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

@@ -0,0 +1,28 @@
+import type { AdapterBase } from '../base.ts';
+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;
+        designSchema?: string;
+    };
+}
+export interface ReviewOutput {
+    findings: Finding[];
+    rawOutput: string;
+    usage?: {
+        input: number;
+        output: number;
+        costUSD?: number;
+    };
+}
+export interface ReviewEngine extends AdapterBase {
+    review(input: ReviewInput): Promise<ReviewOutput>;
+    estimateTokens(content: string): number;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,12 @@
+export type CommitState = 'pending' | 'success' | 'failure' | 'error';
+export interface CommitStatusOptions {
+    sha: string;
+    state: CommitState;
+    description?: string;
+    context?: string;
+    targetUrl?: string;
+    cwd?: string;
+}
+export declare function resolveCommitSha(cwd: string, envSha?: string): string | null;
+export declare function postCommitStatus(opts: CommitStatusOptions): boolean;
+//# sourceMappingURL=commit-status.d.ts.map

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

@@ -0,0 +1,4 @@
+import type { VcsHost } from './types.ts';
+export declare const githubAdapter: VcsHost;
+export default githubAdapter;
+//# sourceMappingURL=github.d.ts.map

package/dist/src/adapters/vcs-host/types.d.ts

@@ -0,0 +1,42 @@
+import type { AdapterBase } from '../base.ts';
+export interface GenericComment {
+    id: string | number;
+    author: string;
+    body: string;
+    path?: string;
+    line?: number;
+    url?: string;
+}
+export interface PrMetadata {
+    title: string;
+    body: string;
+    files: string[];
+    headSha: string;
+    baseRef: string;
+    headRef: string;
+}
+export interface CreatePrOptions {
+    title: string;
+    body: string;
+    base: string;
+    head: string;
+    draft?: boolean;
+    idempotencyKey?: string;
+}
+export interface CreatePrResult {
+    number: number;
+    url: string;
+    alreadyExisted: boolean;
+}
+export interface VcsHost extends AdapterBase {
+    getPrDiff(pr: number | string): Promise<string>;
+    getPrMetadata(pr: number | string): Promise<PrMetadata>;
+    postComment(pr: number | string, body: string, idempotencyKey?: string): Promise<void>;
+    getReviewComments(pr: number | string): Promise<GenericComment[]>;
+    replyToComment(pr: number | string, commentId: string | number, body: string, idempotencyKey?: string): Promise<void>;
+    createPr(opts: CreatePrOptions): Promise<CreatePrResult>;
+    push(branch: string, opts?: {
+        setUpstream?: boolean;
+    }): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/{src/cli/_pkg-root.ts → dist/src/cli/_pkg-root.d.ts}

@@ -15,52 +15,17 @@
  * `@delegance/claude-autopilot` package.json. Both source and compiled callers
  * land in the same place.
  */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const PACKAGE_NAME = '@delegance/claude-autopilot';
-
 /**
  * Walks up from the caller's location looking for the package.json that
  * declares `name === '@delegance/claude-autopilot'`. Returns the directory
  * containing that package.json, or null if not found within `maxDepth` levels.
  */
-export function findPackageRoot(callerImportMetaUrl: string, maxDepth = 10): string | null {
-  let dir = path.dirname(fileURLToPath(callerImportMetaUrl));
-  for (let i = 0; i < maxDepth; i++) {
-    const candidate = path.join(dir, 'package.json');
-    if (fs.existsSync(candidate)) {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(candidate, 'utf8')) as { name?: string };
-        if (pkg.name === PACKAGE_NAME) return dir;
-      } catch {
-        /* keep walking */
-      }
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
-}
-
+export declare function findPackageRoot(callerImportMetaUrl: string, maxDepth?: number): string | null;
 /**
  * Throws a clear error if the package root can't be located. Use at sites that
  * absolutely require the root (e.g. preset config lookup).
  */
-export function requirePackageRoot(callerImportMetaUrl: string): string {
-  const root = findPackageRoot(callerImportMetaUrl);
-  if (!root) {
-    throw new Error(
-      `[claude-autopilot] Could not locate package root from ${fileURLToPath(callerImportMetaUrl)}. ` +
-      `Reinstall: npm install -g @delegance/claude-autopilot@alpha`,
-    );
-  }
-  return root;
-}
-
+export declare function requirePackageRoot(callerImportMetaUrl: string): string;
 /**
  * Resolve a sibling-module path for dynamic `import()` that works under both
  * source (caller is `.ts`) and compiled (caller is `.js`) layouts.
@@ -78,8 +43,5 @@ export function requirePackageRoot(callerImportMetaUrl: string): string {
  * @param callerImportMetaUrl Caller's `import.meta.url`.
  * @returns Absolute filesystem path suitable for `import()`.
  */
-export function resolveSiblingModule(ref: string, callerImportMetaUrl: string): string {
-  const callerIsCompiled = callerImportMetaUrl.endsWith('.js') || callerImportMetaUrl.endsWith('.mjs');
-  const adjustedRef = callerIsCompiled ? ref.replace(/\.ts$/, '.js') : ref;
-  return fileURLToPath(new URL(adjustedRef, callerImportMetaUrl));
-}
+export declare function resolveSiblingModule(ref: string, callerImportMetaUrl: string): string;
+//# sourceMappingURL=_pkg-root.d.ts.map

package/dist/src/cli/autoregress-bridge.d.ts

@@ -0,0 +1,3 @@
+export declare function buildAutoregressArgs(args: string[]): string[];
+export declare function runAutoregress(args: string[]): number;
+//# sourceMappingURL=autoregress-bridge.d.ts.map

package/dist/src/cli/baseline.d.ts

@@ -0,0 +1,7 @@
+export interface BaselineCommandOptions {
+    cwd?: string;
+    note?: string;
+    baselinePath?: string;
+}
+export declare function runBaseline(sub: string, options?: BaselineCommandOptions): Promise<number>;
+//# sourceMappingURL=baseline.d.ts.map

package/dist/src/cli/ci.d.ts

@@ -0,0 +1,23 @@
+export interface CiCommandOptions {
+    cwd?: string;
+    configPath?: string;
+    base?: string;
+    postComments?: boolean;
+    sarifOutput?: string;
+    diff?: boolean;
+    inlineComments?: boolean;
+    newOnly?: boolean;
+    failOn?: 'critical' | 'warning' | 'note' | 'none';
+}
+/**
+ * `guardrail ci` — opinionated single-command CI entrypoint.
+ *
+ * Defaults:
+ *   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 declare function runCi(options?: CiCommandOptions): Promise<number>;
+//# sourceMappingURL=ci.d.ts.map

package/dist/src/cli/costs.d.ts

@@ -0,0 +1,2 @@
+export declare function runCosts(cwd?: string): Promise<number>;
+//# sourceMappingURL=costs.d.ts.map

package/dist/src/cli/council.d.ts

@@ -0,0 +1,8 @@
+export declare function runCouncilCmd(opts: {
+    prompt?: string;
+    contextFile?: string;
+    configPath?: string;
+    dryRun?: boolean;
+    noSynthesize?: boolean;
+}): Promise<number>;
+//# sourceMappingURL=council.d.ts.map

package/dist/src/cli/detector.d.ts

@@ -0,0 +1,8 @@
+export interface DetectionResult {
+    preset: string;
+    testCommand: string;
+    confidence: 'high' | 'low';
+    evidence: string;
+}
+export declare function detectProject(cwd: string): DetectionResult;
+//# sourceMappingURL=detector.d.ts.map

package/dist/src/cli/explain.d.ts

@@ -0,0 +1,8 @@
+export interface ExplainCommandOptions {
+    cwd?: string;
+    configPath?: string;
+    target?: string;
+    index?: number;
+}
+export declare function runExplain(options?: ExplainCommandOptions): Promise<number>;
+//# sourceMappingURL=explain.d.ts.map

package/dist/src/cli/fix.d.ts

@@ -0,0 +1,10 @@
+export interface FixCommandOptions {
+    cwd?: string;
+    configPath?: string;
+    severity?: 'critical' | 'warning' | 'all';
+    dryRun?: boolean;
+    yes?: boolean;
+    noVerify?: boolean;
+}
+export declare function runFix(options?: FixCommandOptions): Promise<number>;
+//# sourceMappingURL=fix.d.ts.map

package/dist/src/cli/hook.d.ts

@@ -0,0 +1,9 @@
+export declare const GUARDRAIL_MARKER = "# guardrail-managed";
+export declare function runHook(sub: string, options?: {
+    cwd?: string;
+    force?: boolean;
+    silent?: boolean;
+    preCommitOnly?: boolean;
+    prePushOnly?: boolean;
+}): Promise<number>;
+//# sourceMappingURL=hook.d.ts.map

package/dist/src/cli/ignore-helper.d.ts

@@ -0,0 +1,7 @@
+export interface IgnoreCommandOptions {
+    cwd?: string;
+    all?: boolean;
+    dryRun?: boolean;
+}
+export declare function runIgnore(options?: IgnoreCommandOptions): Promise<number>;
+//# sourceMappingURL=ignore-helper.d.ts.map

package/dist/src/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/src/cli/index.js

@@ -28,6 +28,44 @@ import { runTestGen } from "./test-gen.js";
 import { runCouncilCmd } from "./council.js";
 import { runMigrateV4 } from "./migrate-v4.js";
 import { findPackageRoot } from "./_pkg-root.js";
+import { GuardrailError } from "../core/errors.js";
+// Format unhandled errors as a one-line user-facing message instead of dumping a
+// Node stack trace. Auth/network failures are by far the most common path here
+// (bad/missing API key, rate limit, network blip) and surfacing the raw stack
+// reads as "the tool is broken" when it isn't.
+function formatTopLevelError(err) {
+    if (err instanceof GuardrailError) {
+        const provider = err.provider ? ` [${err.provider}]` : '';
+        const hint = err.code === 'auth'
+            ? '\n  hint: check your API key (ANTHROPIC_API_KEY / OPENAI_API_KEY / GEMINI_API_KEY) or run: claude-autopilot doctor'
+            : err.code === 'rate_limit'
+                ? '\n  hint: rate-limited by provider — retry shortly or switch model in guardrail.config.yaml'
+                : err.code === 'invalid_config'
+                    ? '\n  hint: check guardrail.config.yaml — claude-autopilot doctor'
+                    : '';
+        return { message: `[claude-autopilot]${provider} ${err.code}: ${err.message}${hint}`, exit: 1 };
+    }
+    if (err instanceof Error) {
+        return { message: `[claude-autopilot] ${err.message}`, exit: 1 };
+    }
+    return { message: `[claude-autopilot] ${String(err)}`, exit: 1 };
+}
+process.on('unhandledRejection', err => {
+    const { message, exit } = formatTopLevelError(err);
+    process.stderr.write(`\x1b[31m${message}\x1b[0m\n`);
+    if (process.env.CLAUDE_AUTOPILOT_DEBUG === '1' && err instanceof Error && err.stack) {
+        process.stderr.write(`\x1b[2m${err.stack}\x1b[0m\n`);
+    }
+    process.exit(exit);
+});
+process.on('uncaughtException', err => {
+    const { message, exit } = formatTopLevelError(err);
+    process.stderr.write(`\x1b[31m${message}\x1b[0m\n`);
+    if (process.env.CLAUDE_AUTOPILOT_DEBUG === '1' && err.stack) {
+        process.stderr.write(`\x1b[2m${err.stack}\x1b[0m\n`);
+    }
+    process.exit(exit);
+});
 const args = process.argv.slice(2);
 // Version flag — read package.json via the shared package-root helper. Works
 // under both source (src/cli/index.ts) and compiled (dist/src/cli/index.js)
@@ -269,7 +307,7 @@ switch (subcommand) {
         break;
     }
     case 'init': {
-        console.log('\x1b[33m[init] guardrail init is deprecated — use: npx guardrail setup\x1b[0m\n');
+        // `init` and `setup` are aliases. Keep both supported — no nag banner.
         const force = args.includes('--force');
         await runSetup({ force });
         break;

package/dist/src/cli/lsp.d.ts

@@ -0,0 +1,29 @@
+import type { Finding } from '../core/findings/types.ts';
+export declare function findingToUri(filePath: string, cwd: string): string;
+export declare function findingToDiagnostic(f: Finding): {
+    range: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+    severity: number;
+    source: string;
+    code: string;
+    message: string;
+};
+export declare function groupByUri(findings: Finding[], cwd: string): Map<string, Finding[]>;
+export declare function encodeMessage(body: object): Buffer;
+/** Parse as many complete LSP messages as possible from `buf`. Returns parsed objects and remaining bytes. */
+export declare function parseMessages(buf: Buffer): {
+    messages: unknown[];
+    remaining: Buffer;
+};
+export declare function runLsp(options?: {
+    cwd?: string;
+}): Promise<void>;
+//# sourceMappingURL=lsp.d.ts.map

package/dist/src/cli/mcp.d.ts

@@ -0,0 +1,5 @@
+export declare function runMcp(options?: {
+    cwd?: string;
+    configPath?: string;
+}): Promise<void>;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/src/cli/migrate-v4.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `claude-autopilot migrate-v4` — codemod for v4 → v5 rename.
+ *
+ * Scans a repo for @delegance/guardrail + guardrail CLI references and proposes
+ * replacements. Writes with `--write`, restores from manifest with `--undo`.
+ *
+ * Mutation rules (per codex review of alpha.3 spec):
+ *   - package.json: updates dependencies, devDependencies, optionalDependencies,
+ *     peerDependencies. Preserves key ordering within each section. Preserves
+ *     semver operator shape (^/~/>=/exact) — only rewrites the package name and
+ *     bumps to ^5.0.0-alpha.
+ *   - Shell scripts, Makefiles, workflow yaml, Dockerfiles: word-boundary match
+ *     on `guardrail <verb>` → `claude-autopilot <verb>`, and
+ *     `@delegance/guardrail` → `@delegance/claude-autopilot`.
+ *   - package-lock.json: NOT touched (regenerated by npm install).
+ *
+ * --undo reads `.claude-autopilot/migrate-v4-manifest.json` and restores files
+ * by sha256 match. Rejects restoration if the current file differs from the
+ * backup's post-write hash, preventing clobber of user edits.
+ */
+export interface MigrateV4Options {
+    cwd?: string;
+    write?: boolean;
+    undo?: boolean;
+    path?: string;
+}
+export declare function runMigrateV4(options?: MigrateV4Options): Promise<number>;
+//# sourceMappingURL=migrate-v4.d.ts.map

package/dist/src/cli/pr-comment.d.ts

@@ -0,0 +1,13 @@
+import type { RunResult } from '../core/pipeline/run.ts';
+import type { GuardrailConfig } from '../core/config/types.ts';
+import type { GitContext } from '../core/detect/git-context.ts';
+/** Detect the current open PR number via gh CLI or CI env vars. */
+export declare function detectPrNumber(cwd: string): number | null;
+/** Format a RunResult into a markdown PR comment. */
+export declare function formatComment(result: RunResult, config: GuardrailConfig, gitCtx: GitContext, touchedFileCount: number): string;
+/** Post or update the autopilot comment on the given PR. */
+export declare function postPrComment(pr: number, body: string, cwd: string): Promise<{
+    action: 'created' | 'updated';
+    url: string | null;
+}>;
+//# sourceMappingURL=pr-comment.d.ts.map

package/dist/src/cli/pr-desc.d.ts

@@ -0,0 +1,31 @@
+import type { Finding } from '../core/findings/types.ts';
+export interface PrDescOptions {
+    base?: string;
+    post?: boolean;
+    yes?: boolean;
+    output?: string;
+    _gitDiff?: string;
+    _branchName?: string;
+    _cachedFindings?: Finding[];
+    _reviewEngine?: {
+        review(input: {
+            content: string;
+            kind: string;
+        }): Promise<{
+            rawOutput: string;
+        }>;
+    };
+}
+export interface PrDescResult {
+    title: string;
+    body: string;
+    prUrl?: string;
+}
+export declare function truncateDiff(diff: string, charLimit?: number): string;
+export declare function summarizeFindings(findings: Finding[], max?: number): string;
+export declare function parseDescription(raw: string): {
+    title: string;
+    body: string;
+};
+export declare function runPrDesc(options: PrDescOptions): Promise<PrDescResult>;
+//# sourceMappingURL=pr-desc.d.ts.map

package/dist/src/cli/pr-review-comments.d.ts

@@ -0,0 +1,12 @@
+import type { Finding } from '../core/findings/types.ts';
+export interface PostReviewCommentsResult {
+    posted: number;
+    skipped: number;
+}
+/**
+ * Posts (or re-submits) a PR review with inline comments for each finding
+ * that has a file + line number. Findings without line numbers are skipped.
+ * Re-runs dismiss the previous autopilot review first to avoid stacking.
+ */
+export declare function postReviewComments(pr: number, findings: Finding[], cwd: string): Promise<PostReviewCommentsResult>;
+//# sourceMappingURL=pr-review-comments.d.ts.map