builder-assistant-engineer 0.2.0

package/dist/digest/read.js

@@ -0,0 +1,28 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+const BATCH_SIZE = 64;
+const BINARY_SNIFF_BYTES = 8_000;
+export async function readText(root, path) {
+    try {
+        const buffer = await readFile(join(root, ...path.split("/")));
+        if (buffer.subarray(0, BINARY_SNIFF_BYTES).includes(0))
+            return undefined;
+        return buffer.toString("utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function readTexts(root, paths) {
+    const texts = new Map();
+    for (let start = 0; start < paths.length; start += BATCH_SIZE) {
+        const batch = paths.slice(start, start + BATCH_SIZE);
+        const results = await Promise.all(batch.map((path) => readText(root, path)));
+        batch.forEach((path, index) => {
+            const text = results[index];
+            if (text !== undefined)
+                texts.set(path, text);
+        });
+    }
+    return texts;
+}

package/dist/digest/redact.js

@@ -0,0 +1,37 @@
+const REDACTED = "[REDACTED]";
+export const SECRET_TOKENS = [
+    ["private key", /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g],
+    [
+        "private key",
+        /-----BEGIN PGP PRIVATE KEY BLOCK-----[\s\S]*?-----END PGP PRIVATE KEY BLOCK-----/g,
+    ],
+    ["AWS access key", /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g],
+    ["Slack webhook", /https:\/\/hooks\.slack\.com\/services\/T\w+\/B\w+\/\w+/g],
+    ["GitHub token", /\bgh[pousr]_[A-Za-z0-9]{36,}\b/g],
+    ["GitHub token", /\bgithub_pat_[A-Za-z0-9_]{22,}/g],
+    ["Slack token", /\bxox[abprs]-[A-Za-z0-9-]{10,}/g],
+    ["API key", /\bsk-[A-Za-z0-9_-]{20,}/g],
+    ["Stripe key", /\b[rs]k_(?:live|test)_[A-Za-z0-9]{16,}/g],
+    ["Google API key", /\bAIza[0-9A-Za-z_-]{35}/g],
+    ["npm token", /\bnpm_[A-Za-z0-9]{36}\b/g],
+    ["GitLab token", /\bglpat-[A-Za-z0-9_-]{20,}/g],
+    ["JWT", /\beyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g],
+];
+const TOKENS = [
+    ...SECRET_TOKENS.map(([, pattern]) => pattern),
+    /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+];
+const KEYWORD = "[A-Za-z0-9_.-]*(?:api[_-]?key|secret|token|passw(?:or)?d|pwd|credential)[A-Za-z0-9_.-]*";
+const VALUES = [
+    [new RegExp(`(${KEYWORD}["']?\\s*[:=]\\s*)(["'])[^"'\\s]{8,}\\2`, "gi"), `$1$2${REDACTED}$2`],
+    [
+        /^(\s*(?:export\s+)?[A-Z0-9_]*(?:KEY|SECRET|TOKEN|PASSWORD|PASSWD|PWD|CREDENTIALS?)[A-Z0-9_]*\s*[=:]\s*)[^\s"'#]{8,}/gm,
+        `$1${REDACTED}`,
+    ],
+    [/(_auth(?:Token)?\s*=\s*)\S+/g, `$1${REDACTED}`],
+    [/([a-z][a-z0-9+.-]*:\/\/)[^\s:@/]+:[^\s@/]+@/gi, `$1${REDACTED}@`],
+];
+export function redact(text) {
+    const withoutTokens = TOKENS.reduce((result, pattern) => result.replace(pattern, REDACTED), text);
+    return VALUES.reduce((result, [pattern, replacement]) => result.replace(pattern, replacement), withoutTokens);
+}

package/dist/digest/render.js

@@ -0,0 +1,138 @@
+import { BASELINE_CHECKS } from "./baseline.js";
+import { renderBlock } from "./budget.js";
+import { isLockfile, languageOf } from "./files.js";
+import { codeFence, formatBytes } from "./format.js";
+import { renderTree } from "./tree.js";
+const LANGUAGE_ROWS = 12;
+const LARGEST_FILES = 10;
+const BRANCH_LIMIT = 20;
+const OMITTED_LIMIT = 50;
+export function renderHead(facts) {
+    return [
+        renderSummary(facts),
+        renderBaseline(facts.baseline),
+        renderLanguages(facts.scan),
+        list("Entry points", facts.entryPoints),
+        list("Configs", facts.configs),
+        list("Docs", facts.docs),
+        `## Tree (depth ${facts.treeDepth})\n\n${renderFileTree(facts)}`,
+        renderGit(facts.git),
+        renderTodos(facts.todos),
+        renderLargest(facts.scan),
+    ].join("\n\n");
+}
+export function renderContents(blocks) {
+    let group = "";
+    let text = "";
+    for (const block of blocks) {
+        if (block.group !== group) {
+            group = block.group;
+            text += `## ${group}\n\n`;
+        }
+        text += renderBlock(block);
+    }
+    return text;
+}
+export function renderOmitted(paths) {
+    if (paths.length === 0)
+        return "";
+    const shown = paths.slice(0, OMITTED_LIMIT).map((path) => `- ${path}`);
+    const extra = paths.length - OMITTED_LIMIT;
+    const more = extra > 0 ? [`- … ${extra} more`] : [];
+    return [
+        "## Omitted for budget",
+        "",
+        "Not included above; read them directly if needed.",
+        "",
+        ...shown,
+        ...more,
+        "",
+    ].join("\n");
+}
+function renderSummary(facts) {
+    const bytes = facts.scan.files.reduce((sum, file) => sum + file.size, 0);
+    const truncated = facts.scan.truncated ? ` (scan stopped at ${facts.scan.files.length})` : "";
+    return [
+        "# Repository digest",
+        "",
+        `- Root: ${facts.name}`,
+        `- Mode: ${facts.mode}`,
+        `- Files: ${facts.scan.files.length} (${formatBytes(bytes)})${truncated}`,
+        `- Manifests: ${joinOrNone(facts.manifests.map((manifest) => manifest.path))}`,
+        `- Package managers: ${joinOrNone(facts.packageManagers)}`,
+        `- Frameworks: ${joinOrNone(facts.frameworks)}`,
+    ].join("\n");
+}
+function renderBaseline(baseline) {
+    const rows = BASELINE_CHECKS.map((check) => {
+        const evidence = baseline[check];
+        return evidence.length > 0
+            ? `- ${check}: present — ${evidence.join("; ")}`
+            : `- ${check}: absent`;
+    });
+    return ["## Baseline", "", ...rows].join("\n");
+}
+function renderLanguages(scan) {
+    const totals = new Map();
+    for (const file of scan.files) {
+        const language = languageOf(file.path);
+        if (!language)
+            continue;
+        const total = totals.get(language) ?? { files: 0, bytes: 0 };
+        totals.set(language, { files: total.files + 1, bytes: total.bytes + file.size });
+    }
+    if (totals.size === 0)
+        return "## Languages\n\nNo source files.";
+    const rows = [...totals.entries()]
+        .sort(([, a], [, b]) => b.bytes - a.bytes)
+        .slice(0, LANGUAGE_ROWS)
+        .map(([language, total]) => `| ${language} | ${total.files} | ${formatBytes(total.bytes)} |`);
+    return ["## Languages", "", "| Language | Files | Size |", "| --- | --- | --- |", ...rows].join("\n");
+}
+function renderFileTree(facts) {
+    const paths = facts.scan.files.map((file) => file.path);
+    return paths.length > 0 ? codeFence(renderTree(paths, facts.treeDepth), "text") : "Empty.";
+}
+function renderGit(git) {
+    if (!git)
+        return "## Git\n\nNot a git repository.";
+    const extra = git.branches.length - BRANCH_LIMIT;
+    const branches = git.branches.slice(0, BRANCH_LIMIT).join(", ") + (extra > 0 ? ` (+${extra})` : "");
+    return [
+        "## Git",
+        "",
+        `- Branch: ${git.branch || "(detached)"}`,
+        `- Branches: ${branches || "none"}`,
+        `- Uncommitted changes: ${git.changes} files`,
+        "- Recent commits:",
+        ...(git.commits.length > 0 ? git.commits.map((commit) => `  - ${commit}`) : ["  - none"]),
+    ].join("\n");
+}
+function renderTodos(todos) {
+    if (todos.total === 0)
+        return "## TODO/FIXME\n\nNone found.";
+    const tags = Object.entries(todos.byTag)
+        .sort(([a, x], [b, y]) => y - x || (a < b ? -1 : 1))
+        .map(([tag, count]) => `${tag} ${count}`)
+        .join(", ");
+    const files = todos.files.map(([path, count]) => `${path} (${count})`).join(", ");
+    return ["## TODO/FIXME", "", `- Total: ${todos.total} (${tags})`, `- Top files: ${files}`].join("\n");
+}
+function renderLargest(scan) {
+    const largest = scan.files
+        .filter((file) => !isLockfile(file.path))
+        .sort((a, b) => b.size - a.size)
+        .slice(0, LARGEST_FILES)
+        .map((file) => `- ${file.path} — ${formatBytes(file.size)}`);
+    return ["## Largest files", "", ...(largest.length > 0 ? largest : ["None."])].join("\n");
+}
+function list(title, items) {
+    return [
+        `## ${title}`,
+        "",
+        ...(items.length > 0 ? items.map((item) => `- ${item}`) : ["None found."]),
+    ].join("\n");
+}
+function joinOrNone(items) {
+    return items.length > 0 ? items.join(", ") : "none";
+}

package/dist/digest/select.js

@@ -0,0 +1,116 @@
+import { posix } from "node:path";
+import { asRecord } from "../core/json.js";
+import { isCiPath } from "./baseline.js";
+import { baseName, byPath } from "./files.js";
+import { ecosystemOf } from "./manifests.js";
+export const MAX_ENTRY_POINTS = 8;
+export const MAX_DOCS = 10;
+export const MAX_CONFIGS = 20;
+const ENTRY_PATTERNS = [
+    /^(src\/)?(index|main|app|server|cli)\.(ts|tsx|mts|js|jsx|mjs|cjs)$/,
+    /^(src\/)?App\.(tsx|jsx|vue|svelte)$/,
+    /^(src\/)?app\/(page|layout)\.(tsx|jsx)$/,
+    /^pages\/(index|_app)\.(tsx|jsx|js)$/,
+    /^(app\/|src\/[^/]+\/)?(main|app|manage|wsgi|asgi|__main__)\.py$/,
+    /^src\/(main|lib)\.rs$/,
+    /^(cmd\/[^/]+\/)?main\.go$/,
+    /^Program\.cs$/,
+    /^src\/main\/java\/.+Application\.java$/,
+    /^public\/index\.php$/,
+    /^artisan$/,
+    /^config\.ru$/,
+    /^lib\/main\.dart$/,
+    /^Sources\/[^/]+\/main\.swift$/,
+];
+const ROOT_DOCS = [
+    /^readme(\.[a-z]+)?$/i,
+    /^agents\.md$/i,
+    /^claude\.md$/i,
+    /^gemini\.md$/i,
+    /^contributing(\.[a-z]+)?$/i,
+    /^architecture(\.[a-z]+)?$/i,
+];
+const CONFIG_NAMES = [
+    /^tsconfig(\..+)?\.json$/,
+    /^jsconfig\.json$/,
+    /^Dockerfile(\..+)?$/,
+    /^(docker-)?compose(\..+)?\.ya?ml$/,
+    /^eslint\.config\.[cm]?[jt]s$/,
+    /^\.eslintrc(\..+)?$/,
+    /^\.prettierrc(\..+)?$/,
+    /^prettier\.config\.[cm]?[jt]s$/,
+    /^biome\.jsonc?$/,
+    /^\.editorconfig$/,
+    /^(vite|vitest|jest|playwright|webpack|rollup|next|nuxt|svelte|astro|tailwind|postcss|babel)\.config\.[cm]?[jt]s$/,
+    /^Makefile$/,
+    /^justfile$/i,
+    /^Taskfile\.ya?ml$/,
+    /^\.nvmrc$/,
+    /^\.node-version$/,
+    /^\.python-version$/,
+    /^\.tool-versions$/,
+    /^tox\.ini$/,
+    /^\.?ruff\.toml$/,
+    /^\.?mypy\.ini$/,
+    /^pytest\.ini$/,
+    /^\.golangci\.ya?ml$/,
+    /^\.rubocop\.yml$/,
+    /^phpunit\.xml(\.dist)?$/,
+    /^Procfile$/,
+    /^fly\.toml$/,
+    /^vercel\.json$/,
+    /^netlify\.toml$/,
+    /^turbo\.json$/,
+    /^nx\.json$/,
+    /^pnpm-workspace\.yaml$/,
+    /^\.env\.(example|sample|template)$/,
+];
+export function findEntryPoints(paths, manifests) {
+    const available = new Set(paths);
+    const declared = manifests
+        .flatMap(declaredEntries)
+        .map((path) => resolveSource(path, available))
+        .filter((path) => path !== undefined);
+    const conventional = paths.filter((path) => ENTRY_PATTERNS.some((pattern) => pattern.test(path)));
+    return [...new Set([...declared, ...conventional])].slice(0, MAX_ENTRY_POINTS);
+}
+export function findDocs(paths) {
+    const root = ROOT_DOCS.flatMap((pattern) => paths.filter((path) => !path.includes("/") && pattern.test(path)));
+    const nested = paths
+        .filter((path) => /^docs?\/.+\.(md|mdx|rst|txt)$/i.test(path) && !path.startsWith("docs/plan/"))
+        .sort(byPath);
+    return [...new Set([...root, ...nested])].slice(0, MAX_DOCS);
+}
+export function findConfigs(paths) {
+    return paths
+        .filter((path) => isCiPath(path) || CONFIG_NAMES.some((pattern) => pattern.test(baseName(path))))
+        .filter((path) => ecosystemOf(path) === undefined)
+        .sort(byPath)
+        .slice(0, MAX_CONFIGS);
+}
+function declaredEntries(manifest) {
+    if (baseName(manifest.path) !== "package.json" || !manifest.json)
+        return [];
+    const { main, module, bin, exports } = manifest.json;
+    const dir = posix.dirname(manifest.path);
+    return [main, module, ...binEntries(bin), exportRoot(exports)]
+        .filter((value) => typeof value === "string")
+        .map((value) => posix.normalize(posix.join(dir, value)));
+}
+function binEntries(bin) {
+    return typeof bin === "string" ? [bin] : Object.values(asRecord(bin));
+}
+function exportRoot(exports) {
+    if (typeof exports === "string")
+        return exports;
+    const root = asRecord(exports)["."] ?? exports;
+    if (typeof root === "string")
+        return root;
+    const conditions = asRecord(root);
+    return conditions.import ?? conditions.default ?? conditions.require;
+}
+function resolveSource(path, available) {
+    const stem = path.replace(/^(dist|build|lib|out)\//, "src/").replace(/\.(m|c)?js$/, "");
+    const candidates = [path, ...[".ts", ".tsx", ".mts", ".js"].map((ext) => `${stem}${ext}`)];
+    return candidates.find((candidate) => available.has(candidate));
+}

package/dist/digest/todos.js

@@ -0,0 +1,16 @@
+const TAG = /\b(TODO|FIXME|HACK|XXX)\b/g;
+const TOP_FILES = 10;
+export function countTodos(texts) {
+    const byTag = {};
+    const files = [];
+    for (const [path, text] of texts) {
+        const tags = Array.from(text.matchAll(TAG), (match) => match[1] ?? "");
+        for (const tag of tags)
+            byTag[tag] = (byTag[tag] ?? 0) + 1;
+        if (tags.length > 0)
+            files.push([path, tags.length]);
+    }
+    files.sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1));
+    const total = files.reduce((sum, [, count]) => sum + count, 0);
+    return { total, byTag, files: files.slice(0, TOP_FILES) };
+}

package/dist/digest/tree.js

@@ -0,0 +1,55 @@
+export const DEFAULT_TREE_DEPTH = 3;
+export const TREE_MAX_LINES = 300;
+export const TREE_ENTRIES_PER_DIR = 30;
+export function renderTree(paths, depth = DEFAULT_TREE_DEPTH) {
+    const lines = [];
+    renderNode(buildTree(paths), 0, depth, lines);
+    if (lines.length <= TREE_MAX_LINES)
+        return lines.join("\n");
+    const hidden = lines.length - TREE_MAX_LINES;
+    return [...lines.slice(0, TREE_MAX_LINES), `… ${hidden} more lines`].join("\n");
+}
+function buildTree(paths) {
+    const root = newNode();
+    for (const path of paths) {
+        const parts = path.split("/");
+        const file = parts.pop() ?? path;
+        let node = root;
+        node.count++;
+        for (const part of parts) {
+            const child = node.dirs.get(part) ?? newNode();
+            node.dirs.set(part, child);
+            node = child;
+            node.count++;
+        }
+        node.files.push(file);
+    }
+    return root;
+}
+function renderNode(node, level, depth, lines) {
+    const indent = "  ".repeat(level);
+    const dirs = [...node.dirs.entries()].sort(([a], [b]) => (a < b ? -1 : 1));
+    const files = [...node.files].sort();
+    let shown = 0;
+    for (const [name, child] of dirs) {
+        if (shown++ >= TREE_ENTRIES_PER_DIR)
+            break;
+        if (level + 1 >= depth) {
+            lines.push(`${indent}${name}/ (${child.count} files)`);
+            continue;
+        }
+        lines.push(`${indent}${name}/`);
+        renderNode(child, level + 1, depth, lines);
+    }
+    for (const file of files) {
+        if (shown++ >= TREE_ENTRIES_PER_DIR)
+            break;
+        lines.push(`${indent}${file}`);
+    }
+    const hidden = dirs.length + files.length - TREE_ENTRIES_PER_DIR;
+    if (hidden > 0)
+        lines.push(`${indent}… ${hidden} more`);
+}
+function newNode() {
+    return { dirs: new Map(), files: [], count: 0 };
+}

package/dist/digest/walk.js

@@ -0,0 +1,72 @@
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import ignore, {} from "ignore";
+import { readTextIfExists } from "../core/fs.js";
+export const MAX_FILES = 50_000;
+const SKIPPED_DIRS = new Set([
+    ".git",
+    ".hg",
+    ".svn",
+    ".bae",
+    "node_modules",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".tox",
+    ".next",
+    ".nuxt",
+    ".svelte-kit",
+    ".turbo",
+    ".cache",
+    ".gradle",
+    ".idea",
+    ".terraform",
+    "coverage",
+]);
+export async function scanFiles(root, maxFiles = MAX_FILES) {
+    const scan = { files: [], truncated: false };
+    const rules = await loadRules(root, "", [".gitignore", ".baeignore"]);
+    await walk(root, "", rules, scan, maxFiles);
+    return scan;
+}
+async function walk(root, dir, inherited, scan, maxFiles) {
+    const rules = dir ? [...inherited, ...(await loadRules(root, dir, [".gitignore"]))] : inherited;
+    for (const entry of await listDir(join(root, dir))) {
+        if (scan.files.length >= maxFiles) {
+            scan.truncated = true;
+            return;
+        }
+        const path = dir ? `${dir}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            if (!SKIPPED_DIRS.has(entry.name) && !isIgnored(path, true, rules)) {
+                await walk(root, path, rules, scan, maxFiles);
+            }
+        }
+        else if (entry.isFile() && !isIgnored(path, false, rules)) {
+            scan.files.push({ path, size: (await stat(join(root, path))).size });
+        }
+    }
+}
+async function listDir(path) {
+    try {
+        const entries = await readdir(path, { withFileTypes: true });
+        return entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    }
+    catch {
+        return [];
+    }
+}
+async function loadRules(root, dir, names) {
+    const texts = await Promise.all(names.map((name) => readTextIfExists(join(root, dir, name))));
+    const patterns = texts.filter((text) => text !== undefined);
+    return patterns.length > 0 ? [{ base: dir, matcher: ignore().add(patterns.join("\n")) }] : [];
+}
+function isIgnored(path, isDir, rules) {
+    return rules.some(({ base, matcher }) => {
+        const relative = base ? path.slice(base.length + 1) : path;
+        return matcher.ignores(isDir ? `${relative}/` : relative);
+    });
+}

package/dist/gates/capture.js

@@ -0,0 +1,145 @@
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { configSchema } from "../config/schema.js";
+import { readTextIfExists, writeText } from "../core/fs.js";
+import { flaggedFiles, headCommit, isGitRepo } from "../core/git.js";
+import { BAE_DIR } from "../core/paths.js";
+import { loadPrompt } from "../core/prompt-loader.js";
+import { repoState } from "../core/state.js";
+import { findReviewer } from "../review/reviewer.js";
+import { scopePaths } from "../review/scope.js";
+import { hashPaths, takeSnapshot } from "../review/snapshot.js";
+import { runDir } from "../tasks/runs.js";
+import { verificationCommands } from "../tasks/schema.js";
+import { collectProtected, TASKS_DIR } from "./contract.js";
+import { captureIgnore } from "./ignore-rules.js";
+import { suiteBaselineSchema, suiteCommands } from "./regression.js";
+export const CAPTURED_PROMPTS = ["review", "retry", "lesson", "fix-format"];
+const promptSchema = z.object({ path: z.string(), text: z.string() });
+const captureSchema = z.object({
+    version: z.literal(1),
+    id: z.string(),
+    path: z.string(),
+    takenAt: z.string(),
+    git: z.boolean(),
+    base: z.string().optional(),
+    snapshot: z.record(z.string(), z.string().nullable()),
+    ignore: z.array(z.object({ dir: z.string(), text: z.string() })),
+    config: configSchema,
+    task: z.string(),
+    prompts: z.object({
+        review: promptSchema,
+        retry: promptSchema,
+        lesson: promptSchema,
+        "fix-format": promptSchema,
+    }),
+    reviewer: z.string(),
+    agentsMd: z.string().optional(),
+    protected: z.record(z.string(), z.string()),
+    shadows: z.array(z.string()).default([]),
+    flagged: z.array(z.string()).default([]),
+    baseline: suiteBaselineSchema.optional(),
+    skips: z.array(z.string()).default([]),
+    late: z.boolean().optional(),
+    finished: z.boolean().optional(),
+});
+const CAPTURE_FILE = "capture.json";
+const ACTIVE_FILE = "active.json";
+const AGENTS_MD = "AGENTS.md";
+export async function prepareCapture(cwd, config, task) {
+    const previous = await readCapture(cwd, task.meta.id);
+    const reuse = previous && !previous.finished ? previous : undefined;
+    const fixed = reuse
+        ? {
+            takenAt: reuse.takenAt,
+            git: reuse.git,
+            base: reuse.base,
+            snapshot: reuse.snapshot,
+            ignore: reuse.ignore,
+            baseline: reuse.baseline,
+            skips: reuse.skips,
+            late: reuse.late,
+        }
+        : await captureFixed(cwd);
+    return {
+        version: 1,
+        id: task.meta.id,
+        path: task.path,
+        ...fixed,
+        ...(await captureContract(cwd, config, task)),
+    };
+}
+export async function readCapture(cwd, id) {
+    const text = await readTextIfExists(join(runDir(cwd, id), CAPTURE_FILE));
+    if (text === undefined)
+        return undefined;
+    try {
+        const result = captureSchema.safeParse(JSON.parse(text));
+        return result.success ? result.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function saveCapture(cwd, capture) {
+    const path = join(runDir(cwd, capture.id), CAPTURE_FILE);
+    await writeText(path, `${JSON.stringify(capture, null, 2)}\n`);
+}
+export async function markActive(cwd, id) {
+    await writeText(join(repoState(cwd), ACTIVE_FILE), `${JSON.stringify({ id })}\n`);
+}
+export async function clearActive(cwd) {
+    await rm(join(repoState(cwd), ACTIVE_FILE), { force: true });
+}
+export async function readActive(cwd) {
+    const text = await readTextIfExists(join(repoState(cwd), ACTIVE_FILE));
+    try {
+        const id = JSON.parse(text ?? "").id;
+        return typeof id === "string" ? id : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function trustAgentsMd(cwd, capture, trusted) {
+    const current = await readTextIfExists(join(cwd, AGENTS_MD));
+    capture.agentsMd = trusted;
+    if (current === trusted) {
+        capture.protected[AGENTS_MD] = trusted;
+        Object.assign(capture.snapshot, await hashPaths(cwd, [AGENTS_MD]));
+    }
+    await saveCapture(cwd, capture);
+}
+export function capturedPrompt(capture, name) {
+    return capture.prompts[name];
+}
+async function captureFixed(cwd) {
+    const git = await isGitRepo(cwd);
+    const base = git ? await headCommit(cwd) : undefined;
+    return {
+        takenAt: new Date().toISOString(),
+        git,
+        ...(base ? { base } : {}),
+        snapshot: await takeSnapshot(cwd, [BAE_DIR, TASKS_DIR]),
+        ignore: git ? await captureIgnore(cwd) : [],
+        skips: [],
+    };
+}
+async function captureContract(cwd, config, task) {
+    const prompts = await Promise.all(CAPTURED_PROMPTS.map((name) => loadPrompt(name, cwd)));
+    const agentsMd = await readTextIfExists(join(cwd, AGENTS_MD));
+    return {
+        config,
+        task: task.text,
+        prompts: Object.fromEntries(CAPTURED_PROMPTS.map((name, index) => [name, prompts[index]])),
+        reviewer: await findReviewer(cwd, config.backend),
+        ...(agentsMd === undefined ? {} : { agentsMd }),
+        ...(await collectProtected(cwd, {
+            suite: suiteCommands(config).map((item) => item.command),
+            verification: verificationCommands(task.body),
+            own: scopePaths(task),
+        })),
+        flagged: (await flaggedFiles(cwd)) ?? [],
+    };
+}