@delfini/cli 0.1.0-rc.0

package/dist/chunk-UGNHP6L5.js

@@ -0,0 +1,1277 @@
+import {
+  ZodError,
+  analysisSchema,
+  buildPromptWithDrops,
+  classifyEntry,
+  estimatePromptTokens,
+  external_exports,
+  filterDiff,
+  init_esm_shims,
+  normalizeDocScope,
+  validateAndReconcile,
+  validateDocScopeEntry
+} from "./chunk-MUW24ZC4.js";
+
+// src/cli.ts
+init_esm_shims();
+import { readFileSync as readFileSync4 } from "fs";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { Command, CommanderError } from "commander";
+
+// src/commands/diff-status.ts
+init_esm_shims();
+import simpleGit2 from "simple-git";
+
+// src/git.ts
+init_esm_shims();
+import simpleGit from "simple-git";
+var RepoRootNotFoundError = class extends Error {
+  code = "REPO_ROOT_NOT_FOUND";
+  constructor(cause) {
+    super("not inside a git repository \u2014 Delfini requires a git checkout");
+    this.name = "RepoRootNotFoundError";
+    if (cause !== void 0) {
+      ;
+      this.cause = cause;
+    }
+  }
+};
+async function getRepoRoot(cwd) {
+  const baseDir = cwd ?? process.cwd();
+  const git = simpleGit({ baseDir });
+  try {
+    const raw = await git.revparse(["--show-toplevel"]);
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+      throw new RepoRootNotFoundError();
+    }
+    return trimmed;
+  } catch (err) {
+    if (err instanceof RepoRootNotFoundError) throw err;
+    throw new RepoRootNotFoundError(err);
+  }
+}
+async function getCurrentBranch(git) {
+  const raw = await git.revparse(["--abbrev-ref", "HEAD"]);
+  return raw.trim();
+}
+async function getDefaultBranch(git) {
+  try {
+    const raw = await git.raw(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]);
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("origin/")) {
+      return trimmed.slice("origin/".length);
+    }
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  } catch {
+  }
+  for (const name of ["main", "master"]) {
+    try {
+      await git.raw(["rev-parse", "--verify", "--quiet", `refs/heads/${name}`]);
+      return name;
+    } catch {
+    }
+  }
+  return "main";
+}
+var TRACE_DIR_PREFIX = ".delfini-trace/";
+async function listUntrackedFiles(git) {
+  const raw = await git.raw(["ls-files", "--others", "--exclude-standard", "-z"]);
+  return raw.split("\0").filter((line) => line.length > 0).filter((line) => !line.startsWith(TRACE_DIR_PREFIX));
+}
+async function hasUncommittedChanges(git) {
+  const diff = await git.diff(["HEAD"]);
+  if (diff.trim().length > 0) {
+    return true;
+  }
+  const untracked = await listUntrackedFiles(git);
+  return untracked.length > 0;
+}
+async function hasCommittedChangesAgainst(git, baseRef) {
+  const diff = await git.diff([baseRef, "HEAD"]);
+  return diff.trim().length > 0;
+}
+async function resolveBaseRef(git, explicitBase, stderr) {
+  if (explicitBase !== void 0 && explicitBase.length > 0) {
+    return explicitBase;
+  }
+  try {
+    const raw = await git.raw(["merge-base", "HEAD", "origin/main"]);
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+      stderr.write(
+        "\u26A0\uFE0F  Could not resolve `git merge-base HEAD origin/main` \u2014 diff base falling back to HEAD (empty diff).\n"
+      );
+      return "HEAD";
+    }
+    return trimmed;
+  } catch {
+    stderr.write(
+      "\u26A0\uFE0F  Could not resolve `git merge-base HEAD origin/main` \u2014 diff base falling back to HEAD (empty diff).\n"
+    );
+    return "HEAD";
+  }
+}
+
+// src/commands/diff-status.ts
+async function runDiffStatus(options = {}) {
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  let repoRoot;
+  try {
+    repoRoot = options.repoRoot ?? await getRepoRoot();
+  } catch (err) {
+    if (err instanceof RepoRootNotFoundError) {
+      stderr.write(`${err.message}
+`);
+    } else {
+      stderr.write(`diff-status failed: ${describeError(err)}
+`);
+    }
+    return 1;
+  }
+  try {
+    const git = simpleGit2({ baseDir: repoRoot });
+    const baseRef = await resolveBaseRef(git, options.base, stderr);
+    const branch = await getCurrentBranch(git);
+    const defaultBranch = await getDefaultBranch(git);
+    const isDefaultBranch = branch !== "HEAD" && branch === defaultBranch;
+    const hasLocalChanges = await hasUncommittedChanges(git);
+    const hasCommittedChanges = await hasCommittedChangesAgainst(git, baseRef);
+    const status = {
+      branch,
+      isDefaultBranch,
+      hasLocalChanges,
+      hasCommittedChanges
+    };
+    stdout.write(`${JSON.stringify(status)}
+`);
+    return 0;
+  } catch (err) {
+    stderr.write(`diff-status failed: ${describeError(err)}
+`);
+    return 1;
+  }
+}
+function describeError(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+
+// src/commands/install.ts
+init_esm_shims();
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join2, resolve } from "path";
+import { createInterface } from "readline/promises";
+import { fileURLToPath } from "url";
+
+// src/trace.ts
+init_esm_shims();
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+var TRACE_DIR_NAME = ".delfini-trace";
+var GITIGNORE_LINE = ".delfini-trace/";
+function ensureTraceDir(repoRoot) {
+  const tracePath = join(repoRoot, TRACE_DIR_NAME);
+  if (existsSync(tracePath)) {
+    const stat = statSync(tracePath);
+    if (!stat.isDirectory()) {
+      throw new Error(
+        `ensureTraceDir: ${tracePath} exists but is not a directory. Remove or rename it so the CLI can create the trace directory.`
+      );
+    }
+    return tracePath;
+  }
+  mkdirSync(tracePath, { recursive: true });
+  return tracePath;
+}
+function appendToGitignore(repoRoot) {
+  const gitignorePath = join(repoRoot, ".gitignore");
+  const existed = existsSync(gitignorePath);
+  const existingContent = existed ? readFileSync(gitignorePath, "utf8") : "";
+  const lines = existingContent.split(/\r?\n/);
+  for (const line of lines) {
+    if (line.trim() === GITIGNORE_LINE) {
+      return { changed: false };
+    }
+  }
+  const useCRLF = existingContent.includes("\r\n");
+  const newline = useCRLF ? "\r\n" : "\n";
+  if (!existed || existingContent.length === 0) {
+    writeFileSync(gitignorePath, `${GITIGNORE_LINE}${newline}`);
+    return { changed: true };
+  }
+  const endsWithNewline = existingContent.endsWith("\n");
+  const prefix = endsWithNewline ? "" : newline;
+  appendFileSync(gitignorePath, `${prefix}${GITIGNORE_LINE}${newline}`);
+  return { changed: true };
+}
+function writeTraceFile(repoRoot, filename, content) {
+  validateBasename(filename);
+  const traceDir = ensureTraceDir(repoRoot);
+  const target = join(traceDir, filename);
+  writeFileSync(target, content);
+  return target;
+}
+function writeRetryAttemptFile(repoRoot, attemptNumber, content) {
+  if (attemptNumber !== 1 && attemptNumber !== 2) {
+    throw new Error(
+      `writeRetryAttemptFile: attemptNumber must be 1 or 2, got ${String(attemptNumber)}`
+    );
+  }
+  return writeTraceFile(repoRoot, `findings-attempt-${attemptNumber}.json`, content);
+}
+function validateBasename(filename) {
+  if (filename.length === 0) {
+    throw new Error("writeTraceFile: filename must not be empty");
+  }
+  if (filename === "." || filename === "..") {
+    throw new Error(`writeTraceFile: filename must not be "${filename}"`);
+  }
+  if (filename.includes("/") || filename.includes("\\")) {
+    throw new Error(
+      `writeTraceFile: filename must be a basename without path separators, got "${filename}"`
+    );
+  }
+}
+
+// src/commands/install.ts
+var InstallToolNotSupportedError = class extends Error {
+  code = "INSTALL_TOOL_NOT_SUPPORTED";
+  constructor(tool) {
+    super(
+      `delfini install: --tool '${tool}' is not supported. The Skill is Claude-only in V1 (design-spec NG2 / project-context "Skill \u2014 Out of Scope in V1 / V1.1: No multi-LLM-provider support \u2014 Claude-only by design"). Use --tool CLAUDE (the default).`
+    );
+    this.name = "InstallToolNotSupportedError";
+  }
+};
+var CLAUDE_MD_OPEN_MARKER = "<!-- delfini:auto-invoke-block-v1 -->";
+var CLAUDE_MD_CLOSE_MARKER = "<!-- /delfini:auto-invoke-block-v1 -->";
+var SKILL_RELATIVE_PATH = ".claude/skills/delfini/SKILL.md";
+var CLAUDE_MD_FILENAME = "CLAUDE.md";
+var SUPPORTED_TOOL = "CLAUDE";
+var TEMPLATES_DIR = resolveTemplatesDir();
+function resolveTemplatesDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  return resolve(here, "..", "..", "templates");
+}
+async function runInstall(targetPath, options) {
+  const tool = options?.tool ?? SUPPORTED_TOOL;
+  const logger = options?.logger ?? console;
+  if (tool !== SUPPORTED_TOOL) {
+    throw new InstallToolNotSupportedError(tool);
+  }
+  const resolvedTarget = resolve(process.cwd(), targetPath);
+  const repoRoot = await getRepoRoot(resolvedTarget);
+  writeSkillTemplate(repoRoot, logger);
+  await applyAutoInvokeDecision(repoRoot, logger, options?.confirmAutoInvoke);
+  appendGitignoreLine(repoRoot, logger);
+}
+function parseYesNo(answer) {
+  const normalised = answer.trim().toLowerCase();
+  return normalised === "y" || normalised === "yes";
+}
+async function applyAutoInvokeDecision(repoRoot, logger, confirmAutoInvoke) {
+  const decision = await resolveAutoInvoke(confirmAutoInvoke);
+  if (decision === "yes") {
+    appendClaudeMdBlock(repoRoot, logger);
+  } else if (decision === "no") {
+    stripClaudeMdBlock(repoRoot, logger);
+  } else {
+    const target = join2(repoRoot, CLAUDE_MD_FILENAME);
+    log(logger, `CLAUDE.md \u2192 ${target} (non-interactive shell: auto-invoke prompt skipped, no change)`);
+  }
+}
+async function resolveAutoInvoke(confirmAutoInvoke) {
+  if (confirmAutoInvoke) {
+    return await confirmAutoInvoke() ? "yes" : "no";
+  }
+  if (!process.stdin.isTTY) {
+    return "skip";
+  }
+  return await promptAutoInvoke() ? "yes" : "no";
+}
+async function promptAutoInvoke() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await rl.question("Auto-invoke /delfini on PR creation? (y/n) ");
+    return parseYesNo(answer);
+  } finally {
+    rl.close();
+  }
+}
+function writeSkillTemplate(repoRoot, logger) {
+  const target = join2(repoRoot, SKILL_RELATIVE_PATH);
+  const templateSource = join2(TEMPLATES_DIR, "SKILL.md");
+  const content = readFileSync2(templateSource);
+  mkdirSync2(dirname(target), { recursive: true });
+  writeFileSync2(target, content);
+  log(logger, `SKILL.md \u2192 ${target}`);
+}
+function appendClaudeMdBlock(repoRoot, logger) {
+  const target = join2(repoRoot, CLAUDE_MD_FILENAME);
+  const blockSource = join2(TEMPLATES_DIR, "claude-md-append-block.txt");
+  const body = readFileSync2(blockSource, "utf8").replace(/\s+$/u, "");
+  const block = `${CLAUDE_MD_OPEN_MARKER}
+${body}
+${CLAUDE_MD_CLOSE_MARKER}
+`;
+  if (!existsSync2(target)) {
+    writeFileSync2(target, block);
+    log(logger, `CLAUDE.md \u2192 ${target} (created)`);
+    return;
+  }
+  const existing = readFileSync2(target, "utf8");
+  if (existing.includes(CLAUDE_MD_OPEN_MARKER)) {
+    log(logger, `CLAUDE.md \u2192 ${target} (block already present, no change)`);
+    return;
+  }
+  if (existing.length === 0) {
+    writeFileSync2(target, block);
+    log(logger, `CLAUDE.md \u2192 ${target} (block appended)`);
+    return;
+  }
+  const needsLeadingNewline = !existing.endsWith("\n");
+  const prefix = needsLeadingNewline ? "\n" : "";
+  writeFileSync2(target, `${existing}${prefix}${block}`);
+  log(logger, `CLAUDE.md \u2192 ${target} (block appended)`);
+}
+function stripClaudeMdBlock(repoRoot, logger) {
+  const target = join2(repoRoot, CLAUDE_MD_FILENAME);
+  if (!existsSync2(target)) {
+    log(logger, `CLAUDE.md \u2192 ${target} (no block to remove, no change)`);
+    return;
+  }
+  const existing = readFileSync2(target, "utf8");
+  const openIdx = existing.indexOf(CLAUDE_MD_OPEN_MARKER);
+  if (openIdx === -1) {
+    log(logger, `CLAUDE.md \u2192 ${target} (no block to remove, no change)`);
+    return;
+  }
+  const afterOpen = openIdx + CLAUDE_MD_OPEN_MARKER.length;
+  const closeIdx = existing.indexOf(CLAUDE_MD_CLOSE_MARKER, afterOpen);
+  let endIdx;
+  if (closeIdx === -1) {
+    endIdx = existing.length;
+  } else {
+    endIdx = closeIdx + CLAUDE_MD_CLOSE_MARKER.length;
+    if (existing.startsWith("\r\n", endIdx)) {
+      endIdx += 2;
+    } else if (existing[endIdx] === "\n") {
+      endIdx += 1;
+    }
+  }
+  const result = existing.slice(0, openIdx) + existing.slice(endIdx);
+  writeFileSync2(target, result);
+  log(logger, `CLAUDE.md \u2192 ${target} (block removed)`);
+}
+function appendGitignoreLine(repoRoot, logger) {
+  const target = join2(repoRoot, ".gitignore");
+  const { changed } = appendToGitignore(repoRoot);
+  if (changed) {
+    log(logger, `.gitignore \u2192 ${target} (appended .delfini-trace/)`);
+  } else {
+    log(logger, `.gitignore \u2192 ${target} (.delfini-trace/ already present, no change)`);
+  }
+}
+function log(logger, message) {
+  if (typeof logger.log === "function") {
+    logger.log(message);
+  }
+}
+
+// src/commands/local-finalize.ts
+init_esm_shims();
+import { promises as fs } from "fs";
+import path from "path";
+var TRACE_DIR_RELATIVE = ".delfini-trace";
+var ANALYSIS_INPUT_FILENAME = "analysis-input.json";
+var REPORT_FILENAME = "report.md";
+var SEVERITY_ICON = {
+  High: "[H]",
+  Medium: "[M]",
+  Low: "[L]"
+};
+var ClarifyingQuestionSchema = external_exports.object({
+  whatChanged: external_exports.string().min(1),
+  naturalHomeDoc: external_exports.string().min(1),
+  naturalHomeSection: external_exports.string().min(1),
+  question: external_exports.string().min(1),
+  proposedReplacement: external_exports.string().nullable()
+});
+var ClarifyingQuestionsArraySchema = external_exports.array(ClarifyingQuestionSchema);
+async function runLocalFinalize(options) {
+  const stderr = options.stderr ?? process.stderr;
+  const stdout = options.stdout ?? process.stdout;
+  const repoRoot = options.repoRoot ?? await getRepoRoot();
+  const findingsPath = path.isAbsolute(options.findingsPath) ? options.findingsPath : path.join(repoRoot, options.findingsPath);
+  let findingsContent;
+  try {
+    findingsContent = await fs.readFile(findingsPath, "utf8");
+  } catch (err) {
+    return emitSchemaValidationError(stderr, [
+      {
+        path: "findings.json",
+        message: `Failed to read findings file at "${findingsPath}": ${formatErrorMessage(err)}`
+      }
+    ]);
+  }
+  let rawJson;
+  try {
+    rawJson = JSON.parse(findingsContent);
+  } catch (err) {
+    return emitSchemaValidationError(stderr, [
+      {
+        path: "findings.json",
+        message: `Failed to parse findings.json as JSON: ${formatErrorMessage(err)}`
+      }
+    ]);
+  }
+  const analysisInputPath = path.join(repoRoot, TRACE_DIR_RELATIVE, ANALYSIS_INPUT_FILENAME);
+  let docs;
+  try {
+    const raw = await fs.readFile(analysisInputPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.docs)) {
+      return emitSchemaValidationError(stderr, [
+        {
+          path: "analysis-input.json",
+          message: `analysis-input.json is missing the "docs" array. Re-run \`delfini local-prepare\`.`
+        }
+      ]);
+    }
+    docs = parsed.docs;
+  } catch (err) {
+    return emitSchemaValidationError(stderr, [
+      {
+        path: "analysis-input.json",
+        message: `Failed to read analysis-input.json at "${analysisInputPath}": ${formatErrorMessage(err)}. Run \`delfini local-prepare\` first.`
+      }
+    ]);
+  }
+  let clarifications;
+  try {
+    const clarifyingQuestionsRaw = extractClarifyingQuestionsField(rawJson);
+    clarifications = ClarifyingQuestionsArraySchema.parse(clarifyingQuestionsRaw);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      return emitSchemaValidationError(stderr, formatZodIssues(err, "clarifyingQuestions"));
+    }
+    throw err;
+  }
+  let result;
+  try {
+    result = validateAndReconcile(rawJson, docs, (message) => {
+      stderr.write(`\u26A0\uFE0F  ${message}
+`);
+    });
+  } catch (err) {
+    if (err instanceof ZodError) {
+      return emitSchemaValidationError(stderr, formatZodIssues(err));
+    }
+    throw err;
+  }
+  const report = renderReport(result, clarifications);
+  writeTraceFile(repoRoot, REPORT_FILENAME, report);
+  stdout.write(report.endsWith("\n") ? report : `${report}
+`);
+  const hasApplyEligible = result.contradictions.length > 0 || result.additions.length > 0;
+  const hasNarrativeOnly = (result.narrativeOnlyContradictions ?? []).length > 0;
+  return hasApplyEligible || hasNarrativeOnly ? 1 : 0;
+}
+function emitSchemaValidationError(stderr, issues) {
+  const payload = { error: "schema_validation", issues };
+  stderr.write(`${JSON.stringify(payload, null, 2)}
+`);
+  return 3;
+}
+function formatZodIssues(err, prefix) {
+  return err.issues.map((issue) => ({
+    path: [prefix, ...issue.path].filter((p) => p !== void 0 && p !== "").map(String).join("."),
+    message: issue.message
+  }));
+}
+function formatErrorMessage(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+function extractClarifyingQuestionsField(rawJson) {
+  if (typeof rawJson !== "object" || rawJson === null) {
+    return [];
+  }
+  if (!("clarifyingQuestions" in rawJson)) {
+    return [];
+  }
+  const value = rawJson.clarifyingQuestions;
+  return value ?? [];
+}
+function renderReport(result, clarifications) {
+  const narrativeOnly = result.narrativeOnlyContradictions ?? [];
+  const applyEligibleDriftCount = result.contradictions.length;
+  const narrativeOnlyCount = narrativeOnly.length;
+  const driftCount = applyEligibleDriftCount + narrativeOnlyCount;
+  const additiveCount = result.additions.length;
+  const clarificationCount = clarifications.length;
+  const parts = [];
+  parts.push("# Delfini drift analysis");
+  parts.push("");
+  parts.push(
+    `${driftCount} drift, ${additiveCount} additive, ${clarificationCount} clarification finding(s).`
+  );
+  parts.push("");
+  if (applyEligibleDriftCount === 0 && additiveCount === 0) {
+    parts.push("No apply-eligible findings.");
+    parts.push("");
+  } else {
+    parts.push("## Apply-eligible findings");
+    parts.push("");
+    let index = 1;
+    for (const drift of result.contradictions) {
+      parts.push(renderDriftFinding(drift, index));
+      parts.push("");
+      index += 1;
+    }
+    for (const additive of result.additions) {
+      parts.push(renderAdditiveFinding(additive, index));
+      parts.push("");
+      index += 1;
+    }
+  }
+  if (narrativeOnlyCount > 0 || clarificationCount > 0) {
+    parts.push("## Manual review required");
+    parts.push("");
+    for (const drift of narrativeOnly) {
+      parts.push(renderNarrativeOnlyDrift(drift));
+      parts.push("");
+    }
+    for (const clarification of clarifications) {
+      parts.push(renderClarification(clarification));
+      parts.push("");
+    }
+  }
+  return parts.join("\n");
+}
+function renderDriftFinding(c, index) {
+  const lines = [];
+  const icon = SEVERITY_ICON[c.severity];
+  lines.push(
+    `### [${index}] ${icon} drift: ${c.targetDocPath}:${c.targetLineStart}-${c.targetLineEnd}`
+  );
+  lines.push("");
+  lines.push(`**Section:** ${c.targetSection}`);
+  lines.push(`**Severity:** ${c.severity}  **Confidence:** ${c.confidence}/5`);
+  lines.push("");
+  lines.push(`**What changed:** ${c.whatChanged}`);
+  lines.push(`**What contradicts:** ${c.whatContradicts}`);
+  lines.push("");
+  lines.push("**Proposed change:**");
+  lines.push("```diff");
+  for (const line of c.quotedDocText.replace(/\r\n/g, "\n").split("\n")) {
+    lines.push(`- ${line}`);
+  }
+  const replacement = c.proposedReplacement ?? "<empty>";
+  for (const line of replacement.replace(/\r\n/g, "\n").split("\n")) {
+    lines.push(`+ ${line}`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function renderAdditiveFinding(a, index) {
+  const lines = [];
+  const icon = SEVERITY_ICON[a.severity];
+  lines.push(
+    `### [${index}] ${icon} additive: ${a.targetDocPath} \u2014 insert ${a.insertionMode} line ${a.anchorLine}`
+  );
+  lines.push("");
+  lines.push(`**Anchor section:** ${a.anchorSection}`);
+  lines.push(`**Severity:** ${a.severity}  **Confidence:** ${a.confidence}/5`);
+  lines.push("");
+  lines.push(`**What changed:** ${a.whatChanged}`);
+  lines.push(`**Rationale:** ${a.rationaleForAddition}`);
+  lines.push("");
+  lines.push(`**Proposed addition (insert ${a.insertionMode} line ${a.anchorLine}):**`);
+  lines.push("```diff");
+  for (const line of a.proposedContent.replace(/\r\n/g, "\n").split("\n")) {
+    lines.push(`+ ${line}`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+function renderNarrativeOnlyDrift(c) {
+  const lines = [];
+  const icon = SEVERITY_ICON[c.severity];
+  lines.push(
+    `### ${icon} narrative-only drift: ${c.targetDocPath}:${c.targetLineStart}-${c.targetLineEnd}`
+  );
+  lines.push("");
+  lines.push(`**Section:** ${c.targetSection}`);
+  lines.push(`**Severity:** ${c.severity}  **Confidence:** ${c.confidence}/5`);
+  lines.push("");
+  lines.push(`**What changed:** ${c.whatChanged}`);
+  lines.push(`**What contradicts:** ${c.whatContradicts}`);
+  lines.push("");
+  lines.push("**Quoted doc text:**");
+  lines.push("```");
+  lines.push(c.quotedDocText);
+  lines.push("```");
+  lines.push("");
+  lines.push(
+    "**Resolution:** The doc rule above is correct; the PR code violates it. Fix the code (or hand-edit the doc if the rule itself needs to change) \u2014 no auto-apply available."
+  );
+  return lines.join("\n");
+}
+function renderClarification(q) {
+  const lines = [];
+  lines.push(`### Clarification: ${q.naturalHomeDoc} \u2014 ${q.naturalHomeSection}`);
+  lines.push("");
+  lines.push(`**What changed:** ${q.whatChanged}`);
+  lines.push(`**Question:** ${q.question}`);
+  if (q.proposedReplacement !== null) {
+    lines.push("");
+    lines.push("**Suggested replacement (optional):**");
+    lines.push("```");
+    lines.push(q.proposedReplacement);
+    lines.push("```");
+  }
+  return lines.join("\n");
+}
+
+// src/commands/local-prepare.ts
+init_esm_shims();
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { promises as fs3 } from "fs";
+import { execFile } from "child_process";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { promisify } from "util";
+import simpleGit3 from "simple-git";
+
+// src/doc-scope.ts
+init_esm_shims();
+import { promises as fs2 } from "fs";
+import path2 from "path";
+import { glob } from "tinyglobby";
+var DOC_SCOPE_RELATIVE_PATH = ".claude/skills/delfini/doc-scope.json";
+var DOC_SCOPE_VERSION = 1;
+var DOC_SCOPE_VERSION_MISMATCH_MESSAGE = "your doc-scope.json is for a newer @delfini/cli; please upgrade.";
+var REPO_ROOT_REL = ".";
+var DocScopeVersionMismatchError = class extends Error {
+  code = "DOC_SCOPE_VERSION_MISMATCH";
+  constructor(message = DOC_SCOPE_VERSION_MISMATCH_MESSAGE) {
+    super(message);
+    this.name = "DocScopeVersionMismatchError";
+  }
+};
+var DocScopeCorruptError = class extends Error {
+  code = "DOC_SCOPE_CORRUPT";
+  constructor(message) {
+    super(message);
+    this.name = "DocScopeCorruptError";
+  }
+};
+var DocScopeValidationError = class extends Error {
+  code = "DOC_SCOPE_VALIDATION";
+  constructor(message) {
+    super(message);
+    this.name = "DocScopeValidationError";
+  }
+};
+var docScopeSchemaV1 = external_exports.object({
+  version: external_exports.literal(1),
+  doc_scope: external_exports.array(external_exports.string().min(1))
+});
+var versionProbeSchema = external_exports.object({
+  version: external_exports.number().int().positive()
+});
+async function readDocScope(repoRoot) {
+  const root = repoRoot ?? await getRepoRoot();
+  const target = path2.join(root, DOC_SCOPE_RELATIVE_PATH);
+  let raw;
+  try {
+    raw = await fs2.readFile(target, "utf8");
+  } catch (err) {
+    if (isNoEntError(err)) return null;
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new DocScopeCorruptError(
+      `${DOC_SCOPE_RELATIVE_PATH} is malformed: ${err.message}`
+    );
+  }
+  const probe = versionProbeSchema.safeParse(parsed);
+  if (probe.success && probe.data.version > DOC_SCOPE_VERSION) {
+    throw new DocScopeVersionMismatchError();
+  }
+  const result = docScopeSchemaV1.safeParse(parsed);
+  if (!result.success) {
+    throw new DocScopeCorruptError(
+      `${DOC_SCOPE_RELATIVE_PATH} is malformed: ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`
+    );
+  }
+  return result.data;
+}
+async function writeDocScope(paths, options) {
+  const root = options?.repoRoot ?? await getRepoRoot();
+  if (!Array.isArray(paths) || paths.length === 0) {
+    throw new DocScopeValidationError("at least one path is required");
+  }
+  const errors = [];
+  for (const entry of paths) {
+    const err = validateDocScopeEntry(entry, REPO_ROOT_REL);
+    if (err !== null) errors.push(err);
+  }
+  if (errors.length > 0) {
+    throw new DocScopeValidationError(
+      `${DOC_SCOPE_RELATIVE_PATH}: invalid path(s):
+${errors.map((e) => `  - ${e}`).join("\n")}`
+    );
+  }
+  const normalised = normalizeDocScope(paths);
+  if (normalised.length === 0) {
+    throw new DocScopeValidationError(
+      `${DOC_SCOPE_RELATIVE_PATH}: every entry collapses to an empty scope after normalisation (e.g. '.', './', 'docs/..') \u2014 provide at least one concrete path`
+    );
+  }
+  const target = path2.join(root, DOC_SCOPE_RELATIVE_PATH);
+  await fs2.mkdir(path2.dirname(target), { recursive: true });
+  const payload = { version: DOC_SCOPE_VERSION, doc_scope: normalised };
+  const json = `${JSON.stringify(payload, null, 2)}
+`;
+  await fs2.writeFile(target, json, "utf8");
+}
+async function docScopeExists(repoRoot) {
+  const root = repoRoot ?? await getRepoRoot();
+  const target = path2.join(root, DOC_SCOPE_RELATIVE_PATH);
+  try {
+    const st = await fs2.stat(target);
+    return st.isFile();
+  } catch {
+    return false;
+  }
+}
+async function deleteDocScope(repoRoot) {
+  const root = repoRoot ?? await getRepoRoot();
+  const target = path2.join(root, DOC_SCOPE_RELATIVE_PATH);
+  try {
+    await fs2.unlink(target);
+  } catch (err) {
+    if (!isNoEntError(err)) throw err;
+  }
+}
+async function expandDocScope(paths, repoRoot) {
+  const root = repoRoot ?? await getRepoRoot();
+  const normalisedRoot = path2.resolve(root);
+  const found = /* @__PURE__ */ new Set();
+  const missing = [];
+  for (const rawEntry of paths) {
+    if (typeof rawEntry !== "string") continue;
+    const normalised = normalizeDocScope([rawEntry]);
+    if (normalised.length === 0) {
+      if (rawEntry.trim().length > 0) missing.push(rawEntry);
+      continue;
+    }
+    const entry = normalised[0];
+    if (validateDocScopeEntry(entry, REPO_ROOT_REL) !== null) {
+      missing.push(rawEntry);
+      continue;
+    }
+    if (classifyEntry(entry) === "glob") {
+      const matches = await glob(entry, {
+        cwd: root,
+        absolute: true,
+        onlyFiles: true,
+        dot: false,
+        // Case-folding parity with the engine predicate (`nocase: true`).
+        caseSensitiveMatch: false,
+        // Migrating from fast-glob — disable tinyglobby's directory-pattern
+        // auto-expansion so a glob like `packages/*/README.md` keeps exact
+        // fast-glob semantics.
+        expandDirectories: false
+      });
+      const inRoot = matches.filter((m) => isInsideRoot(m, normalisedRoot));
+      if (inRoot.length === 0) {
+        missing.push(rawEntry);
+      } else {
+        for (const m of inRoot) found.add(m);
+      }
+      continue;
+    }
+    const absolute = path2.resolve(root, entry);
+    let stat;
+    try {
+      stat = await fs2.stat(absolute);
+    } catch (err) {
+      if (isNoEntError(err)) {
+        missing.push(rawEntry);
+        continue;
+      }
+      throw err;
+    }
+    if (stat.isDirectory()) {
+      const children = await glob("**/*.md", {
+        cwd: absolute,
+        absolute: true,
+        onlyFiles: true,
+        caseSensitiveMatch: false,
+        dot: false,
+        expandDirectories: false
+      });
+      for (const c of children) {
+        if (isInsideRoot(c, normalisedRoot)) found.add(c);
+      }
+    } else if (stat.isFile()) {
+      if (isInsideRoot(absolute, normalisedRoot)) found.add(absolute);
+    } else {
+      missing.push(rawEntry);
+    }
+  }
+  const files = Array.from(found).sort();
+  return { files, missingPaths: missing };
+}
+function isNoEntError(err) {
+  return typeof err === "object" && err !== null && err.code === "ENOENT";
+}
+function isInsideRoot(absolute, normalisedRoot) {
+  const resolved = path2.resolve(absolute);
+  return resolved === normalisedRoot || resolved.startsWith(normalisedRoot + path2.sep);
+}
+
+// src/commands/local-prepare.ts
+var execFileAsync = promisify(execFile);
+var UNTRACKED_DIFF_MAX_BUFFER = 64 * 1024 * 1024;
+var PROMPT_TOKEN_BUDGET = 15e4;
+var DEFAULT_RELEVANCE_THRESHOLD = 5;
+function formatMissingPathWarning(path5) {
+  return `\u26A0\uFE0F Skipped: \`${path5}\` (no longer exists)
+`;
+}
+var PROMPT_TEMPLATE_CANDIDATES = [
+  "./prompt.md",
+  "../../../drift-engine/src/prompt.md"
+];
+function resolvePromptTemplatePath(baseUrl) {
+  const tried = [];
+  for (const rel of PROMPT_TEMPLATE_CANDIDATES) {
+    const candidate = fileURLToPath2(new URL(rel, baseUrl));
+    if (existsSync3(candidate)) return candidate;
+    tried.push(candidate);
+  }
+  throw new Error(
+    "Could not locate the drift-engine prompt template. Tried:\n" + tried.map((p) => `  - ${p}`).join("\n") + "\nIf running the bundled CLI, ensure `dist/prompt.md` was produced by the build (tsup onSuccess copies drift-engine/src/prompt.md). Re-run `pnpm --filter @delfini/cli build`."
+  );
+}
+var cachedTemplate;
+function loadTemplate() {
+  if (cachedTemplate === void 0) {
+    cachedTemplate = readFileSync3(resolvePromptTemplatePath(import.meta.url), "utf8");
+  }
+  return cachedTemplate;
+}
+async function runLocalPrepare(options = {}) {
+  const stderr = options.stderr ?? process.stderr;
+  const stdout = options.stdout ?? process.stdout;
+  const budget = options.promptTokenBudget ?? PROMPT_TOKEN_BUDGET;
+  const diffSource = options.diffSource ?? "local";
+  if (diffSource !== "local" && diffSource !== "committed" && diffSource !== "both") {
+    throw new Error(
+      `Invalid --diff-source "${String(diffSource)}". Valid values: local, committed, both.`
+    );
+  }
+  const repoRoot = options.repoRoot ?? await getRepoRoot();
+  const scopePaths = await resolveScopePaths(options.scope, repoRoot);
+  if (scopePaths === null) {
+    stderr.write(
+      "No doc-scope configured. Pass `--scope <paths>` or run the skill\nfirst-run setup to create `.claude/skills/delfini/doc-scope.json`.\n"
+    );
+    return 2;
+  }
+  const expansion = await expandDocScope(scopePaths, repoRoot);
+  for (const missing of expansion.missingPaths) {
+    stderr.write(formatMissingPathWarning(missing));
+  }
+  const git = simpleGit3({ baseDir: repoRoot });
+  const baseRef = await resolveBaseRef(git, options.base, stderr);
+  const rawDiff = await computeDiff(git, repoRoot, baseRef, diffSource);
+  let diff = rawDiff;
+  let filterResult = null;
+  if (options.enableDiffPreFilter === true) {
+    filterResult = filterDiff(rawDiff);
+    diff = filterResult.keptDiff;
+  }
+  const docs = await readDocs(expansion.files, repoRoot, stderr);
+  const prMetadata = await buildPRMetadata(git, repoRoot, baseRef);
+  const input = { diff, docs, prMetadata };
+  const useRankedFill = typeof options.relevanceThreshold === "number" && Number.isFinite(options.relevanceThreshold) && options.relevanceThreshold > 0;
+  const buildResult = buildPromptWithDrops(input, loadTemplate(), {
+    relevanceThreshold: options.relevanceThreshold,
+    // Pass the budget ONLY when retrieval is on; otherwise omit so the
+    // default code path stays observably unchanged (AC5).
+    promptTokenBudget: useRankedFill ? budget : void 0
+  });
+  const prompt = buildResult.prompt;
+  const droppedSections = buildResult.droppedSections;
+  const estimatedTokens = estimatePromptTokens(prompt);
+  if (estimatedTokens > budget) {
+    const payload = {
+      error: "prompt_too_large",
+      estimatedTokens,
+      suggestion: "Narrow your doc-scope (try '/delfini --scope <fewer-paths>'), split the PR, or shrink the diff \u2014 the prompt is over budget even before any doc sections fit."
+    };
+    stdout.write(`${JSON.stringify(payload)}
+`);
+    return 4;
+  }
+  if (droppedSections.length > 0) {
+    stderr.write(`dropped ${droppedSections.length} section(s) \u2014 over prompt budget
+`);
+  }
+  ensureTraceDir(repoRoot);
+  const schemaJson = zodToJsonSchema(analysisSchema);
+  const traceJson = { ...input };
+  if (filterResult !== null) {
+    traceJson._filterResult = {
+      droppedPaths: filterResult.droppedPaths,
+      droppedHunks: filterResult.droppedHunks
+    };
+  }
+  if (droppedSections.length > 0) {
+    traceJson._rankedFillResult = { droppedSections };
+  }
+  writeTraceFile(repoRoot, "analysis-input.json", `${JSON.stringify(traceJson, null, 2)}
+`);
+  writeTraceFile(repoRoot, "analysis-prompt.md", prompt);
+  writeTraceFile(repoRoot, "schema.json", `${JSON.stringify(schemaJson, null, 2)}
+`);
+  return 0;
+}
+async function resolveScopePaths(scopeOption, repoRoot) {
+  if (scopeOption !== void 0) {
+    const normalised = normaliseScopeOption(scopeOption);
+    if (normalised.length === 0) {
+      return null;
+    }
+    return normalised;
+  }
+  const persisted = await readDocScope(repoRoot);
+  if (persisted === null) {
+    return null;
+  }
+  return persisted.doc_scope;
+}
+function normaliseScopeOption(scope) {
+  const raw = Array.isArray(scope) ? scope : scope.split(",");
+  return raw.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+async function computeDiff(git, repoRoot, baseRef, diffSource) {
+  switch (diffSource) {
+    case "committed":
+      return git.diff([baseRef, "HEAD"]);
+    case "local": {
+      const tracked = await git.diff(["HEAD"]);
+      const untracked = await computeUntrackedDiff(git, repoRoot);
+      return concatDiff(tracked, untracked);
+    }
+    case "both": {
+      const tracked = await git.diff([baseRef]);
+      const untracked = await computeUntrackedDiff(git, repoRoot);
+      return concatDiff(tracked, untracked);
+    }
+  }
+}
+async function computeUntrackedDiff(git, repoRoot) {
+  const untracked = await listUntrackedFiles(git);
+  if (untracked.length === 0) {
+    return "";
+  }
+  const parts = [];
+  for (const rel of untracked) {
+    const fileDiff = await diffUntrackedFile(repoRoot, rel);
+    if (fileDiff.length > 0) {
+      parts.push(fileDiff);
+    }
+  }
+  return parts.join("");
+}
+async function diffUntrackedFile(repoRoot, relPath) {
+  const args = ["-C", repoRoot, "diff", "--no-index", "--no-color", "--", "/dev/null", relPath];
+  try {
+    const { stdout } = await execFileAsync("git", args, { maxBuffer: UNTRACKED_DIFF_MAX_BUFFER });
+    return stdout;
+  } catch (err) {
+    const e = err;
+    if (e.code === 1 && typeof e.stdout === "string") {
+      return e.stdout;
+    }
+    throw err;
+  }
+}
+function concatDiff(tracked, untracked) {
+  if (tracked.length === 0) return untracked;
+  if (untracked.length === 0) return tracked;
+  return tracked.endsWith("\n") ? `${tracked}${untracked}` : `${tracked}
+${untracked}`;
+}
+async function readDocs(absolutePaths, repoRoot, stderr) {
+  const docs = [];
+  for (const abs of absolutePaths) {
+    const relative = path3.relative(repoRoot, abs).split(path3.sep).join("/");
+    let content;
+    try {
+      content = await fs3.readFile(abs, "utf8");
+    } catch (err) {
+      if (isNoEntError2(err)) {
+        stderr.write(formatMissingPathWarning(relative));
+        continue;
+      }
+      throw err;
+    }
+    docs.push({
+      path: relative,
+      content,
+      // V1 — no YAML front-matter parsing. See story Dev Notes §
+      // "frontMatterLineCount deferral".
+      frontMatterLineCount: 0
+    });
+  }
+  return docs;
+}
+function isNoEntError2(err) {
+  return typeof err === "object" && err !== null && err.code === "ENOENT";
+}
+async function buildPRMetadata(git, repoRoot, baseRef) {
+  const headSha = await safeShortSha(git, "HEAD");
+  const baseSha = await safeShortSha(git, baseRef);
+  return {
+    owner: "local",
+    repo: path3.basename(repoRoot),
+    prNumber: 0,
+    headSha,
+    baseSha,
+    title: "Local /delfini run"
+  };
+}
+async function safeShortSha(git, ref) {
+  try {
+    const raw = await git.revparse(["--short", ref]);
+    const trimmed = raw.trim();
+    return trimmed.length > 0 ? trimmed : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function zodToJsonSchema(schema) {
+  return walk(schema);
+}
+function walk(schema) {
+  const def = schema._def;
+  const typeName = def.typeName;
+  switch (typeName) {
+    case "ZodObject": {
+      const shape = schema.shape;
+      const properties = {};
+      const required = [];
+      for (const [key, child] of Object.entries(shape)) {
+        const childSchema = child;
+        properties[key] = walk(childSchema);
+        const childTypeName = childSchema._def.typeName;
+        if (childTypeName !== "ZodOptional" && childTypeName !== "ZodDefault") {
+          required.push(key);
+        }
+      }
+      const result = { type: "object", properties, additionalProperties: false };
+      if (required.length > 0) {
+        result.required = required;
+      }
+      return result;
+    }
+    case "ZodArray": {
+      const inner = def.type;
+      return { type: "array", items: walk(inner) };
+    }
+    case "ZodString": {
+      const result = { type: "string" };
+      const checks = def.checks ?? [];
+      for (const check of checks) {
+        if (check.kind === "min" && typeof check.value === "number") {
+          result.minLength = check.value;
+        }
+      }
+      return result;
+    }
+    case "ZodNumber": {
+      const result = { type: "number" };
+      const checks = def.checks ?? [];
+      for (const check of checks) {
+        if (check.kind === "min" && typeof check.value === "number") {
+          result.minimum = check.value;
+        }
+        if (check.kind === "max" && typeof check.value === "number") {
+          result.maximum = check.value;
+        }
+        if (check.kind === "int") {
+          result.type = "integer";
+        }
+      }
+      return result;
+    }
+    case "ZodEnum": {
+      const values = def.values;
+      return { type: "string", enum: values };
+    }
+    case "ZodLiteral": {
+      const value = def.value;
+      const literal = { const: value };
+      if (typeof value === "string") literal.type = "string";
+      else if (typeof value === "number") literal.type = "number";
+      else if (typeof value === "boolean") literal.type = "boolean";
+      return literal;
+    }
+    case "ZodNullable": {
+      const inner = def.innerType;
+      const innerSchema = walk(inner);
+      if (typeof innerSchema.type === "string") {
+        return { ...innerSchema, type: [innerSchema.type, "null"] };
+      }
+      return { ...innerSchema, type: Array.isArray(innerSchema.type) ? [...innerSchema.type, "null"] : ["null"] };
+    }
+    case "ZodOptional":
+    case "ZodDefault": {
+      const inner = def.innerType;
+      return walk(inner);
+    }
+    default:
+      throw new Error(
+        `zodToJsonSchema: unsupported Zod type "${typeName ?? "unknown"}" \u2014 extend the walker.`
+      );
+  }
+}
+
+// src/cli.ts
+var pkg = readPackageJson();
+function readPackageJson() {
+  const here = path4.dirname(fileURLToPath3(import.meta.url));
+  const pkgPath = path4.join(here, "..", "package.json");
+  const raw = readFileSync4(pkgPath, "utf8");
+  return JSON.parse(raw);
+}
+async function main(argv) {
+  const program = new Command();
+  program.name("delfini").description("Delfini Skill CLI \u2014 deterministic, never calls an LLM.").version(pkg.version, "-V, --version", "print the @delfini/cli version").option("--reset-scope", "delete the persisted doc-scope.json").exitOverride();
+  program.action(async (opts) => {
+    if (opts.resetScope) {
+      await handleResetScope();
+    }
+  });
+  program.command("install <path>").description(
+    "Scaffold .claude/skills/delfini/SKILL.md + CLAUDE.md auto-invoke + .gitignore append"
+  ).option("--tool <agent>", "Coding agent target (only 'CLAUDE' supported in V1)", "CLAUDE").option("--auto-invoke", "append the CLAUDE.md auto-invoke block without prompting").option("--no-auto-invoke", "strip the CLAUDE.md auto-invoke block without prompting").action(async (targetPath, opts) => {
+    const confirmAutoInvoke = opts.autoInvoke === void 0 ? void 0 : () => Promise.resolve(opts.autoInvoke);
+    await runInstall(targetPath, { tool: opts.tool, confirmAutoInvoke });
+  });
+  program.command("local-prepare").description(
+    "Compute diff + doc-scope + prompt + token-budget gate; write .delfini-trace/"
+  ).option("--scope <paths>", "Comma-separated doc-scope paths (overrides doc-scope.json)").option("--base <ref>", "Diff base ref (default: git merge-base HEAD origin/main)").option(
+    "--diff-source <source>",
+    "Which diff to analyse: 'local' (default), 'committed', or 'both'",
+    "local"
+  ).option(
+    "--relevance-threshold <n>",
+    `Render only doc SECTIONS scoring at/above N against the diff (Tier 1 +20 / Tier 2 +10 per file / Tier 3 +3 per identifier capped at 30 / Tier 4 +5 per heading), most-relevant-first up to the prompt budget. Default: ${DEFAULT_RELEVANCE_THRESHOLD} (token-efficient retrieval on). Pass 0 to disable and embed every in-scope doc whole. When retained sections still exceed the prompt budget, ranked-fill drops the lowest-scoring sections first and reports what was dropped.`,
+    (value) => {
+      if (!/^\d+$/.test(value)) {
+        throw new Error("--relevance-threshold must be a non-negative integer");
+      }
+      const parsed = Number.parseInt(value, 10);
+      if (!Number.isFinite(parsed)) {
+        throw new Error("--relevance-threshold must be a non-negative integer");
+      }
+      return parsed;
+    },
+    // Default ON at the CLI call-site (NFR49). `runLocalPrepare` stays a pure
+    // pass-through — this default is what makes a real `delfini local-prepare`
+    // run retrieve. Commander applies the default verbatim (it does not run
+    // the parser above on it), so a numeric literal is correct here.
+    DEFAULT_RELEVANCE_THRESHOLD
+  ).option(
+    "--enable-diff-prefilter",
+    "Drop lockfile/generated/vendored/fixture paths + pure-whitespace/import-only hunks from the diff before prompt assembly (Story P3.7.2 / FR151). Default: off \u2014 assembled prompt is byte-identical to the no-flag baseline."
+  ).action(
+    async (opts) => {
+      const exitCode = await runLocalPrepare({
+        scope: opts.scope,
+        base: opts.base,
+        diffSource: opts.diffSource,
+        relevanceThreshold: opts.relevanceThreshold,
+        enableDiffPreFilter: opts.enableDiffPrefilter
+      });
+      process.exitCode = exitCode;
+    }
+  );
+  program.command("diff-status").description("Report branch + local/committed change state as JSON (read-only)").option("--base <ref>", "Diff base ref (default: git merge-base HEAD origin/main)").action(async (opts) => {
+    const exitCode = await runDiffStatus({ base: opts.base });
+    process.exitCode = exitCode;
+  });
+  program.command("local-finalize <findingsPath>").description(
+    "Validate findings.json, reconcile line numbers, render .delfini-trace/report.md"
+  ).action(async (findingsPath) => {
+    const exitCode = await runLocalFinalize({ findingsPath });
+    process.exitCode = exitCode;
+  });
+  try {
+    await program.parseAsync(argv);
+  } catch (err) {
+    if (err instanceof CommanderError && err.exitCode === 0) {
+      return;
+    }
+    throw err;
+  }
+}
+async function handleResetScope() {
+  try {
+    await deleteDocScope();
+  } catch (err) {
+    if (err instanceof RepoRootNotFoundError) {
+      return;
+    }
+    throw err;
+  }
+}
+
+export {
+  RepoRootNotFoundError,
+  getRepoRoot,
+  runDiffStatus,
+  ensureTraceDir,
+  appendToGitignore,
+  writeTraceFile,
+  writeRetryAttemptFile,
+  InstallToolNotSupportedError,
+  runInstall,
+  runLocalFinalize,
+  DOC_SCOPE_RELATIVE_PATH,
+  DOC_SCOPE_VERSION,
+  DocScopeVersionMismatchError,
+  DocScopeCorruptError,
+  DocScopeValidationError,
+  readDocScope,
+  writeDocScope,
+  docScopeExists,
+  deleteDocScope,
+  expandDocScope,
+  PROMPT_TOKEN_BUDGET,
+  runLocalPrepare,
+  main
+};