@delegance/claude-autopilot 6.2.2 → 7.2.0

package/dist/src/cli/scaffold.js

@@ -0,0 +1,287 @@
+// v7.2.0 — `claude-autopilot scaffold --from-spec <path>`
+//
+// Closes the biggest remaining day-1 friction the v7.1.6 blank-repo
+// benchmark identified: even with auto-scaffolded CLAUDE.md and .gitignore
+// (v7.1.7), a fresh repo still needs a hand-written package.json, tsconfig,
+// and directory skeleton before any feature work happens. This verb reads
+// a spec markdown file's `## Files` section and creates the listed
+// directories + a starter package.json + tsconfig.json.
+//
+// Scope intentionally small:
+//   - Node ESM only (one-shot ship; per-stack expansion is v8 work).
+//   - Touches files, never overwrites (operator opted into autopilot, not
+//     into us nuking their package.json).
+//   - Inspects spec for `scripts:` / `dependencies:` / `devDependencies:`
+//     hints in plain prose; uses heuristics rather than a strict schema.
+//
+// Spec format expectations (matches v7.1.6 benchmark spec shape):
+//
+//   ## Files
+//
+//   * `package.json` — `type: module`, `bin: { foo: bin/foo.js }`,
+//     `dependencies: { @anthropic-ai/sdk: ^0.91 }`, ...
+//   * `bin/foo.js` — argv parser + main loop.
+//   * `src/baz.js` — pure function.
+//   * `tests/foo.test.js` — node:test cases.
+//   * `README.md` — usage + install.
+//
+// Heuristics:
+//   - Backtick-quoted paths in `## Files` bullets become directories
+//     (parent of the path) and empty placeholder files (the path itself).
+//   - JSON-ish tokens in the bullet description (`type: module`,
+//     `dependencies: { foo: ^1 }`) get parsed loosely and merged into
+//     a starter package.json.
+//   - tsconfig is a Node 22 ESM default with `allowJs+checkJs+noEmit`
+//     when the spec lists `.js` files (matches v7.1.6 benchmark project),
+//     or compiled NodeNext when it lists `.ts`.
+//
+// What this DELIBERATELY does NOT do:
+//   - Run `npm install`. The user can decide which package manager.
+//   - Pick a test runner if the spec doesn't say. Echoes `npm test`.
+//   - Generate the CLAUDE.md (that's v7.1.7's job).
+//
+// Exit codes:
+//   0 — scaffolded (or all targets already existed; idempotent)
+//   1 — spec file missing or not readable
+//   2 — spec missing a `## Files` section
+import * as fs from 'node:fs';
+import * as fsAsync from 'node:fs/promises';
+import * as path from 'node:path';
+const PASS = '\x1b[32m✓\x1b[0m';
+const SKIP = '\x1b[2m·\x1b[0m';
+const BOLD = (t) => `\x1b[1m${t}\x1b[0m`;
+const DIM = (t) => `\x1b[2m${t}\x1b[0m`;
+/**
+ * Parse the `## Files` (or `## files`) section of a spec markdown file.
+ * Tolerant: missing section returns `null`; malformed bullets are skipped
+ * silently. Returns extracted file paths + best-effort package-hint blob.
+ */
+export function parseSpecFiles(markdown) {
+    const filesSectionRe = /^##\s+files\s*$/im;
+    const m = filesSectionRe.exec(markdown);
+    if (!m)
+        return null;
+    const startIdx = m.index + m[0].length;
+    // Section ends at next heading or EOF.
+    const tail = markdown.slice(startIdx);
+    const nextHeadingMatch = /^#{1,6}\s+\S/m.exec(tail);
+    const sectionBody = nextHeadingMatch
+        ? tail.slice(0, nextHeadingMatch.index)
+        : tail;
+    const paths = [];
+    // Bullet line: `* \`path\` — desc` or `- \`path\` — desc`.
+    const bulletRe = /^[*-]\s+`([^`]+)`/gm;
+    let bm;
+    while ((bm = bulletRe.exec(sectionBody)) !== null) {
+        const captured = bm[1];
+        if (!captured)
+            continue;
+        const raw = captured.trim();
+        // Skip prose-y entries by requiring path-shape: contains `/` or
+        // ends in known ext, OR is a known root-level file.
+        if (/[/.](?:js|ts|tsx|jsx|md|json|yaml|yml|sh|py|rs|go|rb|sql)$/i.test(raw) ||
+            raw === 'package.json' ||
+            raw === 'tsconfig.json' ||
+            raw === 'README.md' ||
+            raw === '.gitignore') {
+            paths.push(raw);
+        }
+    }
+    // Loose package.json hint extraction. Look for inline tokens.
+    const packageHints = {};
+    if (/`?type\s*:\s*['"`]?module['"`]?/.test(sectionBody))
+        packageHints.type = 'module';
+    // bin: { foo: bin/foo.js }
+    const binMatch = /bin\s*:\s*\{\s*([^}]+)\s*\}/.exec(sectionBody);
+    const binBody = binMatch?.[1];
+    if (binBody) {
+        const entries = {};
+        for (const part of binBody.split(',')) {
+            const [name, target] = part.split(':').map((s) => s.trim().replace(/['"`]/g, ''));
+            if (name && target)
+                entries[name] = target;
+        }
+        if (Object.keys(entries).length > 0)
+            packageHints.bin = entries;
+    }
+    // dependencies: { foo: ^1 }
+    const depMatch = /dependencies\s*:\s*\{\s*([^}]+)\s*\}/i.exec(sectionBody);
+    const depBody = depMatch?.[1];
+    if (depBody) {
+        const entries = {};
+        for (const part of depBody.split(',')) {
+            const [name, version] = part.split(':').map((s) => s.trim().replace(/['"`]/g, ''));
+            if (name && version)
+                entries[name] = version;
+        }
+        if (Object.keys(entries).length > 0)
+            packageHints.dependencies = entries;
+    }
+    // scripts: { test: "..." }  (handles quoted values via a 2nd pass)
+    const scriptsMatch = /scripts\s*:\s*\{\s*([^}]+)\s*\}/i.exec(sectionBody);
+    const scriptsBody = scriptsMatch?.[1];
+    if (scriptsBody) {
+        const entries = {};
+        // Use looser splitter — colon inside quoted values is fine.
+        const partRe = /([a-z_-]+)\s*:\s*["']([^"']+)["']/gi;
+        let pm;
+        while ((pm = partRe.exec(scriptsBody)) !== null) {
+            const [, key, value] = pm;
+            if (key && value)
+                entries[key] = value;
+        }
+        if (Object.keys(entries).length > 0)
+            packageHints.scripts = entries;
+    }
+    return { paths, packageHints };
+}
+/**
+ * Build a minimal starter package.json. Caller passes in any explicit
+ * hints (parsed from spec); we layer Node 22 ESM defaults on top.
+ */
+export function buildStarterPackageJson(projectName, hints) {
+    const pkg = {
+        name: projectName,
+        version: '0.1.0',
+        private: true,
+        type: hints.type ?? 'module',
+        engines: { node: '>=22' },
+        scripts: {
+            test: 'node --test tests/*.test.js',
+            ...hints.scripts,
+        },
+    };
+    if (hints.bin)
+        pkg.bin = hints.bin;
+    if (hints.dependencies)
+        pkg.dependencies = hints.dependencies;
+    if (hints.devDependencies)
+        pkg.devDependencies = hints.devDependencies;
+    return pkg;
+}
+const STARTER_TSCONFIG_JS = {
+    compilerOptions: {
+        target: 'ES2022',
+        module: 'NodeNext',
+        moduleResolution: 'NodeNext',
+        allowJs: true,
+        checkJs: true,
+        noEmit: true,
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        types: ['node'],
+    },
+    include: ['bin/**/*', 'src/**/*', 'tests/**/*'],
+};
+const STARTER_TSCONFIG_TS = {
+    compilerOptions: {
+        target: 'ES2022',
+        module: 'NodeNext',
+        moduleResolution: 'NodeNext',
+        outDir: 'dist',
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        types: ['node'],
+    },
+    include: ['bin/**/*', 'src/**/*', 'tests/**/*'],
+};
+export async function runScaffold(opts) {
+    const cwd = opts.cwd ?? process.cwd();
+    const specAbs = path.isAbsolute(opts.specPath) ? opts.specPath : path.join(cwd, opts.specPath);
+    if (!fs.existsSync(specAbs)) {
+        process.stderr.write(`[scaffold] spec file not found: ${specAbs}\n`);
+        process.exit(1);
+    }
+    const md = await fsAsync.readFile(specAbs, 'utf8');
+    const parsed = parseSpecFiles(md);
+    if (!parsed) {
+        process.stderr.write(`[scaffold] spec missing a "## Files" section: ${specAbs}\n`);
+        process.exit(2);
+    }
+    console.log(`\n${BOLD('[scaffold]')} ${DIM(specAbs)}\n`);
+    const projectName = path.basename(cwd);
+    const filesCreated = [];
+    const filesSkippedExisting = [];
+    const dirsCreated = [];
+    let packageJsonAction = 'skipped-exists';
+    let tsconfigAction = 'skipped-no-ts';
+    // 1) Create directories first.
+    const dirs = new Set();
+    for (const p of parsed.paths) {
+        const d = path.dirname(p);
+        if (d && d !== '.')
+            dirs.add(d);
+    }
+    for (const d of dirs) {
+        const abs = path.join(cwd, d);
+        if (fs.existsSync(abs))
+            continue;
+        if (!opts.dryRun)
+            await fsAsync.mkdir(abs, { recursive: true });
+        dirsCreated.push(d);
+        console.log(`  ${PASS}  mkdir   ${DIM(d + '/')}`);
+    }
+    // 2) Create placeholder files (skip ones we'll handle specially).
+    const SPECIAL = new Set(['package.json', 'tsconfig.json']);
+    for (const p of parsed.paths) {
+        if (SPECIAL.has(p))
+            continue;
+        const abs = path.join(cwd, p);
+        if (fs.existsSync(abs)) {
+            filesSkippedExisting.push(p);
+            console.log(`  ${SKIP}  exists  ${DIM(p)}`);
+            continue;
+        }
+        if (!opts.dryRun) {
+            await fsAsync.mkdir(path.dirname(abs), { recursive: true });
+            // Touch — empty file. Real content is the agent's job.
+            await fsAsync.writeFile(abs, '', 'utf8');
+        }
+        filesCreated.push(p);
+        console.log(`  ${PASS}  touch   ${DIM(p)}`);
+    }
+    // 3) package.json — only if the spec lists it.
+    if (parsed.paths.includes('package.json')) {
+        const pkgAbs = path.join(cwd, 'package.json');
+        if (fs.existsSync(pkgAbs)) {
+            packageJsonAction = 'skipped-exists';
+            console.log(`  ${SKIP}  exists  ${DIM('package.json (preserved)')}`);
+        }
+        else {
+            const pkg = buildStarterPackageJson(projectName, parsed.packageHints);
+            if (!opts.dryRun) {
+                await fsAsync.writeFile(pkgAbs, JSON.stringify(pkg, null, 2) + '\n', 'utf8');
+            }
+            packageJsonAction = 'created';
+            console.log(`  ${PASS}  write   ${DIM('package.json (Node 22 ESM starter)')}`);
+        }
+    }
+    // 4) tsconfig.json — only if the spec lists it. JS-flavor when the
+    //    other paths are predominantly .js, TS-flavor for .ts.
+    if (parsed.paths.includes('tsconfig.json')) {
+        const tsAbs = path.join(cwd, 'tsconfig.json');
+        if (fs.existsSync(tsAbs)) {
+            tsconfigAction = 'skipped-exists';
+            console.log(`  ${SKIP}  exists  ${DIM('tsconfig.json (preserved)')}`);
+        }
+        else {
+            const otherPaths = parsed.paths.filter((p) => !SPECIAL.has(p));
+            const tsCount = otherPaths.filter((p) => /\.tsx?$/.test(p)).length;
+            const jsCount = otherPaths.filter((p) => /\.jsx?$/.test(p)).length;
+            const config = tsCount > jsCount ? STARTER_TSCONFIG_TS : STARTER_TSCONFIG_JS;
+            tsconfigAction = 'created';
+            if (!opts.dryRun) {
+                await fsAsync.writeFile(tsAbs, JSON.stringify(config, null, 2) + '\n', 'utf8');
+            }
+            const flavor = config === STARTER_TSCONFIG_TS ? 'compiled TS to dist/' : 'JS w/ JSDoc + checkJs';
+            console.log(`  ${PASS}  write   ${DIM(`tsconfig.json (${flavor})`)}`);
+        }
+    }
+    console.log(`\n${BOLD('Done.')} ${DIM(`${dirsCreated.length} dirs, ${filesCreated.length} files created, ${filesSkippedExisting.length} skipped.`)}\n`);
+    if (opts.dryRun)
+        console.log(DIM(`(--dry-run: no files were written)\n`));
+    return { filesCreated, dirsCreated, filesSkippedExisting, packageJsonAction, tsconfigAction };
+}
+//# sourceMappingURL=scaffold.js.map

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

@@ -1,3 +1,4 @@
+import { type DetectionResult } from './detector.ts';
 export type ProfileName = 'security-strict' | 'team' | 'solo';
 export interface SetupOptions {
     cwd?: string;
@@ -6,4 +7,33 @@ export interface SetupOptions {
     profile?: ProfileName;
 }
 export declare function runSetup(options?: SetupOptions): Promise<void>;
+/**
+ * Append `entries` to `<cwd>/.gitignore` if missing. Returns the entries
+ * actually added (empty array when all already present, .gitignore is empty
+ * + we don't want to create one, etc.).
+ *
+ * Behavior:
+ *   - .gitignore exists: parse line-by-line, skip entries already present
+ *     (exact match after trim, ignoring leading `!`), append the rest.
+ *   - .gitignore missing: create it with the entries. Reasonable default
+ *     for a fresh `setup` since the user is opting into autopilot's cache.
+ *
+ * Idempotent: safe to call twice with the same entries.
+ */
+export declare function ensureGitignoreEntries(cwd: string, entries: string[]): Promise<string[]>;
+/**
+ * Write a starter `<cwd>/CLAUDE.md` if none exists. Pulls stack-detection
+ * info from the same `detection` result that drove preset selection, so the
+ * scaffolded conventions match the actual project.
+ *
+ * The starter doc is intentionally short (~35 lines) — a real project will
+ * grow it. The goal is to give downstream agents an anchor for the most
+ * common "I had to guess" decisions the v7.1.6 benchmark agent reported:
+ * commit-message style, test command, error class shape, prompt location.
+ *
+ * Returns true when the file was written (false if it already exists; we
+ * never overwrite — operator opted into autopilot, not into us nuking
+ * their docs).
+ */
+export declare function ensureStarterClaudeMd(cwd: string, detection: DetectionResult): Promise<boolean>;
 //# sourceMappingURL=setup.d.ts.map

package/dist/src/cli/setup.js

@@ -138,6 +138,26 @@ export async function runSetup(options = {}) {
     for (const line of presetContent.trimEnd().split('\n')) {
         console.log(`  ${DIM(line)}`);
     }
+    // v7.1.7 — Auto-add `.guardrail-cache/` and `node_modules/` to .gitignore.
+    // Per the v7.1.6 blank-repo benchmark, these are the two most common
+    // day-1 paper cuts: `setup` creates the cache dir on first run, and (for
+    // Node projects) `npm install` creates `node_modules` — neither belongs
+    // in git. Skipped silently if already present or no .gitignore exists
+    // and we don't want to create one without consent.
+    const gitignoreAdds = await ensureGitignoreEntries(cwd, [
+        '.guardrail-cache/',
+        'node_modules/',
+    ]);
+    if (gitignoreAdds.length > 0) {
+        console.log(`\n  ${PASS}  Added to .gitignore: ${DIM(gitignoreAdds.join(', '))}`);
+    }
+    // v7.1.7 — Auto-scaffold a starter CLAUDE.md if none exists. Closes ~5 of
+    // 6 friction points the benchmark agent hit on a blank repo (commit
+    // style, error class shape, test runner choice, etc.).
+    const claudeMdAdded = await ensureStarterClaudeMd(cwd, detection);
+    if (claudeMdAdded) {
+        console.log(`  ${PASS}  Wrote starter CLAUDE.md`);
+    }
     let hookInstalled = false;
     if (!options.skipHook) {
         const hookCode = await runHook('install', { cwd, silent: true });
@@ -152,6 +172,19 @@ export async function runSetup(options = {}) {
     console.log('\nChecking prerequisites…');
     await runDoctor();
     console.log(`\n${BOLD('Next steps:')}\n`);
+    // v7.1.9 — Generic+low-confidence detection prompt. The v7.1.8 benchmark
+    // re-run on a truly blank repo (no package.json / go.mod / language signal)
+    // surfaced this: setup runs fine but downstream agents get a CLAUDE.md
+    // saying "Detected: Generic (low confidence)" with no concrete next step
+    // to improve detection. Surfacing the actionable "scaffold a stack file
+    // first" hint converts a paper-cut into a one-liner.
+    if (detection.preset === 'generic' && detection.confidence === 'low') {
+        console.log(`  ${WARN}  ${CYAN('Stack detection: Generic (low confidence).')}`);
+        console.log(`       For higher-quality reviews + stack-specific presets, scaffold a`);
+        console.log(`       package manifest first, then re-run setup:`);
+        console.log(`         npm init -y                              ${DIM('# or: pnpm init, go mod init, cargo init')}`);
+        console.log(`         npx claude-autopilot setup --force       ${DIM('# re-detect with the new manifest')}\n`);
+    }
     if (!hasKey) {
         console.log(`  1. ${CYAN('Set an LLM API key')} — guardrail needs one to review code:`);
         console.log(`       export ANTHROPIC_API_KEY=sk-ant-...     # https://console.anthropic.com/`);
@@ -175,4 +208,108 @@ export async function runSetup(options = {}) {
         }
     }
 }
+// ---------------------------------------------------------------------------
+// v7.1.7 — setup-verb day-1 polish helpers
+// ---------------------------------------------------------------------------
+/**
+ * Append `entries` to `<cwd>/.gitignore` if missing. Returns the entries
+ * actually added (empty array when all already present, .gitignore is empty
+ * + we don't want to create one, etc.).
+ *
+ * Behavior:
+ *   - .gitignore exists: parse line-by-line, skip entries already present
+ *     (exact match after trim, ignoring leading `!`), append the rest.
+ *   - .gitignore missing: create it with the entries. Reasonable default
+ *     for a fresh `setup` since the user is opting into autopilot's cache.
+ *
+ * Idempotent: safe to call twice with the same entries.
+ */
+export async function ensureGitignoreEntries(cwd, entries) {
+    const gitignorePath = path.join(cwd, '.gitignore');
+    let existing = [];
+    let existingContent = '';
+    try {
+        existingContent = await fsAsync.readFile(gitignorePath, 'utf8');
+        existing = existingContent
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l.length > 0 && !l.startsWith('#'));
+    }
+    catch {
+        // File doesn't exist — that's fine, we'll create it below.
+    }
+    const present = new Set(existing.map((l) => l.replace(/^!/, '')));
+    const missing = entries.filter((e) => !present.has(e.replace(/^!/, '')));
+    if (missing.length === 0)
+        return [];
+    // Build the appended block. Add a trailing newline first so we don't
+    // collide with a no-final-newline file.
+    const needsLeadingNewline = existingContent.length > 0 && !existingContent.endsWith('\n');
+    const block = (needsLeadingNewline ? '\n' : '') +
+        (existingContent.length > 0 ? '# claude-autopilot (v7.1.7+)\n' : '') +
+        missing.join('\n') +
+        '\n';
+    await fsAsync.writeFile(gitignorePath, existingContent + block, 'utf8');
+    return missing;
+}
+/**
+ * Write a starter `<cwd>/CLAUDE.md` if none exists. Pulls stack-detection
+ * info from the same `detection` result that drove preset selection, so the
+ * scaffolded conventions match the actual project.
+ *
+ * The starter doc is intentionally short (~35 lines) — a real project will
+ * grow it. The goal is to give downstream agents an anchor for the most
+ * common "I had to guess" decisions the v7.1.6 benchmark agent reported:
+ * commit-message style, test command, error class shape, prompt location.
+ *
+ * Returns true when the file was written (false if it already exists; we
+ * never overwrite — operator opted into autopilot, not into us nuking
+ * their docs).
+ */
+export async function ensureStarterClaudeMd(cwd, detection) {
+    const dest = path.join(cwd, 'CLAUDE.md');
+    if (fs.existsSync(dest))
+        return false;
+    const stackLabel = PRESET_LABELS[detection.preset] ?? detection.preset;
+    const today = new Date().toISOString().slice(0, 10);
+    const body = [
+        `# CLAUDE.md`,
+        ``,
+        `Project conventions for AI-assisted contributions. Auto-scaffolded by`,
+        `\`claude-autopilot setup\` on ${today}; edit freely.`,
+        ``,
+        `## Stack`,
+        ``,
+        `- **Detected:** ${stackLabel} (${detection.confidence} confidence)`,
+        `- **Test command:** \`${detection.testCommand}\``,
+        `- **Evidence:** ${detection.evidence}`,
+        ``,
+        `## Conventions`,
+        ``,
+        `- **Commit messages:** Conventional Commits (\`feat:\`, \`fix:\`,`,
+        `  \`docs:\`, \`refactor:\`, \`test:\`, \`chore:\`). One sentence first`,
+        `  line, optional body.`,
+        `- **Branches:** \`feat/<topic>\`, \`fix/<topic>\`, \`chore/<topic>\`.`,
+        `- **Errors:** prefer custom \`Error\` subclasses with a string \`code\``,
+        `  field for programmatic handling. Example:`,
+        `  \`\`\`ts`,
+        `  class FetchFailed extends Error { code = 'fetch_failed' as const; }`,
+        `  \`\`\``,
+        `- **Tests:** colocated with source under \`tests/\` or \`__tests__/\`.`,
+        `  Run via \`${detection.testCommand}\`.`,
+        ``,
+        `## Patterns to mimic`,
+        ``,
+        `- TODO: as the project grows, list 2-3 example files agents should`,
+        `  read first to learn local style.`,
+        ``,
+        `## Common pitfalls`,
+        ``,
+        `- TODO: list any non-obvious gotchas — env-var quirks, ordering`,
+        `  requirements, footguns the test suite won't catch.`,
+        ``,
+    ].join('\n');
+    await fsAsync.writeFile(dest, body, 'utf8');
+    return true;
+}
 //# sourceMappingURL=setup.js.map

package/dist/src/core/run-state/events.js

@@ -286,8 +286,16 @@ export function replayState(runDir) {
         const observed = events[0].schema_version;
         if (typeof observed === 'number' &&
             (observed < minSupported || observed > maxSupported)) {
-            throw new GuardrailError(`run dir at ${runDir} has schema_version ${observed}; this binary supports schema_version ${minSupported}..${maxSupported}. ` +
-                `Use the version of claude-autopilot that created this run dir, or delete the run dir to start fresh.`, {
+            // v7.0 — when the observed version is HIGHER than this binary
+            // supports, the run was written by a newer Autopilot. Surface the
+            // "downgrade resume is not supported" hint so operators understand
+            // why a v6 binary can't pick up a v7-written run dir.
+            const downgradeHint = observed > maxSupported
+                ? ` state was written by a newer Autopilot version (schema_version=${observed}; this binary supports [${minSupported}..${maxSupported}]); downgrade resume is not supported.`
+                : '';
+            throw new GuardrailError(`run dir at ${runDir} has schema_version ${observed}; this binary supports schema_version ${minSupported}..${maxSupported}.` +
+                downgradeHint +
+                ` Use the version of claude-autopilot that created this run dir, or delete the run dir to start fresh.`, {
                 code: 'corrupted_state',
                 provider: 'run-state',
                 details: {

package/dist/src/core/run-state/resolve-engine.d.ts

@@ -2,99 +2,44 @@
  *  callers which precedence layer won so they can surface it in diagnostics
  *  (`runs show`, `--json` envelopes, etc.). */
 export interface ResolveEngineResult {
-    /** Final decision — whether the engine runs for this invocation. */
+    /** Final decision — whether the engine runs for this invocation.
+     *  v7.0+: always `true`. */
     enabled: boolean;
-    /** Which precedence layer produced the decision. */
+    /** Which precedence layer produced the decision. v7.0+: always
+     *  `'default'` (engine is unconditionally on). */
     source: 'cli' | 'env' | 'config' | 'default';
-    /** Human-readable explanation, suitable for run.warning details / verbose
-     *  CLI output / debug logs. */
+    /** Human-readable explanation. */
     reason: string;
-    /** When `source === 'env'` and the env value was malformed, this carries the
-     *  raw string so the caller can route a `run.warning` describing the
-     *  fallthrough. Absent on the happy path. */
+    /** When the env value was malformed in pre-v7 callers, this carried
+     *  the raw string so the caller could route a `run.warning`. v7.0+
+     *  ignores env values entirely; field is left undefined. */
     invalidEnvValue?: string;
 }
 export interface ResolveEngineOptions {
-    /** True if `--engine` was passed; false if `--no-engine`; undefined if
-     *  neither flag was present. The CLI parser is responsible for rejecting
-     *  the case where BOTH flags are passed before this function is called. */
+    /** Pre-v7 CLI flag override. v7.0+ ignores this — the engine is
+     *  always on. */
     cliEngine?: boolean;
-    /** Raw value of `process.env.CLAUDE_AUTOPILOT_ENGINE`. Undefined if the
-     *  variable is unset. Empty string is treated as unset (matches Node's
-     *  convention). Case-insensitive parsing of the string value. */
+    /** Pre-v7 env value. v7.0+ ignores this. */
     envValue?: string;
-    /** Value of `engine.enabled` from guardrail.config.yaml, or undefined if
-     *  the config file is missing / does not declare the key. */
+    /** Pre-v7 config value. v7.0+ ignores this. */
     configEnabled?: boolean;
-    /** Built-in default. v6.0: false. Tests pin this explicitly to exercise
-     *  the v6.1-flip behavior without needing to bump the constant globally. */
+    /** Pre-v7 built-in default override. v7.0+ ignores this. */
     builtInDefault?: boolean;
 }
-/** v6.1+ ships with the engine ON by default — flipped from the v6.0
- *  default (`false`) per `docs/specs/v6.1-default-flip.md`. Exported so
- *  tests / future releases can pin a known value. */
-export declare const ENGINE_DEFAULT_V6_1: true;
-/** Historical v6.0 default. Preserved verbatim — its semantic meaning
- *  ("the v6.0 default was off") doesn't change just because the active
- *  default flipped. Out-of-tree consumers that pinned this constant get
- *  the value the name promises. Use `ENGINE_DEFAULT_V6_1` for the active
- *  default. Removed in v7.
- *  @deprecated Use `ENGINE_DEFAULT_V6_1` or omit `builtInDefault` to inherit
- *  the active default. */
-export declare const ENGINE_DEFAULT_V6_0: false;
 /** Parse a stringly-typed env value into a tri-state boolean.
- *  Accepts (case-insensitive): on, off, true, false, 1, 0, yes, no.
- *  Returns undefined for any other input INCLUDING empty / whitespace-only
- *  strings — that signals the caller to fall through to the next precedence
- *  layer. */
+ *  Retained for back-compat with any out-of-tree callers; the v7
+ *  resolver does not consult env values. */
 export declare function parseEngineEnvValue(raw: string | undefined): boolean | undefined;
-/** Resolve whether the Run State Engine should run for this invocation.
- *  Pure function — does not touch process.env, fs, or anything I/O. */
-export declare function resolveEngineEnabled(opts?: ResolveEngineOptions): ResolveEngineResult;
-/** Stable copy emitted on stderr when a user explicitly opts out of the
- *  engine via `--no-engine`, `CLAUDE_AUTOPILOT_ENGINE=off`, or
- *  `engine.enabled: false`. v7 removes the escape hatch entirely.
- *
- *  Exported for tests + downstream consumers (e.g. CI parsers) that want to
- *  match against the exact string. Kept on a single line so terminals don't
- *  wrap mid-message. */
-export declare const ENGINE_OFF_DEPRECATION_MESSAGE = "[deprecation] --no-engine / engine.enabled: false will be removed in v7. Migrate to engine-on (default).";
-/** Optional callback shape for the deprecation warner. Tests pass a capture
- *  function; production callers omit it and get the default `process.stderr`
- *  writer. Kept narrow (single-arg) so a `jest.fn` or a `(msg) => lines.push(msg)`
- *  array sink is trivially droppable. */
+/** v7.0+ — engine is always on. Pure function; ignores all inputs.
+ *  Source compatible with v6.x call sites. */
+export declare function resolveEngineEnabled(_opts?: ResolveEngineOptions): ResolveEngineResult;
+/** v6.1-era stable deprecation banner. v7.0+ never emits this string —
+ *  the path is gone. Kept exported so out-of-tree consumers that imported
+ *  it still type-check. */
+export declare const ENGINE_OFF_DEPRECATION_MESSAGE = "[deprecation] --no-engine / engine.enabled: false were removed in v7.0. Migration: drop the flag/env/config.";
 export type EngineDeprecationWarn = (message: string) => void;
-/** Decide whether v6.1's `--no-engine` deprecation warning applies for a
- *  given resolver result. Returns `true` ONLY when the user explicitly
- *  opted out (via CLI flag, env var, or config) — never on the v6.1 default
- *  (which is `enabled: true`, so it can't trigger here anyway) and never
- *  when the engine is actually on. Pure: takes the resolver result, returns
- *  a boolean.
- *
- *  Why this is a separate predicate (not collapsed into the warner): the
- *  CLI dispatcher wants to ALSO emit a typed `run.warning` event into a
- *  ledger when the engine ends up on but the resolver came from a layer
- *  that's about to be removed — except today, on v6.1, the only path that
- *  warns IS the "engine off, explicit opt-out" path. So the predicate
- *  collapses cleanly to that single condition. v7 removes both. */
-export declare function shouldWarnEngineOffDeprecation(resolved: Pick<ResolveEngineResult, 'enabled' | 'source'>): boolean;
-/** Emit the v6.1 `--no-engine` deprecation warning to stderr (or the
- *  supplied `warn` callback) when the resolver result indicates the user
- *  explicitly opted out of the engine. No-op when:
- *    - the engine is on (no opt-out happened);
- *    - the source is `'default'` (v6.1's flipped default = on, so a default
- *      result with `enabled: false` is impossible without a custom
- *      `builtInDefault` override — and even that path doesn't warn since
- *      it's not a user-driven opt-out).
- *
- *  Pure-ish: side-effect is captured behind the optional `warn` callback so
- *  tests can assert on the message without spawning a subprocess. The
- *  default warner writes to `process.stderr` with a trailing newline.
- *
- *  Returns `true` when the warning fired, `false` when it was a no-op. The
- *  return value is purely informational — callers can use it to decide
- *  whether to also append a `run.warning` event into a run ledger (only
- *  meaningful on the engine-on path; the v6.1 deprecation only fires on
- *  engine-off, where there's no run dir to write into). */
-export declare function emitEngineOffDeprecationWarning(resolved: Pick<ResolveEngineResult, 'enabled' | 'source'>, warn?: EngineDeprecationWarn): boolean;
+/** v7.0+ no-op. Always returns false. */
+export declare function shouldWarnEngineOffDeprecation(_resolved: Pick<ResolveEngineResult, 'enabled' | 'source'>): boolean;
+/** v7.0+ no-op. Always returns false. */
+export declare function emitEngineOffDeprecationWarning(_resolved: Pick<ResolveEngineResult, 'enabled' | 'source'>, _warn?: EngineDeprecationWarn): boolean;
 //# sourceMappingURL=resolve-engine.d.ts.map