arcane-cli 1.10.0 → 1.10.2

package/dist/assets/.arcane/spells/spell-sync-pull-request.md

@@ -1,10 +1,10 @@
 ---
 name: Spell — Sync Pull Request
-description: Safely sync an open PR's branch with its target when it has fallen behind — recoverable pre-rebase ref, mechanical-vs-ambiguous conflict handling, force-with-lease push, provider-verified landing. Use when a PR needs rebasing onto a moved target, or was routed here from spell-create-pull-request/spell-ship's own conflict-stop points.
+description: Safely sync an open PR's branch with its target when it has fallen behind — recoverable pre-rebase ref, mechanical / regenerable / ambiguous conflict handling, force-with-lease push, provider-verified landing. Use when a PR needs rebasing onto a moved target, or was routed here from spell-create-pull-request/spell-ship's own conflict-stop points.
 claude_description: Use PROACTIVELY whenever an open PR has fallen behind its target branch and needs a safe rebase/sync, or when spell-create-pull-request/spell-ship stop on a conflict they route here.
 argument-hint: '[PR number or branch name]'
 agent: agent
-last_updated: 2026-08-31
+last_updated: 2026-10-01
 ---
 
 ## Executive Summary
@@ -13,7 +13,9 @@ last_updated: 2026-08-31
 - It is the recovery path `spell-create-pull-request` and `spell-ship` route to when they detect a
   conflict they deliberately don't try to resolve themselves.
 - It draws a hard line between conflicts safe to resolve mechanically (identical changes on both sides)
-  and conflicts that need a human — it never guesses on the ambiguous side of that line.
+  and conflicts that need a human — it never guesses on the ambiguous side of that line. A third class,
+  a script-regenerable artifact, is neither merged nor handed off: it is regenerated against the rebased
+  tree and verified by its own check.
 - Every history-rewriting step is preceded by a recoverable ref, and every push uses
   `--force-with-lease`, never bare `--force`.
 
@@ -72,7 +74,7 @@ Resolve the repository's actual merge-strategy ladder from `git-conventions.md`
 - **Never** produce a squash or semi-linear result as part of this sync — those are never sanctioned,
   regardless of which of the two above applies.
 
-## Step 3 — Classify any conflict: mechanical vs. ambiguous
+## Step 3 — Classify any conflict: mechanical, regenerable, or ambiguous
 
 If Step 2 completes with no conflicts, skip straight to Step 4 — **this is the common case and it must
 not be treated as a special case of conflict handling.**
@@ -84,6 +86,25 @@ then classify **each conflicted hunk independently** — a single file can conta
   same import added the same way), or one side's change is a strict superset of the other's with no
   semantic divergence. Resolve by keeping the superset/identical content, verify no line from either
   side's *unique* content was dropped, stage the file, and continue the rebase/merge.
+- **Regenerable** — the file is a committed artifact that a script owns: a known command regenerates it
+  from other files in the tree and overwrites it unconditionally, ignoring any conflict markers already
+  in it. Neither side's content is the right answer, because both were computed from trees that no
+  longer exist; the correct content is a fresh regeneration against the post-rebase tree. **Do not
+  hand-merge the diff and do not pick a side.** Leave the conflicted file as it is, run its regeneration
+  command, verify with the file's own `--check` command, then stage the file and continue the
+  rebase/merge. Known artifacts and their commands:
+  - `docs/plans/*/show-report.{json,html}` — `npm run fix:report` in Arcane's own repository (`spell
+    report` in a consumer), verified by `npm run check:report`. On a program's own `completed:` day the
+    regeneration must go in a **trailer-free, report-only commit** that touches nothing else, because
+    the close-commit logic counts any other commit made that day (recorded in
+    `docs/plans/upstream-intake-2026-09/PLAN.md`, "What this program taught").
+  - Self-hosted parity copies and client shims under `.arcane/`, `.github/`, `.claude/` and `.agents/`
+    in Arcane's own repository — `npm run fix:self-host-parity`, verified by
+    `npm run check:self-host-parity`. A compiled asset with its own `fix:*`/`check:*` pair in
+    `package.json` follows the same rule.
+  - `package-lock.json` — `npm install` against the rebased `package.json`, verified by `npm ci`.
+  A file you cannot name a regeneration command for is not regenerable: classify its hunks as mechanical
+  or ambiguous like any other, and never promote a hand-edited file to this class to avoid a STOP.
 - **Ambiguous** — the same lines changed with different intent, or you cannot establish with confidence
   that one side's content is a strict superset of the other's. **STOP.** Do not guess, do not pick a
   side, do not attempt a "reasonable-looking" merge of the two. Abort the in-progress rebase/merge
@@ -177,6 +198,8 @@ report the discrepancy rather than declaring the sync done.
 ```
 
 - If Step 3 resolved any mechanical conflicts, list exactly which files and what was kept from each side.
+- If Step 3 regenerated any artifact, name the file, the regeneration command that was run and the
+  `--check` command that verified the result.
 - If Step 3 aborted on an ambiguous conflict, this report never runs — Step 3's own STOP report is final.
 - Never delete the Step 1 recoverable ref as part of this report — that is the human's call.
 
@@ -185,6 +208,9 @@ report the discrepancy rather than declaring the sync done.
 - Never push with bare `--force` — only `--force-with-lease`, and never retry a rejected lease blindly.
 - Never guess on an ambiguous conflict — abort and hand off, every time, with no exception for
   "obviously trivial-looking" content on either side that this spell cannot independently verify.
+- Never hand-merge a script-regenerable artifact — regenerate it against the rebased tree and verify it
+  with its own check; and never classify a file as regenerable without naming the command that
+  regenerates it.
 - Never skip the recoverable ref (Step 1), even for a sync expected to be clean — the ref costs nothing
   and the alternative is an unrecoverable mistake on the case that turns out not to be clean.
 - Never report a sync as complete on a push success alone — provider verification (Step 5) is mandatory.

package/dist/assets/.github/prompts/spell-sync-pull-request.prompt.md

@@ -1,10 +1,10 @@
 ---
 name: Spell — Sync Pull Request
-description: Safely sync an open PR's branch with its target when it has fallen behind — recoverable pre-rebase ref, mechanical-vs-ambiguous conflict handling, force-with-lease push, provider-verified landing. Use when a PR needs rebasing onto a moved target, or was routed here from spell-create-pull-request/spell-ship's own conflict-stop points.
+description: Safely sync an open PR's branch with its target when it has fallen behind — recoverable pre-rebase ref, mechanical / regenerable / ambiguous conflict handling, force-with-lease push, provider-verified landing. Use when a PR needs rebasing onto a moved target, or was routed here from spell-create-pull-request/spell-ship's own conflict-stop points.
 claude_description: Use PROACTIVELY whenever an open PR has fallen behind its target branch and needs a safe rebase/sync, or when spell-create-pull-request/spell-ship stop on a conflict they route here.
 argument-hint: '[PR number or branch name]'
 agent: agent
-last_updated: 2026-08-31
+last_updated: 2026-10-01
 ---
 
 This prompt is the Arcane `spell-sync-pull-request` spell. Read [`.arcane/spells/spell-sync-pull-request.md`](../../.arcane/spells/spell-sync-pull-request.md) and follow it as the complete workflow.

package/dist/index.js

@@ -4417,14 +4417,14 @@ async function runInitUser(options, storeRoot, assetsDir, packageVersion) {
 }
 
 // src/modules/component-install.ts
-import { stat } from "fs/promises";
+import { readFile as readFile7, stat, writeFile as writeFile9 } from "fs/promises";
 import { join as join8 } from "path";
 async function planComponentInstall(component, targetDir, assetsDir, opts = {}) {
   const files = [];
   const stateOf = async (file, src) => {
     const dest = join8(targetDir, file);
     if (!await fileExists(dest)) return { file, src, state: "missing" };
-    if ((await stat(dest)).isDirectory()) return { file, src, state: "differs" };
+    if ((await stat(dest)).isDirectory()) return { file, src, state: "directory" };
     const same = await hashFile(dest) === await hashFile(src);
     return { file, src, state: same ? "identical" : "differs" };
   };
@@ -4437,37 +4437,76 @@ async function planComponentInstall(component, targetDir, assetsDir, opts = {})
       files.push(await stateOf(file, join8(assetsDir, file)));
     }
   }
-  const present = files.filter((f) => f.state !== "missing");
-  const missing = files.filter((f) => f.state === "missing");
-  if (opts.force) return { component, files, toCopy: files, kept: [], conflicts: [] };
-  return component.skipExisting ? { component, files, toCopy: missing, kept: present, conflicts: [] } : { component, files, toCopy: missing, kept: [], conflicts: present };
+  const of = (...states) => files.filter((f) => states.includes(f.state));
+  if (opts.force) {
+    return { component, files, toCopy: of("missing", "identical", "differs"), kept: [], conflicts: of("directory") };
+  }
+  if (component.skipExisting) {
+    return { component, files, toCopy: of("missing"), kept: of("identical", "differs", "directory"), conflicts: [] };
+  }
+  return { component, files, toCopy: of("missing", "identical"), kept: [], conflicts: of("differs", "directory") };
 }
 async function executeInstallPlan(plan, targetDir) {
   const files = [];
   const fileHashes = {};
-  for (const { file, src } of plan.toCopy) {
-    fileHashes[file] = await copyFile(src, targetDir, file, { force: true });
-    files.push(file);
+  const written = [];
+  try {
+    for (const { file, src, state } of plan.toCopy) {
+      const previous = state === "missing" ? null : await readFile7(join8(targetDir, file));
+      fileHashes[file] = await copyFile(src, targetDir, file, { force: true });
+      written.push({ file, previous });
+      files.push(file);
+    }
+  } catch (err) {
+    await rollback(written, targetDir);
+    throw err;
   }
   return { files, fileHashes };
 }
+async function rollback(written, targetDir) {
+  for (const { file, previous } of [...written].reverse()) {
+    try {
+      if (previous === null) {
+        await removeWithin(targetDir, file);
+        await removeEmptyAncestors(targetDir, file);
+      } else {
+        await writeFile9(join8(targetDir, file), previous);
+      }
+    } catch {
+    }
+  }
+}
 
 // src/commands/add.ts
 function describeExisting(f) {
+  if (f.state === "directory") return "is a directory";
   return f.state === "identical" ? "identical to the packaged file" : "differs from the packaged file";
 }
+function directoryConflict(plan) {
+  return plan.conflicts.find((f) => f.state === "directory");
+}
 function printDryRun2(name, plan, options) {
   for (const f of plan.files) {
     if (f.state === "missing") {
       console.log(`  [dry-run] Would copy: ${f.file}`);
+    } else if (f.state === "directory" && !(plan.component.skipExisting && !options.force)) {
+      console.log(`  [dry-run] Would refuse: ${f.file} (exists, is a directory) \u2014 remove it first`);
     } else if (options.force) {
       console.log(`  [dry-run] Would overwrite: ${f.file} (exists, ${describeExisting(f)})`);
     } else if (plan.component.skipExisting) {
       console.log(`  [dry-run] Would keep: ${f.file} (exists, yours, ${describeExisting(f)})`);
+    } else if (f.state === "identical") {
+      console.log(`  [dry-run] Would adopt: ${f.file} (exists, identical to the packaged file)`);
     } else {
       console.log(`  [dry-run] Would refuse: ${f.file} (exists, ${describeExisting(f)}) \u2014 needs --force`);
     }
   }
+  const dir = directoryConflict(plan);
+  if (dir) {
+    console.log(`
+[dry-run] Would refuse component "${name}": a directory is at "${dir.file}", which --force does not replace. Remove it first.`);
+    return;
+  }
   if (plan.conflicts.length > 0) {
     console.log(
       `
@@ -4501,6 +4540,13 @@ async function addOne(name, options, targetDir, assetsDir, packageVersion) {
     printDryRun2(name, plan, options);
     return plan.conflicts.length > 0 ? "failed" : "added";
   }
+  const dir = directoryConflict(plan);
+  if (dir) {
+    console.error(
+      `Cannot add "${name}": "${dir.file}" is a directory, which --force does not replace. Nothing was written. Remove it first.`
+    );
+    return "failed";
+  }
   if (plan.conflicts.length > 0) {
     const others = plan.conflicts.length - 1;
     console.error(
@@ -4561,7 +4607,7 @@ async function runAdd(names, options, targetDir, assetsDir, packageVersion) {
 
 // src/commands/update.ts
 import { dirname as dirname5, join as join10 } from "path";
-import { readFile as readFile7, writeFile as writeFile9 } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile10 } from "fs/promises";
 
 // src/modules/merge3.ts
 var CONFLICT_START = "<<<<<<< yours (edited)";
@@ -4819,7 +4865,7 @@ async function planUpdateInstalls(args) {
     if (component.files.length === 0) continue;
     const plan = await planComponentInstall(component, args.targetDir, args.assetsDir, {});
     if (plan.conflicts.length > 0) {
-      leftAlone.push({ name, kind: "prerequisite", reason: `${plan.conflicts[0].file} already exists${plan.conflicts.length > 1 ? ` (and ${plan.conflicts.length - 1} more)` : ""}, and update does not overwrite` });
+      leftAlone.push({ name, kind: "prerequisite", reason: conflictReason(plan) });
       continue;
     }
     items.push({ plan, kind: "prerequisite", requiredBy });
@@ -4829,13 +4875,19 @@ async function planUpdateInstalls(args) {
     if (component.initOnly || component.files.length === 0) continue;
     const plan = await planComponentInstall(component, args.targetDir, args.assetsDir, {});
     if (plan.conflicts.length > 0) {
-      leftAlone.push({ name: candidate.name, kind: "new", reason: `${plan.conflicts[0].file} already exists, and update does not overwrite` });
+      leftAlone.push({ name: candidate.name, kind: "new", reason: conflictReason(plan) });
       continue;
     }
     items.push({ plan, kind: "new", requiredBy: [] });
   }
   return { items, leftAlone };
 }
+function conflictReason(plan) {
+  const first = plan.conflicts[0];
+  if (first.state === "directory") return `${first.file} is a directory, which update does not replace`;
+  const more = plan.conflicts.length > 1 ? ` (and ${plan.conflicts.length - 1} more)` : "";
+  return `${first.file} already exists${more}, and update does not overwrite`;
+}
 function label(item) {
   return item.kind === "prerequisite" ? `prerequisite of ${item.requiredBy.join(", ")}` : "newly available";
 }
@@ -5348,11 +5400,11 @@ async function runUpdate(options, targetDir, assetsDir, packageVersion) {
             handled = true;
           } else {
             const [currentContent, newContent] = await Promise.all([
-              readFile7(join10(targetDir, file), "utf-8"),
-              readFile7(srcPath, "utf-8")
+              readFile8(join10(targetDir, file), "utf-8"),
+              readFile8(srcPath, "utf-8")
             ]);
             const result = merge3(oldVendorContent, currentContent, newContent);
-            await writeFile9(join10(targetDir, file), result.content, "utf-8");
+            await writeFile10(join10(targetDir, file), result.content, "utf-8");
             fileHashes[file] = await hashFile(srcPath);
             if (result.hasConflict) {
               conflictedFiles.push(file);
@@ -5537,7 +5589,7 @@ ${verb} ${orphansToReport.length} orphaned file(s) (tracked before this update,
 import { dirname as dirname7 } from "path";
 
 // src/modules/version-check.ts
-import { readFile as readFile8, writeFile as writeFile10, mkdir as mkdir6 } from "fs/promises";
+import { readFile as readFile9, writeFile as writeFile11, mkdir as mkdir6 } from "fs/promises";
 import { dirname as dirname6, join as join11 } from "path";
 import { homedir as homedir3 } from "os";
 import { createRequire } from "module";
@@ -5556,7 +5608,7 @@ var DEFAULT_CACHE_PATH = join11(homedir3(), ".arcane", "version-cache.json");
 var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
 async function readCache(cachePath) {
   try {
-    const content = await readFile8(cachePath, "utf-8");
+    const content = await readFile9(cachePath, "utf-8");
     const parsed = JSON.parse(content);
     if (typeof parsed.latest !== "string" || typeof parsed.checkedAt !== "string") {
       return null;
@@ -5569,7 +5621,7 @@ async function readCache(cachePath) {
 async function writeCache(cachePath, latest) {
   await mkdir6(dirname6(cachePath), { recursive: true });
   const entry = { latest, checkedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  await writeFile10(cachePath, JSON.stringify(entry, null, 2), "utf-8");
+  await writeFile11(cachePath, JSON.stringify(entry, null, 2), "utf-8");
 }
 async function getLatestVersion(feedUrl) {
   const normalizedBase = feedUrl.endsWith("/") ? feedUrl : feedUrl + "/";
@@ -5940,7 +5992,7 @@ async function uninstallUserTier(options, storeRoot, manifest) {
 }
 
 // src/commands/doctor.ts
-import { access as access4, readdir as readdir9, readFile as readFile11, mkdir as mkdir7, copyFile as fsCopyFile } from "fs/promises";
+import { access as access4, readdir as readdir9, readFile as readFile12, mkdir as mkdir7, copyFile as fsCopyFile } from "fs/promises";
 import { join as join15, dirname as dirname9 } from "path";
 
 // src/config/incidents.ts
@@ -6009,7 +6061,7 @@ function evaluateIncidentGate(records) {
 }
 
 // src/modules/denylist-scan.ts
-import { readFile as readFile9, readdir as readdir7 } from "fs/promises";
+import { readFile as readFile10, readdir as readdir7 } from "fs/promises";
 import { join as join13, relative } from "path";
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -6027,7 +6079,7 @@ async function scanFile(absolutePath, displayPath, rules) {
   const findings = [];
   let content;
   try {
-    content = await readFile9(absolutePath, "utf8");
+    content = await readFile10(absolutePath, "utf8");
   } catch {
     return findings;
   }
@@ -6321,7 +6373,7 @@ function parseAdoRemote(url) {
 }
 
 // src/modules/placeholders.ts
-import { readdir as readdir8, readFile as readFile10 } from "fs/promises";
+import { readdir as readdir8, readFile as readFile11 } from "fs/promises";
 import { join as join14 } from "path";
 var PLACEHOLDER_STANDARD_FILE = "spell-authoring-standards.md";
 var RUNTIME_PLACEHOLDERS_START = "<!-- runtime-placeholders:start -->";
@@ -6417,7 +6469,7 @@ function parseRuntimePlaceholders(standardContent) {
 async function scanGovernancePlaceholders(governanceDir) {
   let standard;
   try {
-    standard = await readFile10(join14(governanceDir, PLACEHOLDER_STANDARD_FILE), "utf8");
+    standard = await readFile11(join14(governanceDir, PLACEHOLDER_STANDARD_FILE), "utf8");
   } catch (err) {
     if (err.code === "ENOENT") {
       return { status: "skipped", reason: `${PLACEHOLDER_STANDARD_FILE} is not installed` };
@@ -6436,7 +6488,7 @@ async function scanGovernancePlaceholders(governanceDir) {
   const templateDocs = [];
   const findings = [];
   for (const file of files) {
-    const content = await readFile10(join14(governanceDir, file), "utf8");
+    const content = await readFile11(join14(governanceDir, file), "utf8");
     const status = parseFrontmatterStatus(content);
     if (status === "template") templateDocs.push(file);
     if (status !== "active") continue;
@@ -6502,7 +6554,7 @@ async function checkArcaneManifest(targetDir) {
   } catch {
     const selfHostedManifestPath = join15(targetDir, "src", "assets", ".arcane.json");
     try {
-      const raw = await readFile11(selfHostedManifestPath, "utf8");
+      const raw = await readFile12(selfHostedManifestPath, "utf8");
       const manifest = JSON.parse(raw);
       if (isRecord3(manifest) && manifest["selfHosted"] === true && manifest["tracking_mode"] === "internal") {
         return {
@@ -6521,7 +6573,7 @@ async function checkArcaneManifest(targetDir) {
     };
   }
   try {
-    const raw = await readFile11(manifestPath2, "utf8");
+    const raw = await readFile12(manifestPath2, "utf8");
     const manifest = JSON.parse(raw);
     if (!isRecord3(manifest) || typeof manifest["version"] !== "string" || !manifest["version"] || !Array.isArray(manifest["components"])) {
       return {
@@ -6845,7 +6897,7 @@ async function checkMcpConfig(targetDir) {
   const filePath = join15(targetDir, ".mcp.json");
   let raw;
   try {
-    raw = await readFile11(filePath, "utf8");
+    raw = await readFile12(filePath, "utf8");
   } catch {
     return { name, passed: true, blocking: false, message: "no .mcp.json \u2014 nothing to check" };
   }
@@ -6917,7 +6969,7 @@ async function checkDelegations(targetDir) {
   const filePath = join15(targetDir, ".arcane", "delegations.json");
   let raw;
   try {
-    raw = await readFile11(filePath, "utf8");
+    raw = await readFile12(filePath, "utf8");
   } catch {
     return { name, passed: true, blocking: false, message: "no delegations recorded" };
   }
@@ -7137,16 +7189,16 @@ async function runDoctor(targetDir, options = {}, assetsDir) {
 }
 
 // src/commands/ward.ts
-import { readFile as readFile13 } from "fs/promises";
+import { readFile as readFile14 } from "fs/promises";
 
 // src/modules/ward.ts
-import { readdir as readdir10, readFile as readFile12 } from "fs/promises";
+import { readdir as readdir10, readFile as readFile13 } from "fs/promises";
 import { join as join16, relative as relative2 } from "path";
 async function scanFileAllRules(absolutePath, displayPath, rules) {
   const findings = [];
   let content;
   try {
-    content = await readFile12(absolutePath, "utf8");
+    content = await readFile13(absolutePath, "utf8");
   } catch {
     return findings;
   }
@@ -7241,7 +7293,7 @@ async function runWard(repoRoot, options = {}) {
     const findings2 = await scanFileAllRules(absolutePath, displayPath, allRules);
     if (findings2.length > 0) {
       try {
-        fileLines.set(displayPath, (await readFile12(absolutePath, "utf8")).split("\n"));
+        fileLines.set(displayPath, (await readFile13(absolutePath, "utf8")).split("\n"));
       } catch {
       }
     }
@@ -7269,7 +7321,7 @@ function parseTermsFileContent(raw) {
 }
 async function readTermsFile(filePath) {
   try {
-    return parseTermsFileContent(await readFile13(filePath, "utf8"));
+    return parseTermsFileContent(await readFile14(filePath, "utf8"));
   } catch (error) {
     console.warn(
       `\u26A0 arcane: could not read --terms-file "${filePath}": ${error.message}`
@@ -7484,11 +7536,11 @@ import { access as access5 } from "fs/promises";
 import { join as join19 } from "path";
 
 // src/modules/show-report/generate.ts
-import { mkdir as mkdir8, readdir as readdir11, readFile as readFile15, writeFile as writeFile11 } from "fs/promises";
+import { mkdir as mkdir8, readdir as readdir11, readFile as readFile16, writeFile as writeFile12 } from "fs/promises";
 import { basename as basename3, dirname as dirname10, isAbsolute, join as join18, relative as relative3, resolve as resolve4 } from "path";
 
 // src/modules/show-report/model.ts
-import { readFile as readFile14 } from "fs/promises";
+import { readFile as readFile15 } from "fs/promises";
 import { join as join17 } from "path";
 
 // src/modules/show-report/plan-parser.ts
@@ -7762,7 +7814,7 @@ async function getCast(cwd, fromRef, toRef, generatedOutputs = []) {
 // src/modules/show-report/model.ts
 async function readOptional(path4) {
   try {
-    return await readFile14(path4, "utf8");
+    return await readFile15(path4, "utf8");
   } catch {
     return null;
   }
@@ -7864,7 +7916,7 @@ async function buildShowReportModel(options) {
   const ledgerAbsPath = join17(options.rootDir, ledgerRelPath);
   const decisionsAbsPath = join17(options.rootDir, "DECISIONS.md");
   const [planContent, queueContent, ledgerContent, decisionsContent] = await Promise.all([
-    readFile14(planAbsPath, "utf8"),
+    readFile15(planAbsPath, "utf8"),
     readOptional(queueAbsPath),
     readOptional(ledgerAbsPath),
     readOptional(decisionsAbsPath)
@@ -8060,7 +8112,7 @@ function toPosix(path4) {
 async function programFromPlan(rootDir, slug, planRelPath) {
   let planContent;
   try {
-    planContent = await readFile15(join18(rootDir, planRelPath), "utf8");
+    planContent = await readFile16(join18(rootDir, planRelPath), "utf8");
   } catch {
     return { skipped: { slug, reason: `no PLAN.md at ${planRelPath}` } };
   }
@@ -8105,14 +8157,14 @@ function normalizeLineEndings2(content) {
 }
 async function readOptionalFile(path4) {
   try {
-    return await readFile15(path4, "utf8");
+    return await readFile16(path4, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
   }
 }
 async function generateReport(rootDir, program2, templateHtml, theme = "auto") {
-  const planContent = await readFile15(join18(rootDir, program2.planRelPath), "utf8");
+  const planContent = await readFile16(join18(rootDir, program2.planRelPath), "utf8");
   const frontmatter = parseFrontmatter(planContent);
   const model = await buildShowReportModel({
     rootDir,
@@ -8132,7 +8184,7 @@ async function generateReport(rootDir, program2, templateHtml, theme = "auto") {
   };
 }
 async function runReportGeneration(options) {
-  const templateHtml = await readFile15(options.templatePath, "utf8");
+  const templateHtml = await readFile16(options.templatePath, "utf8");
   const theme = options.theme ?? "auto";
   const drifted = [];
   const repaired = [];
@@ -8155,7 +8207,7 @@ async function runReportGeneration(options) {
         drifted.push(`${relPath} does not match a regeneration from its sources.`);
         if (options.mode === "write") {
           await mkdir8(outAbs, { recursive: true });
-          await writeFile11(join18(options.rootDir, relPath), expected, "utf8");
+          await writeFile12(join18(options.rootDir, relPath), expected, "utf8");
           repaired.push(relPath);
         }
       }