claudeos-core 1.5.0 → 1.6.0

package/plan-installer/scanners/scan-java.js

@@ -20,7 +20,7 @@ async function scanJavaDomains(stack, ROOT) {
 
   const javaFiles = await glob("src/main/java/**/*.java", { cwd: ROOT });
   for (const f of javaFiles) {
-    const m = f.match(/src\/main\/java\/(.+?)\/(controller|aggregator|service|mapper|dao|dto|entity|repository|adapter)/);
+    const m = f.match(/src\/main\/java\/(.+?)\/(controller|aggregator|facade|usecase|orchestrator|service|mapper|dao|dto|entity|repository|adapter)/);
     if (m) { rootPackage = m[1].replace(/\//g, "."); break; }
   }
   const domainMap = {};
@@ -100,16 +100,16 @@ async function scanJavaDomains(stack, ROOT) {
     if (Object.keys(domainMap).length > 0) detectedPattern = "C";
   }
 
-  // ── Supplementary scan: detect domains without controllers (service/dao/aggregator only) ──
+  // ── Supplementary scan: detect domains without controllers (service/dao/aggregator/facade/usecase only) ──
   // Runs for ALL detected patterns (A/B/C/D/E) to catch core-only domains
   {
     const serviceDirs = await glob("src/main/java/**/*/service/*.java", { cwd: ROOT });
     const mapperDirs = await glob("src/main/java/**/*/{mapper,repository,dao}/*.java", { cwd: ROOT });
-    const aggregatorDirs = await glob("src/main/java/**/*/aggregator/*.java", { cwd: ROOT });
-    const allServiceFiles = [...serviceDirs, ...mapperDirs, ...aggregatorDirs];
+    const orchestrationDirs = await glob("src/main/java/**/*/{aggregator,facade,usecase,orchestrator}/*.java", { cwd: ROOT });
+    const allServiceFiles = [...serviceDirs, ...mapperDirs, ...orchestrationDirs];
     const skipDomains = ["common", "config", "util", "utils", "base", "core", "shared", "global", "framework", "infra", "front", "admin", "back", "internal", "external", "web", "app", "test", "tests", "main", "generated", "build"];
     for (const f of allServiceFiles) {
-      const m = f.match(/\/([^/]+)\/(service|mapper|repository|dao|aggregator)\/[^/]+\.java$/);
+      const m = f.match(/\/([^/]+)\/(service|mapper|repository|dao|aggregator|facade|usecase|orchestrator)\/[^/]+\.java$/);
       if (m) {
         const d = m[1];
         if (!domainMap[d] && !skipDomains.includes(d) && !/^v\d+$/.test(d)) {
@@ -119,7 +119,7 @@ async function scanJavaDomains(stack, ROOT) {
     }
   }
 
-  // Scan service/mapper/dao/aggregator/dto/xml files for each domain
+  // Scan service/mapper/dao/aggregator/facade/usecase/dto/xml files for each domain
   for (const d of Object.keys(domainMap)) {
     const p = domainMap[d].pattern;
     const dn = domainMap[d].domainName || d;
@@ -129,12 +129,12 @@ async function scanJavaDomains(stack, ROOT) {
       svcGlob = `src/main/java/**/service/${d}/*.java`;
       mprGlob = `src/main/java/**/{mapper,repository,dao}/${d}/*.java`;
       dtoGlob = `src/main/java/**/dto/${d}/**/*.java`;
-      aggGlob = `src/main/java/**/aggregator/${d}/*.java`;
+      aggGlob = `src/main/java/**/{aggregator,facade,usecase,orchestrator}/${d}/*.java`;
     } else if (p === "B" || p === "D") {
       svcGlob = `src/main/java/**/${dn}/service/*.java`;
       mprGlob = `src/main/java/**/${dn}/{mapper,repository,dao}/*.java`;
       dtoGlob = `src/main/java/**/${dn}/dto/**/*.java`;
-      aggGlob = `src/main/java/**/${dn}/aggregator/*.java`;
+      aggGlob = `src/main/java/**/${dn}/{aggregator,facade,usecase,orchestrator}/*.java`;
     } else if (p === "E") {
       svcGlob = `src/main/java/**/${d}/{application,domain}/**/*.java`;
       mprGlob = `src/main/java/**/${d}/adapter/out/{persistence,repository}/*.java`;
@@ -146,9 +146,14 @@ async function scanJavaDomains(stack, ROOT) {
       svcGlob = `src/main/java/**/service/${cap}*.java`;
       mprGlob = `src/main/java/**/{mapper,repository,dao}/${cap}*.java`;
       dtoGlob = `src/main/java/**/dto/${cap}*.java`;
-      aggGlob = `src/main/java/**/aggregator/${cap}*.java`;
+      aggGlob = `src/main/java/**/{aggregator,facade,usecase,orchestrator}/${cap}*.java`;
     }
-    const xmlGlob = `src/main/resources/{mapper,mybatis}/**/${dn}/*.xml`;
+    // Pattern C (flat): XML may be in flat directory without domain subdirectory (e.g., mapper/OrderMapper.xml)
+    // Other patterns: XML is in domain subdirectory (e.g., mapper/order/OrderMapper.xml)
+    const capDn = dn.charAt(0).toUpperCase() + dn.slice(1);
+    const xmlGlob = p === "C"
+      ? `src/main/resources/{mapper,mybatis}/**/{${dn}/${capDn}*.xml,${capDn}*.xml}`
+      : `src/main/resources/{mapper,mybatis}/**/${dn}/*.xml`;
 
     const svc = await glob(svcGlob, { cwd: ROOT });
     const mpr = await glob(mprGlob, { cwd: ROOT });
@@ -169,7 +174,7 @@ async function scanJavaDomains(stack, ROOT) {
     const javaDomains = {};
     const skipNames = ["common", "config", "util", "utils", "base", "shared", "global", "framework", "infra", "api", "main", "front", "admin", "back", "internal", "external", "web", "app", "test", "tests", "generated", "build"];
     const versionPattern = /^v\d+$/;
-    const layerNames = ["controller", "aggregator", "service", "mapper", "repository", "dao", "dto", "vo", "entity", "adapter"];
+    const layerNames = ["controller", "aggregator", "facade", "usecase", "orchestrator", "service", "mapper", "repository", "dao", "dto", "vo", "entity", "adapter"];
 
     for (const f of allJava) {
       const parts = f.replace(/\\/g, "/").split("/");
@@ -182,7 +187,7 @@ async function scanJavaDomains(stack, ROOT) {
           if (i > 0 && !skipNames.includes(prevDir) && !layerNames.includes(prevDir) && !prevDir.includes(".") && !versionPattern.test(prevDir)) {
             if (!javaDomains[prevDir]) javaDomains[prevDir] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: "B" };
             if (parts[i] === "controller") javaDomains[prevDir].controllers++;
-            else if (parts[i] === "aggregator" || parts[i] === "service") javaDomains[prevDir].services++;
+            else if (["aggregator", "facade", "usecase", "orchestrator", "service"].includes(parts[i])) javaDomains[prevDir].services++;
             else if (["mapper", "repository", "dao"].includes(parts[i])) javaDomains[prevDir].mappers++;
             else if (["dto", "vo"].includes(parts[i])) javaDomains[prevDir].dtos++;
           }
@@ -190,7 +195,7 @@ async function scanJavaDomains(stack, ROOT) {
           if (nextDir && !nextDir.endsWith(".java") && !skipNames.includes(nextDir) && !layerNames.includes(nextDir) && !versionPattern.test(nextDir)) {
             if (!javaDomains[nextDir]) javaDomains[nextDir] = { controllers: 0, services: 0, mappers: 0, dtos: 0, xmlMappers: 0, pattern: "A" };
             if (parts[i] === "controller") javaDomains[nextDir].controllers++;
-            else if (parts[i] === "aggregator" || parts[i] === "service") javaDomains[nextDir].services++;
+            else if (["aggregator", "facade", "usecase", "orchestrator", "service"].includes(parts[i])) javaDomains[nextDir].services++;
             else if (["mapper", "repository", "dao"].includes(parts[i])) javaDomains[nextDir].mappers++;
             else if (["dto", "vo"].includes(parts[i])) javaDomains[nextDir].dtos++;
           }

package/plan-installer/scanners/scan-kotlin.js

@@ -9,15 +9,18 @@
 const path = require("path");
 const { glob } = require("glob");
 
+// Normalize backslash paths from glob on Windows to forward slashes
+const norm = (p) => p.replace(/\\/g, "/");
+
 async function scanKotlinDomains(stack, ROOT) {
   const backendDomains = [];
   let rootPackage = null;
 
   // Scan all .kt files across all submodules
-  const ktFiles = await glob("**/src/main/kotlin/**/*.kt", {
+  const ktFiles = (await glob("**/src/main/kotlin/**/*.kt", {
     cwd: ROOT,
     ignore: ["**/node_modules/**", "**/build/**", "**/test/**", "**/generated/**"],
-  });
+  })).map(norm);
 
   // Detect root package from first controller/service file
   for (const f of ktFiles) {
@@ -33,13 +36,19 @@ async function scanKotlinDomains(stack, ROOT) {
   ];
   const moduleSet = {};
   for (const mg of moduleGlobs) {
-    const moduleDirs = await glob(mg, { cwd: ROOT });
+    const moduleDirs = (await glob(mg, { cwd: ROOT })).map(norm);
     for (const md of moduleDirs) {
-      const parts = md.replace(/\/src\/main\/kotlin\/$/, "").split("/");
+      const parts = md.replace(/\/src\/main\/kotlin\/?$/, "").split("/");
       const moduleName = parts[parts.length - 1]; // e.g., "reservation-command-server"
       if (moduleSet[moduleName]) {
-        // Name conflict: use full relative path as key to avoid silent loss
-        const fullKey = md.replace(/\/src\/main\/kotlin\/$/, "").replace(/\//g, "__");
+        // Name conflict: upgrade first entry to full key too
+        if (!moduleName.includes("__")) {
+          const existingPath = moduleSet[moduleName];
+          const existingFullKey = existingPath.replace(/\/src\/main\/kotlin\/?$/, "").replace(/\//g, "__");
+          moduleSet[existingFullKey] = existingPath;
+          delete moduleSet[moduleName];
+        }
+        const fullKey = md.replace(/\/src\/main\/kotlin\/?$/, "").replace(/\//g, "__");
         moduleSet[fullKey] = md;
       } else {
         moduleSet[moduleName] = md;
@@ -53,16 +62,21 @@ async function scanKotlinDomains(stack, ROOT) {
   const domainMap = {};
 
   for (const [moduleName, modulePath] of Object.entries(moduleSet)) {
-    if (skipModules.some(s => moduleName.includes(s))) continue;
+    // Full key (e.g., "servers__command__reservation-command-server") → extract actual module name
+    const actualModuleName = moduleName.includes("__")
+      ? moduleName.split("__").pop()
+      : moduleName;
+
+    if (skipModules.some(s => actualModuleName.includes(s))) continue;
 
     // Determine server type from module name
     let serverType = "standalone";
     for (const [key, val] of Object.entries(serverTypes)) {
-      if (moduleName.includes(key)) { serverType = val; break; }
+      if (actualModuleName.includes(key)) { serverType = val; break; }
     }
 
     // Extract domain name from module name
-    let domainName = moduleName
+    let domainName = actualModuleName
       .replace(/-(?:command|query|bff|integration|adapter)-server$/, "")
       .replace(/-server$/, "");
 
@@ -73,7 +87,7 @@ async function scanKotlinDomains(stack, ROOT) {
     }
 
     // Scan files in this module (append "/" to prevent prefix overlap)
-    const modulePrefix = modulePath.replace(/\/$/, "").replace(/\/src\/main\/kotlin$/, "") + "/";
+    const modulePrefix = modulePath.replace(/\/?$/, "").replace(/\/src\/main\/kotlin$/, "") + "/";
     const moduleKtFiles = ktFiles.filter(f => f.startsWith(modulePrefix) || f === modulePrefix.slice(0, -1));
     const controllers = moduleKtFiles.filter(f => /controller/i.test(f)).length;
     const services = moduleKtFiles.filter(f => /service/i.test(f)).length;
@@ -84,17 +98,27 @@ async function scanKotlinDomains(stack, ROOT) {
     if (totalFiles === 0) continue;
 
     const key = `${domainName}:${serverType}`;
-    domainMap[key] = {
-      name: domainName,
-      moduleName,
-      modulePath,
-      serverType,
-      controllers,
-      services,
-      repositories,
-      dtos,
-      totalFiles,
-    };
+    if (domainMap[key]) {
+      // Merge into existing entry (e.g., same domain+type from collided module names)
+      domainMap[key].moduleNames.push(moduleName);
+      domainMap[key].controllers += controllers;
+      domainMap[key].services += services;
+      domainMap[key].repositories += repositories;
+      domainMap[key].dtos += dtos;
+      domainMap[key].totalFiles += totalFiles;
+    } else {
+      domainMap[key] = {
+        name: domainName,
+        moduleNames: [moduleName],
+        modulePath,
+        serverType,
+        controllers,
+        services,
+        repositories,
+        dtos,
+        totalFiles,
+      };
+    }
   }
 
   // Group by domain: merge command/query/bff of same domain
@@ -105,7 +129,7 @@ async function scanKotlinDomains(stack, ROOT) {
       domainGroups[name] = { name, type: "backend", modules: [], controllers: 0, services: 0, repositories: 0, dtos: 0, totalFiles: 0, serverTypes: [] };
     }
     const dg = domainGroups[name];
-    dg.modules.push(info.moduleName);
+    dg.modules.push(...info.moduleNames);
     dg.controllers += info.controllers;
     dg.services += info.services;
     dg.repositories += info.repositories;
@@ -131,7 +155,7 @@ async function scanKotlinDomains(stack, ROOT) {
   }
 
   // Also scan shared libraries as special domains
-  const libDirs = await glob("{shared-lib,integration-lib,*-lib}/src/main/kotlin/", { cwd: ROOT });
+  const libDirs = (await glob("{shared-lib,integration-lib,*-lib}/src/main/kotlin/", { cwd: ROOT })).map(norm);
   for (const ld of libDirs) {
     const libName = ld.split("/")[0];
     if (domainGroups[libName]) continue; // Already captured

package/plan-installer/scanners/scan-node.js

@@ -2,6 +2,7 @@
  * ClaudeOS-Core — Node.js Structure Scanner
  *
  * Scans Node.js backend (Express/NestJS/Fastify) project structure to discover domains.
+ * Supports monorepo layouts (apps/*, packages/*) in addition to single-project src/.
  */
 
 const path = require("path");
@@ -9,10 +10,23 @@ const { glob } = require("glob");
 
 async function scanNodeDomains(stack, ROOT) {
   const backendDomains = [];
+  const skipDirs = ["common", "shared", "config", "utils", "lib", "core", "main", "interfaces", "types", "constants", "guards", "decorators", "pipes", "filters", "interceptors"];
 
+  // Collect candidate directories: standard src/ + monorepo apps/*/src/
   const nestModules = await glob("src/modules/*/", { cwd: ROOT });
-  const srcDirs = nestModules.length > 0 ? nestModules : await glob("src/*/", { cwd: ROOT });
-  const skipDirs = ["common", "shared", "config", "utils", "lib", "core", "main", "interfaces", "types", "constants", "guards", "decorators", "pipes", "filters", "interceptors"];
+  let srcDirs = nestModules.length > 0 ? nestModules : await glob("src/*/", { cwd: ROOT });
+
+  // Monorepo: scan apps/*/src/ and packages/*/src/ when standard src/ yields nothing backend-relevant
+  if (stack.monorepo || srcDirs.length === 0) {
+    const monoModules = await glob("{apps,packages}/*/src/modules/*/", { cwd: ROOT, ignore: ["**/node_modules/**"] });
+    if (monoModules.length > 0) {
+      srcDirs = [...srcDirs, ...monoModules];
+    } else {
+      const monoDirs = await glob("{apps,packages}/*/src/*/", { cwd: ROOT, ignore: ["**/node_modules/**"] });
+      srcDirs = [...srcDirs, ...monoDirs];
+    }
+  }
+
   for (let dir of srcDirs) {
     if (!dir.endsWith("/")) dir += "/";
     const name = path.basename(dir.replace(/\/$/, ""));

package/plan-installer/stack-detector.js

@@ -90,7 +90,8 @@ async function detectStack(ROOT) {
     framework: null, frameworkVersion: null,
     buildTool: null, database: null, orm: null,
     frontend: null, frontendVersion: null,
-    packageManager: null, detected: [],
+    packageManager: null, monorepo: null, workspaces: null,
+    detected: [],
   };
 
   // ── Java/Kotlin: Gradle ──
@@ -115,6 +116,8 @@ async function detectStack(ROOT) {
       if (jv) stack.languageVersion = jv[1];
 
       detectFirst(stack, "orm", g, GRADLE_ORM_RULES);
+      // Exclude "postgres" (substring of postgresql — false positive on r2dbc-postgres) and "sqlite" (rare in Gradle deps)
+      // "postgresql" is still matched via DB_KEYWORD_RULES; h2 uses word-boundary check separately
       detectDb(stack, g, DB_KEYWORD_RULES.filter(([kw]) => !["postgres", "sqlite"].includes(kw)));
 
       // Kotlin detection: override language if Kotlin plugin found
@@ -235,7 +238,45 @@ async function detectStack(ROOT) {
     const pkg = readJsonSafe(path.join(ROOT, "package.json"));
     if (pkg) {
       stack.detected.push("package.json");
+
+      // ── Monorepo detection ──
+      // Detect monorepo markers: turbo.json, pnpm-workspace.yaml, lerna.json, package.json#workspaces
+      if (existsSafe(path.join(ROOT, "turbo.json"))) { stack.monorepo = "turborepo"; stack.detected.push("turbo.json"); }
+      else if (existsSafe(path.join(ROOT, "pnpm-workspace.yaml"))) { stack.monorepo = "pnpm-workspace"; stack.detected.push("pnpm-workspace.yaml"); }
+      else if (existsSafe(path.join(ROOT, "lerna.json"))) { stack.monorepo = "lerna"; stack.detected.push("lerna.json"); }
+      else if (pkg.workspaces) { stack.monorepo = "npm-workspaces"; stack.detected.push("npm-workspaces"); }
+      if (stack.monorepo) {
+        // Resolve workspace paths from package.json#workspaces or pnpm-workspace.yaml
+        let wsPatterns = [];
+        if (Array.isArray(pkg.workspaces)) wsPatterns = pkg.workspaces;
+        else if (pkg.workspaces && Array.isArray(pkg.workspaces.packages)) wsPatterns = pkg.workspaces.packages;
+        if (wsPatterns.length === 0 && existsSafe(path.join(ROOT, "pnpm-workspace.yaml"))) {
+          const wy = readFileSafe(path.join(ROOT, "pnpm-workspace.yaml"));
+          const wm = [...wy.matchAll(/- ['"]?([^'"#\n]+)['"]?/g)].map(m => m[1].trim());
+          if (wm.length > 0) wsPatterns = wm;
+        }
+        if (wsPatterns.length > 0) stack.workspaces = wsPatterns;
+      }
+
+      // Merge deps from root + sub-package package.json files (monorepo)
+      // Sub-packages provide framework/frontend/ORM that root may lack
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (stack.monorepo) {
+        const subPkgGlobs = ["{apps,packages}/*/package.json"];
+        if (stack.workspaces) {
+          for (const ws of stack.workspaces) {
+            const wsGlob = ws.replace(/\/?\*?\*?$/, "/*/package.json");
+            if (!subPkgGlobs.includes(wsGlob)) subPkgGlobs.push(wsGlob);
+          }
+        }
+        for (const spg of subPkgGlobs) {
+          const subPkgs = await glob(spg, { cwd: ROOT, ignore: ["**/node_modules/**"] });
+          for (const sp of subPkgs) {
+            const sub = readJsonSafe(path.join(ROOT, sp));
+            if (sub) Object.assign(deps, sub.dependencies, sub.devDependencies);
+          }
+        }
+      }
 
       if (!stack.language) stack.language = deps.typescript ? "typescript" : "javascript";
       if (deps.typescript) { stack.detected.push("typescript"); const tv = deps.typescript.match(/(\d+(?:\.\d+)*)/); if (tv) stack.languageVersion = tv[1]; }

package/plan-validator/index.js

@@ -15,126 +15,22 @@
 const fs = require("fs");
 const path = require("path");
 const { glob } = require("glob");
+const { parseFileBlocks, parseCodeBlocks, replaceFileBlock, replaceCodeBlock, CODE_BLOCK_PLANS } = require("../lib/plan-parser");
+const { updateStaleReport } = require("../lib/stale-report");
 
 const ROOT = process.env.CLAUDEOS_ROOT || path.resolve(__dirname, "../..");
 const PLAN = path.join(ROOT, "claudeos-core/plan");
 const GEN  = path.join(ROOT, "claudeos-core/generated");
 
-// Plan files using code block format (the rest use <file> block format)
-const CODE_BLOCK_PLANS = ["21.sync-rules-master.md"];
+// CODE_BLOCK_PLANS imported from lib/plan-parser.js
 
 function rel(p) {
   return path.relative(ROOT, p).replace(/\\/g, "/");
 }
 
-// Extract <file path="..."> ... </file> blocks
-function extractFileBlocks(content) {
-  const result = [];
-  let m;
-  const re = /<file\s+path="([^"]+)">\s*\n([\s\S]*?)\n<\/file>/g;
-  while ((m = re.exec(content)) !== null) {
-    result.push({ path: m[1], content: m[2] });
-  }
-  return result;
-}
-
-// Extract ## N. `path` \n```markdown ... ``` blocks
-// Uses indexOf-based parsing to correctly handle nested code fences inside markdown content
-function extractCodeBlocks(content) {
-  const result = [];
-  const headingRe = /^##\s+\d+\.\s+([^\n]+)/gm;
-  let headingMatch;
-  while ((headingMatch = headingRe.exec(content)) !== null) {
-    const filePath = headingMatch[1].replace(/`/g, "").trim();
-    // Find the opening ```markdown after the heading
-    const openFence = content.indexOf("```markdown\n", headingMatch.index);
-    if (openFence < 0) continue;
-    const contentStart = openFence + "```markdown\n".length;
-    // Find the matching closing ``` — track nesting depth to skip inner fenced blocks
-    let searchPos = contentStart;
-    let closingPos = -1;
-    let nestDepth = 0;
-    while (searchPos < content.length) {
-      const nextFence = content.indexOf("\n```", searchPos);
-      if (nextFence < 0) break;
-      const fenceLineStart = nextFence + 1; // position of ```
-      // Determine end of this ``` line
-      const nextNewline = content.indexOf("\n", fenceLineStart + 3);
-      const restOfLine = nextNewline >= 0
-        ? content.substring(fenceLineStart + 3, nextNewline)
-        : content.substring(fenceLineStart + 3);
-      // Opening fence: ``` followed by a language tag (non-empty alphanumeric text)
-      const isOpening = /^[a-zA-Z]/.test(restOfLine.trim());
-      if (isOpening) {
-        nestDepth++;
-        searchPos = nextNewline >= 0 ? nextNewline : fenceLineStart + 3;
-      } else if (nestDepth > 0) {
-        nestDepth--;
-        searchPos = nextNewline >= 0 ? nextNewline : fenceLineStart + 3;
-      } else {
-        closingPos = fenceLineStart;
-        break;
-      }
-    }
-    if (closingPos < 0) continue;
-    const blockContent = content.substring(contentStart, closingPos).trimEnd();
-    result.push({ path: filePath, content: blockContent });
-    // Advance headingRe past this block to avoid re-matching inside content
-    headingRe.lastIndex = closingPos;
-  }
-  return result;
-}
-
-// Replace <file> block content with new content
-function replaceFileBlock(content, filePath, newContent) {
-  const escaped = filePath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return content.replace(
-    new RegExp(`(<file\\s+path="${escaped}">\\s*\\n)[\\s\\S]*?(\\n</file>)`, "g"),
-    `$1${newContent}$2`
-  );
-}
-
-// Replace code block content with new content
-// Uses indexOf-based approach to avoid regex issues with nested code fences
-function replaceCodeBlock(content, filePath, newContent) {
-  const cleanPath = filePath.replace(/`/g, "");
-  // Find the heading line containing the file path
-  const headingPattern = new RegExp(`^##\\s+\\d+\\.\\s+\`?${cleanPath.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\`?`, "m");
-  const headingMatch = headingPattern.exec(content);
-  if (!headingMatch) return content;
-  // Find the opening ```markdown after the heading
-  const afterHeading = content.indexOf("```markdown\n", headingMatch.index);
-  if (afterHeading < 0) return content;
-  const contentStart = afterHeading + "```markdown\n".length;
-  // Find the matching closing ``` — track nesting depth to skip inner fenced blocks
-  let searchPos = contentStart;
-  let closingPos = -1;
-  let nestDepth = 0;
-  while (searchPos < content.length) {
-    const nextFence = content.indexOf("\n```", searchPos);
-    if (nextFence < 0) break;
-    const fenceLineStart = nextFence + 1; // position of ```
-    // Determine end of this ``` line
-    const nextNewline = content.indexOf("\n", fenceLineStart + 3);
-    const restOfLine = nextNewline >= 0
-      ? content.substring(fenceLineStart + 3, nextNewline)
-      : content.substring(fenceLineStart + 3);
-    // Opening fence: ``` followed by a language tag (non-empty alphanumeric text)
-    const isOpening = /^[a-zA-Z]/.test(restOfLine.trim());
-    if (isOpening) {
-      nestDepth++;
-      searchPos = nextNewline >= 0 ? nextNewline : fenceLineStart + 3;
-    } else if (nestDepth > 0) {
-      nestDepth--;
-      searchPos = nextNewline >= 0 ? nextNewline : fenceLineStart + 3;
-    } else {
-      closingPos = fenceLineStart;
-      break;
-    }
-  }
-  if (closingPos < 0) return content;
-  return content.substring(0, contentStart) + newContent + "\n" + content.substring(closingPos);
-}
+// Aliases for backward compatibility (used by tests and main())
+function extractFileBlocks(content) { return parseFileBlocks(content, { includeContent: true }); }
+function extractCodeBlocks(content) { return parseCodeBlocks(content, { includeContent: true }); }
 
 async function main() {
   const validModes = ["--check", "--refresh", "--execute"];
@@ -244,16 +140,10 @@ async function main() {
     );
 
     // Also write to stale-report.json for consolidated health reporting
-    const rp = path.join(GEN, "stale-report.json");
-    let ex = {};
-    if (fs.existsSync(rp)) {
-      try { ex = JSON.parse(fs.readFileSync(rp, "utf-8")); } catch { ex = {}; }
-    }
-    ex.planValidation = { checkedAt: new Date().toISOString(), mode, total, synced, drift, missing };
-    if (!ex.summary) ex.summary = {};
-    ex.summary.planDrift = drift;
-    ex.summary.planMissing = missing;
-    fs.writeFileSync(rp, JSON.stringify(ex, null, 2));
+    updateStaleReport(GEN, "planValidation",
+      { checkedAt: new Date().toISOString(), mode, total, synced, drift, missing },
+      { planDrift: drift, planMissing: missing }
+    );
   }
 
   process.exit(drift + missing > 0 ? 1 : 0);
@@ -261,7 +151,7 @@ async function main() {
 
 // Export for testing; run main() only when executed directly
 if (require.main === module) {
-  main().catch(console.error);
+  main().catch(e => { console.error(`\n  ❌ Unexpected error: ${e.message || e}`); process.exit(1); });
 }
 
 module.exports = { extractFileBlocks, extractCodeBlocks, replaceFileBlock, replaceCodeBlock };

package/sync-checker/index.js

@@ -15,6 +15,7 @@
 const fs = require("fs");
 const path = require("path");
 const { glob } = require("glob");
+const { updateStaleReport } = require("../lib/stale-report");
 
 const ROOT = process.env.CLAUDEOS_ROOT || path.resolve(__dirname, "../..");
 const GEN = path.join(ROOT, "claudeos-core/generated");
@@ -105,24 +106,10 @@ async function main() {
   console.log(total === 0 ? "  ✅ All in sync\n" : `  ⚠️  ${total} issues\n`);
 
   // ─── Update stale-report.json ────────────────────────────
-  if (fs.existsSync(GEN)) {
-    const rp = path.join(GEN, "stale-report.json");
-    let ex = {};
-    if (fs.existsSync(rp)) {
-      try { ex = JSON.parse(fs.readFileSync(rp, "utf-8")); } catch { ex = {}; }
-    }
-    ex.syncMisses = {
-      checkedAt: new Date().toISOString(),
-      unregistered: issues.unreg,
-      orphaned: issues.orphan,
-    };
-    ex.summary = {
-      ...ex.summary,
-      syncIssues: total,
-      status: total === 0 ? "ok" : "warning",
-    };
-    fs.writeFileSync(rp, JSON.stringify(ex, null, 2));
-  }
+  updateStaleReport(GEN, "syncMisses",
+    { checkedAt: new Date().toISOString(), unregistered: issues.unreg, orphaned: issues.orphan },
+    { syncIssues: total, status: total === 0 ? "ok" : "warning" }
+  );
 
   // Exit 1 only for orphaned files (actual breakage), not for unregistered (informational)
   const orphanCount = issues.orphan.length;
@@ -130,7 +117,7 @@ async function main() {
 }
 
 if (require.main === module) {
-  main().catch(console.error);
+  main().catch(e => { console.error(`\n  ❌ Unexpected error: ${e.message || e}`); process.exit(1); });
 }
 
 module.exports = { main };