@ryuenn3123/agentic-senior-core 2.5.15 → 2.5.17

package/.agent-context/prompts/init-project.md

@@ -1,7 +1,7 @@
 # Prompts: Initialize Project
 
 > Copy-paste one of these prompts to your AI agent (Cursor, Windsurf, Copilot, Antigravity) right after cloning this repository.
-> V1.4 recommendation: run `bunx @fatidaprilian/agentic-senior-core init` first to compile dynamic governance context.
+> V1.4 recommendation: run `bunx @fatidaprilian/agentic-senior-core init` first to compile dynamic rules operations context (Federated Governance baseline).
 
 ---
 

package/.agent-context/prompts/review-code.md

@@ -19,6 +19,7 @@ Use these checklists:
 6. Enforce context-triggered strict audits: review requests, PR-intent workflows, and major feature completion must run strict security and performance audits; small edits stay lightweight unless strict mode is explicitly forced.
 7. Enforce cross-session consistency guardian: session handoff must include active architecture contract summary, drift detection must warn before direction changes, and direction changes require explicit user confirmation.
 8. Enforce explain-on-demand state visibility: default responses must avoid unnecessary state-file internals, state internals are exposed only on explicit request, and diagnostic mode must explain relevant state decisions when needed.
+9. Enforce single-source and lazy-loading policy: canonical rule source must be explicitly enforced, language-specific guidance must load lazily based on detected scope, and conflicting duplicate rule instructions must not appear during normal flow.
 
 For EVERY violation found:
 - State the exact file and line

package/.agent-context/review-checklists/pr-checklist.md

@@ -124,3 +124,8 @@ VERDICT: PASS / FAIL (X/Y items passed)
 - [ ] Default responses avoid unnecessary state-file internals
 - [ ] State internals are exposed only on explicit request
 - [ ] Diagnostic mode can explain relevant state decisions when needed
+
+### 14. Single Source and Lazy Rule Loading
+- [ ] Canonical rule source is explicitly defined and enforced
+- [ ] Language-specific guidance is loaded lazily based on detected scope
+- [ ] No conflicting duplicate rule instructions during normal flow

package/.agent-context/rules/architecture.md

@@ -32,6 +32,14 @@ State internals must stay invisible by default.
 - Diagnostic mode explains relevant state decisions when needed.
 - Keep default explanations concise and outcome-first; show raw state details only in diagnostic mode.
 
+## Single Source of Truth and Lazy Rule Loading
+
+- Canonical rule source is .instructions.md.
+- Adapter entry files stay thin and must point to the canonical source.
+- Load language-specific stack guidance lazily based on detected scope.
+- Do not preload unrelated stack profiles during normal flow.
+- Keep rule-loading output deterministic for init and release validation.
+
 ## The Core Principle
 
 **Every layer has ONE job. Layer leaks are bugs — not "pragmatic shortcuts."**

package/.agent-context/state/memory-continuity-benchmark.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-04-17T13:21:48.914Z",
+  "generatedAt": "2026-04-18T02:40:52.883Z",
   "reportName": "memory-continuity-benchmark",
   "schemaVersion": "1.0.0",
   "passed": true,

package/.agent-context/state/onboarding-report.json

@@ -1,11 +1,20 @@
 {
-  "cliVersion": "2.0.1",
-  "generatedAt": "2026-04-08T14:58:53.636Z",
+  "cliVersion": "2.5.16",
+  "generatedAt": "2026-04-18T00:00:00.000Z",
   "operationMode": "upgrade",
   "selectedProfile": "beginner",
   "selectedProfilePack": null,
   "selectedStack": "typescript.md",
+  "selectedAdditionalStacks": [],
   "selectedBlueprint": "api-nextjs.md",
+  "selectedAdditionalBlueprints": [],
+  "ruleLoadingPolicy": {
+    "canonicalSource": ".instructions.md",
+    "stackLoadingMode": "lazy",
+    "loadedOnDemand": true,
+    "primaryStack": "typescript.md",
+    "additionalStacks": []
+  },
   "ciGuardrailsEnabled": true,
   "setupDurationMs": 106,
   "selectedSkillDomains": [],

package/.cursorrules

@@ -1,7 +1,7 @@
 # AGENTIC-SENIOR-CORE DYNAMIC GOVERNANCE RULESET
 
-Generated by Agentic-Senior-Core CLI v2.5.15
-Timestamp: 2026-04-15T00:14:51.184Z
+Generated by Agentic-Senior-Core CLI v2.5.17
+Timestamp: 2026-04-18T03:00:00.000Z
 Selected profile: beginner
 Selected policy file: .agent-context/policies/llm-judge-threshold.json
 

package/.windsurfrules

@@ -1,7 +1,7 @@
 # AGENTIC-SENIOR-CORE DYNAMIC GOVERNANCE RULESET
 
-Generated by Agentic-Senior-Core CLI v2.5.15
-Timestamp: 2026-04-15T00:14:51.184Z
+Generated by Agentic-Senior-Core CLI v2.5.17
+Timestamp: 2026-04-18T03:00:00.000Z
 Selected profile: beginner
 Selected policy file: .agent-context/policies/llm-judge-threshold.json
 

package/README.md

@@ -74,7 +74,7 @@ If you see `Property $schema is not allowed`, keep `.vscode/mcp.json` without `$
 
 | Command | Purpose |
 |---------|---------|
-| `agentic-senior-core init` | Initialize governance context |
+| `agentic-senior-core init` | Initialize rules operations context (Federated Governance baseline) |
 | `agentic-senior-core upgrade --dry-run` | Preview safe upgrades |
 | `agentic-senior-core optimize --show` | Show token optimization state |
 | `agentic-senior-core skill frontend --tier advance` | Select skill packs |

package/lib/cli/commands/init.mjs

@@ -583,7 +583,7 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
     }
 
     console.log(`\nAgentic-Senior-Core CLI v${CLI_VERSION}`);
-    console.log('I will copy governance files into your target folder and compile a single rulebook for your AI tools.');
+    console.log('I will copy rules operations assets (Federated Governance baseline) into your target folder and compile a single rulebook for your AI tools.');
 
     if (selectedPreset) {
       console.log(`Using preset: ${initOptions.preset} (${selectedPreset.description}).`);
@@ -881,7 +881,7 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
           ? selectedProfilePack.defaultCi
       : selectedProfile.lockCi
         ? selectedProfile.defaultCi
-        : await askYesNo('Enable CI/CD guardrails and the LLM Judge policy?', userInterface, selectedProfile.defaultCi);
+        : await askYesNo('Enable CI/CD quality checks (guardrails) and the LLM Judge policy?', userInterface, selectedProfile.defaultCi);
 
     await copyGovernanceAssetsToTarget(resolvedTargetDirectoryPath, {
       includeMcpTemplate: shouldIncludeMcpTemplate,
@@ -1078,7 +1078,7 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
       console.log(`- Additional blueprints: ${selectedAdditionalBlueprintFileNames.map((blueprintFileName) => toTitleCase(blueprintFileName)).join(', ')}`);
     }
     console.log(`- Runtime environment: ${resolveRuntimeEnvironmentLabelFromKey(selectedRuntimeEnvironmentKey)} (detected: ${detectedRuntimeEnvironment.label})`);
-    console.log(`- CI/CD guardrails: ${includeCiGuardrails ? 'enabled' : 'disabled'}`);
+    console.log(`- CI/CD quality checks (guardrails): ${includeCiGuardrails ? 'enabled' : 'disabled'}`);
     console.log(`- Blocking severities: ${formatBlockingSeverities(selectedProfile.blockingSeverities)}`);
     console.log(`- Setup time: ${formatDuration(setupDurationMs)}`);
     console.log('- Generated files: .cursorrules, .windsurfrules, and .agent-context/state/onboarding-report.json');
@@ -1099,7 +1099,7 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
       console.log('- Token optimization policy: disabled (--no-token-optimize)');
     }
     console.log('\nPlain-language summary:');
-    console.log(`I prepared a ${selectedProfile.displayName.toLowerCase()} governance pack for a ${toTitleCase(selectedResolvedStackFileName)} project using the ${toTitleCase(selectedResolvedBlueprintFileName)} blueprint.`);
+    console.log(`I prepared a ${selectedProfile.displayName.toLowerCase()} rules operations pack (Federated Governance baseline) for a ${toTitleCase(selectedResolvedStackFileName)} project using the ${toTitleCase(selectedResolvedBlueprintFileName)} blueprint.`);
     if (selectedAdditionalStackFileNames.length > 0) {
       console.log(`I also included additional stack context for ${selectedAdditionalStackFileNames.map((stackFileName) => toTitleCase(stackFileName)).join(', ')}.`);
     }

package/lib/cli/commands/upgrade.mjs

@@ -100,7 +100,7 @@ export async function runUpgradeCommand(targetDirectoryArgument, upgradeOptions
 
   try {
     console.log(`\nAgentic-Senior-Core CLI v${CLI_VERSION}`);
-    console.log('Running upgrade assistant for an existing repository.');
+    console.log('Running rules operations upgrade assistant (Federated Governance baseline) for an existing repository.');
 
     await copyGovernanceAssetsToTarget(resolvedTargetDirectoryPath, {
       includeMcpTemplate: upgradeOptions.includeMcpTemplate === true,
@@ -193,7 +193,7 @@ export async function runUpgradeCommand(targetDirectoryArgument, upgradeOptions
     if (selectedAdditionalBlueprintFileNames.length > 0) {
       console.log(`- Additional blueprints: ${selectedAdditionalBlueprintFileNames.map((blueprintFileName) => toTitleCase(blueprintFileName)).join(', ')}`);
     }
-    console.log(`- CI/CD guardrails: ${includeCiGuardrails ? 'enabled' : 'disabled'}`);
+    console.log(`- CI/CD quality checks (guardrails): ${includeCiGuardrails ? 'enabled' : 'disabled'}`);
     console.log(`- Existing rules lines: ${currentRuleLineCount}`);
     console.log(`- Planned rules lines: ${plannedRuleLineCount}`);
     console.log(`- Rules changed: ${isRulesContentChanged ? 'yes' : 'no'}`);

package/lib/cli/compiler.mjs

@@ -80,6 +80,13 @@ export async function writeOnboardingReport({
     selectedAdditionalStacks: selectedAdditionalStackFileNames,
     selectedBlueprint: selectedBlueprintFileName,
     selectedAdditionalBlueprints: selectedAdditionalBlueprintFileNames,
+    ruleLoadingPolicy: {
+      canonicalSource: '.instructions.md',
+      stackLoadingMode: 'lazy',
+      loadedOnDemand: true,
+      primaryStack: selectedStackFileName,
+      additionalStacks: selectedAdditionalStackFileNames,
+    },
     ciGuardrailsEnabled: includeCiGuardrails,
     setupDurationMs,
     selectedSkillDomains,
@@ -174,7 +181,7 @@ export async function buildCompiledRulesContent({
       '## BOOTSTRAP CHAIN (MANDATORY)',
       'Load every layer before responding. Do not skip steps:',
       '1. .agent-context/rules/',
-      '2. .agent-context/stacks/',
+      '2. .agent-context/stacks/ (lazy by task scope)',
       '3. .agent-context/blueprints/',
       '4. .agent-context/skills/',
       '5. .agent-context/prompts/',
@@ -220,6 +227,18 @@ export async function buildCompiledRulesContent({
     );
   }
 
+  contextBlocks.push(
+    [
+      '## LAYER 2 POLICY: LAZY RULE LOADING',
+      `Primary stack profile is always loaded for this project: .agent-context/stacks/${selectedStackFileName}`,
+      normalizedAdditionalStackFileNames.length > 0
+        ? `Additional stack profiles load on demand: ${normalizedAdditionalStackFileNames.map((stackFileName) => `.agent-context/stacks/${stackFileName}`).join(', ')}`
+        : 'Additional stack profiles load only when explicitly selected or detected.',
+      'Load stack guidance only when task scope touches that stack.',
+      'Avoid eager loading unrelated stack profiles to prevent instruction conflicts.',
+    ].join('\n')
+  );
+
   const blueprintFilePath = path.join(selectedBlueprintsDirectoryPath, selectedBlueprintFileName);
   const blueprintContent = await fs.readFile(blueprintFilePath, 'utf8');
   const blueprintSummary = firstMarkdownHeading(blueprintContent, selectedBlueprintFileName);

package/lib/cli/utils.mjs

@@ -49,7 +49,7 @@ export function printUsage() {
   console.log('  --project-description  Architecture intent text used for stack/blueprint recommendation');
   console.log('  --architect-token-budget  Max token estimate used by recommendation research (default: 900)');
   console.log('  --architect-timeout-ms  Max recommendation research time in milliseconds (default: 1500)');
-  console.log('  --ci         Override CI/CD guardrails (true|false)');
+  console.log('  --ci         Override CI/CD quality checks (guardrails) (true|false)');
   console.log('  --token-optimize  Explicitly enable token optimization policy during init (default behavior)');
   console.log('  --token-agent     Set token optimization agent target (copilot, claude, cursor, windsurf, gemini, codex, cline)');
   console.log('  --no-token-optimize  Disable token optimization policy during init');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryuenn3123/agentic-senior-core",
-  "version": "2.5.15",
+  "version": "2.5.17",
   "type": "module",
   "description": "Force your AI Agent to code like a Staff Engineer, not a Junior.",
   "bin": {
@@ -47,6 +47,7 @@
     "audit:context-triggered": "node ./scripts/context-triggered-audit.mjs",
     "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",
     "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",

package/scripts/release-gate.mjs

@@ -34,6 +34,7 @@ const DOCUMENTATION_BOUNDARY_AUDIT_SCRIPT_PATH = 'scripts/documentation-boundary
 const CONTEXT_TRIGGERED_AUDIT_SCRIPT_PATH = 'scripts/context-triggered-audit.mjs';
 const RULES_GUARDIAN_AUDIT_SCRIPT_PATH = 'scripts/rules-guardian-audit.mjs';
 const EXPLAIN_ON_DEMAND_AUDIT_SCRIPT_PATH = 'scripts/explain-on-demand-audit.mjs';
+const SINGLE_SOURCE_LAZY_LOADING_AUDIT_SCRIPT_PATH = 'scripts/single-source-lazy-loading-audit.mjs';
 const BACKEND_ARCHITECTURE_RULE_PATH = '.agent-context/rules/architecture.md';
 const BACKEND_REVIEW_CHECKLIST_PATH = '.agent-context/review-checklists/pr-checklist.md';
 const REFACTOR_PROMPT_PATH = '.agent-context/prompts/refactor.md';
@@ -605,6 +606,73 @@ function runReleaseGate() {
     }
   }
 
+  const singleSourceLazyLoadingAuditExecution = runMachineReadableScript(
+    SINGLE_SOURCE_LAZY_LOADING_AUDIT_SCRIPT_PATH,
+    ['--workflow', 'pr-preparation']
+  );
+  if (!singleSourceLazyLoadingAuditExecution.report) {
+    const failureDetails = singleSourceLazyLoadingAuditExecution.executionErrorMessage
+      ? `Single-source lazy-loading audit execution failed before producing a machine-readable report: ${singleSourceLazyLoadingAuditExecution.executionErrorMessage}`
+      : 'Single-source lazy-loading audit did not produce machine-readable JSON output';
+    pushResult(results, false, 'single-source-lazy-loading-audit', failureDetails);
+  } else {
+    diagnostics.singleSourceLazyLoadingAudit = singleSourceLazyLoadingAuditExecution.report;
+    pushResult(
+      results,
+      true,
+      'single-source-lazy-loading-audit',
+      `single-source-lazy-loading-audit executed (passed=${singleSourceLazyLoadingAuditExecution.report.passed}, failures=${singleSourceLazyLoadingAuditExecution.report.failureCount})`
+    );
+
+    if (singleSourceLazyLoadingAuditExecution.report?.canonicalSource?.enforced === true) {
+      pushResult(
+        results,
+        true,
+        'canonical-rule-source-hard-rule',
+        'Canonical rule source is explicitly defined and enforced'
+      );
+    } else {
+      pushResult(
+        results,
+        false,
+        'canonical-rule-source-hard-rule',
+        'Canonical rule source enforcement failed in single-source lazy-loading audit'
+      );
+    }
+
+    if (singleSourceLazyLoadingAuditExecution.report?.lazyRuleLoading?.enforced === true) {
+      pushResult(
+        results,
+        true,
+        'lazy-rule-loading-hard-rule',
+        'Language-specific guidance is loaded lazily by detected scope'
+      );
+    } else {
+      pushResult(
+        results,
+        false,
+        'lazy-rule-loading-hard-rule',
+        'Lazy rule loading enforcement failed in single-source lazy-loading audit'
+      );
+    }
+
+    if (singleSourceLazyLoadingAuditExecution.report?.duplicationPolicy?.noConflictingDuplicates === true) {
+      pushResult(
+        results,
+        true,
+        'no-conflicting-duplicate-rule-instructions',
+        'No conflicting duplicate rule instructions detected in normal flow'
+      );
+    } else {
+      pushResult(
+        results,
+        false,
+        'no-conflicting-duplicate-rule-instructions',
+        'Conflicting duplicate rule instructions detected by single-source lazy-loading audit'
+      );
+    }
+  }
+
   const frontendParityChecklistContent = readText(FRONTEND_PARITY_CHECKLIST_PATH);
   if (!frontendParityChecklistContent) {
     pushResult(results, false, 'frontend-parity-checklist-exists', `Missing ${FRONTEND_PARITY_CHECKLIST_PATH}`);

package/scripts/single-source-lazy-loading-audit.mjs

@@ -0,0 +1,535 @@
+#!/usr/bin/env node
+
+/**
+ * single-source-lazy-loading-audit.mjs
+ *
+ * Enforces V3.0-010 policy:
+ * - One canonical rule source is explicitly defined and enforced.
+ * - Language-specific rule guidance loads lazily by detected scope.
+ * - Conflicting duplicate instruction paths are prevented.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const REPOSITORY_ROOT = resolve(__dirname, '..');
+
+const CANONICAL_SOURCE_PATH = '.instructions.md';
+const ADAPTER_PATHS = [
+  'AGENTS.md',
+  '.github/copilot-instructions.md',
+  '.gemini/instructions.md',
+];
+const COMPILER_PATH = 'lib/cli/compiler.mjs';
+const ONBOARDING_REPORT_PATH = '.agent-context/state/onboarding-report.json';
+const ARCHITECTURE_RULE_PATH = '.agent-context/rules/architecture.md';
+const PR_CHECKLIST_PATH = '.agent-context/review-checklists/pr-checklist.md';
+const REVIEW_PROMPT_PATH = '.agent-context/prompts/review-code.md';
+const COMPILED_RULE_PATHS = ['.cursorrules', '.windsurfrules'];
+
+const DEFAULT_WORKFLOW = 'standard';
+const SUPPORTED_WORKFLOWS = new Set([
+  DEFAULT_WORKFLOW,
+  'pr-preparation',
+  'review-request',
+  'session-handoff',
+  'init',
+  'upgrade',
+]);
+
+const STACK_CATALOG_FILE_NAMES = [
+  'typescript.md',
+  'python.md',
+  'java.md',
+  'php.md',
+  'go.md',
+  'csharp.md',
+  'rust.md',
+  'ruby.md',
+  'flutter.md',
+  'react-native.md',
+];
+
+const MAX_EAGER_STACK_MENTIONS = 4;
+
+const REQUIRED_ARCHITECTURE_RULE_SNIPPETS = [
+  '## Single Source of Truth and Lazy Rule Loading',
+  'Canonical rule source is .instructions.md.',
+  'Load language-specific stack guidance lazily based on detected scope.',
+  'Do not preload unrelated stack profiles during normal flow.',
+];
+
+const REQUIRED_PR_CHECKLIST_SNIPPETS = [
+  'Canonical rule source is explicitly defined and enforced',
+  'Language-specific guidance is loaded lazily based on detected scope',
+  'No conflicting duplicate rule instructions during normal flow',
+];
+
+const REQUIRED_REVIEW_PROMPT_SNIPPETS = [
+  'Enforce single-source and lazy-loading policy: canonical rule source must be explicitly enforced, language-specific guidance must load lazily based on detected scope, and conflicting duplicate rule instructions must not appear during normal flow.',
+];
+
+const REQUIRED_COMPILER_SNIPPETS = [
+  '## LAYER 2 POLICY: LAZY RULE LOADING',
+  'Load stack guidance only when task scope touches that stack.',
+  'Avoid eager loading unrelated stack profiles to prevent instruction conflicts.',
+  "stackLoadingMode: 'lazy'",
+];
+
+function pushResult(results, isPassed, checkName, details) {
+  results.push({
+    checkName,
+    passed: isPassed,
+    details,
+  });
+}
+
+function normalizeLineEndings(content) {
+  return String(content || '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+
+function readText(relativeFilePath) {
+  const absolutePath = resolve(REPOSITORY_ROOT, relativeFilePath);
+  if (!existsSync(absolutePath)) {
+    return '';
+  }
+
+  return readFileSync(absolutePath, 'utf8');
+}
+
+function normalizeFilePath(filePath) {
+  return filePath.replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+function parseGitFileList(rawOutput) {
+  if (typeof rawOutput !== 'string' || rawOutput.trim().length === 0) {
+    return [];
+  }
+
+  return rawOutput
+    .split(/\r?\n/)
+    .map((filePath) => filePath.trim())
+    .filter((filePath) => filePath.length > 0)
+    .map(normalizeFilePath);
+}
+
+function runGitFileQuery(commandArguments) {
+  try {
+    const rawOutput = execFileSync('git', commandArguments, {
+      cwd: REPOSITORY_ROOT,
+      encoding: 'utf8',
+      maxBuffer: 1024 * 1024,
+    });
+
+    return parseGitFileList(rawOutput);
+  } catch {
+    return [];
+  }
+}
+
+function uniqueSorted(filePaths) {
+  return Array.from(new Set(filePaths)).sort((leftPath, rightPath) => leftPath.localeCompare(rightPath));
+}
+
+function collectChangedFiles() {
+  const workingTreeFiles = runGitFileQuery(['diff', '--name-only']);
+  const stagedFiles = runGitFileQuery(['diff', '--name-only', '--cached']);
+  const workingScopeFiles = uniqueSorted([...workingTreeFiles, ...stagedFiles]);
+
+  if (workingScopeFiles.length > 0) {
+    return {
+      source: 'working-tree-and-index',
+      files: workingScopeFiles,
+    };
+  }
+
+  const latestCommitRangeFiles = runGitFileQuery(['diff', '--name-only', 'HEAD~1..HEAD']);
+  if (latestCommitRangeFiles.length > 0) {
+    return {
+      source: 'latest-commit-range',
+      files: uniqueSorted(latestCommitRangeFiles),
+    };
+  }
+
+  const headCommitFiles = runGitFileQuery(['show', '--pretty=format:', '--name-only', 'HEAD']);
+  if (headCommitFiles.length > 0) {
+    return {
+      source: 'head-commit',
+      files: uniqueSorted(headCommitFiles),
+    };
+  }
+
+  return {
+    source: 'none',
+    files: [],
+  };
+}
+
+function parseCliArguments(argumentList) {
+  let workflow = DEFAULT_WORKFLOW;
+
+  for (let argumentIndex = 0; argumentIndex < argumentList.length; argumentIndex += 1) {
+    const argumentValue = argumentList[argumentIndex];
+
+    if (argumentValue === '--workflow') {
+      const nextArgumentValue = argumentList[argumentIndex + 1];
+      if (nextArgumentValue && !nextArgumentValue.startsWith('--')) {
+        workflow = nextArgumentValue;
+        argumentIndex += 1;
+      }
+      continue;
+    }
+
+    if (argumentValue.startsWith('--workflow=')) {
+      workflow = argumentValue.slice('--workflow='.length);
+    }
+  }
+
+  const normalizedWorkflow = String(workflow).trim().toLowerCase() || DEFAULT_WORKFLOW;
+
+  return {
+    workflow: SUPPORTED_WORKFLOWS.has(normalizedWorkflow) ? normalizedWorkflow : DEFAULT_WORKFLOW,
+  };
+}
+
+function assertSnippetCoverage(sourceLabel, sourcePath, requiredSnippets, failures, results) {
+  const sourceContent = readText(sourcePath);
+
+  if (!sourceContent) {
+    failures.push(`Missing ${sourceLabel} source: ${sourcePath}`);
+    pushResult(results, false, `${sourceLabel}-source-exists`, `Missing ${sourcePath}`);
+    return false;
+  }
+
+  pushResult(results, true, `${sourceLabel}-source-exists`, `${sourcePath} is present`);
+
+  const missingSnippets = requiredSnippets.filter((requiredSnippet) => !sourceContent.includes(requiredSnippet));
+
+  if (missingSnippets.length > 0) {
+    failures.push(`Missing ${sourceLabel} snippets: ${missingSnippets.join(', ')}`);
+    pushResult(
+      results,
+      false,
+      `${sourceLabel}-source-coverage`,
+      `Missing snippets in ${sourcePath}: ${missingSnippets.join(', ')}`
+    );
+    return false;
+  }
+
+  pushResult(results, true, `${sourceLabel}-source-coverage`, `${sourceLabel} snippets are complete`);
+  return true;
+}
+
+function parseJsonSafely(rawText) {
+  if (typeof rawText !== 'string' || rawText.trim().length === 0) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(rawText);
+  } catch {
+    return null;
+  }
+}
+
+function countStackMentions(textContent) {
+  return STACK_CATALOG_FILE_NAMES.reduce((mentionCount, stackFileName) => (
+    mentionCount + (textContent.includes(stackFileName) ? 1 : 0)
+  ), 0);
+}
+
+function runAudit() {
+  const parsedArguments = parseCliArguments(process.argv.slice(2));
+  const changedScope = collectChangedFiles();
+  const changedFiles = changedScope.files;
+  const results = [];
+  const failures = [];
+  const warnings = [];
+
+  pushResult(results, true, 'context-workflow', `workflow=${parsedArguments.workflow}`);
+
+  const canonicalSourceContent = readText(CANONICAL_SOURCE_PATH);
+  const canonicalSourceExists = canonicalSourceContent.length > 0;
+
+  if (!canonicalSourceExists) {
+    failures.push(`Missing canonical source: ${CANONICAL_SOURCE_PATH}`);
+    pushResult(results, false, 'canonical-source-exists', `Missing ${CANONICAL_SOURCE_PATH}`);
+  } else {
+    pushResult(results, true, 'canonical-source-exists', `${CANONICAL_SOURCE_PATH} is present`);
+  }
+
+  const canonicalHash = canonicalSourceExists
+    ? createHash('sha256').update(normalizeLineEndings(canonicalSourceContent)).digest('hex')
+    : '';
+
+  let adapterHashPassCount = 0;
+  const adapterChecks = [];
+
+  for (const adapterPath of ADAPTER_PATHS) {
+    const adapterContent = readText(adapterPath);
+
+    if (!adapterContent) {
+      failures.push(`Missing adapter file: ${adapterPath}`);
+      pushResult(results, false, 'adapter-file-exists', `Missing ${adapterPath}`);
+      adapterChecks.push({
+        path: adapterPath,
+        exists: false,
+        thinAdapterMode: false,
+        sourcePointerValid: false,
+        hashMatchesCanonical: false,
+      });
+      continue;
+    }
+
+    pushResult(results, true, 'adapter-file-exists', `${adapterPath} is present`);
+
+    const thinAdapterMode = adapterContent.includes('Adapter Mode: thin');
+    const sourcePointerValid = adapterContent.includes('Adapter Source: .instructions.md');
+    const hashMatch = adapterContent.match(/Canonical Snapshot SHA256:\s*([a-f0-9]{64})/);
+    const hashMatchesCanonical = Boolean(hashMatch && canonicalHash && hashMatch[1] === canonicalHash);
+
+    if (!thinAdapterMode) {
+      failures.push(`${adapterPath} must stay in thin adapter mode`);
+      pushResult(results, false, 'adapter-thin-mode', `${adapterPath} is missing Adapter Mode: thin metadata`);
+    } else {
+      pushResult(results, true, 'adapter-thin-mode', `${adapterPath} declares thin adapter mode`);
+    }
+
+    if (!sourcePointerValid) {
+      failures.push(`${adapterPath} must point to canonical source .instructions.md`);
+      pushResult(results, false, 'adapter-canonical-source-pointer', `${adapterPath} is missing canonical source pointer`);
+    } else {
+      pushResult(results, true, 'adapter-canonical-source-pointer', `${adapterPath} points to canonical source`);
+    }
+
+    if (!hashMatch) {
+      failures.push(`${adapterPath} must declare Canonical Snapshot SHA256`);
+      pushResult(results, false, 'adapter-canonical-hash', `${adapterPath} is missing Canonical Snapshot SHA256 metadata`);
+    } else if (!hashMatchesCanonical) {
+      failures.push(`${adapterPath} canonical hash drift detected`);
+      pushResult(results, false, 'adapter-canonical-hash', `${adapterPath} hash does not match ${CANONICAL_SOURCE_PATH}`);
+    } else {
+      adapterHashPassCount += 1;
+      pushResult(results, true, 'adapter-canonical-hash', `${adapterPath} hash matches canonical source`);
+    }
+
+    adapterChecks.push({
+      path: adapterPath,
+      exists: true,
+      thinAdapterMode,
+      sourcePointerValid,
+      hashMatchesCanonical,
+    });
+  }
+
+  const architectureCoverageComplete = assertSnippetCoverage(
+    'single-source-lazy-loading-architecture-rule',
+    ARCHITECTURE_RULE_PATH,
+    REQUIRED_ARCHITECTURE_RULE_SNIPPETS,
+    failures,
+    results
+  );
+
+  const checklistCoverageComplete = assertSnippetCoverage(
+    'single-source-lazy-loading-pr-checklist',
+    PR_CHECKLIST_PATH,
+    REQUIRED_PR_CHECKLIST_SNIPPETS,
+    failures,
+    results
+  );
+
+  const reviewPromptCoverageComplete = assertSnippetCoverage(
+    'single-source-lazy-loading-review-prompt',
+    REVIEW_PROMPT_PATH,
+    REQUIRED_REVIEW_PROMPT_SNIPPETS,
+    failures,
+    results
+  );
+
+  const compilerCoverageComplete = assertSnippetCoverage(
+    'single-source-lazy-loading-compiler-policy',
+    COMPILER_PATH,
+    REQUIRED_COMPILER_SNIPPETS,
+    failures,
+    results
+  );
+
+  const onboardingReportContent = readText(ONBOARDING_REPORT_PATH);
+  const onboardingReport = parseJsonSafely(onboardingReportContent);
+
+  let onboardingLazyPolicyMode = 'missing';
+  let onboardingLazyPolicyValidated = false;
+
+  if (!onboardingReportContent) {
+    warnings.push(`Missing ${ONBOARDING_REPORT_PATH}; fallback lazy policy inference used`);
+    pushResult(results, false, 'lazy-loading-onboarding-state', `Missing ${ONBOARDING_REPORT_PATH}`);
+  } else if (!onboardingReport) {
+    failures.push(`Invalid JSON in ${ONBOARDING_REPORT_PATH}`);
+    pushResult(results, false, 'lazy-loading-onboarding-state', `Cannot parse ${ONBOARDING_REPORT_PATH}`);
+  } else {
+    const lazyPolicy = onboardingReport.ruleLoadingPolicy;
+
+    if (lazyPolicy
+      && lazyPolicy.canonicalSource === CANONICAL_SOURCE_PATH
+      && lazyPolicy.stackLoadingMode === 'lazy'
+      && lazyPolicy.loadedOnDemand === true) {
+      onboardingLazyPolicyMode = 'explicit-lazy-policy';
+      onboardingLazyPolicyValidated = true;
+      pushResult(results, true, 'lazy-loading-onboarding-state', `${ONBOARDING_REPORT_PATH} exposes explicit lazy loading policy`);
+    } else if (typeof onboardingReport.selectedStack === 'string' && onboardingReport.selectedStack.trim().length > 0) {
+      onboardingLazyPolicyMode = 'selected-stack-fallback';
+      onboardingLazyPolicyValidated = true;
+      warnings.push('Onboarding report does not include explicit ruleLoadingPolicy; using selectedStack fallback inference');
+      pushResult(
+        results,
+        true,
+        'lazy-loading-onboarding-state',
+        `${ONBOARDING_REPORT_PATH} includes selectedStack fallback for lazy loading policy`
+      );
+    } else {
+      onboardingLazyPolicyMode = 'invalid';
+      failures.push(`${ONBOARDING_REPORT_PATH} must include selectedStack or explicit ruleLoadingPolicy`);
+      pushResult(results, false, 'lazy-loading-onboarding-state', `${ONBOARDING_REPORT_PATH} missing lazy loading policy signals`);
+    }
+  }
+
+  let compiledRulesCanonicalPassCount = 0;
+  let eagerLoadingDetected = false;
+  const compiledRuleChecks = [];
+
+  for (const compiledRulePath of COMPILED_RULE_PATHS) {
+    const compiledRuleContent = readText(compiledRulePath);
+
+    if (!compiledRuleContent) {
+      failures.push(`Missing compiled rules file: ${compiledRulePath}`);
+      pushResult(results, false, 'compiled-rules-file-exists', `Missing ${compiledRulePath}`);
+      compiledRuleChecks.push({
+        path: compiledRulePath,
+        exists: false,
+        canonicalBaselineDeclared: false,
+        stackMentionCount: 0,
+        eagerLoadingDetected: false,
+      });
+      continue;
+    }
+
+    pushResult(results, true, 'compiled-rules-file-exists', `${compiledRulePath} is present`);
+
+    const canonicalBaselineDeclared = compiledRuleContent.includes('Canonical baseline: .instructions.md');
+    if (canonicalBaselineDeclared) {
+      compiledRulesCanonicalPassCount += 1;
+      pushResult(results, true, 'compiled-rules-canonical-baseline', `${compiledRulePath} declares canonical baseline`);
+    } else {
+      failures.push(`${compiledRulePath} must declare canonical baseline ${CANONICAL_SOURCE_PATH}`);
+      pushResult(results, false, 'compiled-rules-canonical-baseline', `${compiledRulePath} is missing canonical baseline declaration`);
+    }
+
+    const stackMentionCount = countStackMentions(compiledRuleContent);
+    const isEagerLoading = stackMentionCount > MAX_EAGER_STACK_MENTIONS;
+
+    if (isEagerLoading) {
+      eagerLoadingDetected = true;
+      failures.push(`${compiledRulePath} appears to preload too many stack profiles (${stackMentionCount})`);
+      pushResult(
+        results,
+        false,
+        'compiled-rules-lazy-loading-density',
+        `${compiledRulePath} has ${stackMentionCount} stack profile mentions; expected <= ${MAX_EAGER_STACK_MENTIONS}`
+      );
+    } else {
+      pushResult(
+        results,
+        true,
+        'compiled-rules-lazy-loading-density',
+        `${compiledRulePath} has ${stackMentionCount} stack profile mentions (lazy-loading threshold satisfied)`
+      );
+    }
+
+    compiledRuleChecks.push({
+      path: compiledRulePath,
+      exists: true,
+      canonicalBaselineDeclared,
+      stackMentionCount,
+      eagerLoadingDetected: isEagerLoading,
+    });
+  }
+
+  const canonicalSourceEnforced = canonicalSourceExists
+    && adapterHashPassCount === ADAPTER_PATHS.length
+    && compiledRulesCanonicalPassCount === COMPILED_RULE_PATHS.length
+    && architectureCoverageComplete
+    && checklistCoverageComplete
+    && reviewPromptCoverageComplete;
+
+  if (canonicalSourceEnforced) {
+    pushResult(results, true, 'canonical-source-hard-rule', 'Canonical rule source is explicitly defined and enforced');
+  } else {
+    failures.push('Canonical rule source hard-rule is not fully enforced');
+    pushResult(results, false, 'canonical-source-hard-rule', 'Canonical source enforcement failed');
+  }
+
+  const lazyRuleLoadingEnforced = compilerCoverageComplete
+    && onboardingLazyPolicyValidated
+    && !eagerLoadingDetected;
+
+  if (lazyRuleLoadingEnforced) {
+    pushResult(results, true, 'lazy-rule-loading-hard-rule', 'Language-specific guidance is loaded lazily by detected scope');
+  } else {
+    failures.push('Lazy rule loading hard-rule is not fully enforced');
+    pushResult(results, false, 'lazy-rule-loading-hard-rule', 'Lazy loading enforcement failed');
+  }
+
+  const noConflictingDuplicates = canonicalSourceEnforced && !eagerLoadingDetected;
+
+  if (noConflictingDuplicates) {
+    pushResult(results, true, 'no-conflicting-duplicate-rule-instructions', 'No conflicting duplicate rule instructions detected in normal flow');
+  } else {
+    failures.push('Conflicting duplicate rule instructions detected in normal flow');
+    pushResult(results, false, 'no-conflicting-duplicate-rule-instructions', 'Duplicate/conflicting instruction risk detected');
+  }
+
+  const reportPayload = {
+    generatedAt: new Date().toISOString(),
+    auditName: 'single-source-lazy-loading-audit',
+    workflow: parsedArguments.workflow,
+    source: changedScope.source,
+    changedFileCount: changedFiles.length,
+    changedFiles,
+    canonicalSource: {
+      path: CANONICAL_SOURCE_PATH,
+      hash: canonicalHash,
+      enforced: canonicalSourceEnforced,
+      adapterChecks,
+      compiledRuleChecks,
+    },
+    lazyRuleLoading: {
+      enforced: lazyRuleLoadingEnforced,
+      compilerPolicySnippetsComplete: compilerCoverageComplete,
+      onboardingPolicyMode: onboardingLazyPolicyMode,
+      onboardingPolicyValidated: onboardingLazyPolicyValidated,
+      eagerLoadingDetected,
+      maxAllowedStackMentions: MAX_EAGER_STACK_MENTIONS,
+    },
+    duplicationPolicy: {
+      noConflictingDuplicates,
+      conflictingDuplicateSignals: noConflictingDuplicates
+        ? []
+        : ['canonical-source-enforcement-or-lazy-loading-density-failed'],
+    },
+    passed: failures.length === 0,
+    failureCount: failures.length,
+    failures,
+    warnings,
+    results,
+  };
+
+  console.log(JSON.stringify(reportPayload, null, 2));
+  process.exit(reportPayload.passed ? 0 : 1);
+}
+
+runAudit();

package/scripts/validate.mjs

@@ -80,6 +80,26 @@ const REQUIRED_HUMAN_WRITING_SNIPPETS = [
     ],
   },
 ];
+const TERMINOLOGY_REFERENCE_PATHS = [
+  'README.md',
+  'docs/roadmap.md',
+];
+const REQUIRED_TERMINOLOGY_ROW_PATTERNS = [
+  {
+    label: 'Federated Governance -> Federated Rules Operations',
+    pattern: /\|\s*Federated Governance\s*\|\s*Federated Rules Operations\s*\|/u,
+  },
+  {
+    label: 'Governance Engine -> Rules Engine',
+    pattern: /\|\s*Governance Engine\s*\|\s*Rules Engine\s*\|/u,
+  },
+  {
+    label: 'Guardrails -> Quality Checks',
+    pattern: /\|\s*Guardrails\s*\|\s*Quality Checks\s*\|/u,
+  },
+];
+const REQUIRED_TERMINOLOGY_RULE_SNIPPET =
+  'Rule: on first mention in developer-facing docs, include canonical term in parentheses.';
 
 const validationResult = {
   passed: 0,
@@ -175,6 +195,7 @@ async function validateRequiredFiles() {
     'scripts/context-triggered-audit.mjs',
     'scripts/rules-guardian-audit.mjs',
     'scripts/explain-on-demand-audit.mjs',
+    'scripts/single-source-lazy-loading-audit.mjs',
     'scripts/release-gate.mjs',
     'scripts/generate-sbom.mjs',
     'scripts/init-project.sh',
@@ -726,6 +747,41 @@ async function validateDocumentationFlow() {
   }
 }
 
+async function validateTerminologyMapping() {
+  console.log('\nChecking terminology mapping consistency...');
+
+  for (const terminologyReferencePath of TERMINOLOGY_REFERENCE_PATHS) {
+    const absoluteReferencePath = join(ROOT_DIR, terminologyReferencePath);
+
+    if (!(await fileExists(absoluteReferencePath))) {
+      fail(`Missing terminology reference source: ${terminologyReferencePath}`);
+      continue;
+    }
+
+    const referenceContent = await readTextFile(absoluteReferencePath);
+
+    if (referenceContent.includes('Terminology Mapping (Final)')) {
+      pass(`${terminologyReferencePath} includes Terminology Mapping (Final)`);
+    } else {
+      fail(`${terminologyReferencePath} must include Terminology Mapping (Final)`);
+    }
+
+    for (const terminologyRowRule of REQUIRED_TERMINOLOGY_ROW_PATTERNS) {
+      if (terminologyRowRule.pattern.test(referenceContent)) {
+        pass(`${terminologyReferencePath} includes mapping row: ${terminologyRowRule.label}`);
+      } else {
+        fail(`${terminologyReferencePath} is missing mapping row: ${terminologyRowRule.label}`);
+      }
+    }
+
+    if (referenceContent.includes(REQUIRED_TERMINOLOGY_RULE_SNIPPET)) {
+      pass(`${terminologyReferencePath} includes first-mention canonical term rule`);
+    } else {
+      fail(`${terminologyReferencePath} must include first-mention canonical term rule`);
+    }
+  }
+}
+
 async function validateMcpConfiguration() {
   console.log('\nChecking MCP configuration...');
 
@@ -974,6 +1030,7 @@ async function main() {
   await validatePolicyFile();
   await validateVersionConsistency();
   await validateDocumentationFlow();
+  await validateTerminologyMapping();
   await validateMcpConfiguration();
   await validateHumanWritingGovernance();
   await validateInstructionAdapters();