@pieai/doc-gov 0.9.6 → 0.9.8

package/cli-guide.md

@@ -62,7 +62,9 @@ pnpm doc-gov migrate --profile doc-only --check
 - It also checks that local paths written in backticks inside router-facing
   files such as `AGENTS.md`, `CLAUDE.md`, `README.md`, and the starter
   `AGENTS.template.md` can actually be opened, which catches stale startup
-  instructions early.
+  instructions early. An exact PGS-managed shared-rule symlink remains valid
+  when its private sibling checkout is unavailable in standalone CI; ordinary
+  dangling or noncanonical links still fail.
 
 It does not choose a workflow for a specific task.
 

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/commands/approve.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join5 } from "node:path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join6 } from "node:path";
 
 // src/core/frontmatter.ts
 import { readFileSync } from "node:fs";
@@ -238,6 +238,95 @@ function toRepoPath2(rootDir, absolutePath) {
   return relative2(rootDir, absolutePath).split(/\\/g).join("/");
 }
 
+// src/core/managed-shared-rules.ts
+import { existsSync as existsSync2, lstatSync as lstatSync2, readFileSync as readFileSync3, readlinkSync } from "node:fs";
+import { join as join3, relative as relative3, resolve as resolve2 } from "node:path";
+
+// src/core/symlinks.ts
+function normalizeSymlinkTarget(target) {
+  return target.replaceAll("\\", "/");
+}
+
+// src/core/managed-shared-rules.ts
+var SHARED_RULE_PATH_PREFIX = "docs/policy/shared-rules/";
+var PGS_SHARED_RULE_TARGET_PATTERN = /^(?:\.\.\/)+ProjectGovernanceSystem\/agent-assets\/rules\/pie-rules\/([^/]+\.md)$/;
+function isUnresolvedManagedSharedRuleSymlink(rootDir, candidatePath) {
+  const repoPath = toRepoPath3(rootDir, candidatePath);
+  const filename = sharedRuleFilename(repoPath);
+  if (!filename) return false;
+  let stats;
+  try {
+    stats = lstatSync2(candidatePath);
+  } catch {
+    return false;
+  }
+  if (!stats.isSymbolicLink() || existsSync2(candidatePath)) return false;
+  try {
+    const target = normalizeSymlinkTarget(readlinkSync(candidatePath));
+    const match = target.match(PGS_SHARED_RULE_TARGET_PATTERN);
+    return match?.[1] === filename;
+  } catch {
+    return false;
+  }
+}
+function findUnavailableManagedSharedRuleEntries(rootDir) {
+  const manifestEntries = readManifestEntries(rootDir);
+  return manifestEntries.filter(
+    (entry) => entry.type === "policy" && isUnresolvedManagedSharedRuleSymlink(rootDir, join3(rootDir, entry.path))
+  );
+}
+function sharedRuleFilename(repoPath) {
+  if (!repoPath.startsWith(SHARED_RULE_PATH_PREFIX)) return void 0;
+  const filename = repoPath.slice(SHARED_RULE_PATH_PREFIX.length);
+  if (!filename || filename.includes("/") || !filename.endsWith(".md")) return void 0;
+  return filename;
+}
+function readManifestEntries(rootDir) {
+  const manifestPath = join3(rootDir, "docs/governance/MANIFEST.yml");
+  if (!existsSync2(manifestPath)) return [];
+  try {
+    const lines = readFileSync3(manifestPath, "utf8").split("\n");
+    const entries = [];
+    let current;
+    const flush = () => {
+      if (current && typeof current.id === "string" && typeof current.path === "string" && typeof current.type === "string" && typeof current.status === "string" && typeof current.canonical === "boolean" && typeof current.lastReviewed === "string" && typeof current.pinned === "boolean") {
+        entries.push(current);
+      }
+    };
+    for (const line of lines) {
+      const idMatch = line.match(/^\s+- id:\s*(.+?)\s*$/);
+      if (idMatch) {
+        flush();
+        current = { id: cleanValue(idMatch[1] ?? "") };
+        continue;
+      }
+      if (!current) continue;
+      const fieldMatch = line.match(
+        /^\s+(path|type|status|canonical|last_reviewed|pinned):\s*(.*?)\s*$/
+      );
+      if (!fieldMatch) continue;
+      const field = fieldMatch[1];
+      const value = cleanValue(fieldMatch[2] ?? "");
+      if (field === "path") current.path = value;
+      if (field === "type") current.type = value;
+      if (field === "status") current.status = value;
+      if (field === "canonical") current.canonical = value === "true";
+      if (field === "last_reviewed") current.lastReviewed = value;
+      if (field === "pinned") current.pinned = value === "true";
+    }
+    flush();
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function cleanValue(value) {
+  return value.replace(/^(['"])(.*)\1$/, "$2");
+}
+function toRepoPath3(rootDir, candidatePath) {
+  return relative3(resolve2(rootDir), resolve2(candidatePath)).split(/\\/g).join("/");
+}
+
 // src/core/lifecycle.ts
 var normalStatuses = [
   "draft",
@@ -405,6 +494,24 @@ function checkDocs(rootDir = process.cwd()) {
     issues.push(...result.issues);
     if (result.record) records.push(result.record);
   }
+  for (const entry of findUnavailableManagedSharedRuleEntries(rootDir)) {
+    records.push({
+      id: entry.id,
+      title: entry.id,
+      type: entry.type,
+      status: entry.status,
+      canonical: entry.canonical,
+      owner: "external-shared-rule",
+      created: entry.lastReviewed,
+      lastReviewed: entry.lastReviewed,
+      domain: "shared-rule",
+      tags: ["shared-rule"],
+      pinned: entry.pinned,
+      related: [],
+      supersedes: [],
+      path: entry.path
+    });
+  }
   issues.push(...validateGlobalIntegrity(records));
   return {
     ok: issues.length === 0,
@@ -510,8 +617,8 @@ function pathToRepo(rootDir, path) {
 }
 
 // src/core/paths.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { basename, join as join3 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { basename, join as join4 } from "node:path";
 function planPath(rootDir, type, slugInput) {
   const cleanSlug = slugInput.replace(/^\/+|\/+$/g, "");
   if (!cleanSlug) throw new Error("Slug is required.");
@@ -580,8 +687,8 @@ function planPath(rootDir, type, slugInput) {
   throw new Error(`Unknown type: ${type}`);
 }
 function nextSerial(rootDir, scanDir, regex) {
-  const root = join3(rootDir, scanDir);
-  if (!existsSync2(root)) return "0001";
+  const root = join4(rootDir, scanDir);
+  if (!existsSync3(root)) return "0001";
   let max = 0;
   walkSerial(rootDir, scanDir, regex, (n) => {
     if (n > max) max = n;
@@ -610,8 +717,8 @@ function todayIso() {
 }
 
 // src/core/manifest.ts
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "node:fs";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join5 } from "node:path";
 function buildManifest(rootDir = process.cwd()) {
   const result = checkDocs(rootDir);
   if (!result.ok) {
@@ -623,14 +730,14 @@ ${error}`);
 }
 function writeManifest(rootDir = process.cwd()) {
   const manifest = buildManifest(rootDir);
-  const path = join4(rootDir, "docs/governance/MANIFEST.yml");
+  const path = join5(rootDir, "docs/governance/MANIFEST.yml");
   mkdirSync(dirname2(path), { recursive: true });
   writeFileSync(path, manifest);
 }
 function manifestInSync(rootDir = process.cwd()) {
-  const path = join4(rootDir, "docs/governance/MANIFEST.yml");
-  if (!existsSync3(path)) return false;
-  return normalizeManifest(readFileSync3(path, "utf8")) === normalizeManifest(buildManifest(rootDir));
+  const path = join5(rootDir, "docs/governance/MANIFEST.yml");
+  if (!existsSync4(path)) return false;
+  return normalizeManifest(readFileSync4(path, "utf8")) === normalizeManifest(buildManifest(rootDir));
 }
 function normalizeManifest(value) {
   return value.replace(/^generated_at: .*$/m, "generated_at: <ignored>").replace(/^generator_version: .*$/m, "generator_version: <ignored>");
@@ -659,7 +766,7 @@ function renderManifest(records) {
 function readPackageVersion() {
   for (const candidate of ["../package.json", "../../package.json"]) {
     try {
-      const packageJson = JSON.parse(readFileSync3(new URL(candidate, import.meta.url), "utf8"));
+      const packageJson = JSON.parse(readFileSync4(new URL(candidate, import.meta.url), "utf8"));
       if (typeof packageJson.version === "string") return packageJson.version;
     } catch {
     }
@@ -695,8 +802,8 @@ function runApprove(args2) {
     );
     return 1;
   }
-  const filePath = join5(root, record.path);
-  const content = readFileSync4(filePath, "utf8");
+  const filePath = join6(root, record.path);
+  const content = readFileSync5(filePath, "utf8");
   let next = content;
   next = updateFrontmatterField(next, "status", toStatus);
   next = updateFrontmatterField(next, "canonical", "true");
@@ -742,8 +849,8 @@ ${newLines.join("\n")}${tail}`;
 
 // src/commands/archive.ts
 import { execFileSync } from "node:child_process";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync5, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename2, dirname as dirname3, join as join6 } from "node:path";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync6, renameSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename2, dirname as dirname3, join as join7 } from "node:path";
 function runArchive(args2) {
   const positional = args2.filter((a) => !a.startsWith("--"));
   const id = positional[0];
@@ -782,9 +889,9 @@ function runArchive(args2) {
   const fileName = basename2(oldPath);
   const archiveDir = `docs/archive/${quarterTag()}-${record.type}`;
   const newPath = `${archiveDir}/${fileName}`;
-  const absNew = join6(root, newPath);
-  const absOld = join6(root, oldPath);
-  let content = readFileSync5(absOld, "utf8");
+  const absNew = join7(root, newPath);
+  const absOld = join7(root, oldPath);
+  let content = readFileSync6(absOld, "utf8");
   content = updateFrontmatterField(content, "type", "archive");
   content = updateFrontmatterField(content, "status", "archived");
   content = updateFrontmatterField(content, "canonical", "false");
@@ -813,12 +920,12 @@ function runArchive(args2) {
 }
 
 // src/commands/audit.ts
-import { existsSync as existsSync5, readdirSync as readdirSync2 } from "node:fs";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync2 } from "node:fs";
+import { join as join8 } from "node:path";
 
 // src/core/link-checker.ts
-import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
-import { dirname as dirname4, extname, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "node:fs";
+import { dirname as dirname4, extname, resolve as resolve3 } from "node:path";
 var CURRENT_MARKDOWN_ROOTS = ["AGENTS.md", "README.md", "docs"];
 var CURRENT_DOC_DIR_PREFIXES = [
   "docs/canon/",
@@ -898,12 +1005,12 @@ function shouldIgnoreTarget(target) {
 function localTargetExists(rootDir, sourcePath, target) {
   const pathPart = decodeTarget(target).split("#")[0]?.split("?")[0] ?? "";
   if (!pathPart) return true;
-  const resolved = pathPart.startsWith("/") ? resolve2(rootDir, `.${pathPart}`) : resolve2(dirname4(sourcePath), pathPart);
+  const resolved = pathPart.startsWith("/") ? resolve3(rootDir, `.${pathPart}`) : resolve3(dirname4(sourcePath), pathPart);
   const candidates = [resolved];
   if (!extname(resolved)) {
     candidates.push(`${resolved}.md`);
   }
-  return candidates.some((candidate) => existsSync4(candidate));
+  return candidates.some((candidate) => existsSync5(candidate));
 }
 function decodeTarget(target) {
   try {
@@ -920,7 +1027,7 @@ function lineNumberAt(content, index) {
   return line;
 }
 function readText(filePath) {
-  return readFileSync6(filePath, "utf8");
+  return readFileSync7(filePath, "utf8");
 }
 
 // src/commands/audit.ts
@@ -934,15 +1041,15 @@ function runAudit() {
     }
     return 1;
   }
-  const migrationSource = join7(root, "Docs-for trans");
-  if (existsSync5(migrationSource)) {
+  const migrationSource = join8(root, "Docs-for trans");
+  if (existsSync6(migrationSource)) {
     const count = countFiles(migrationSource);
     warnings += 1;
     console.log(
       `Migration source still exists: Docs-for trans (${count} files). This was a one-time migration shell; it should not be reintroduced.`
     );
   }
-  if (existsSync5(join7(root, "DocSystemStarter.md"))) {
+  if (existsSync6(join8(root, "DocSystemStarter.md"))) {
     warnings += 1;
     console.log(
       "Stray root-level DocSystemStarter.md exists. The original draft has been archived; remove or re-archive."
@@ -968,7 +1075,7 @@ function runAudit() {
 function countFiles(dir) {
   let count = 0;
   for (const entry of readdirSync2(dir, { withFileTypes: true })) {
-    const path = join7(dir, entry.name);
+    const path = join8(dir, entry.name);
     if (entry.isDirectory()) count += countFiles(path);
     if (entry.isFile() || entry.isSymbolicLink()) count += 1;
   }
@@ -990,19 +1097,12 @@ function runCheck() {
 
 // src/commands/doctor.ts
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync7, readFileSync as readFileSync8 } from "node:fs";
-import { isAbsolute as isAbsolute2, join as join9, resolve as resolve3 } from "node:path";
-
-// src/core/router-integrity.ts
-import { existsSync as existsSync6, lstatSync as lstatSync2, readlinkSync, readFileSync as readFileSync7 } from "node:fs";
-import { join as join8, relative as relative3 } from "node:path";
-
-// src/core/symlinks.ts
-function normalizeSymlinkTarget(target) {
-  return target.replaceAll("\\", "/");
-}
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join10, resolve as resolve4 } from "node:path";
 
 // src/core/router-integrity.ts
+import { existsSync as existsSync7, lstatSync as lstatSync3, readlinkSync as readlinkSync2, readFileSync as readFileSync8 } from "node:fs";
+import { join as join9, relative as relative4 } from "node:path";
 var CENTRAL_REQUIRED_FILES = [
   "AGENTS.md",
   "CLAUDE.md",
@@ -1320,7 +1420,7 @@ function checkRouterIntegrity(rootDir = process.cwd()) {
   const requiredFiles = isCentral ? CENTRAL_REQUIRED_FILES : PROJECT_REQUIRED_FILES;
   const requiredNeedles = isCentral ? CENTRAL_REQUIRED_NEEDLES : PROJECT_REQUIRED_NEEDLES;
   for (const file of requiredFiles) {
-    if (!existsSync6(join8(rootDir, file))) {
+    if (!existsSync7(join9(rootDir, file))) {
       issues.push({
         file,
         code: "missing-router-file",
@@ -1333,7 +1433,7 @@ function checkRouterIntegrity(rootDir = process.cwd()) {
   }
   issues.push(...validateHostSsot(rootDir));
   for (const file of FORBIDDEN_LEGACY_PATHS) {
-    if (existsSync6(join8(rootDir, file))) {
+    if (existsSync7(join9(rootDir, file))) {
       issues.push({
         file,
         code: "legacy-governance-path",
@@ -1343,7 +1443,7 @@ function checkRouterIntegrity(rootDir = process.cwd()) {
   }
   if (!isCentral) {
     for (const file of FORBIDDEN_PROJECT_PATHS) {
-      if (existsSync6(join8(rootDir, file))) {
+      if (existsSync7(join9(rootDir, file))) {
         issues.push({
           file,
           code: "legacy-project-policy-path",
@@ -1352,7 +1452,7 @@ function checkRouterIntegrity(rootDir = process.cwd()) {
       }
     }
     for (const file of SUPERSEDED_PROJECT_CONTRACT_PATHS) {
-      if (existsSync6(join8(rootDir, file))) {
+      if (existsSync7(join9(rootDir, file))) {
         issues.push({
           file,
           code: "superseded-project-contract",
@@ -1361,7 +1461,7 @@ function checkRouterIntegrity(rootDir = process.cwd()) {
       }
     }
     for (const file of FORBIDDEN_PROJECT_ROOTS) {
-      if (existsSync6(join8(rootDir, file))) {
+      if (existsSync7(join9(rootDir, file))) {
         issues.push({
           file,
           code: "project-root-integration-path",
@@ -1371,7 +1471,7 @@ function checkRouterIntegrity(rootDir = process.cwd()) {
     }
   } else {
     for (const file of FORBIDDEN_CENTRAL_ROOTS) {
-      if (existsSync6(join8(rootDir, file))) {
+      if (existsSync7(join9(rootDir, file))) {
         issues.push({
           file,
           code: "central-external-shared-rule-copy",
@@ -1388,9 +1488,9 @@ function checkRouterIntegrity(rootDir = process.cwd()) {
     });
   }
   for (const requirement of requiredNeedles) {
-    const path = join8(rootDir, requirement.file);
-    if (!existsSync6(path)) continue;
-    const content = readFileSync7(path, "utf8");
+    const path = join9(rootDir, requirement.file);
+    if (!existsSync7(path)) continue;
+    const content = readFileSync8(path, "utf8");
     if (!content.includes(requirement.needle)) {
       issues.push({
         file: requirement.file,
@@ -1436,7 +1536,7 @@ function validateHostSsot(rootDir) {
   validateExactSymlink(".claude/skills", "../.agents/skills");
   return issues;
   function validateRegularFile(file) {
-    const stat = safeLstat2(join8(rootDir, file));
+    const stat = safeLstat2(join9(rootDir, file));
     if (!stat || stat.isFile()) return;
     issues.push({
       file,
@@ -1445,7 +1545,7 @@ function validateHostSsot(rootDir) {
     });
   }
   function validateDirectory(file) {
-    const stat = safeLstat2(join8(rootDir, file));
+    const stat = safeLstat2(join9(rootDir, file));
     if (!stat || stat.isDirectory()) return;
     issues.push({
       file,
@@ -1454,7 +1554,7 @@ function validateHostSsot(rootDir) {
     });
   }
   function validateExactSymlink(file, expectedRawTarget) {
-    const path = join8(rootDir, file);
+    const path = join9(rootDir, file);
     const stat = safeLstat2(path);
     if (!stat) return;
     if (!stat.isSymbolicLink()) {
@@ -1465,7 +1565,7 @@ function validateHostSsot(rootDir) {
       });
       return;
     }
-    const rawTarget = normalizeSymlinkTarget(readlinkSync(path));
+    const rawTarget = normalizeSymlinkTarget(readlinkSync2(path));
     if (rawTarget !== expectedRawTarget) {
       issues.push({
         file,
@@ -1477,7 +1577,7 @@ function validateHostSsot(rootDir) {
 }
 function safeLstat2(path) {
   try {
-    return lstatSync2(path);
+    return lstatSync3(path);
   } catch (error) {
     const code = error.code;
     if (code === "ENOENT" || code === "ENOTDIR") return void 0;
@@ -1485,27 +1585,27 @@ function safeLstat2(path) {
   }
 }
 function isCentralRepository(rootDir) {
-  const packageJsonPath = join8(rootDir, "package.json");
-  if (!existsSync6(packageJsonPath)) return false;
+  const packageJsonPath = join9(rootDir, "package.json");
+  if (!existsSync7(packageJsonPath)) return false;
   const packageName = readPackageName(packageJsonPath);
   const centralPackageNames = /* @__PURE__ */ new Set(["project-governance-system", "pro-gov"]);
   return centralPackageNames.has(packageName) && hasCentralRepositoryShape(rootDir);
 }
 function readPackageName(packageJsonPath) {
   try {
-    const packageJson = JSON.parse(readFileSync7(packageJsonPath, "utf8"));
+    const packageJson = JSON.parse(readFileSync8(packageJsonPath, "utf8"));
     return typeof packageJson.name === "string" ? packageJson.name : "";
   } catch {
     return "";
   }
 }
 function hasCentralRepositoryShape(rootDir) {
-  return existsSync6(join8(rootDir, "profiles")) && existsSync6(join8(rootDir, "starter")) && existsSync6(join8(rootDir, "integrations"));
+  return existsSync7(join9(rootDir, "profiles")) && existsSync7(join9(rootDir, "starter")) && existsSync7(join9(rootDir, "integrations"));
 }
 function validateProjectAgentsRouting(rootDir) {
   const issues = [];
   const existingRoutes = PROJECT_AGENTS_ROUTING_FILES.filter(
-    (file) => existsSync6(join8(rootDir, file))
+    (file) => existsSync7(join9(rootDir, file))
   );
   if (existingRoutes.length === 0) {
     issues.push({
@@ -1515,9 +1615,9 @@ function validateProjectAgentsRouting(rootDir) {
     });
     return issues;
   }
-  const agentsPath = join8(rootDir, "AGENTS.md");
-  if (!existsSync6(agentsPath)) return issues;
-  const agents = readFileSync7(agentsPath, "utf8");
+  const agentsPath = join9(rootDir, "AGENTS.md");
+  if (!existsSync7(agentsPath)) return issues;
+  const agents = readFileSync8(agentsPath, "utf8");
   if (!existingRoutes.some((file) => agents.includes(file))) {
     issues.push({
       file: "AGENTS.md",
@@ -1528,9 +1628,9 @@ function validateProjectAgentsRouting(rootDir) {
   return issues;
 }
 function validateRouterBlock(rootDir, file) {
-  const path = join8(rootDir, file);
-  if (!existsSync6(path)) return [];
-  const content = readFileSync7(path, "utf8");
+  const path = join9(rootDir, file);
+  if (!existsSync7(path)) return [];
+  const content = readFileSync8(path, "utf8");
   const begin = content.indexOf(ROUTER_BLOCK_BEGIN);
   const end = content.indexOf(ROUTER_BLOCK_END);
   const issues = [];
@@ -1555,9 +1655,9 @@ function validateRouterBlock(rootDir, file) {
   return issues;
 }
 function validateBacktickedLocalPaths(rootDir, file, pathRoot = "") {
-  const path = join8(rootDir, file);
-  if (!existsSync6(path)) return [];
-  const content = readFileSync7(path, "utf8");
+  const path = join9(rootDir, file);
+  if (!existsSync7(path)) return [];
+  const content = readFileSync8(path, "utf8");
   const issues = [];
   const seen = /* @__PURE__ */ new Set();
   const matches = content.matchAll(/`([^`]+)`/g);
@@ -1567,7 +1667,10 @@ function validateBacktickedLocalPaths(rootDir, file, pathRoot = "") {
     seen.add(value);
     if (!isLocalPathReference(value)) continue;
     const normalized = value.endsWith("/") ? value.slice(0, -1) : value;
-    if (existsSync6(join8(rootDir, pathRoot, normalized)) || existsSync6(join8(rootDir, normalized))) {
+    const candidatePaths = [join9(rootDir, pathRoot, normalized), join9(rootDir, normalized)];
+    if (candidatePaths.some(
+      (candidatePath) => existsSync7(candidatePath) || isUnresolvedManagedSharedRuleSymlink(rootDir, candidatePath)
+    )) {
       continue;
     }
     issues.push({
@@ -1586,9 +1689,9 @@ function isLocalPathReference(value) {
   return value === "README.md" || value.endsWith(".md") || value.endsWith("/") || value.startsWith("docs/") || value.startsWith("starter/") || value.startsWith("profiles/") || value.startsWith("integrations/");
 }
 function validatePortableRouterText(rootDir, file) {
-  const path = join8(rootDir, file);
-  if (!existsSync6(path)) return [];
-  const content = readFileSync7(path, "utf8");
+  const path = join9(rootDir, file);
+  if (!existsSync7(path)) return [];
+  const content = readFileSync8(path, "utf8");
   if (!hasNonPortablePath(content)) return [];
   return [
     {
@@ -1610,7 +1713,7 @@ function hasNonPortablePath(content) {
 function findGovernedReadmes(rootDir) {
   return listMarkdownFiles(rootDir, ["docs", "starter/docs"], {
     includeFile: (repoPath) => repoPath.toLowerCase().endsWith("/readme.md")
-  }).map((path) => relative3(rootDir, path).split(/\\/g).join("/")).filter((repoPath) => repoPath !== "README.md");
+  }).map((path) => relative4(rootDir, path).split(/\\/g).join("/")).filter((repoPath) => repoPath !== "README.md");
 }
 
 // src/commands/doctor.ts
@@ -1678,8 +1781,8 @@ function collectDoctorIssues(rootDir = process.cwd()) {
   return issues;
 }
 function checkLefthook(rootDir) {
-  const path = join9(rootDir, "lefthook.yml");
-  if (!existsSync7(path)) {
+  const path = join10(rootDir, "lefthook.yml");
+  if (!existsSync8(path)) {
     return [
       {
         severity: "warning",
@@ -1688,7 +1791,7 @@ function checkLefthook(rootDir) {
       }
     ];
   }
-  const content = readFileSync8(path, "utf8");
+  const content = readFileSync9(path, "utf8");
   const issues = [];
   for (const command2 of [
     "pnpm doc-gov router-check",
@@ -1725,8 +1828,8 @@ function checkLefthook(rootDir) {
   return issues;
 }
 function checkDocsCheckWorkflow(rootDir) {
-  const path = join9(rootDir, ".github/workflows/docs-check.yml");
-  if (!existsSync7(path)) {
+  const path = join10(rootDir, ".github/workflows/docs-check.yml");
+  if (!existsSync8(path)) {
     return [
       {
         severity: "warning",
@@ -1735,7 +1838,7 @@ function checkDocsCheckWorkflow(rootDir) {
       }
     ];
   }
-  const content = readFileSync8(path, "utf8");
+  const content = readFileSync9(path, "utf8");
   const issues = [];
   for (const command2 of [
     "pnpm doc-gov router-check",
@@ -1755,15 +1858,15 @@ function checkDocsCheckWorkflow(rootDir) {
   return issues;
 }
 function hookCallsLefthook(path) {
-  return existsSync7(path) && readFileSync8(path, "utf8").includes("lefthook");
+  return existsSync8(path) && readFileSync9(path, "utf8").includes("lefthook");
 }
 function resolveGitHookPath(rootDir, hookName) {
   const result = spawnSync("git", ["-C", rootDir, "rev-parse", "--git-path", `hooks/${hookName}`], {
     encoding: "utf8"
   });
   const gitPath = result.status === 0 ? result.stdout.trim() : "";
-  if (!gitPath) return join9(rootDir, ".git/hooks", hookName);
-  return isAbsolute2(gitPath) ? gitPath : resolve3(rootDir, gitPath);
+  if (!gitPath) return join10(rootDir, ".git/hooks", hookName);
+  return isAbsolute2(gitPath) ? gitPath : resolve4(rootDir, gitPath);
 }
 
 // src/commands/find.ts
@@ -1801,12 +1904,12 @@ function runFind(args2) {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join12 } from "node:path";
 
 // src/core/templates.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync10, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join11 } from "node:path";
 var TEMPLATE_FILES = {
   decision: "adr.md",
   spec: "spec.md",
@@ -2014,19 +2117,19 @@ var DEFAULT_TEMPLATES = {
 function loadTemplate(rootDir, type) {
   const file = TEMPLATE_FILES[type];
   if (!file) throw new Error(`No template file mapped for type: ${type}`);
-  const path = join10(rootDir, "docs/governance/templates", file);
-  if (existsSync8(path)) return readFileSync9(path, "utf8");
+  const path = join11(rootDir, "docs/governance/templates", file);
+  if (existsSync9(path)) return readFileSync10(path, "utf8");
   const fallback = DEFAULT_TEMPLATES[file];
   if (fallback) return fallback;
   throw new Error(`Template file is missing: docs/governance/templates/${file}`);
 }
 function ensureDefaultTemplates(rootDir) {
-  const templatesDir = join10(rootDir, "docs/governance/templates");
+  const templatesDir = join11(rootDir, "docs/governance/templates");
   mkdirSync3(templatesDir, { recursive: true });
   let created = 0;
   for (const [file, content] of Object.entries(DEFAULT_TEMPLATES)) {
-    const path = join10(templatesDir, file);
-    if (existsSync8(path)) continue;
+    const path = join11(templatesDir, file);
+    if (existsSync9(path)) continue;
     writeFileSync4(path, content);
     created++;
   }
@@ -2081,16 +2184,16 @@ function runInit(args2) {
   ];
   let created = 0;
   for (const dir of dirs) {
-    const abs = join11(root, dir);
-    if (!existsSync9(abs)) {
+    const abs = join12(root, dir);
+    if (!existsSync10(abs)) {
       mkdirSync4(abs, { recursive: true });
       created++;
     } else if (!force) {
     }
   }
   for (const dir of ["docs/specs/completed", "docs/plans/completed", "docs/archive"]) {
-    const keep = join11(root, dir, ".gitkeep");
-    if (!existsSync9(keep)) writeFileSync5(keep, "");
+    const keep = join12(root, dir, ".gitkeep");
+    if (!existsSync10(keep)) writeFileSync5(keep, "");
   }
   const templatesCreated = ensureDefaultTemplates(root);
   console.log(
@@ -2137,8 +2240,8 @@ function runLinks() {
 }
 
 // src/commands/migrate.ts
-import { existsSync as existsSync10, readFileSync as readFileSync10 } from "node:fs";
-import { join as join12 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync11 } from "node:fs";
+import { join as join13 } from "node:path";
 var PROFILE_ROUTES = {
   "engineering-runtime": "docs/governance/agents-routing/engineering-runtime-v1.1.md",
   "doc-only": "docs/governance/agents-routing/doc-only-v1.1.md"
@@ -2175,11 +2278,11 @@ function checkMigrationReadiness(rootDir, profile) {
     issues.push(`${issue.file}: ${issue.code}: ${issue.message}`);
   }
   const route = PROFILE_ROUTES[profile];
-  if (!existsSync10(join12(rootDir, route))) {
+  if (!existsSync11(join13(rootDir, route))) {
     issues.push(`missing selected profile route: ${route}`);
   }
-  const agentsPath = join12(rootDir, "AGENTS.md");
-  if (existsSync10(agentsPath) && !readFileSync10(agentsPath, "utf8").includes(route)) {
+  const agentsPath = join13(rootDir, "AGENTS.md");
+  if (existsSync11(agentsPath) && !readFileSync11(agentsPath, "utf8").includes(route)) {
     issues.push(`AGENTS.md must name selected profile route: ${route}`);
   }
   return issues;
@@ -2226,8 +2329,8 @@ function readFlag(args2, name) {
 }
 
 // src/commands/new.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname5, join as join13 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname5, join as join14 } from "node:path";
 function runNew(args2) {
   const positional = args2.filter((a) => !a.startsWith("--"));
   const owner = readFlag2(args2, "--owner") ?? "human";
@@ -2253,8 +2356,8 @@ function runNew(args2) {
     console.error(err.message);
     return 1;
   }
-  const absPath = join13(root, plan.filePath);
-  if (existsSync11(absPath) && !force) {
+  const absPath = join14(root, plan.filePath);
+  if (existsSync12(absPath) && !force) {
     console.error(`File already exists: ${plan.filePath}. Use --force to overwrite.`);
     return 1;
   }
@@ -2337,8 +2440,8 @@ function runScan(args2) {
 }
 
 // src/commands/supersede.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join14 } from "node:path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join15 } from "node:path";
 function runSupersede(args2) {
   const [oldId, newId] = args2;
   if (!oldId || !newId) {
@@ -2374,15 +2477,15 @@ function runSupersede(args2) {
     return 1;
   }
   const today = todayIso();
-  const oldPath = join14(root, oldRec.path);
-  let oldContent = readFileSync11(oldPath, "utf8");
+  const oldPath = join15(root, oldRec.path);
+  let oldContent = readFileSync12(oldPath, "utf8");
   oldContent = updateFrontmatterField(oldContent, "status", "superseded");
   oldContent = updateFrontmatterField(oldContent, "canonical", "false");
   oldContent = updateFrontmatterField(oldContent, "superseded_by", newId);
   oldContent = updateFrontmatterField(oldContent, "last_reviewed", today);
   writeFileSync7(oldPath, oldContent);
-  const newPath = join14(root, newRec.path);
-  let newContent = readFileSync11(newPath, "utf8");
+  const newPath = join15(root, newRec.path);
+  let newContent = readFileSync12(newPath, "utf8");
   newContent = appendToFrontmatterList(newContent, "supersedes", newId === oldId ? "" : oldId);
   newContent = updateFrontmatterField(newContent, "last_reviewed", today);
   writeFileSync7(newPath, newContent);
@@ -2431,13 +2534,13 @@ ${lines.join("\n")}${tail}`;
 
 // src/commands/verify-commit-msg.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { existsSync as existsSync12, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync13 } from "node:fs";
 function runVerifyCommitMsg(args2) {
   const msgFile = args2[0];
-  if (!msgFile || !existsSync12(msgFile)) {
+  if (!msgFile || !existsSync13(msgFile)) {
     return 0;
   }
-  const message = readFileSync12(msgFile, "utf8");
+  const message = readFileSync13(msgFile, "utf8");
   if (/^Merge\b/m.test(message) || /^Revert\b/m.test(message)) return 0;
   let stagedFiles = [];
   try {
@@ -2449,7 +2552,7 @@ function runVerifyCommitMsg(args2) {
   }
   const failures = [];
   for (const file of stagedFiles) {
-    if (!existsSync12(file)) continue;
+    if (!existsSync13(file)) continue;
     const fm = readFrontmatterFile(file);
     if (!fm) continue;
     const id = stringValue(fm.data.id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pieai/doc-gov",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "AI-native documentation governance CLI for project docs, agent routing, and lifecycle checks.",
   "keywords": [
     "ai-agents",