builder-assistant-engineer 0.2.0

package/dist/plan/parser.js

@@ -0,0 +1,283 @@
+import { posix } from "node:path";
+import { z } from "zod";
+import { FormatError } from "../core/errors.js";
+import { splitFrontmatter } from "../tasks/frontmatter.js";
+import { findCycle } from "../tasks/graph.js";
+import { withLogSection } from "../tasks/handoff.js";
+import { parseTask, TASK_PATH, taskProblems } from "../tasks/schema.js";
+const questionSchema = z.object({
+    question: z.string().min(1),
+    why: z.string().default(""),
+    options: z.array(z.string()).optional(),
+    blocking: z.boolean().optional(),
+});
+const nullableCommand = z.string().nullish();
+const configBlockSchema = z.object({
+    commands: z.object({
+        test: nullableCommand,
+        lint: nullableCommand,
+        typecheck: nullableCommand,
+        build: nullableCommand,
+    }),
+});
+export const MARKER = /^[ \t]*<<<(SUMMARY|QUESTIONS|CONFIG|END SUMMARY|END QUESTIONS|END CONFIG|END FILE|FILE:[^>\n]*)>>>/gm;
+const MAX_PROBLEMS = 20;
+const ALLOWED_PATHS = [
+    /^AGENTS\.md$/,
+    /^CLAUDE\.md$/,
+    /^GEMINI\.md$/,
+    /^docs\/plan\/[A-Za-z0-9._/-]+\.md$/,
+    /^\.claude\/(agents|commands)\/[A-Za-z0-9._-]+\.md$/,
+    /^\.opencode\/(agent|command)\/[A-Za-z0-9._-]+\.md$/,
+];
+const AGENT_PATH = /^\.(claude\/agents|opencode\/agent)\/[^/]+\.md$/;
+export const PLAN_FORMAT = [
+    "Emit only these blocks, nothing outside them. Paths are relative to the repo root.",
+    "<<<SUMMARY>>>",
+    "5-8 lines for the terminal",
+    "<<<END SUMMARY>>>",
+    "<<<QUESTIONS>>>",
+    'JSON array of up to 5 objects {"question", "why", "options"?, "blocking"?}; [] if none',
+    "<<<END QUESTIONS>>>",
+    "<<<CONFIG>>>",
+    '{"commands": {"test": "...", "lint": "...", "typecheck": "...", "build": "..."}} with null for commands the project will not have',
+    "<<<END CONFIG>>>",
+    "<<<FILE: path/to/file.md>>>",
+    "full file content",
+    "<<<END FILE>>>",
+    "Allowed FILE paths: AGENTS.md, CLAUDE.md, GEMINI.md, docs/plan/**/*.md, docs/plan/tasks/T-NNN-slug.md,",
+    ".claude/agents/*.md, .claude/commands/*.md, .opencode/agent/*.md, .opencode/command/*.md.",
+    "Task files start with YAML frontmatter (id, title, status, phase, depends_on, size S|M|L,",
+    "risk low|medium|high, tests required|optional) and contain the sections Goal, Context, Scope, Steps, Acceptance criteria,",
+    "Verification (commands in a ```sh block, one per line), Risks and notes, and an empty Log.",
+    "Subagent files start with YAML frontmatter that includes a description.",
+].join("\n");
+export function parsePlan(text, options = {}) {
+    const problems = [];
+    const warnings = [];
+    const blocks = tokenize(text, problems, warnings);
+    const summary = single(blocks, "SUMMARY", problems)?.body.trim() ?? "";
+    if (summary === "" && problems.length === 0)
+        problems.push("SUMMARY is empty");
+    const questions = parseQuestions(single(blocks, "QUESTIONS", problems)?.body, problems);
+    const commands = parseConfig(blocks, warnings);
+    const files = collectFiles(blocks, problems).map((file) => TASK_PATH.test(file.path) ? { ...file, content: withLogSection(file.content) } : file);
+    const tasks = validateTasks(files, options.knownTaskIds ?? [], problems);
+    warnings.push(...missingTestPolicies(files));
+    validateAgents(files, options.requireReviewer ?? false, problems);
+    if (problems.length > 0)
+        throw new FormatError(problems.slice(0, MAX_PROBLEMS).join("\n"));
+    return { summary, questions, commands, files, tasks, warnings };
+}
+export function parseFileBlocks(text) {
+    const ignored = [];
+    return collectFiles(tokenize(text, ignored, ignored), ignored);
+}
+export function renderPlan(plan) {
+    return [
+        "<<<SUMMARY>>>",
+        plan.summary,
+        "<<<END SUMMARY>>>",
+        "<<<QUESTIONS>>>",
+        JSON.stringify(plan.questions),
+        "<<<END QUESTIONS>>>",
+        "<<<CONFIG>>>",
+        JSON.stringify({ commands: plan.commands }),
+        "<<<END CONFIG>>>",
+        ...plan.files.flatMap((file) => [
+            `<<<FILE: ${file.path}>>>`,
+            file.content.trimEnd(),
+            "<<<END FILE>>>",
+        ]),
+    ].join("\n");
+}
+function tokenize(text, problems, warnings) {
+    const blocks = [];
+    let open;
+    let outside = 0;
+    let cursor = 0;
+    for (const match of text.matchAll(MARKER)) {
+        const marker = match[1] ?? "";
+        const index = match.index ?? 0;
+        if (!open)
+            outside += text.slice(cursor, index).trim().length;
+        cursor = index + match[0].length;
+        if (marker.startsWith("END ")) {
+            const kind = marker.slice(4);
+            if (open?.kind !== kind) {
+                problems.push(`<<<${marker}>>> without a matching opening marker`);
+                continue;
+            }
+            blocks.push({
+                kind: open.kind,
+                path: open.path,
+                body: stripEdges(text.slice(open.end, index)),
+            });
+            open = undefined;
+            continue;
+        }
+        if (open) {
+            problems.push(`<<<${marker}>>> opened before <<<END ${open.kind}>>> of ${open.path || open.kind}`);
+            continue;
+        }
+        const kind = marker.startsWith("FILE:") ? "FILE" : marker;
+        open = { kind, path: marker.startsWith("FILE:") ? marker.slice(5).trim() : "", end: cursor };
+    }
+    if (open)
+        problems.push(`${open.path || open.kind} is missing <<<END ${open.kind}>>>`);
+    else
+        outside += text.slice(cursor).trim().length;
+    if (outside > 0)
+        warnings.push(`ignored ${outside} characters outside the output blocks`);
+    return blocks;
+}
+function single(blocks, kind, problems) {
+    const found = blocks.filter((block) => block.kind === kind);
+    if (found.length !== 1)
+        problems.push(`expected exactly one ${kind} block, found ${found.length}`);
+    return found[0];
+}
+function parseQuestions(body, problems) {
+    if (body === undefined)
+        return [];
+    const json = unfence(body);
+    let data;
+    try {
+        data = JSON.parse(json);
+    }
+    catch (error) {
+        problems.push(`QUESTIONS is not valid JSON (${error instanceof Error ? error.message : error})`);
+        return [];
+    }
+    const result = z.array(questionSchema).max(5).safeParse(data);
+    if (result.success)
+        return result.data;
+    problems.push(`QUESTIONS does not match the schema (${z.prettifyError(result.error)})`);
+    return [];
+}
+function parseConfig(blocks, warnings) {
+    const found = blocks.filter((block) => block.kind === "CONFIG");
+    if (found.length > 1)
+        warnings.push("ignored every CONFIG block after the first");
+    const body = found[0]?.body;
+    if (body === undefined)
+        return {};
+    let data;
+    try {
+        data = JSON.parse(unfence(body));
+    }
+    catch {
+        warnings.push("ignored the CONFIG block: it is not valid JSON");
+        return {};
+    }
+    const result = configBlockSchema.safeParse(data);
+    if (!result.success) {
+        warnings.push("ignored the CONFIG block: it does not match the schema");
+        return {};
+    }
+    const commands = {};
+    for (const [key, value] of Object.entries(result.data.commands)) {
+        if (value?.trim())
+            commands[key] = value.trim();
+    }
+    return commands;
+}
+function unfence(body) {
+    return body
+        .trim()
+        .replace(/^```(?:json)?\s*\n?/, "")
+        .replace(/\n?```$/, "");
+}
+function collectFiles(blocks, problems) {
+    const files = [];
+    const seen = new Set();
+    for (const block of blocks.filter((candidate) => candidate.kind === "FILE")) {
+        const path = normalizePath(block.path, problems);
+        if (!path)
+            continue;
+        if (seen.has(path))
+            problems.push(`${path} appears more than once`);
+        seen.add(path);
+        files.push({ path, content: `${block.body.trimEnd()}\n` });
+    }
+    if (!seen.has("AGENTS.md"))
+        problems.push("missing FILE block for AGENTS.md");
+    return files;
+}
+function normalizePath(raw, problems) {
+    const path = raw.replace(/^\.\//, "");
+    const unsafe = path === "" || path.includes("\\") || posix.isAbsolute(path) || path.split("/").includes("..");
+    if (unsafe || !ALLOWED_PATHS.some((pattern) => pattern.test(path))) {
+        problems.push(`FILE path not allowed: "${raw}"`);
+        return undefined;
+    }
+    return path;
+}
+function validateTasks(files, knownIds, problems) {
+    const tasks = [];
+    for (const file of files.filter((candidate) => candidate.path.startsWith("docs/plan/tasks/"))) {
+        const fileId = TASK_PATH.exec(file.path)?.[1];
+        if (!fileId) {
+            problems.push(`${file.path}: task files must be named docs/plan/tasks/T-NNN-slug.md`);
+            continue;
+        }
+        try {
+            const task = parseTask(file.path, file.content);
+            if (task.meta.id !== fileId)
+                problems.push(`${file.path}: frontmatter id ${task.meta.id} does not match the file name`);
+            problems.push(...taskProblems(task));
+            tasks.push(task);
+        }
+        catch (error) {
+            if (!(error instanceof FormatError))
+                throw error;
+            problems.push(error.message);
+        }
+    }
+    validateGraph(tasks, knownIds, problems);
+    return tasks;
+}
+function missingTestPolicies(files) {
+    return files
+        .filter((file) => TASK_PATH.test(file.path))
+        .filter((file) => safeFrontmatter(file.content)?.data.tests === undefined)
+        .map((file) => `${file.path}: no tests field in the frontmatter; assuming optional`);
+}
+function validateGraph(tasks, knownIds, problems) {
+    const ids = tasks.map((task) => task.meta.id);
+    const duplicates = ids.filter((id, index) => ids.indexOf(id) !== index);
+    for (const id of new Set(duplicates))
+        problems.push(`task id ${id} is used more than once`);
+    const known = new Set([...ids, ...knownIds]);
+    for (const task of tasks) {
+        const unknown = task.meta.depends_on.filter((id) => !known.has(id));
+        if (unknown.length > 0)
+            problems.push(`${task.meta.id} depends on unknown tasks: ${unknown.join(", ")}`);
+    }
+    const cycle = findCycle(tasks.map((task) => ({ id: task.meta.id, dependsOn: task.meta.depends_on })));
+    if (cycle)
+        problems.push(`dependency cycle: ${cycle.join(" -> ")}`);
+}
+function validateAgents(files, requireReviewer, problems) {
+    const agents = files.filter((file) => AGENT_PATH.test(file.path));
+    for (const agent of agents) {
+        const description = safeFrontmatter(agent.content)?.data.description;
+        if (typeof description !== "string" || description.trim() === "") {
+            problems.push(`${agent.path}: frontmatter must include a description`);
+        }
+    }
+    if (requireReviewer && !agents.some((agent) => /review/i.test(posix.basename(agent.path)))) {
+        problems.push("missing the reviewer subagent (a file whose name contains 'review')");
+    }
+}
+function safeFrontmatter(text) {
+    try {
+        return splitFrontmatter(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function stripEdges(text) {
+    return text.replace(/^[ \t]*\r?\n/, "").replace(/\r?\n[ \t]*$/, "");
+}

package/dist/plan/prior.js

@@ -0,0 +1,32 @@
+import { join } from "node:path";
+import { readTextIfExists } from "../core/fs.js";
+import { truncateText } from "../digest/format.js";
+const PLAN_DOCS = ["00-overview.md", "01-prd.md", "02-architecture.md", "04-roadmap.md"];
+const MAX_DOC_CHARS = 12_000;
+const MAX_PRIOR_CHARS = 80_000;
+export const PRIOR_PLAN_RULES = "Re-emit every pending, in_progress or blocked task you keep, with its id and status unchanged. Pending tasks you leave out are deleted. Done tasks are kept as they are; do not re-emit them.";
+export async function buildPriorPlan(cwd, tasks) {
+    const docs = await Promise.all(PLAN_DOCS.map(async (name) => {
+        const text = await readTextIfExists(join(cwd, "docs", "plan", name));
+        return text ? `### docs/plan/${name}\n\n${truncateText(text.trim(), MAX_DOC_CHARS)}` : "";
+    }));
+    const open = tasks.filter((task) => task.task?.meta.status !== "done");
+    const sections = [
+        PRIOR_PLAN_RULES,
+        ["## Task status", "", ...tasks.map(statusLine)].join("\n"),
+        ["## Plan documents", "", ...docs.filter(Boolean)].join("\n\n"),
+        [
+            "## Open task files",
+            "",
+            ...open.map((task) => `### ${task.path}\n\n${task.text.trim()}`),
+        ].join("\n\n"),
+    ];
+    return truncateText(sections.join("\n\n"), MAX_PRIOR_CHARS);
+}
+function statusLine(task) {
+    const meta = task.task?.meta;
+    if (!meta)
+        return `- ${task.id} [invalid] ${task.path}`;
+    const deps = meta.depends_on.length > 0 ? `, depends on ${meta.depends_on.join(", ")}` : "";
+    return `- ${meta.id} [${meta.status}] ${meta.title} (phase ${meta.phase}${deps})`;
+}

package/dist/plan/questions.js

@@ -0,0 +1,48 @@
+import { readInterview, writeInterview } from "../config/store.js";
+import { t } from "../i18n/index.js";
+import { askQuestion } from "../interview/adaptive.js";
+export async function closeQuestions(ctx, questions) {
+    if (questions.length === 0)
+        return [];
+    const ask = !ctx.flags.yes && !ctx.flags.dryRun;
+    const listed = ask ? questions.filter((question) => !question.blocking) : questions;
+    if (listed.length > 0)
+        ctx.prompter.note(formatQuestions(listed), t("plan.openQuestions"));
+    const closed = [];
+    for (const question of questions) {
+        const answer = ask && question.blocking ? await askQuestion(ctx.prompter, question) : "";
+        closed.push({ ...question, answer: answer.trim() });
+    }
+    await appendQuestions(ctx.cwd, closed);
+    ctx.prompter.info(t("plan.questionsSaved", { count: closed.length }));
+    return closed;
+}
+export function renderQuestions(questions, date) {
+    const sections = questions.map((item) => {
+        const lines = [`### ${item.question}`, ""];
+        if (item.why)
+            lines.push(`- ${t("md.why")}: ${item.why}`);
+        if (item.options?.length)
+            lines.push(`- ${t("md.options")}: ${item.options.join(" / ")}`);
+        if (item.blocking)
+            lines.push(`- ${t("md.blocking")}`);
+        lines.push(`- ${t("md.answer")}: ${item.answer || `_${t("md.open")}_`}`);
+        return lines.join("\n");
+    });
+    return [`## ${t("md.planQuestions", { date })}`, ...sections].join("\n\n");
+}
+async function appendQuestions(cwd, questions) {
+    const current = (await readInterview(cwd))?.trimEnd() ?? `# ${t("md.interview")}`;
+    const date = new Date().toISOString().slice(0, 10);
+    await writeInterview(cwd, `${current}\n\n${renderQuestions(questions, date)}\n`);
+}
+export function formatQuestions(questions) {
+    return questions
+        .map((question, index) => {
+        const flag = question.blocking ? ` [${t("plan.blocking")}]` : "";
+        const options = question.options?.length ? `\n   ${question.options.join(" / ")}` : "";
+        const why = question.why ? ` — ${question.why}` : "";
+        return `${index + 1}.${flag} ${question.question}${why}${options}`;
+    })
+        .join("\n");
+}

package/dist/plan/repair.js

@@ -0,0 +1,33 @@
+import { rawBlocks } from "./continuation.js";
+import { MARKER } from "./parser.js";
+const LOOSE_MARKER = /^[ \t]*<<<[ \t]*(end[ \t]+)?(summary|questions|config|file)[ \t]*(?::[ \t]*([^>\n]*?))?[ \t]*>>>[ \t]*$/gim;
+export function repairPlan(text, truncated) {
+    const spaced = normalizeMarkers(text);
+    const closed = truncated === false ? closeLastFile(spaced.text) : { text: spaced.text, repairs: [] };
+    return { text: closed.text, repairs: [...spaced.repairs, ...closed.repairs] };
+}
+function normalizeMarkers(text) {
+    const strict = new RegExp(MARKER.source, "m");
+    let count = 0;
+    const fixed = text.replace(LOOSE_MARKER, (line, end, kind, path) => {
+        if (strict.test(line))
+            return line;
+        count++;
+        const name = kind.toUpperCase();
+        if (end)
+            return `<<<END ${name}>>>`;
+        return name === "FILE" ? `<<<FILE: ${String(path ?? "").trim()}>>>` : `<<<${name}>>>`;
+    });
+    const repairs = count > 0 ? [`normalized ${count} marker(s) with extra spaces or lowercase`] : [];
+    return { text: fixed, repairs };
+}
+function closeLastFile(text) {
+    const last = rawBlocks(text).at(-1);
+    if (!last || last.closed || !last.key.startsWith("FILE:"))
+        return { text, repairs: [] };
+    const path = last.key.slice("FILE:".length).trim();
+    return {
+        text: `${text.trimEnd()}\n<<<END FILE>>>\n`,
+        repairs: [`closed the last FILE block (${path}) that was missing <<<END FILE>>>`],
+    };
+}

package/dist/plan/report.js

@@ -0,0 +1,37 @@
+import { join } from "node:path";
+import { writeText } from "../core/fs.js";
+import { baePaths } from "../core/paths.js";
+export const PLAN_REPORT = "plan-report.json";
+export function newPlanStats(backend) {
+    return {
+        backend,
+        models: [],
+        continuations: 0,
+        formatRetries: 0,
+        formatErrors: [],
+        evidenceRetries: 0,
+        unverifiedPaths: [],
+        repairs: [],
+    };
+}
+export function recordInfo(stats, info) {
+    if (info.model && !stats.models.includes(info.model))
+        stats.models.push(info.model);
+    if (info.costUsd !== undefined)
+        stats.costUsd = (stats.costUsd ?? 0) + info.costUsd;
+}
+export async function writePlanReport(cwd, stats, parsed, error) {
+    const report = {
+        ...stats,
+        ok: parsed !== undefined,
+        files: parsed?.files.length ?? 0,
+        tasks: parsed?.tasks.length ?? 0,
+        questions: parsed?.questions.length ?? 0,
+        blockingQuestions: parsed?.questions.filter((question) => question.blocking).length ?? 0,
+        warnings: parsed?.warnings ?? [],
+        ...(error === undefined
+            ? {}
+            : { error: error instanceof Error ? error.message : String(error) }),
+    };
+    await writeText(join(baePaths(cwd).tmp, PLAN_REPORT), `${JSON.stringify(report, null, 2)}\n`);
+}

package/dist/plan/run.js

@@ -0,0 +1,191 @@
+import { join, relative } from "node:path";
+import { buildAnalystPrompt } from "../analyst/prompt.js";
+import { runWithFormatRetry } from "../analyst/retry.js";
+import { isAgentBackend } from "../commands/shared.js";
+import { readInterview } from "../config/store.js";
+import { FormatError, UserError } from "../core/errors.js";
+import { writeText } from "../core/fs.js";
+import { baePaths } from "../core/paths.js";
+import { loadPrompt, renderPrompt } from "../core/prompt-loader.js";
+import { truncateText } from "../digest/format.js";
+import { buildDigest } from "../digest/index.js";
+import { scanFiles } from "../digest/walk.js";
+import { t } from "../i18n/index.js";
+import { findTruncation, mergeContinuation } from "./continuation.js";
+import { describeUnverified, findUnverified } from "./evidence.js";
+import { PLAN_FORMAT, parseFileBlocks, parsePlan, renderPlan } from "./parser.js";
+import { repairPlan } from "./repair.js";
+import { newPlanStats, recordInfo, writePlanReport } from "./report.js";
+const MAX_CONTINUATIONS = 3;
+const REJECTED_PLAN = "rejected-plan.md";
+const MAX_REPO_FILES_CHARS = 20_000;
+export async function generatePlan(ctx, config, request) {
+    const interview = (await readInterview(ctx.cwd)) ?? "";
+    if (!interview.trim())
+        ctx.prompter.warn(t("plan.noInterview"));
+    const digest = await ctx.prompter.spinner(t("digest.reading"), async () => {
+        return (await buildDigest(ctx.cwd, { maxChars: config.digest.maxChars })).text;
+    });
+    const prompt = await buildAnalystPrompt(ctx.cwd, {
+        mode: "PLAN",
+        projectType: config.mode,
+        lang: config.lang,
+        targets: config.targets,
+        interview,
+        digest,
+        canExplore: isAgentBackend(config.backend),
+        priorPlan: request.priorPlan,
+    });
+    if (ctx.flags.dryRun) {
+        ctx.print(`${prompt}\n`);
+        return undefined;
+    }
+    const stats = newPlanStats(config.backend);
+    const backend = ctx.createBackend(config.backend);
+    const requireReviewer = config.targets.some((target) => target === "claude-code" || target === "opencode");
+    const parse = (text) => parsePlan(text, { knownTaskIds: request.knownTaskIds, requireReviewer });
+    try {
+        const parsed = await requestPlan(ctx, backend, parse, prompt, stats);
+        const checked = await checkEvidence(ctx, backend, parsed, parse, stats, config.mode);
+        await writePlanReport(ctx.cwd, stats, checked);
+        return checked;
+    }
+    catch (error) {
+        await writePlanReport(ctx.cwd, stats, undefined, error);
+        throw error;
+    }
+}
+async function requestPlan(ctx, backend, parse, prompt, stats) {
+    return ctx.prompter.spinner(t("plan.analyzing"), (update) => {
+        const ending = {};
+        const options = {
+            cwd: ctx.cwd,
+            access: "read",
+            stream: progress(update),
+            onInfo: (info) => {
+                recordInfo(stats, info);
+                if (info.truncated !== undefined)
+                    ending.truncated = info.truncated;
+            },
+        };
+        const repair = (text) => repairAnswer(ctx, text, ending, stats);
+        return runWithFormatRetry({
+            backend,
+            prompt,
+            options,
+            parse,
+            format: PLAN_FORMAT,
+            onRetry: (error) => {
+                stats.formatRetries++;
+                stats.formatErrors.push(error.message);
+                ctx.prompter.warn(t("format.retrying"));
+            },
+            complete: (text) => continueTruncated(ctx, backend, { prompt, text, options, stats, repair }),
+        });
+    });
+}
+function repairAnswer(ctx, text, ending, stats) {
+    const repaired = repairPlan(text, ending.truncated);
+    if (repaired.repairs.length > 0) {
+        stats.repairs.push(...repaired.repairs);
+        ctx.prompter.info(t("format.repaired", { repairs: repaired.repairs.join("; ") }));
+    }
+    return repaired.text;
+}
+async function continueTruncated(ctx, backend, answer) {
+    const { prompt, options, stats, repair } = answer;
+    let current = repair(answer.text);
+    for (let round = 0; round < MAX_CONTINUATIONS; round++) {
+        const cut = findTruncation(current);
+        if (!cut)
+            return current;
+        stats.continuations++;
+        ctx.prompter.warn(t("plan.continuing", { marker: cut.marker }));
+        const request = renderPrompt(await loadPrompt("continue", ctx.cwd), {
+            prompt,
+            partial: cut.complete,
+            next_marker: cut.marker,
+        });
+        const more = await backend.run(request, options);
+        current = repair(mergeContinuation(cut.complete, more));
+    }
+    return current;
+}
+async function checkEvidence(ctx, backend, parsed, parse, stats, mode) {
+    const missing = await findUnverified(ctx.cwd, parsed);
+    if (missing.length === 0)
+        return parsed;
+    stats.evidenceRetries++;
+    ctx.prompter.warn(t("evidence.retrying", { count: missing.length }));
+    const fixed = await ctx.prompter.spinner(t("evidence.fixing"), () => fixPaths(ctx, backend, parsed, missing, parse, stats));
+    const plan = fixed ?? parsed;
+    const remaining = fixed ? await findUnverified(ctx.cwd, fixed) : missing;
+    stats.unverifiedPaths = remaining.map(describeUnverified);
+    if (remaining.length === 0) {
+        ctx.prompter.success(t("evidence.fixed"));
+        return plan;
+    }
+    const lines = remaining.filter((item) => item.line !== undefined);
+    if (mode === "brownfield" && lines.length > 0) {
+        const path = join(baePaths(ctx.cwd).tmp, REJECTED_PLAN);
+        await writeText(path, renderPlan(plan));
+        throw new UserError(t("evidence.linesFailed", {
+            list: lines.map((item) => `- ${describeUnverified(item)}`).join("\n"),
+            path: relative(ctx.cwd, path).split("\\").join("/"),
+        }));
+    }
+    ctx.prompter.warn(t("evidence.unverified", { count: remaining.length }));
+    const list = stats.unverifiedPaths.map((line) => `- ${line}`).join("\n");
+    return { ...plan, summary: `${plan.summary}\n\n${t("evidence.summary")}\n${list}` };
+}
+async function fixPaths(ctx, backend, parsed, missing, parse, stats) {
+    const sources = new Set(missing.map((item) => item.source));
+    const affected = parsed.files.filter((file) => sources.has(file.path));
+    const prompt = renderPrompt(await loadPrompt("fix-paths", ctx.cwd), {
+        paths: missing.map((item) => `- ${describeUnverified(item)}`).join("\n"),
+        files: affected
+            .map((file) => `<<<FILE: ${file.path}>>>\n${file.content.trimEnd()}\n<<<END FILE>>>`)
+            .join("\n\n"),
+        repo_files: await repoFiles(ctx.cwd),
+    });
+    let reply;
+    try {
+        reply = await backend.run(prompt, {
+            cwd: ctx.cwd,
+            access: "read",
+            onInfo: (info) => recordInfo(stats, info),
+        });
+    }
+    catch (error) {
+        if (!(error instanceof UserError))
+            throw error;
+        ctx.prompter.warn(t("evidence.retryFailed", { details: error.message }));
+        return undefined;
+    }
+    const replaced = new Map(parseFileBlocks(repairPlan(reply, undefined).text)
+        .filter((file) => sources.has(file.path))
+        .map((file) => [file.path, file]));
+    if (replaced.size === 0)
+        return undefined;
+    const files = parsed.files.map((file) => replaced.get(file.path) ?? file);
+    try {
+        return { ...parse(renderPlan({ ...parsed, files })), warnings: parsed.warnings };
+    }
+    catch (error) {
+        if (error instanceof FormatError)
+            return undefined;
+        throw error;
+    }
+}
+async function repoFiles(cwd) {
+    const { files } = await scanFiles(cwd);
+    const list = files.map((file) => file.path).join("\n");
+    return truncateText(list || "(no files)", MAX_REPO_FILES_CHARS);
+}
+function progress(update) {
+    let received = 0;
+    return (chunk) => {
+        received += chunk.length;
+        update(t("plan.progress", { chars: received.toLocaleString() }));
+    };
+}