@ryuenn3123/agentic-senior-core 2.5.22 → 3.0.2

package/lib/cli/utils.mjs

@@ -25,16 +25,14 @@ export function printUsage() {
   console.log('  npx @ryuenn3123/agentic-senior-core init');
   console.log('  npm install -g @ryuenn3123/agentic-senior-core && agentic-senior-core init');
   console.log('  bunx @ryuenn3123/agentic-senior-core init   # optional Bun path');
-  console.log('  open GitHub template: https://github.com/fatidaprilian/Agentic-Senior-Core/generate');
   console.log('');
   console.log('Usage:');
   console.log('  agentic-senior-core launch');
   console.log('  agentic-senior-core init [target-directory] [--preset <name>] [--profile <beginner|balanced|strict>] [--profile-pack <name>] [--stack <name>] [--blueprint <name>] [--project-description <text>] [--architect-token-budget <number>] [--architect-timeout-ms <number>] [--architect-research-mode <snapshot|realtime>] [--enable-realtime-research] [--architect-realtime-signal-file <path>] [--ci <true|false>] [--newbie] [--token-optimize] [--no-token-optimize] [--token-agent <name>] [--memory-continuity] [--no-memory-continuity] [--scaffold-docs] [--no-scaffold-docs] [--docs-lang <en|id>] [--project-config <path>] [--runtime-env <auto|linux-wsl|linux|windows|macos>]');
-  console.log('  agentic-senior-core upgrade [target-directory] [--dry-run] [--yes] [--mcp-template]');
+  console.log('  agentic-senior-core upgrade [target-directory] [--dry-run] [--yes] [--mcp-template] [--no-mcp-template] [--prune] [--no-prune]');
   console.log('  agentic-senior-core optimize [target-directory] [--agent <copilot|claude|cursor|windsurf|gemini|codex|cline>] [--enable|--disable] [--show]');
   console.log('  agentic-senior-core mcp');
   console.log('  agentic-senior-core rollback [target-directory]');
-  console.log('  agentic-senior-core skill [domain] [--tier <standard|advance|expert|above>] [--json]');
   console.log('  agentic-senior-core --version');
   console.log('');
   console.log('Options:');
@@ -68,12 +66,12 @@ export function printUsage() {
   console.log('  --runtime-env   Override runtime environment hint (auto, linux-wsl, linux, windows, macos)');
   console.log('  --dry-run    Preview upgrade without writing files');
   console.log('  --yes        Skip confirmation prompts for upgrade');
+  console.log('  --prune      Keep managed governance files synchronized 1:1 (default in upgrade)');
+  console.log('  --no-prune   Do not remove stale managed governance files during upgrade');
   console.log('  --agent      Target agent integration for token optimization mode');
   console.log('  --enable     Enable token optimization policy and rebuild compiled rules');
   console.log('  --disable    Disable token optimization policy and rebuild compiled rules');
   console.log('  --show       Print current token optimization state as JSON');
-  console.log('  --tier       Choose a skill tier for the skill selector');
-  console.log('  --json       Emit machine-readable skill selection output');
 }
 
 export async function pathExists(targetPath) {
@@ -114,11 +112,188 @@ export async function copyDirectory(sourceDirectoryPath, targetDirectoryPath) {
   }
 }
 
+function toPosixRelativePath(relativePath) {
+  return relativePath.split(path.sep).join('/');
+}
+
+function isPathWithinPrefix(relativePath, prefixPath) {
+  const normalizedRelativePath = toPosixRelativePath(relativePath).replace(/\/+$/g, '');
+  const normalizedPrefixPath = toPosixRelativePath(prefixPath).replace(/\/+$/g, '');
+
+  if (!normalizedPrefixPath) {
+    return false;
+  }
+
+  return normalizedRelativePath === normalizedPrefixPath
+    || normalizedRelativePath.startsWith(`${normalizedPrefixPath}/`);
+}
+
+async function collectRelativeTreeEntries(baseDirectoryPath, relativeRootPath) {
+  const files = [];
+  const directories = [];
+
+  if (!(await pathExists(baseDirectoryPath))) {
+    return { files, directories };
+  }
+
+  const normalizedRootPath = toPosixRelativePath(relativeRootPath);
+  directories.push(normalizedRootPath);
+
+  async function walkDirectory(currentDirectoryPath, currentRelativePath) {
+    const directoryEntries = await fs.readdir(currentDirectoryPath, { withFileTypes: true });
+
+    for (const directoryEntry of directoryEntries) {
+      const sourceEntryPath = path.join(currentDirectoryPath, directoryEntry.name);
+      const relativeEntryPath = toPosixRelativePath(path.join(currentRelativePath, directoryEntry.name));
+
+      if (directoryEntry.isDirectory()) {
+        directories.push(relativeEntryPath);
+        await walkDirectory(sourceEntryPath, relativeEntryPath);
+        continue;
+      }
+
+      files.push(relativeEntryPath);
+    }
+  }
+
+  await walkDirectory(baseDirectoryPath, normalizedRootPath);
+  return { files, directories };
+}
+
+async function buildManagedSourceManifest() {
+  const sourceFiles = new Set();
+  const sourceDirectories = new Set();
+
+  for (const sourceDirectoryName of directoryCopies) {
+    const sourceDirectoryPath = path.join(REPO_ROOT, sourceDirectoryName);
+    const sourceTreeEntries = await collectRelativeTreeEntries(sourceDirectoryPath, sourceDirectoryName);
+
+    for (const sourceFilePath of sourceTreeEntries.files) {
+      sourceFiles.add(sourceFilePath);
+    }
+
+    for (const sourceDirectoryPathRelative of sourceTreeEntries.directories) {
+      sourceDirectories.add(sourceDirectoryPathRelative);
+    }
+  }
+
+  for (const entryPointFileName of entryPointFiles) {
+    const sourceFilePath = path.join(REPO_ROOT, entryPointFileName);
+    if (!(await pathExists(sourceFilePath))) {
+      continue;
+    }
+
+    sourceFiles.add(toPosixRelativePath(entryPointFileName));
+  }
+
+  return {
+    files: sourceFiles,
+    directories: sourceDirectories,
+  };
+}
+
+async function collectManagedTargetManifest(resolvedTargetDirectoryPath) {
+  const targetFiles = new Set();
+  const targetDirectories = new Set();
+
+  for (const sourceDirectoryName of directoryCopies) {
+    const targetDirectoryPath = path.join(resolvedTargetDirectoryPath, sourceDirectoryName);
+    const targetTreeEntries = await collectRelativeTreeEntries(targetDirectoryPath, sourceDirectoryName);
+
+    for (const targetFilePath of targetTreeEntries.files) {
+      targetFiles.add(targetFilePath);
+    }
+
+    for (const targetDirectoryPathRelative of targetTreeEntries.directories) {
+      targetDirectories.add(targetDirectoryPathRelative);
+    }
+  }
+
+  for (const entryPointFileName of entryPointFiles) {
+    const targetFilePath = path.join(resolvedTargetDirectoryPath, entryPointFileName);
+    if (!(await pathExists(targetFilePath))) {
+      continue;
+    }
+
+    targetFiles.add(toPosixRelativePath(entryPointFileName));
+  }
+
+  return {
+    files: targetFiles,
+    directories: targetDirectories,
+  };
+}
+
+export async function analyzeManagedGovernanceSurface(
+  resolvedTargetDirectoryPath,
+  options = {}
+) {
+  const preservePathPrefixes = Array.isArray(options.preservePathPrefixes)
+    ? options.preservePathPrefixes
+    : ['.agent-context/state'];
+
+  const sourceManifest = await buildManagedSourceManifest();
+  const targetManifest = await collectManagedTargetManifest(resolvedTargetDirectoryPath);
+
+  const staleFiles = [];
+  const staleDirectories = [];
+  const preservedFiles = [];
+  const preservedDirectories = [];
+
+  const sortedTargetFiles = [...targetManifest.files].sort((leftPath, rightPath) => leftPath.localeCompare(rightPath));
+  const sortedTargetDirectories = [...targetManifest.directories].sort(
+    (leftPath, rightPath) => rightPath.length - leftPath.length || leftPath.localeCompare(rightPath)
+  );
+
+  for (const targetFilePath of sortedTargetFiles) {
+    if (sourceManifest.files.has(targetFilePath)) {
+      continue;
+    }
+
+    if (preservePathPrefixes.some((prefixPath) => isPathWithinPrefix(targetFilePath, prefixPath))) {
+      preservedFiles.push(targetFilePath);
+      continue;
+    }
+
+    staleFiles.push(targetFilePath);
+  }
+
+  for (const targetDirectoryPathRelative of sortedTargetDirectories) {
+    if (sourceManifest.directories.has(targetDirectoryPathRelative)) {
+      continue;
+    }
+
+    if (preservePathPrefixes.some((prefixPath) => isPathWithinPrefix(targetDirectoryPathRelative, prefixPath))) {
+      preservedDirectories.push(targetDirectoryPathRelative);
+      continue;
+    }
+
+    staleDirectories.push(targetDirectoryPathRelative);
+  }
+
+  return {
+    staleFiles,
+    staleDirectories,
+    preservedFiles,
+    preservedDirectories,
+    managedSourceFileCount: sourceManifest.files.size,
+    managedSourceDirectoryCount: sourceManifest.directories.size,
+    managedTargetFileCount: targetManifest.files.size,
+    managedTargetDirectoryCount: targetManifest.directories.size,
+  };
+}
+
 export async function copyGovernanceAssetsToTarget(
   resolvedTargetDirectoryPath,
   options = {}
 ) {
   const shouldIncludeMcpTemplate = options.includeMcpTemplate === true;
+  const shouldPruneManagedSurface = options.pruneManagedSurface === true;
+  const managedSurfacePlan = shouldPruneManagedSurface
+    ? options.managedSurfacePlan || await analyzeManagedGovernanceSurface(resolvedTargetDirectoryPath)
+    : null;
+  const deletedManagedFiles = [];
+  const deletedManagedDirectories = [];
 
   for (const sourceDirectoryName of directoryCopies) {
     const sourceDirectoryPath = path.join(REPO_ROOT, sourceDirectoryName);
@@ -145,6 +320,28 @@ export async function copyGovernanceAssetsToTarget(
     await fs.copyFile(sourceFilePath, targetFilePath);
   }
 
+  if (shouldPruneManagedSurface && managedSurfacePlan) {
+    for (const staleFileRelativePath of managedSurfacePlan.staleFiles) {
+      const staleFilePath = path.join(resolvedTargetDirectoryPath, ...staleFileRelativePath.split('/'));
+      if (!(await pathExists(staleFilePath))) {
+        continue;
+      }
+
+      await fs.unlink(staleFilePath);
+      deletedManagedFiles.push(staleFileRelativePath);
+    }
+
+    for (const staleDirectoryRelativePath of managedSurfacePlan.staleDirectories) {
+      const staleDirectoryPath = path.join(resolvedTargetDirectoryPath, ...staleDirectoryRelativePath.split('/'));
+      if (!(await pathExists(staleDirectoryPath))) {
+        continue;
+      }
+
+      await fs.rm(staleDirectoryPath, { recursive: true, force: true });
+      deletedManagedDirectories.push(staleDirectoryRelativePath);
+    }
+  }
+
   if (shouldIncludeMcpTemplate) {
     const projectName = path.basename(resolvedTargetDirectoryPath);
     const mcpArgs = ['./scripts/mcp-server.mjs'];
@@ -199,7 +396,7 @@ export async function copyGovernanceAssetsToTarget(
           parsedZedSettings.context_servers['agentic-senior-core'] = zedMcpConfig.context_servers['agentic-senior-core'];
           await fs.writeFile(zedSettingsPath, JSON.stringify(parsedZedSettings, null, 2) + '\n', 'utf8');
         }
-      } catch (err) {
+      } catch {
         // Fallback or ignore if user has broken JSON
       }
     }
@@ -216,7 +413,7 @@ export async function copyGovernanceAssetsToTarget(
           if (await pathExists(globalGeminiMcpPath)) {
             const content = await fs.readFile(globalGeminiMcpPath, 'utf8');
             if (content.trim()) {
-              try { geminiConfig = JSON.parse(content); } catch (e) {}
+              try { geminiConfig = JSON.parse(content); } catch {}
             }
           }
           if (!geminiConfig.mcpServers) geminiConfig.mcpServers = {};
@@ -233,12 +430,18 @@ export async function copyGovernanceAssetsToTarget(
           
           await fs.writeFile(globalGeminiMcpPath, JSON.stringify(geminiConfig, null, 2) + '\n', 'utf8');
         }
-      } catch (err) {
+      } catch {
         // Ignore global injection errors
       }
     }
   }
 
+  return {
+    deletedManagedFiles,
+    deletedManagedDirectories,
+    managedSurfacePlan,
+  };
+
 }
 
 export async function askChoice(promptMessage, options, userInterface) {
@@ -346,11 +549,19 @@ export function parseBlockingSeverities(rawSeverityValues, fileName) {
 }
 
 export async function collectFileNames(folderPath) {
-  const fileNames = await fs.readdir(folderPath, { withFileTypes: true });
-  return fileNames
-    .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
-    .map((entry) => entry.name)
-    .sort((leftName, rightName) => leftName.localeCompare(rightName));
+  try {
+    const fileNames = await fs.readdir(folderPath, { withFileTypes: true });
+    return fileNames
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+      .map((entry) => entry.name)
+      .sort((leftName, rightName) => leftName.localeCompare(rightName));
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return [];
+    }
+
+    throw error;
+  }
 }
 
 export function formatBlockingSeverities(blockingSeverities) {

package/mcp.json

@@ -1,31 +1,31 @@
 {
   "version": "1.0",
   "name": "agentic-senior-core",
-  "description": "MCP configuration for governance-aware diagnostics and self-healing workflows with full knowledge injection.",
+  "description": "MCP configuration for governance-aware diagnostics and self-healing workflows with dynamic knowledge injection.",
   "knowledgeLayers": {
     "enabled": true,
-    "description": "8-layer unified knowledge injection for AI agents",
+    "description": "8-layer dynamic knowledge injection for AI agents",
     "layers": {
       "rules": {
         "path": ".agent-context/rules",
         "count": 14,
         "autoLoad": true
       },
-      "stacks": {
-        "path": ".agent-context/stacks",
-        "count": 10,
+      "stack-strategies": {
+        "path": "dynamic",
+        "count": 0,
         "autoLoad": true
       },
-      "blueprints": {
-        "path": ".agent-context/blueprints",
-        "count": 14,
+      "architecture-playbooks": {
+        "path": "dynamic",
+        "count": 0,
         "autoLoad": true
       },
-      "skills": {
-        "path": ".agent-context/skills",
-        "count": 6,
+      "execution-contracts": {
+        "path": "dynamic",
+        "count": 0,
         "autoLoad": true,
-        "packs": ["backend", "frontend", "cli", "distribution", "fullstack", "review-quality"]
+        "sources": ["prompts", "review-checklists", "policies"]
       },
       "prompts": {
         "path": ".agent-context/prompts",
@@ -33,9 +33,9 @@
         "autoLoad": true,
         "templates": ["init-project", "refactor", "review-code"]
       },
-      "profiles": {
-        "path": ".agent-context/profiles",
-        "count": 3,
+      "governance-modes": {
+        "path": "dynamic",
+        "count": 0,
         "autoLoad": true,
         "governance": ["platform", "regulated", "startup"]
       },
@@ -78,11 +78,11 @@
       "steps": [
         "load_all_knowledge_layers",
         "inject_rules",
-        "inject_stacks",
-        "inject_blueprints",
-        "inject_skills",
+        "inject_stack_strategies",
+        "inject_architecture_playbooks",
+        "inject_execution_contracts",
         "inject_prompts",
-        "inject_profiles",
+        "inject_governance_modes",
         "inject_state",
         "inject_policies"
       ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryuenn3123/agentic-senior-core",
-  "version": "2.5.22",
+  "version": "3.0.2",
   "type": "module",
   "description": "Force your AI Agent to code like a Staff Engineer, not a Junior.",
   "bin": {
@@ -48,6 +48,9 @@
     "audit:rules-guardian": "node ./scripts/rules-guardian-audit.mjs",
     "audit:explain-on-demand": "node ./scripts/explain-on-demand-audit.mjs",
     "audit:single-source-lazy-loading": "node ./scripts/single-source-lazy-loading-audit.mjs",
+    "audit:v3-purge": "node ./scripts/v3-purge-audit.mjs",
+    "sync:adapters": "node ./scripts/sync-thin-adapters.mjs",
+    "check:adapters": "node ./scripts/sync-thin-adapters.mjs --check",
     "gate:release": "node ./scripts/release-gate.mjs && node ./scripts/forbidden-content-check.mjs",
     "prepublishOnly": "npm run gate:release",
     "sbom:generate": "node ./scripts/generate-sbom.mjs",
@@ -62,6 +65,6 @@
     "report:docs-quality-drift": "node ./scripts/docs-quality-drift-report.mjs",
     "report:governance-weekly": "node ./scripts/governance-weekly-report.mjs",
     "validate": "node ./scripts/validate.mjs",
-    "test": "node --test ./tests/cli-smoke.test.mjs ./tests/mcp-server.test.mjs ./tests/llm-judge.test.mjs ./tests/enterprise-ops.test.mjs ./tests/skill-tier-gate.test.mjs"
+    "test": "node --test ./tests/cli-smoke.test.mjs ./tests/mcp-server.test.mjs ./tests/llm-judge.test.mjs ./tests/enterprise-ops.test.mjs"
   }
 }

package/scripts/context-triggered-audit.mjs

@@ -16,8 +16,8 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const REPOSITORY_ROOT = resolve(__dirname, '..');
 
-const SECURITY_CHECKLIST_PATH = '.agent-context/review-checklists/security-audit.md';
-const PERFORMANCE_CHECKLIST_PATH = '.agent-context/review-checklists/performance-audit.md';
+const PR_CHECKLIST_PATH = '.agent-context/review-checklists/pr-checklist.md';
+const ARCHITECTURE_CHECKLIST_PATH = '.agent-context/review-checklists/architecture-review.md';
 const DEFAULT_WORKFLOW = 'auto';
 const SMALL_EDIT_MAX_FILES = 3;
 const MAJOR_FEATURE_MIN_SIGNIFICANT_FILES = 4;
@@ -36,18 +36,18 @@ const SUPPORTED_WORKFLOWS = new Set([
   'standard',
 ]);
 
-const REQUIRED_SECURITY_CHECKLIST_SNIPPETS = [
-  '## Context Trigger Policy',
-  'Strict security audit auto-runs for review requests, PR-intent workflows, and major feature completion.',
-  'Small edits default to lightweight mode unless strict mode is explicitly forced.',
-  'User can force strict mode manually at any time.',
+const REQUIRED_PR_CHECKLIST_SNIPPETS = [
+  '### 11. Context-Triggered Audit Mode',
+  'Strict audit mode activates automatically on review and PR-intent workflows',
+  'Small edits avoid heavy checks by default unless strict mode is explicitly requested',
+  'User can always force strict audit mode manually',
 ];
 
-const REQUIRED_PERFORMANCE_CHECKLIST_SNIPPETS = [
-  '## Context Trigger Policy',
-  'Strict performance audit auto-runs for review requests, PR-intent workflows, and major feature completion.',
-  'Small edits default to lightweight mode unless strict mode is explicitly forced.',
-  'User can force strict mode manually at any time.',
+const REQUIRED_ARCHITECTURE_CHECKLIST_SNIPPETS = [
+  '## Backend Universal Principles',
+  'No clever hacks in backend and shared core modules',
+  'No premature abstraction',
+  'Readability over brevity',
 ];
 
 function pushResult(results, isPassed, checkName, details) {
@@ -348,16 +348,16 @@ function runAudit() {
     pushResult(results, true, 'strict-audit-activation', `Strict audit mode activated (${auditMode.triggerReason})`);
 
     assertChecklist(
-      'security',
-      SECURITY_CHECKLIST_PATH,
-      REQUIRED_SECURITY_CHECKLIST_SNIPPETS,
+      'pr',
+      PR_CHECKLIST_PATH,
+      REQUIRED_PR_CHECKLIST_SNIPPETS,
       failures,
       results
     );
     assertChecklist(
-      'performance',
-      PERFORMANCE_CHECKLIST_PATH,
-      REQUIRED_PERFORMANCE_CHECKLIST_SNIPPETS,
+      'architecture',
+      ARCHITECTURE_CHECKLIST_PATH,
+      REQUIRED_ARCHITECTURE_CHECKLIST_SNIPPETS,
       failures,
       results
     );

package/scripts/documentation-boundary-audit.mjs

@@ -15,6 +15,13 @@ import { fileURLToPath } from 'node:url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const REPOSITORY_ROOT = resolve(__dirname, '..');
+const DOCUMENTATION_BOUNDARY_AUDIT_REPORT_VERSION = '2.1.0';
+const AUTO_DOCS_SYNC_SCOPE_PHASE = 'phase-1';
+const AUTO_DOCS_SYNC_SCOPE_BOUNDARIES = [
+  'public-surface',
+  'api-contract',
+  'database-structure',
+];
 
 const CORE_DOCUMENTATION_FILES = new Set(['README.md', 'CHANGELOG.md']);
 
@@ -22,6 +29,12 @@ const BOUNDARY_RULES = [
   {
     boundaryName: 'public-surface',
     requirement: 'Public surface changes must update README.md, CHANGELOG.md, or docs/* in the same scope.',
+    suggestedDocumentationUpdates: [
+      'README.md',
+      'CHANGELOG.md',
+      'docs/architecture-decision-record.md',
+      'docs/flow-overview.md',
+    ],
     trigger(filePath) {
       return /^(bin\/|lib\/|scripts\/)/.test(filePath) && !isDocumentationFilePath(filePath);
     },
@@ -32,6 +45,12 @@ const BOUNDARY_RULES = [
   {
     boundaryName: 'api-contract',
     requirement: 'API endpoint or contract changes must update API/OpenAPI documentation in the same scope.',
+    suggestedDocumentationUpdates: [
+      'docs/api-contract.md',
+      'docs/flow-overview.md',
+      '.agent-context/rules/api-docs.md',
+      'README.md',
+    ],
     trigger(filePath) {
       return !isDocumentationFilePath(filePath)
         && /(api|openapi|contract|controller|route|endpoint)/i.test(filePath);
@@ -45,6 +64,12 @@ const BOUNDARY_RULES = [
   {
     boundaryName: 'database-structure',
     requirement: 'Database structure changes must update schema or migration documentation in the same scope.',
+    suggestedDocumentationUpdates: [
+      'docs/database-schema.md',
+      'docs/flow-overview.md',
+      '.agent-context/rules/database-design.md',
+      'README.md',
+    ],
     trigger(filePath) {
       return !isDocumentationFilePath(filePath)
         && /(database|schema|migration|repository|sql|prisma|typeorm|knex)/i.test(filePath);
@@ -135,6 +160,9 @@ function isDocumentationFilePath(filePath) {
 
 function evaluateBoundary(boundaryRule, changedFiles, changedDocumentationFiles) {
   const boundaryChangedFiles = changedFiles.filter((filePath) => boundaryRule.trigger(filePath));
+  const expectedDocumentationPaths = Array.isArray(boundaryRule.suggestedDocumentationUpdates)
+    ? boundaryRule.suggestedDocumentationUpdates
+    : [];
 
   if (boundaryChangedFiles.length === 0) {
     return {
@@ -144,12 +172,21 @@ function evaluateBoundary(boundaryRule, changedFiles, changedDocumentationFiles)
       passed: true,
       changedFiles: [],
       documentationFiles: [],
+      expectedDocumentationPaths,
+      missingDocumentationUpdates: false,
+      suggestedActions: [],
       details: 'Boundary not triggered by changed scope.',
     };
   }
 
   const matchingDocumentationFiles = changedDocumentationFiles.filter((filePath) => boundaryRule.docsMatcher(filePath));
   const boundaryPassed = matchingDocumentationFiles.length > 0;
+  const suggestedActions = boundaryPassed
+    ? []
+    : [
+      `Update one or more boundary docs: ${expectedDocumentationPaths.join(', ')}`,
+      'Re-run scripts/documentation-boundary-audit.mjs before merge.',
+    ];
 
   const details = boundaryPassed
     ? `Boundary triggered and synchronized with documentation updates: ${matchingDocumentationFiles.join(', ')}`
@@ -162,6 +199,9 @@ function evaluateBoundary(boundaryRule, changedFiles, changedDocumentationFiles)
     passed: boundaryPassed,
     changedFiles: boundaryChangedFiles,
     documentationFiles: matchingDocumentationFiles,
+      expectedDocumentationPaths,
+      missingDocumentationUpdates: !boundaryPassed,
+      suggestedActions,
     details,
   };
 }
@@ -175,25 +215,72 @@ function runDocumentationBoundaryAudit() {
     evaluateBoundary(boundaryRule, changedFiles, changedDocumentationFiles)
   ));
 
-  const failures = boundaryResults
+  const violations = boundaryResults
     .filter((boundaryResult) => boundaryResult.triggered && !boundaryResult.passed)
-    .map((boundaryResult) => {
-      const affectedFiles = boundaryResult.changedFiles.join(', ');
-      return `${boundaryResult.boundaryName}: ${boundaryResult.requirement} Changed files: ${affectedFiles}`;
-    });
+    .map((boundaryResult) => ({
+      boundaryName: boundaryResult.boundaryName,
+      requirement: boundaryResult.requirement,
+      changedFiles: boundaryResult.changedFiles,
+      expectedDocumentationPaths: boundaryResult.expectedDocumentationPaths,
+      suggestedActions: boundaryResult.suggestedActions,
+      diagnosticCode: `BOUNDARY_${boundaryResult.boundaryName.toUpperCase().replace(/-/g, '_')}_DOCS_SYNC_REQUIRED`,
+    }));
+
+  const failures = violations.map((violation) => {
+    const affectedFiles = violation.changedFiles.join(', ');
+    return `${violation.boundaryName}: ${violation.requirement} Changed files: ${affectedFiles}`;
+  });
 
   const reportPayload = {
     generatedAt: new Date().toISOString(),
+    reportVersion: DOCUMENTATION_BOUNDARY_AUDIT_REPORT_VERSION,
     auditName: 'documentation-boundary-audit',
     source: changedScope.source,
     changedFileCount: changedFiles.length,
     changedFiles,
     boundaryResults,
+    violations,
     passed: failures.length === 0,
     failureCount: failures.length,
     failures,
   };
 
+  const triggeredBoundaryResults = boundaryResults.filter((boundaryResult) => boundaryResult.triggered);
+  const passedTriggeredBoundaryResults = triggeredBoundaryResults.filter((boundaryResult) => boundaryResult.passed);
+  const scopeMatchedDocumentationFiles = uniqueSorted(
+    triggeredBoundaryResults.flatMap((boundaryResult) => boundaryResult.documentationFiles),
+  );
+  const scopeMatchedDocumentationFileSet = new Set(scopeMatchedDocumentationFiles);
+  const outOfScopeDocumentationFiles = changedDocumentationFiles.filter(
+    (filePath) => !scopeMatchedDocumentationFileSet.has(filePath),
+  );
+
+  const precisionNumerator = scopeMatchedDocumentationFiles.length;
+  const precisionDenominator = changedDocumentationFiles.length;
+  const recallNumerator = passedTriggeredBoundaryResults.length;
+  const recallDenominator = triggeredBoundaryResults.length;
+
+  const precision = precisionDenominator > 0 ? precisionNumerator / precisionDenominator : 1;
+  const recall = recallDenominator > 0 ? recallNumerator / recallDenominator : 1;
+
+  reportPayload.autoDocsSyncScope = {
+    phase: AUTO_DOCS_SYNC_SCOPE_PHASE,
+    bounded: true,
+    explicitBoundaries: AUTO_DOCS_SYNC_SCOPE_BOUNDARIES,
+  };
+
+  reportPayload.rolloutMetrics = {
+    measuredAt: reportPayload.generatedAt,
+    precision,
+    recall,
+    precisionNumerator,
+    precisionDenominator,
+    recallNumerator,
+    recallDenominator,
+    scopeMatchedDocumentationFiles,
+    outOfScopeDocumentationFiles,
+  };
+
   console.log(JSON.stringify(reportPayload, null, 2));
   process.exit(reportPayload.passed ? 0 : 1);
 }

package/scripts/forbidden-content-check.mjs

@@ -1,4 +1,4 @@
-import { readFileSync, statSync, readdirSync } from 'node:fs';
+import { readFileSync, readdirSync } from 'node:fs';
 import { join, relative } from 'node:path';
 
 const ROOT_DIR = process.cwd();