gsd-pi 2.33.1 → 2.34.0-dev.bbb5216

package/dist/resources/extensions/gsd/auto-prompts.ts

@@ -1,1273 +0,0 @@
-/**
- * Auto-mode Prompt Builders — construct dispatch prompts for each unit type.
- *
- * Pure async functions that load templates and inline file content. No module-level
- * state, no globals — every dependency is passed as a parameter or imported as a
- * utility.
- */
-
-import { loadFile, parseContinue, parsePlan, parseRoadmap, parseSummary, extractUatType, loadActiveOverrides, formatOverridesSection } from "./files.js";
-import type { Override, UatType } from "./files.js";
-import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
-import {
-  resolveMilestoneFile, resolveSliceFile, resolveSlicePath,
-  resolveTasksDir, resolveTaskFiles, resolveTaskFile,
-  relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath,
-  resolveGsdRootFile, relGsdRootFile,
-} from "./paths.js";
-import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
-import type { GSDState, InlineLevel } from "./types.js";
-import type { GSDPreferences } from "./preferences.js";
-import { join } from "node:path";
-import { existsSync } from "node:fs";
-import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
-import { compressToTarget } from "./prompt-compressor.js";
-import { distillSummaries } from "./summary-distiller.js";
-import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
-import { chunkByRelevance, formatChunks } from "./semantic-chunker.js";
-
-// ─── Executor Constraints ─────────────────────────────────────────────────────
-
-/**
- * Format executor context constraints for injection into the plan-slice prompt.
- * Uses the budget engine to compute task count ranges and inline context budgets
- * based on the configured executor model's context window.
- */
-function formatExecutorConstraints(): string {
-  let windowTokens: number;
-  try {
-    const prefs = loadEffectiveGSDPreferences();
-    windowTokens = resolveExecutorContextWindow(undefined, prefs?.preferences);
-  } catch {
-    windowTokens = 200_000; // safe default
-  }
-  const budgets = computeBudgets(windowTokens);
-  const { min, max } = budgets.taskCountRange;
-  const execWindowK = Math.round(windowTokens / 1000);
-  const perTaskBudgetK = Math.round(budgets.inlineContextBudgetChars / 1000);
-  return [
-    `## Executor Context Constraints`,
-    ``,
-    `The agent that executes each task has a **${execWindowK}K token** context window.`,
-    `- Recommended task count for this slice: **${min}–${max} tasks**`,
-    `- Each task gets ~${perTaskBudgetK}K chars of inline context (plans, code, decisions)`,
-    `- Keep individual tasks completable within a single context window — if a task needs more context than fits, split it`,
-  ].join("\n");
-}
-
-// ─── Inline Helpers ───────────────────────────────────────────────────────
-
-/**
- * Load a file and format it for inlining into a prompt.
- * Returns the content wrapped with a source path header, or a fallback
- * message if the file doesn't exist. This eliminates tool calls — the LLM
- * gets the content directly instead of "Read this file:".
- */
-export async function inlineFile(
-  absPath: string | null, relPath: string, label: string,
-): Promise<string> {
-  const content = absPath ? await loadFile(absPath) : null;
-  if (!content) {
-    return `### ${label}\nSource: \`${relPath}\`\n\n_(not found — file does not exist yet)_`;
-  }
-  return `### ${label}\nSource: \`${relPath}\`\n\n${content.trim()}`;
-}
-
-/**
- * Load a file for inlining, returning null if it doesn't exist.
- * Use when the file is optional and should be omitted entirely if absent.
- */
-export async function inlineFileOptional(
-  absPath: string | null, relPath: string, label: string,
-): Promise<string | null> {
-  const content = absPath ? await loadFile(absPath) : null;
-  if (!content) return null;
-  return `### ${label}\nSource: \`${relPath}\`\n\n${content.trim()}`;
-}
-
-/**
- * Smart file inlining — for large files, use semantic chunking to include
- * only the most relevant portions based on the task context.
- * Falls back to full content for small files or when no query is provided.
- *
- * @param absPath Absolute file path
- * @param relPath Relative display path
- * @param label Section label
- * @param query Task description for relevance scoring (optional)
- * @param threshold Character threshold for chunking (default: 3000)
- */
-export async function inlineFileSmart(
-  absPath: string | null, relPath: string, label: string,
-  query?: string, threshold = 3000,
-): Promise<string> {
-  const content = absPath ? await loadFile(absPath) : null;
-  if (!content) {
-    return `### ${label}\nSource: \`${relPath}\`\n\n_(not found — file does not exist yet)_`;
-  }
-
-  // For small files or no query, include full content
-  if (content.length <= threshold || !query) {
-    return `### ${label}\nSource: \`${relPath}\`\n\n${content.trim()}`;
-  }
-
-  // Use semantic chunking for large files
-  const result = chunkByRelevance(content, query, { maxChunks: 5, minScore: 0.05 });
-
-  // If chunking didn't save much (< 20%), just include full content
-  if (result.savingsPercent < 20) {
-    return `### ${label}\nSource: \`${relPath}\`\n\n${content.trim()}`;
-  }
-
-  const formatted = formatChunks(result, relPath);
-  return `### ${label} (${result.omittedChunks} sections omitted for relevance)\nSource: \`${relPath}\`\n\n${formatted}`;
-}
-
-/**
- * Load and inline dependency slice summaries (full content, not just paths).
- */
-export async function inlineDependencySummaries(
-  mid: string, sid: string, base: string, budgetChars?: number,
-): Promise<string> {
-  const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-  const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-  if (!roadmapContent) return "- (no dependencies)";
-
-  const roadmap = parseRoadmap(roadmapContent);
-  const sliceEntry = roadmap.slices.find(s => s.id === sid);
-  if (!sliceEntry || sliceEntry.depends.length === 0) return "- (no dependencies)";
-
-  const sections: string[] = [];
-  const seen = new Set<string>();
-  for (const dep of sliceEntry.depends) {
-    if (seen.has(dep)) continue;
-    seen.add(dep);
-    const summaryFile = resolveSliceFile(base, mid, dep, "SUMMARY");
-    const summaryContent = summaryFile ? await loadFile(summaryFile) : null;
-    const relPath = relSliceFile(base, mid, dep, "SUMMARY");
-    if (summaryContent) {
-      sections.push(`#### ${dep} Summary\nSource: \`${relPath}\`\n\n${summaryContent.trim()}`);
-    } else {
-      sections.push(`- \`${relPath}\` _(not found)_`);
-    }
-  }
-
-  const result = sections.join("\n\n");
-  if (budgetChars !== undefined && result.length > budgetChars) {
-    // For 3+ summaries, try distillation first (preserves more information)
-    if (sections.length >= 3) {
-      const rawSummaries = sections.map(s => {
-        // Extract content after the header line
-        const lines = s.split("\n");
-        const contentStart = lines.findIndex(l => l.startsWith("Source:"));
-        return contentStart >= 0 ? lines.slice(contentStart + 1).join("\n").trim() : s;
-      });
-      const distilled = distillSummaries(rawSummaries, budgetChars);
-      if (distilled.content.length <= budgetChars) {
-        return distilled.content;
-      }
-    }
-    // Fall back to section-boundary truncation
-    const { truncateAtSectionBoundary } = await import("./context-budget.js");
-    return truncateAtSectionBoundary(result, budgetChars).content;
-  }
-  return result;
-}
-
-/**
- * Load a well-known .gsd/ root file for optional inlining.
- * Handles the existsSync check internally.
- */
-export async function inlineGsdRootFile(
-  base: string, filename: string, label: string,
-): Promise<string | null> {
-  const key = filename.replace(/\.md$/i, "").toUpperCase() as "PROJECT" | "DECISIONS" | "QUEUE" | "STATE" | "REQUIREMENTS" | "KNOWLEDGE";
-  const absPath = resolveGsdRootFile(base, key);
-  if (!existsSync(absPath)) return null;
-  return inlineFileOptional(absPath, relGsdRootFile(key), label);
-}
-
-// ─── DB-Aware Inline Helpers ──────────────────────────────────────────────
-
-/**
- * Shared DB-fallback pattern: attempt a DB query via the context-store, format
- * the result, and fall back to the filesystem file when the DB is unavailable
- * or the query yields no results.
- *
- * @param base       Project root for filesystem fallback
- * @param label      Section heading (e.g. "Decisions")
- * @param filename   Filesystem fallback file (e.g. "decisions.md")
- * @param queryDb    Async callback receiving the dynamically-imported
- *                   context-store module. Returns formatted markdown or null.
- */
-async function inlineFromDbOrFile(
-  base: string,
-  label: string,
-  filename: string,
-  queryDb: (cs: typeof import("./context-store.js")) => string | null,
-): Promise<string | null> {
-  try {
-    const { isDbAvailable } = await import("./gsd-db.js");
-    if (isDbAvailable()) {
-      const contextStore = await import("./context-store.js");
-      const content = queryDb(contextStore);
-      if (content) {
-        return `### ${label}\nSource: \`.gsd/${filename.toUpperCase().replace(/\.MD$/i, "")}.md\`\n\n${content}`;
-      }
-    }
-  } catch {
-    // DB not available — fall through to filesystem
-  }
-  return inlineGsdRootFile(base, filename, label);
-}
-
-/**
- * Inline decisions with optional milestone scoping from the DB.
- * Falls back to filesystem via inlineGsdRootFile when DB unavailable or empty.
- */
-export async function inlineDecisionsFromDb(
-  base: string, milestoneId?: string, scope?: string, level?: InlineLevel,
-): Promise<string | null> {
-  const inlineLevel = level ?? resolveInlineLevel();
-  return inlineFromDbOrFile(base, "Decisions", "decisions.md", (cs) => {
-    const decisions = cs.queryDecisions({ milestoneId, scope });
-    if (decisions.length === 0) return null;
-    return inlineLevel !== "full"
-      ? formatDecisionsCompact(decisions)
-      : cs.formatDecisionsForPrompt(decisions);
-  });
-}
-
-/**
- * Inline requirements with optional slice scoping from the DB.
- * Falls back to filesystem via inlineGsdRootFile when DB unavailable or empty.
- */
-export async function inlineRequirementsFromDb(
-  base: string, sliceId?: string, level?: InlineLevel,
-): Promise<string | null> {
-  const inlineLevel = level ?? resolveInlineLevel();
-  return inlineFromDbOrFile(base, "Requirements", "requirements.md", (cs) => {
-    const requirements = cs.queryRequirements({ sliceId });
-    if (requirements.length === 0) return null;
-    return inlineLevel !== "full"
-      ? formatRequirementsCompact(requirements)
-      : cs.formatRequirementsForPrompt(requirements);
-  });
-}
-
-/**
- * Inline project context from the DB.
- * Falls back to filesystem via inlineGsdRootFile when DB unavailable or empty.
- */
-export async function inlineProjectFromDb(
-  base: string,
-): Promise<string | null> {
-  return inlineFromDbOrFile(base, "Project", "project.md", (cs) => {
-    return cs.queryProject();
-  });
-}
-
-// ─── Skill Discovery ──────────────────────────────────────────────────────
-
-/**
- * Build the skill discovery template variables for research prompts.
- * Returns { skillDiscoveryMode, skillDiscoveryInstructions } for template substitution.
- */
-export function buildSkillDiscoveryVars(): { skillDiscoveryMode: string; skillDiscoveryInstructions: string } {
-  const mode = resolveSkillDiscoveryMode();
-
-  if (mode === "off") {
-    return {
-      skillDiscoveryMode: "off",
-      skillDiscoveryInstructions: " Skill discovery is disabled. Skip this step.",
-    };
-  }
-
-  const autoInstall = mode === "auto";
-  const instructions = `
-   Identify the key technologies, frameworks, and services this work depends on (e.g. Stripe, Clerk, Supabase, JUCE, SwiftUI).
-   For each, check if a professional agent skill already exists:
-   - First check \`<available_skills>\` in your system prompt — a skill may already be installed.
-   - For technologies without an installed skill, run: \`npx skills find "<technology>"\`
-   - Only consider skills that are **directly relevant** to core technologies — not tangentially related.
-   - Evaluate results by install count and relevance to the actual work.${autoInstall
-    ? `
-   - Install relevant skills: \`npx skills add <owner/repo@skill> -g -y\`
-   - Record installed skills in the "Skills Discovered" section of your research output.
-   - Installed skills will automatically appear in subsequent units' system prompts — no manual steps needed.`
-    : `
-   - Note promising skills in your research output with their install commands, but do NOT install them.
-   - The user will decide which to install.`
-  }`;
-
-  return {
-    skillDiscoveryMode: mode,
-    skillDiscoveryInstructions: instructions,
-  };
-}
-
-// ─── Text Helpers ──────────────────────────────────────────────────────────
-
-export function extractMarkdownSection(content: string, heading: string): string | null {
-  const match = new RegExp(`^## ${escapeRegExp(heading)}\\s*$`, "m").exec(content);
-  if (!match) return null;
-
-  const start = match.index + match[0].length;
-  const rest = content.slice(start);
-  const nextHeading = rest.match(/^##\s+/m);
-  const end = nextHeading?.index ?? rest.length;
-  return rest.slice(0, end).trim();
-}
-
-export function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function oneLine(text: string): string {
-  return text.replace(/\s+/g, " ").trim();
-}
-
-/** Build the standard inlined-context section used by all prompt builders. */
-function buildInlinedContextSection(inlined: string[]): string {
-  return `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
-}
-
-/** Build the formatted list of available GSD source files for planners to read on demand. */
-function buildSourceFileList(base: string, opts?: { includeProject?: boolean }): string {
-  const paths: string[] = [];
-  if (opts?.includeProject && existsSync(resolveGsdRootFile(base, "PROJECT")))
-    paths.push(`- **Project**: \`${relGsdRootFile("PROJECT")}\``);
-  if (existsSync(resolveGsdRootFile(base, "REQUIREMENTS")))
-    paths.push(`- **Requirements**: \`${relGsdRootFile("REQUIREMENTS")}\``);
-  if (existsSync(resolveGsdRootFile(base, "DECISIONS")))
-    paths.push(`- **Decisions**: \`${relGsdRootFile("DECISIONS")}\``);
-  if (paths.length === 0) {
-    const types = opts?.includeProject ? "project/requirements/decisions" : "requirements/decisions";
-    return `_No ${types} files found._`;
-  }
-  return paths.join("\n");
-}
-
-// ─── Section Builders ──────────────────────────────────────────────────────
-
-export function buildResumeSection(
-  continueContent: string | null,
-  legacyContinueContent: string | null,
-  continueRelPath: string,
-  legacyContinueRelPath: string | null,
-): string {
-  const resolvedContent = continueContent ?? legacyContinueContent;
-  const resolvedRelPath = continueContent ? continueRelPath : legacyContinueRelPath;
-
-  if (!resolvedContent || !resolvedRelPath) {
-    return ["## Resume State", "- No continue file present. Start from the top of the task plan."].join("\n");
-  }
-
-  const cont = parseContinue(resolvedContent);
-  const lines = [
-    "## Resume State",
-    `Source: \`${resolvedRelPath}\``,
-    `- Status: ${cont.frontmatter.status || "in_progress"}`,
-  ];
-
-  if (cont.frontmatter.step && cont.frontmatter.totalSteps) {
-    lines.push(`- Progress: step ${cont.frontmatter.step} of ${cont.frontmatter.totalSteps}`);
-  }
-  if (cont.completedWork) lines.push(`- Completed: ${oneLine(cont.completedWork)}`);
-  if (cont.remainingWork) lines.push(`- Remaining: ${oneLine(cont.remainingWork)}`);
-  if (cont.decisions) lines.push(`- Decisions: ${oneLine(cont.decisions)}`);
-  if (cont.nextAction) lines.push(`- Next action: ${oneLine(cont.nextAction)}`);
-
-  return lines.join("\n");
-}
-
-export async function buildCarryForwardSection(priorSummaryPaths: string[], base: string): Promise<string> {
-  if (priorSummaryPaths.length === 0) {
-    return ["## Carry-Forward Context", "- No prior task summaries in this slice."].join("\n");
-  }
-
-  const items = await Promise.all(priorSummaryPaths.map(async (relPath) => {
-    const absPath = join(base, relPath);
-    const content = await loadFile(absPath);
-    if (!content) return `- \`${relPath}\``;
-
-    const summary = parseSummary(content);
-    const provided = summary.frontmatter.provides.slice(0, 2).join("; ");
-    const decisions = summary.frontmatter.key_decisions.slice(0, 2).join("; ");
-    const patterns = summary.frontmatter.patterns_established.slice(0, 2).join("; ");
-    const keyFiles = summary.frontmatter.key_files.slice(0, 3).join("; ");
-    const diagnostics = extractMarkdownSection(content, "Diagnostics");
-
-    const parts = [summary.title || relPath];
-    if (summary.oneLiner) parts.push(summary.oneLiner);
-    if (provided) parts.push(`provides: ${provided}`);
-    if (decisions) parts.push(`decisions: ${decisions}`);
-    if (patterns) parts.push(`patterns: ${patterns}`);
-    if (keyFiles) parts.push(`key_files: ${keyFiles}`);
-    if (diagnostics) parts.push(`diagnostics: ${oneLine(diagnostics)}`);
-
-    return `- \`${relPath}\` — ${parts.join(" | ")}`;
-  }));
-
-  return ["## Carry-Forward Context", ...items].join("\n");
-}
-
-export function extractSliceExecutionExcerpt(content: string | null, relPath: string): string {
-  if (!content) {
-    return [
-      "## Slice Plan Excerpt",
-      `Slice plan not found at dispatch time. Read \`${relPath}\` before running slice-level verification.`,
-    ].join("\n");
-  }
-
-  const lines = content.split("\n");
-  const goalLine = lines.find(l => l.startsWith("**Goal:**"))?.trim();
-  const demoLine = lines.find(l => l.startsWith("**Demo:**"))?.trim();
-
-  const verification = extractMarkdownSection(content, "Verification");
-  const observability = extractMarkdownSection(content, "Observability / Diagnostics");
-
-  const parts = ["## Slice Plan Excerpt", `Source: \`${relPath}\``];
-  if (goalLine) parts.push(goalLine);
-  if (demoLine) parts.push(demoLine);
-  if (verification) {
-    parts.push("", "### Slice Verification", verification.trim());
-  }
-  if (observability) {
-    parts.push("", "### Slice Observability / Diagnostics", observability.trim());
-  }
-
-  return parts.join("\n");
-}
-
-// ─── Prior Task Summaries ──────────────────────────────────────────────────
-
-export async function getPriorTaskSummaryPaths(
-  mid: string, sid: string, currentTid: string, base: string,
-): Promise<string[]> {
-  const tDir = resolveTasksDir(base, mid, sid);
-  if (!tDir) return [];
-
-  const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
-  const currentNum = parseInt(currentTid.replace(/^T/, ""), 10);
-  const sRel = relSlicePath(base, mid, sid);
-
-  return summaryFiles
-    .filter(f => {
-      const num = parseInt(f.replace(/^T/, ""), 10);
-      return num < currentNum;
-    })
-    .map(f => `${sRel}/tasks/${f}`);
-}
-
-// ─── Adaptive Replanning Checks ────────────────────────────────────────────
-
-/**
- * Check if the most recently completed slice needs reassessment.
- * Returns { sliceId } if reassessment is needed, null otherwise.
- *
- * Skips reassessment when:
- * - No roadmap exists yet
- * - No slices are completed
- * - The last completed slice already has an assessment file
- * - All slices are complete (milestone done — no point reassessing)
- */
-export async function checkNeedsReassessment(
-  base: string, mid: string, state: GSDState,
-): Promise<{ sliceId: string } | null> {
-  const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-  const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-  if (!roadmapContent) return null;
-
-  const roadmap = parseRoadmap(roadmapContent);
-  const completedSlices = roadmap.slices.filter(s => s.done);
-  const incompleteSlices = roadmap.slices.filter(s => !s.done);
-
-  // No completed slices or all slices done — skip
-  if (completedSlices.length === 0 || incompleteSlices.length === 0) return null;
-
-  // Check the last completed slice
-  const lastCompleted = completedSlices[completedSlices.length - 1];
-  const assessmentFile = resolveSliceFile(base, mid, lastCompleted.id, "ASSESSMENT");
-  const hasAssessment = !!(assessmentFile && await loadFile(assessmentFile));
-
-  if (hasAssessment) return null;
-
-  // Fallback: check the expected path directly via existsSync.
-  // resolveSliceFile relies on directory listing (readdirSync) which may not
-  // reflect a freshly written file in git worktree directories on some
-  // filesystems (observed on macOS APFS). A direct existsSync on the
-  // constructed path bypasses directory listing entirely. (#1112)
-  const sliceDir = resolveSlicePath(base, mid, lastCompleted.id);
-  if (sliceDir) {
-    const directPath = join(sliceDir, `${lastCompleted.id}-ASSESSMENT.md`);
-    if (existsSync(directPath)) return null;
-  }
-
-  // Also need a summary to reassess against
-  const summaryFile = resolveSliceFile(base, mid, lastCompleted.id, "SUMMARY");
-  const hasSummary = !!(summaryFile && await loadFile(summaryFile));
-
-  if (!hasSummary) return null;
-
-  return { sliceId: lastCompleted.id };
-}
-
-/**
- * Check if the most recently completed slice needs a UAT run.
- * Returns { sliceId, uatType } if UAT should be dispatched, null otherwise.
- *
- * Skips when:
- * - No roadmap or no completed slices
- * - All slices are done (milestone complete path — reassessment handles it)
- * - uat_dispatch preference is not enabled
- * - No UAT file exists for the slice
- * - UAT result file already exists (idempotent — already ran)
- */
-export async function checkNeedsRunUat(
-  base: string, mid: string, state: GSDState, prefs: GSDPreferences | undefined,
-): Promise<{ sliceId: string; uatType: UatType } | null> {
-  const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-  const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-  if (!roadmapContent) return null;
-
-  const roadmap = parseRoadmap(roadmapContent);
-  const completedSlices = roadmap.slices.filter(s => s.done);
-  const incompleteSlices = roadmap.slices.filter(s => !s.done);
-
-  // No completed slices — nothing to UAT yet
-  if (completedSlices.length === 0) return null;
-
-  // All slices done — milestone complete path, skip (reassessment handles)
-  if (incompleteSlices.length === 0) return null;
-
-  // uat_dispatch must be opted in
-  if (!prefs?.uat_dispatch) return null;
-
-  // Take the last completed slice
-  const lastCompleted = completedSlices[completedSlices.length - 1];
-  const sid = lastCompleted.id;
-
-  // UAT file must exist
-  const uatFile = resolveSliceFile(base, mid, sid, "UAT");
-  if (!uatFile) return null;
-  const uatContent = await loadFile(uatFile);
-  if (!uatContent) return null;
-
-  // If a UAT result already exists, the UAT unit has already run and must not
-  // be re-dispatched. PASS means progression can continue; any non-PASS verdict
-  // must be handled by the dispatch table's verdict gate, which stops progression
-  // with a human-action message instead of replaying the same run-uat unit.
-  const uatResultFile = resolveSliceFile(base, mid, sid, "UAT-RESULT");
-  if (uatResultFile) {
-    const resultContent = await loadFile(uatResultFile);
-    if (resultContent) return null;
-  }
-
-  // Classify UAT type; skip non-artifact-driven types — auto-mode can only
-  // execute mechanical checks. Non-artifact UATs are tracked in the dashboard
-  // but don't block auto-mode progression.
-  const uatType = extractUatType(uatContent) ?? "human-experience";
-  if (uatType !== "artifact-driven") return null;
-
-  return { sliceId: sid, uatType };
-}
-
-// ─── Prompt Builders ──────────────────────────────────────────────────────
-
-export async function buildResearchMilestonePrompt(mid: string, midTitle: string, base: string): Promise<string> {
-  const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
-  const contextRel = relMilestoneFile(base, mid, "CONTEXT");
-
-  const inlined: string[] = [];
-  inlined.push(await inlineFile(contextPath, contextRel, "Milestone Context"));
-  const projectInline = await inlineProjectFromDb(base);
-  if (projectInline) inlined.push(projectInline);
-  const requirementsInline = await inlineRequirementsFromDb(base);
-  if (requirementsInline) inlined.push(requirementsInline);
-  const decisionsInline = await inlineDecisionsFromDb(base, mid);
-  if (decisionsInline) inlined.push(decisionsInline);
-  const knowledgeInlineRM = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
-  if (knowledgeInlineRM) inlined.push(knowledgeInlineRM);
-  inlined.push(inlineTemplate("research", "Research"));
-
-  const inlinedContext = buildInlinedContextSection(inlined);
-
-  const outputRelPath = relMilestoneFile(base, mid, "RESEARCH");
-  return loadPrompt("research-milestone", {
-    workingDirectory: base,
-    milestoneId: mid, milestoneTitle: midTitle,
-    milestonePath: relMilestonePath(base, mid),
-    contextPath: contextRel,
-    outputPath: join(base, outputRelPath),
-    inlinedContext,
-    ...buildSkillDiscoveryVars(),
-  });
-}
-
-export async function buildPlanMilestonePrompt(mid: string, midTitle: string, base: string, level?: InlineLevel): Promise<string> {
-  const inlineLevel = level ?? resolveInlineLevel();
-  const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
-  const contextRel = relMilestoneFile(base, mid, "CONTEXT");
-  const researchPath = resolveMilestoneFile(base, mid, "RESEARCH");
-  const researchRel = relMilestoneFile(base, mid, "RESEARCH");
-
-  const inlined: string[] = [];
-  inlined.push(await inlineFile(contextPath, contextRel, "Milestone Context"));
-  const researchInline = await inlineFileOptional(researchPath, researchRel, "Milestone Research");
-  if (researchInline) inlined.push(researchInline);
-  const { inlinePriorMilestoneSummary } = await import("./files.js");
-  const priorSummaryInline = await inlinePriorMilestoneSummary(mid, base);
-  if (priorSummaryInline) inlined.push(priorSummaryInline);
-  const sourceFilePaths = buildSourceFileList(base, { includeProject: true });
-
-  const knowledgeInlinePM = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
-  if (knowledgeInlinePM) inlined.push(knowledgeInlinePM);
-  inlined.push(inlineTemplate("roadmap", "Roadmap"));
-  if (inlineLevel === "full") {
-    inlined.push(inlineTemplate("decisions", "Decisions"));
-    inlined.push(inlineTemplate("plan", "Slice Plan"));
-    inlined.push(inlineTemplate("task-plan", "Task Plan"));
-    inlined.push(inlineTemplate("secrets-manifest", "Secrets Manifest"));
-  } else if (inlineLevel === "standard") {
-    inlined.push(inlineTemplate("decisions", "Decisions"));
-    inlined.push(inlineTemplate("plan", "Slice Plan"));
-    inlined.push(inlineTemplate("task-plan", "Task Plan"));
-  }
-
-  const inlinedContext = buildInlinedContextSection(inlined);
-
-  const outputRelPath = relMilestoneFile(base, mid, "ROADMAP");
-  const secretsOutputPath = join(base, relMilestoneFile(base, mid, "SECRETS"));
-  const researchOutputRelPath = relMilestoneFile(base, mid, "RESEARCH");
-  return loadPrompt("plan-milestone", {
-    workingDirectory: base,
-    milestoneId: mid, milestoneTitle: midTitle,
-    milestonePath: relMilestonePath(base, mid),
-    contextPath: contextRel,
-    researchPath: researchRel,
-    outputPath: join(base, outputRelPath),
-    secretsOutputPath,
-    inlinedContext,
-    sourceFilePaths,
-    researchOutputPath: join(base, researchOutputRelPath),
-    ...buildSkillDiscoveryVars(),
-  });
-}
-
-export async function buildResearchSlicePrompt(
-  mid: string, _midTitle: string, sid: string, sTitle: string, base: string,
-): Promise<string> {
-  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
-  const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
-  const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
-  const contextRel = relMilestoneFile(base, mid, "CONTEXT");
-  const milestoneResearchPath = resolveMilestoneFile(base, mid, "RESEARCH");
-  const milestoneResearchRel = relMilestoneFile(base, mid, "RESEARCH");
-
-  const inlined: string[] = [];
-  inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
-  const contextInline = await inlineFileOptional(contextPath, contextRel, "Milestone Context");
-  if (contextInline) inlined.push(contextInline);
-  const researchInline = await inlineFileOptional(milestoneResearchPath, milestoneResearchRel, "Milestone Research");
-  if (researchInline) inlined.push(researchInline);
-  const decisionsInline = await inlineDecisionsFromDb(base, mid);
-  if (decisionsInline) inlined.push(decisionsInline);
-  const requirementsInline = await inlineRequirementsFromDb(base, sid);
-  if (requirementsInline) inlined.push(requirementsInline);
-  const knowledgeInlineRS = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
-  if (knowledgeInlineRS) inlined.push(knowledgeInlineRS);
-  inlined.push(inlineTemplate("research", "Research"));
-
-  const depContent = await inlineDependencySummaries(mid, sid, base);
-  const activeOverrides = await loadActiveOverrides(base);
-  const overridesInline = formatOverridesSection(activeOverrides);
-  if (overridesInline) inlined.unshift(overridesInline);
-
-  const inlinedContext = buildInlinedContextSection(inlined);
-
-  const outputRelPath = relSliceFile(base, mid, sid, "RESEARCH");
-  return loadPrompt("research-slice", {
-    workingDirectory: base,
-    milestoneId: mid, sliceId: sid, sliceTitle: sTitle,
-    slicePath: relSlicePath(base, mid, sid),
-    roadmapPath: roadmapRel,
-    contextPath: contextRel,
-    milestoneResearchPath: milestoneResearchRel,
-    outputPath: join(base, outputRelPath),
-    inlinedContext,
-    dependencySummaries: depContent,
-    ...buildSkillDiscoveryVars(),
-  });
-}
-
-export async function buildPlanSlicePrompt(
-  mid: string, _midTitle: string, sid: string, sTitle: string, base: string, level?: InlineLevel,
-): Promise<string> {
-  const inlineLevel = level ?? resolveInlineLevel();
-  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
-  const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
-  const researchPath = resolveSliceFile(base, mid, sid, "RESEARCH");
-  const researchRel = relSliceFile(base, mid, sid, "RESEARCH");
-
-  const inlined: string[] = [];
-  inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
-  const researchInline = await inlineFileOptional(researchPath, researchRel, "Slice Research");
-  if (researchInline) inlined.push(researchInline);
-  const sliceSourceFilePaths = buildSourceFileList(base);
-
-  const knowledgeInlinePS = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
-  if (knowledgeInlinePS) inlined.push(knowledgeInlinePS);
-  inlined.push(inlineTemplate("plan", "Slice Plan"));
-  if (inlineLevel === "full") {
-    inlined.push(inlineTemplate("task-plan", "Task Plan"));
-  }
-
-  const depContent = await inlineDependencySummaries(mid, sid, base);
-  const planActiveOverrides = await loadActiveOverrides(base);
-  const planOverridesInline = formatOverridesSection(planActiveOverrides);
-  if (planOverridesInline) inlined.unshift(planOverridesInline);
-
-  const inlinedContext = buildInlinedContextSection(inlined);
-
-  // Build executor context constraints from the budget engine
-  const executorContextConstraints = formatExecutorConstraints();
-
-  const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
-  const commitInstruction = "Do not commit planning artifacts — .gsd/ is managed externally.";
-  return loadPrompt("plan-slice", {
-    workingDirectory: base,
-    milestoneId: mid, sliceId: sid, sliceTitle: sTitle,
-    slicePath: relSlicePath(base, mid, sid),
-    roadmapPath: roadmapRel,
-    researchPath: researchRel,
-    outputPath: join(base, outputRelPath),
-    inlinedContext,
-    dependencySummaries: depContent,
-    executorContextConstraints,
-    commitInstruction,
-    sourceFilePaths: sliceSourceFilePaths,
-  });
-}
-
-export async function buildExecuteTaskPrompt(
-  mid: string, sid: string, sTitle: string,
-  tid: string, tTitle: string, base: string, level?: InlineLevel,
-): Promise<string> {
-  const inlineLevel = level ?? resolveInlineLevel();
-
-  const priorSummaries = await getPriorTaskSummaryPaths(mid, sid, tid, base);
-  const priorLines = priorSummaries.length > 0
-    ? priorSummaries.map(p => `- \`${p}\``).join("\n")
-    : "- (no prior tasks)";
-
-  const taskPlanPath = resolveTaskFile(base, mid, sid, tid, "PLAN");
-  const taskPlanContent = taskPlanPath ? await loadFile(taskPlanPath) : null;
-  const taskPlanRelPath = relSlicePath(base, mid, sid) + `/tasks/${tid}-PLAN.md`;
-  const taskPlanInline = taskPlanContent
-    ? [
-      "## Inlined Task Plan (authoritative local execution contract)",
-      `Source: \`${taskPlanRelPath}\``,
-      "",
-      taskPlanContent.trim(),
-    ].join("\n")
-    : [
-      "## Inlined Task Plan (authoritative local execution contract)",
-      `Task plan not found at dispatch time. Read \`${taskPlanRelPath}\` before executing.`,
-    ].join("\n");
-
-  const slicePlanPath = resolveSliceFile(base, mid, sid, "PLAN");
-  const slicePlanContent = slicePlanPath ? await loadFile(slicePlanPath) : null;
-  const slicePlanExcerpt = extractSliceExecutionExcerpt(slicePlanContent, relSliceFile(base, mid, sid, "PLAN"));
-
-  // Check for continue file (new naming or legacy)
-  const continueFile = resolveSliceFile(base, mid, sid, "CONTINUE");
-  const legacyContinueDir = resolveSlicePath(base, mid, sid);
-  const legacyContinuePath = legacyContinueDir ? join(legacyContinueDir, "continue.md") : null;
-  const continueContent = continueFile ? await loadFile(continueFile) : null;
-  const legacyContinueContent = !continueContent && legacyContinuePath ? await loadFile(legacyContinuePath) : null;
-  const continueRelPath = relSliceFile(base, mid, sid, "CONTINUE");
-  const resumeSection = buildResumeSection(
-    continueContent,
-    legacyContinueContent,
-    continueRelPath,
-    legacyContinuePath ? `${relSlicePath(base, mid, sid)}/continue.md` : null,
-  );
-
-  // For minimal inline level, only carry forward the most recent prior summary
-  const effectivePriorSummaries = inlineLevel === "minimal" && priorSummaries.length > 1
-    ? priorSummaries.slice(-1)
-    : priorSummaries;
-  const carryForwardSection = await buildCarryForwardSection(effectivePriorSummaries, base);
-
-  // Inline project knowledge if available (smart-chunked for relevance)
-  const knowledgeAbsPath = resolveGsdRootFile(base, "KNOWLEDGE");
-  const knowledgeInlineET = existsSync(knowledgeAbsPath)
-    ? await inlineFileSmart(
-        knowledgeAbsPath,
-        relGsdRootFile("KNOWLEDGE"),
-        "Project Knowledge",
-        `${tTitle} ${sTitle}`,  // use task + slice title as relevance query
-      )
-    : null;
-  // Only include if it has content (not a "not found" result)
-  const knowledgeContent = knowledgeInlineET && !knowledgeInlineET.includes("not found") ? knowledgeInlineET : null;
-
-  const inlinedTemplates = inlineLevel === "minimal"
-    ? inlineTemplate("task-summary", "Task Summary")
-    : [
-        inlineTemplate("task-summary", "Task Summary"),
-        inlineTemplate("decisions", "Decisions"),
-        ...(knowledgeContent ? [knowledgeContent] : []),
-      ].join("\n\n---\n\n");
-
-  const taskSummaryPath = join(base, `${relSlicePath(base, mid, sid)}/tasks/${tid}-SUMMARY.md`);
-
-  const activeOverrides = await loadActiveOverrides(base);
-  const overridesSection = formatOverridesSection(activeOverrides);
-
-  // Compute verification budget for the executor's context window (issue #707)
-  const prefs = loadEffectiveGSDPreferences();
-  const contextWindow = resolveExecutorContextWindow(undefined, prefs?.preferences);
-  const budgets = computeBudgets(contextWindow);
-  const verificationBudget = `~${Math.round(budgets.verificationBudgetChars / 1000)}K chars`;
-
-  // Compress carry-forward section when it exceeds 40% of inline context budget.
-  // Only compress when compression_strategy is "compress" (budget/balanced profiles).
-  const carryForwardBudget = Math.floor(budgets.inlineContextBudgetChars * 0.4);
-  let finalCarryForward = carryForwardSection;
-  if (carryForwardSection.length > carryForwardBudget) {
-    const { resolveCompressionStrategy } = await import("./preferences.js");
-    if (resolveCompressionStrategy() === "compress") {
-      finalCarryForward = compressToTarget(carryForwardSection, carryForwardBudget).content;
-    }
-  }
-
-  return loadPrompt("execute-task", {
-    overridesSection,
-    workingDirectory: base,
-    milestoneId: mid, sliceId: sid, sliceTitle: sTitle, taskId: tid, taskTitle: tTitle,
-    planPath: join(base, relSliceFile(base, mid, sid, "PLAN")),
-    slicePath: relSlicePath(base, mid, sid),
-    taskPlanPath: taskPlanRelPath,
-    taskPlanInline,
-    slicePlanExcerpt,
-    carryForwardSection: finalCarryForward,
-    resumeSection,
-    priorTaskLines: priorLines,
-    taskSummaryPath,
-    inlinedTemplates,
-    verificationBudget,
-  });
-}
-
-export async function buildCompleteSlicePrompt(
-  mid: string, _midTitle: string, sid: string, sTitle: string, base: string, level?: InlineLevel,
-): Promise<string> {
-  const inlineLevel = level ?? resolveInlineLevel();
-
-  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
-  const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
-  const slicePlanPath = resolveSliceFile(base, mid, sid, "PLAN");
-  const slicePlanRel = relSliceFile(base, mid, sid, "PLAN");
-
-  const inlined: string[] = [];
-  inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
-  inlined.push(await inlineFile(slicePlanPath, slicePlanRel, "Slice Plan"));
-  if (inlineLevel !== "minimal") {
-    const requirementsInline = await inlineRequirementsFromDb(base, sid, inlineLevel);
-    if (requirementsInline) inlined.push(requirementsInline);
-  }
-  const knowledgeInlineCS = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
-  if (knowledgeInlineCS) inlined.push(knowledgeInlineCS);
-
-  // Inline all task summaries for this slice
-  const tDir = resolveTasksDir(base, mid, sid);
-  if (tDir) {
-    const summaryFiles = resolveTaskFiles(tDir, "SUMMARY").sort();
-    for (const file of summaryFiles) {
-      const absPath = join(tDir, file);
-      const content = await loadFile(absPath);
-      const sRel = relSlicePath(base, mid, sid);
-      const relPath = `${sRel}/tasks/${file}`;
-      if (content) {
-        inlined.push(`### Task Summary: ${file.replace(/-SUMMARY\.md$/i, "")}\nSource: \`${relPath}\`\n\n${content.trim()}`);
-      }
-    }
-  }
-  inlined.push(inlineTemplate("slice-summary", "Slice Summary"));
-  if (inlineLevel !== "minimal") {
-    inlined.push(inlineTemplate("uat", "UAT"));
-  }
-  const completeActiveOverrides = await loadActiveOverrides(base);
-  const completeOverridesInline = formatOverridesSection(completeActiveOverrides);
-  if (completeOverridesInline) inlined.unshift(completeOverridesInline);
-
-  const inlinedContext = buildInlinedContextSection(inlined);
-
-  const sliceRel = relSlicePath(base, mid, sid);
-  const sliceSummaryPath = join(base, `${sliceRel}/${sid}-SUMMARY.md`);
-  const sliceUatPath = join(base, `${sliceRel}/${sid}-UAT.md`);
-
-  return loadPrompt("complete-slice", {
-    workingDirectory: base,
-    milestoneId: mid, sliceId: sid, sliceTitle: sTitle,
-    slicePath: sliceRel,
-    roadmapPath: join(base, roadmapRel),
-    inlinedContext,
-    sliceSummaryPath,
-    sliceUatPath,
-  });
-}
-
-export async function buildCompleteMilestonePrompt(
-  mid: string, midTitle: string, base: string, level?: InlineLevel,
-): Promise<string> {
-  const inlineLevel = level ?? resolveInlineLevel();
-  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
-  const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
-
-  const inlined: string[] = [];
-  inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
-
-  // Inline all slice summaries (deduplicated by slice ID)
-  const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-  if (roadmapContent) {
-    const roadmap = parseRoadmap(roadmapContent);
-    const seenSlices = new Set<string>();
-    for (const slice of roadmap.slices) {
-      if (seenSlices.has(slice.id)) continue;
-      seenSlices.add(slice.id);
-      const summaryPath = resolveSliceFile(base, mid, slice.id, "SUMMARY");
-      const summaryRel = relSliceFile(base, mid, slice.id, "SUMMARY");
-      inlined.push(await inlineFile(summaryPath, summaryRel, `${slice.id} Summary`));
-    }
-  }
-
-  // Inline root GSD files (skip for minimal — completion can read these if needed)
-  if (inlineLevel !== "minimal") {
-    const requirementsInline = await inlineRequirementsFromDb(base, undefined, inlineLevel);
-    if (requirementsInline) inlined.push(requirementsInline);
-    const decisionsInline = await inlineDecisionsFromDb(base, mid, undefined, inlineLevel);
-    if (decisionsInline) inlined.push(decisionsInline);
-    const projectInline = await inlineProjectFromDb(base);
-    if (projectInline) inlined.push(projectInline);
-  }
-  const knowledgeInlineCM = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
-  if (knowledgeInlineCM) inlined.push(knowledgeInlineCM);
-  // Inline milestone context file (milestone-level, not GSD root)
-  const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
-  const contextRel = relMilestoneFile(base, mid, "CONTEXT");
-  const contextInline = await inlineFileOptional(contextPath, contextRel, "Milestone Context");
-  if (contextInline) inlined.push(contextInline);
-  inlined.push(inlineTemplate("milestone-summary", "Milestone Summary"));
-
-  const inlinedContext = buildInlinedContextSection(inlined);
-
-  const milestoneSummaryPath = join(base, `${relMilestonePath(base, mid)}/${mid}-SUMMARY.md`);
-
-  return loadPrompt("complete-milestone", {
-    workingDirectory: base,
-    milestoneId: mid,
-    milestoneTitle: midTitle,
-    roadmapPath: roadmapRel,
-    inlinedContext,
-    milestoneSummaryPath,
-  });
-}
-
-export async function buildValidateMilestonePrompt(
-  mid: string, midTitle: string, base: string, level?: InlineLevel,
-): Promise<string> {
-  const inlineLevel = level ?? resolveInlineLevel();
-  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
-  const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
-
-  const inlined: string[] = [];
-  inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
-
-  // Inline all slice summaries and UAT results
-  const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-  if (roadmapContent) {
-    const roadmap = parseRoadmap(roadmapContent);
-    const seenSlices = new Set<string>();
-    for (const slice of roadmap.slices) {
-      if (seenSlices.has(slice.id)) continue;
-      seenSlices.add(slice.id);
-      const summaryPath = resolveSliceFile(base, mid, slice.id, "SUMMARY");
-      const summaryRel = relSliceFile(base, mid, slice.id, "SUMMARY");
-      inlined.push(await inlineFile(summaryPath, summaryRel, `${slice.id} Summary`));
-
-      const uatPath = resolveSliceFile(base, mid, slice.id, "UAT-RESULT");
-      const uatRel = relSliceFile(base, mid, slice.id, "UAT-RESULT");
-      const uatInline = await inlineFileOptional(uatPath, uatRel, `${slice.id} UAT Result`);
-      if (uatInline) inlined.push(uatInline);
-    }
-  }
-
-  // Inline existing VALIDATION file if this is a re-validation round
-  const validationPath = resolveMilestoneFile(base, mid, "VALIDATION");
-  const validationRel = relMilestoneFile(base, mid, "VALIDATION");
-  const validationContent = validationPath ? await loadFile(validationPath) : null;
-  let remediationRound = 0;
-  if (validationContent) {
-    const roundMatch = validationContent.match(/remediation_round:\s*(\d+)/);
-    remediationRound = roundMatch ? parseInt(roundMatch[1], 10) + 1 : 1;
-    inlined.push(`### Previous Validation (re-validation round ${remediationRound})\nSource: \`${validationRel}\`\n\n${validationContent.trim()}`);
-  }
-
-  // Inline root GSD files
-  if (inlineLevel !== "minimal") {
-    const requirementsInline = await inlineRequirementsFromDb(base, undefined, inlineLevel);
-    if (requirementsInline) inlined.push(requirementsInline);
-    const decisionsInline = await inlineDecisionsFromDb(base, mid, undefined, inlineLevel);
-    if (decisionsInline) inlined.push(decisionsInline);
-    const projectInline = await inlineProjectFromDb(base);
-    if (projectInline) inlined.push(projectInline);
-  }
-  const knowledgeInline = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
-  if (knowledgeInline) inlined.push(knowledgeInline);
-  // Inline milestone context file
-  const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
-  const contextRel = relMilestoneFile(base, mid, "CONTEXT");
-  const contextInline = await inlineFileOptional(contextPath, contextRel, "Milestone Context");
-  if (contextInline) inlined.push(contextInline);
-
-  const inlinedContext = buildInlinedContextSection(inlined);
-
-  const validationOutputPath = join(base, `${relMilestonePath(base, mid)}/${mid}-VALIDATION.md`);
-  const roadmapOutputPath = `${relMilestonePath(base, mid)}/${mid}-ROADMAP.md`;
-
-  return loadPrompt("validate-milestone", {
-    workingDirectory: base,
-    milestoneId: mid,
-    milestoneTitle: midTitle,
-    roadmapPath: roadmapOutputPath,
-    inlinedContext,
-    validationPath: validationOutputPath,
-    remediationRound: String(remediationRound),
-  });
-}
-
-export async function buildReplanSlicePrompt(
-  mid: string, midTitle: string, sid: string, sTitle: string, base: string,
-): Promise<string> {
-  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
-  const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
-  const slicePlanPath = resolveSliceFile(base, mid, sid, "PLAN");
-  const slicePlanRel = relSliceFile(base, mid, sid, "PLAN");
-
-  const inlined: string[] = [];
-  inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
-  inlined.push(await inlineFile(slicePlanPath, slicePlanRel, "Current Slice Plan"));
-
-  // Find the blocker task summary — the completed task with blocker_discovered: true
-  let blockerTaskId = "";
-  const tDir = resolveTasksDir(base, mid, sid);
-  if (tDir) {
-    const summaryFiles = resolveTaskFiles(tDir, "SUMMARY").sort();
-    for (const file of summaryFiles) {
-      const absPath = join(tDir, file);
-      const content = await loadFile(absPath);
-      if (!content) continue;
-      const summary = parseSummary(content);
-      const sRel = relSlicePath(base, mid, sid);
-      const relPath = `${sRel}/tasks/${file}`;
-      if (summary.frontmatter.blocker_discovered) {
-        blockerTaskId = summary.frontmatter.id || file.replace(/-SUMMARY\.md$/i, "");
-        inlined.push(`### Blocker Task Summary: ${blockerTaskId}\nSource: \`${relPath}\`\n\n${content.trim()}`);
-      }
-    }
-  }
-
-  // Inline decisions
-  const decisionsInline = await inlineDecisionsFromDb(base, mid);
-  if (decisionsInline) inlined.push(decisionsInline);
-  const replanActiveOverrides = await loadActiveOverrides(base);
-  const replanOverridesInline = formatOverridesSection(replanActiveOverrides);
-  if (replanOverridesInline) inlined.unshift(replanOverridesInline);
-
-  const inlinedContext = buildInlinedContextSection(inlined);
-
-  const replanPath = join(base, `${relSlicePath(base, mid, sid)}/${sid}-REPLAN.md`);
-
-  // Build capture context for replan prompt (captures that triggered this replan)
-  let captureContext = "(none)";
-  try {
-    const { loadReplanCaptures } = await import("./triage-resolution.js");
-    const replanCaptures = loadReplanCaptures(base);
-    if (replanCaptures.length > 0) {
-      captureContext = replanCaptures.map(c =>
-        `- **${c.id}**: "${c.text}" — ${c.rationale ?? "no rationale"}`
-      ).join("\n");
-    }
-  } catch {
-    // Non-fatal — captures module may not be available
-  }
-
-  return loadPrompt("replan-slice", {
-    workingDirectory: base,
-    milestoneId: mid,
-    sliceId: sid,
-    sliceTitle: sTitle,
-    slicePath: relSlicePath(base, mid, sid),
-    planPath: join(base, slicePlanRel),
-    blockerTaskId,
-    inlinedContext,
-    replanPath,
-    captureContext,
-  });
-}
-
-export async function buildRunUatPrompt(
-  mid: string, sliceId: string, uatPath: string, base: string,
-): Promise<string> {
-  const inlined: string[] = [];
-  inlined.push(await inlineFile(resolveSliceFile(base, mid, sliceId, "UAT"), uatPath, `${sliceId} UAT`));
-
-  const summaryPath = resolveSliceFile(base, mid, sliceId, "SUMMARY");
-  const summaryRel = relSliceFile(base, mid, sliceId, "SUMMARY");
-  if (summaryPath) {
-    const summaryInline = await inlineFileOptional(summaryPath, summaryRel, `${sliceId} Summary`);
-    if (summaryInline) inlined.push(summaryInline);
-  }
-
-  const projectInline = await inlineProjectFromDb(base);
-  if (projectInline) inlined.push(projectInline);
-
-  const inlinedContext = buildInlinedContextSection(inlined);
-
-  const uatResultPath = join(base, relSliceFile(base, mid, sliceId, "UAT-RESULT"));
-
-  return loadPrompt("run-uat", {
-    workingDirectory: base,
-    milestoneId: mid,
-    sliceId,
-    uatPath,
-    uatResultPath,
-    inlinedContext,
-  });
-}
-
-export async function buildReassessRoadmapPrompt(
-  mid: string, midTitle: string, completedSliceId: string, base: string, level?: InlineLevel,
-): Promise<string> {
-  const inlineLevel = level ?? resolveInlineLevel();
-  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
-  const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
-  const summaryPath = resolveSliceFile(base, mid, completedSliceId, "SUMMARY");
-  const summaryRel = relSliceFile(base, mid, completedSliceId, "SUMMARY");
-
-  const inlined: string[] = [];
-  inlined.push(await inlineFile(roadmapPath, roadmapRel, "Current Roadmap"));
-  inlined.push(await inlineFile(summaryPath, summaryRel, `${completedSliceId} Summary`));
-  if (inlineLevel !== "minimal") {
-    const projectInline = await inlineProjectFromDb(base);
-    if (projectInline) inlined.push(projectInline);
-    const requirementsInline = await inlineRequirementsFromDb(base, undefined, inlineLevel);
-    if (requirementsInline) inlined.push(requirementsInline);
-    const decisionsInline = await inlineDecisionsFromDb(base, mid, undefined, inlineLevel);
-    if (decisionsInline) inlined.push(decisionsInline);
-  }
-  const knowledgeInlineRA = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
-  if (knowledgeInlineRA) inlined.push(knowledgeInlineRA);
-
-  const inlinedContext = buildInlinedContextSection(inlined);
-
-  const assessmentPath = join(base, relSliceFile(base, mid, completedSliceId, "ASSESSMENT"));
-
-  // Build deferred captures context for reassess prompt
-  let deferredCaptures = "(none)";
-  try {
-    const { loadDeferredCaptures } = await import("./triage-resolution.js");
-    const deferred = loadDeferredCaptures(base);
-    if (deferred.length > 0) {
-      deferredCaptures = deferred.map(c =>
-        `- **${c.id}**: "${c.text}" — ${c.rationale ?? "deferred during triage"}`
-      ).join("\n");
-    }
-  } catch {
-    // Non-fatal — captures module may not be available
-  }
-
-  const reassessCommitInstruction = "Do not commit planning artifacts — .gsd/ is managed externally.";
-
-  return loadPrompt("reassess-roadmap", {
-    workingDirectory: base,
-    milestoneId: mid,
-    milestoneTitle: midTitle,
-    completedSliceId,
-    roadmapPath: roadmapRel,
-    completedSliceSummaryPath: summaryRel,
-    assessmentPath,
-    inlinedContext,
-    deferredCaptures,
-    commitInstruction: reassessCommitInstruction,
-  });
-}
-
-export async function buildRewriteDocsPrompt(
-  mid: string, midTitle: string,
-  activeSlice: { id: string; title: string } | null,
-  base: string,
-  overrides: Override[],
-): Promise<string> {
-  const sid = activeSlice?.id;
-  const sTitle = activeSlice?.title ?? "";
-  const docList: string[] = [];
-
-  if (sid) {
-    const slicePlanPath = resolveSliceFile(base, mid, sid, "PLAN");
-    const slicePlanRel = relSliceFile(base, mid, sid, "PLAN");
-    if (slicePlanPath) {
-      docList.push(`- Slice plan: \`${slicePlanRel}\``);
-      const tDir = resolveTasksDir(base, mid, sid);
-      if (tDir) {
-        const planContent = await loadFile(slicePlanPath);
-        if (planContent) {
-          const plan = parsePlan(planContent);
-          for (const task of plan.tasks) {
-            if (!task.done) {
-              const taskPlanPath = resolveTaskFile(base, mid, sid, task.id, "PLAN");
-              if (taskPlanPath) {
-                const taskRelPath = `${relSlicePath(base, mid, sid)}/tasks/${task.id}-PLAN.md`;
-                docList.push(`- Task plan: \`${taskRelPath}\``);
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  const decisionsPath = resolveGsdRootFile(base, "DECISIONS");
-  if (existsSync(decisionsPath)) docList.push(`- Decisions: \`${relGsdRootFile("DECISIONS")}\``);
-  const requirementsPath = resolveGsdRootFile(base, "REQUIREMENTS");
-  if (existsSync(requirementsPath)) docList.push(`- Requirements: \`${relGsdRootFile("REQUIREMENTS")}\``);
-  const projectPath = resolveGsdRootFile(base, "PROJECT");
-  if (existsSync(projectPath)) docList.push(`- Project: \`${relGsdRootFile("PROJECT")}\``);
-  const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
-  const contextRel = relMilestoneFile(base, mid, "CONTEXT");
-  if (contextPath) docList.push(`- Milestone context (reference only): \`${contextRel}\``);
-  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
-  const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
-  if (roadmapPath) docList.push(`- Roadmap: \`${roadmapRel}\``);
-
-  const overrideContent = overrides.map((o, i) => [
-    `### Override ${i + 1}`,
-    `**Change:** ${o.change}`,
-    `**Issued:** ${o.timestamp}`,
-    `**During:** ${o.appliedAt}`,
-  ].join("\n")).join("\n\n");
-
-  const documentList = docList.length > 0 ? docList.join("\n") : "- No active plan documents found.";
-
-  return loadPrompt("rewrite-docs", {
-    milestoneId: mid,
-    milestoneTitle: midTitle,
-    sliceId: sid ?? "none",
-    sliceTitle: sTitle,
-    overrideContent,
-    documentList,
-    overridesPath: relGsdRootFile("OVERRIDES"),
-  });
-}