@ryuenn3123/agentic-senior-core 4.4.0 → 5.2.0

package/scripts/validate/coverage-checks.mjs

@@ -1,446 +0,0 @@
-import { join, relative } from 'node:path';
-import {
-  COMPLIANCE_ALIAS_TERMS,
-  COMPLIANCE_TERMINOLOGY_BOUNDARY_PATHS,
-  FORBIDDEN_ACTIVE_BIAS_ANCHOR_SNIPPETS,
-  FORMAL_ARTIFACT_PATHS,
-  FORBIDDEN_TEMPLATE_BOOTSTRAP_SNIPPETS,
-  REQUIRED_COMPLIANCE_CANONICAL_SNIPPETS,
-  REQUIRED_DEPENDENCY_FRESHNESS_AUTOMATION_SNIPPETS,
-  REQUIRED_DETECTION_TRANSPARENCY_SNIPPETS,
-  REQUIRED_DETERMINISTIC_BOUNDARY_ENFORCEMENT_SNIPPETS,
-  REQUIRED_DEVELOPER_FIRST_MENTION_PATTERNS,
-  REQUIRED_DIAGRAM_FORMAT_SNIPPETS,
-  REQUIRED_DOCKER_RUNTIME_AUTOMATION_SNIPPETS,
-  REQUIRED_HUMAN_WRITING_SNIPPETS,
-  REQUIRED_STACK_DECISION_BOUNDARY_SNIPPETS,
-  REQUIRED_TEMPLATE_FREE_BOOTSTRAP_SNIPPETS,
-  REQUIRED_TERMINOLOGY_ROW_PATTERNS,
-  REQUIRED_TERMINOLOGY_RULE_SNIPPET,
-  REQUIRED_UI_DESIGN_AUTOMATION_SNIPPETS,
-  REQUIRED_UNIVERSAL_SOP_SNIPPETS,
-  REQUIRED_UPGRADE_UI_CONTRACT_WARNING_SNIPPETS,
-  TERMINOLOGY_REFERENCE_PATHS,
-  THIN_ADAPTER_PATHS,
-} from './config.mjs';
-
-async function validateSnippetCoverage({
-  heading,
-  coverageRules,
-  missingLabel,
-  snippetLabel,
-  context,
-}) {
-  const { ROOT_DIR, fileExists, readTextFile, pass, fail } = context;
-
-  console.log(`\n${heading}`);
-
-  for (const coverageRule of coverageRules) {
-    const absoluteCoveragePath = join(ROOT_DIR, coverageRule.path);
-
-    if (!(await fileExists(absoluteCoveragePath))) {
-      fail(`Missing ${missingLabel}: ${coverageRule.path}`);
-      continue;
-    }
-
-    const coverageContent = await readTextFile(absoluteCoveragePath);
-    for (const requiredSnippet of coverageRule.snippets) {
-      if (coverageContent.includes(requiredSnippet)) {
-        pass(`${coverageRule.path} includes ${snippetLabel}: ${requiredSnippet}`);
-      } else {
-        fail(`${coverageRule.path} is missing ${snippetLabel}: ${requiredSnippet}`);
-      }
-    }
-  }
-}
-
-export async function validateTerminologyMapping(context) {
-  const { ROOT_DIR, fileExists, readTextFile, pass, fail } = context;
-
-  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`);
-    }
-  }
-
-  for (const firstMentionRule of REQUIRED_DEVELOPER_FIRST_MENTION_PATTERNS) {
-    const absoluteFirstMentionPath = join(ROOT_DIR, firstMentionRule.path);
-
-    if (!(await fileExists(absoluteFirstMentionPath))) {
-      fail(`Missing developer-facing first-mention source: ${firstMentionRule.path}`);
-      continue;
-    }
-
-    const firstMentionContent = await readTextFile(absoluteFirstMentionPath);
-    if (firstMentionRule.pattern.test(firstMentionContent)) {
-      pass(`${firstMentionRule.path} keeps first-mention rule: ${firstMentionRule.label}`);
-    } else {
-      fail(`${firstMentionRule.path} must keep first-mention rule: ${firstMentionRule.label}`);
-    }
-  }
-
-  for (const compliancePath of COMPLIANCE_TERMINOLOGY_BOUNDARY_PATHS) {
-    const absoluteCompliancePath = join(ROOT_DIR, compliancePath);
-
-    if (!(await fileExists(absoluteCompliancePath))) {
-      fail(`Missing compliance/audit artifact for terminology boundary: ${compliancePath}`);
-      continue;
-    }
-
-    const complianceContent = await readTextFile(absoluteCompliancePath);
-    for (const aliasTerm of COMPLIANCE_ALIAS_TERMS) {
-      if (complianceContent.includes(aliasTerm)) {
-        fail(`${compliancePath} must not use developer-facing alias in compliance context: ${aliasTerm}`);
-      } else {
-        pass(`${compliancePath} keeps canonical terminology boundary for alias: ${aliasTerm}`);
-      }
-    }
-  }
-
-  for (const complianceRule of REQUIRED_COMPLIANCE_CANONICAL_SNIPPETS) {
-    const absoluteComplianceRulePath = join(ROOT_DIR, complianceRule.path);
-
-    if (!(await fileExists(absoluteComplianceRulePath))) {
-      fail(`Missing compliance canonical source: ${complianceRule.path}`);
-      continue;
-    }
-
-    const complianceRuleContent = await readTextFile(absoluteComplianceRulePath);
-    if (complianceRuleContent.includes(complianceRule.snippet)) {
-      pass(`${complianceRule.path} keeps canonical terminology rule: ${complianceRule.label}`);
-    } else {
-      fail(`${complianceRule.path} must keep canonical terminology rule: ${complianceRule.label}`);
-    }
-  }
-}
-
-export async function validateDetectionTransparencyCoverage(context) {
-  await validateSnippetCoverage({
-    heading: 'Checking existing-project detection transparency coverage...',
-    coverageRules: REQUIRED_DETECTION_TRANSPARENCY_SNIPPETS,
-    missingLabel: 'detection transparency source',
-    snippetLabel: 'detection transparency snippet',
-    context,
-  });
-}
-
-export async function validateStackDecisionBoundaryCoverage(context) {
-  await validateSnippetCoverage({
-    heading: 'Checking stack decision boundary coverage...',
-    coverageRules: REQUIRED_STACK_DECISION_BOUNDARY_SNIPPETS,
-    missingLabel: 'stack decision boundary source',
-    snippetLabel: 'stack decision boundary snippet',
-    context,
-  });
-}
-
-export async function validateUniversalSopConsolidationCoverage(context) {
-  await validateSnippetCoverage({
-    heading: 'Checking Universal SOP consolidation coverage...',
-    coverageRules: REQUIRED_UNIVERSAL_SOP_SNIPPETS,
-    missingLabel: 'Universal SOP source',
-    snippetLabel: 'Universal SOP snippet',
-    context,
-  });
-}
-
-export async function validateDiagramFormatCoverage(context) {
-  await validateSnippetCoverage({
-    heading: 'Checking documentation diagram format coverage...',
-    coverageRules: REQUIRED_DIAGRAM_FORMAT_SNIPPETS,
-    missingLabel: 'diagram format source',
-    snippetLabel: 'diagram format snippet',
-    context,
-  });
-}
-
-export async function validateTemplateFreeBootstrapCoverage(context) {
-  const { ROOT_DIR, fileExists, readTextFile, pass, fail } = context;
-
-  console.log('\nChecking template-free dynamic bootstrap coverage...');
-
-  for (const coverageRule of REQUIRED_TEMPLATE_FREE_BOOTSTRAP_SNIPPETS) {
-    const absoluteCoveragePath = join(ROOT_DIR, coverageRule.path);
-
-    if (!(await fileExists(absoluteCoveragePath))) {
-      fail(`Missing template-free bootstrap source: ${coverageRule.path}`);
-      continue;
-    }
-
-    const coverageContent = await readTextFile(absoluteCoveragePath);
-    for (const requiredSnippet of coverageRule.snippets) {
-      if (coverageContent.includes(requiredSnippet)) {
-        pass(`${coverageRule.path} includes template-free bootstrap snippet: ${requiredSnippet}`);
-      } else {
-        fail(`${coverageRule.path} is missing template-free bootstrap snippet: ${requiredSnippet}`);
-      }
-    }
-  }
-
-  for (const forbiddenRule of FORBIDDEN_TEMPLATE_BOOTSTRAP_SNIPPETS) {
-    const absoluteForbiddenPath = join(ROOT_DIR, forbiddenRule.path);
-
-    if (!(await fileExists(absoluteForbiddenPath))) {
-      fail(`Missing template-free bootstrap source: ${forbiddenRule.path}`);
-      continue;
-    }
-
-    const forbiddenContent = await readTextFile(absoluteForbiddenPath);
-    for (const forbiddenSnippet of forbiddenRule.snippets) {
-      if (forbiddenContent.includes(forbiddenSnippet)) {
-        fail(`${forbiddenRule.path} must not include active template snippet: ${forbiddenSnippet}`);
-      } else {
-        pass(`${forbiddenRule.path} excludes active template snippet: ${forbiddenSnippet}`);
-      }
-    }
-  }
-}
-
-export async function validateUpgradeUiContractWarningCoverage(context) {
-  await validateSnippetCoverage({
-    heading: 'Checking upgrade UI contract warning coverage...',
-    coverageRules: REQUIRED_UPGRADE_UI_CONTRACT_WARNING_SNIPPETS,
-    missingLabel: 'upgrade UI contract warning source',
-    snippetLabel: 'upgrade UI contract warning snippet',
-    context,
-  });
-}
-
-export async function validateUiDesignAutomationCoverage(context) {
-  await validateSnippetCoverage({
-    heading: 'Checking UI design automation coverage...',
-    coverageRules: REQUIRED_UI_DESIGN_AUTOMATION_SNIPPETS,
-    missingLabel: 'UI design automation source',
-    snippetLabel: 'UI design automation snippet',
-    context,
-  });
-}
-
-export async function validateDockerRuntimeAutomationCoverage(context) {
-  await validateSnippetCoverage({
-    heading: 'Checking Docker runtime automation coverage...',
-    coverageRules: REQUIRED_DOCKER_RUNTIME_AUTOMATION_SNIPPETS,
-    missingLabel: 'Docker runtime automation source',
-    snippetLabel: 'Docker runtime automation snippet',
-    context,
-  });
-}
-
-export async function validateDependencyFreshnessAutomationCoverage(context) {
-  await validateSnippetCoverage({
-    heading: 'Checking dependency freshness automation coverage...',
-    coverageRules: REQUIRED_DEPENDENCY_FRESHNESS_AUTOMATION_SNIPPETS,
-    missingLabel: 'dependency freshness automation source',
-    snippetLabel: 'dependency freshness automation snippet',
-    context,
-  });
-}
-
-export async function validateDeterministicBoundaryEnforcementCoverage(context) {
-  await validateSnippetCoverage({
-    heading: 'Checking deterministic boundary enforcement coverage...',
-    coverageRules: REQUIRED_DETERMINISTIC_BOUNDARY_ENFORCEMENT_SNIPPETS,
-    missingLabel: 'deterministic boundary source',
-    snippetLabel: 'deterministic boundary snippet',
-    context,
-  });
-}
-
-export async function validateRulesOnlyActiveSurfaceCoverage(context) {
-  const { ROOT_DIR, fileExists, readTextFile, pass, fail } = context;
-
-  console.log('\nChecking rules-only active surface cleanup...');
-
-  for (const forbiddenRule of FORBIDDEN_ACTIVE_BIAS_ANCHOR_SNIPPETS) {
-    const absoluteForbiddenPath = join(ROOT_DIR, forbiddenRule.path);
-
-    if (!(await fileExists(absoluteForbiddenPath))) {
-      fail(`Missing rules-only active surface source: ${forbiddenRule.path}`);
-      continue;
-    }
-
-    const forbiddenContent = await readTextFile(absoluteForbiddenPath);
-    for (const forbiddenSnippet of forbiddenRule.snippets) {
-      if (forbiddenContent.includes(forbiddenSnippet)) {
-        fail(`${forbiddenRule.path} must not include active bias-anchor snippet: ${forbiddenSnippet}`);
-      } else {
-        pass(`${forbiddenRule.path} excludes active bias-anchor snippet: ${forbiddenSnippet}`);
-      }
-    }
-  }
-}
-
-export async function validateHumanWritingGovernance(context) {
-  const { ROOT_DIR, fileExists, readTextFile, pass, fail } = context;
-
-  console.log('\nChecking human writing governance...');
-
-  const disallowedEmojiPattern = /[\u2705\u274C\u26A0\u{1F4CC}\u{1F536}\u{1F4CE}\u{1F534}\u{1F7E0}\u{1F7E1}\u{1F7E2}]/u;
-
-  for (const formalArtifactPath of FORMAL_ARTIFACT_PATHS) {
-    const absoluteFormalArtifactPath = join(ROOT_DIR, formalArtifactPath);
-
-    if (!(await fileExists(absoluteFormalArtifactPath))) {
-      fail(`Missing formal artifact for writing governance: ${formalArtifactPath}`);
-      continue;
-    }
-
-    const formalArtifactContent = await readTextFile(absoluteFormalArtifactPath);
-    if (disallowedEmojiPattern.test(formalArtifactContent)) {
-      fail(`${formalArtifactPath} contains disallowed emoji symbols in formal text`);
-    } else {
-      pass(`${formalArtifactPath} has no disallowed emoji symbols`);
-    }
-  }
-
-  for (const snippetRule of REQUIRED_HUMAN_WRITING_SNIPPETS) {
-    const absoluteRulePath = join(ROOT_DIR, snippetRule.path);
-    if (!(await fileExists(absoluteRulePath))) {
-      fail(`Missing writing governance source: ${snippetRule.path}`);
-      continue;
-    }
-
-    const writingRuleContent = await readTextFile(absoluteRulePath);
-    for (const requiredSnippet of snippetRule.snippets) {
-      if (writingRuleContent.includes(requiredSnippet)) {
-        pass(`${snippetRule.path} includes writing governance snippet: ${requiredSnippet}`);
-      } else {
-        fail(`${snippetRule.path} is missing writing governance snippet: ${requiredSnippet}`);
-      }
-    }
-  }
-}
-
-export async function validateInstructionAdapters(context) {
-  const {
-    ROOT_DIR,
-    CANONICAL_INSTRUCTION_PATH,
-    fileExists,
-    readTextFile,
-    normalizeLineEndings,
-    pass,
-    fail,
-  } = context;
-
-  console.log('\nChecking instruction adapter consolidation...');
-
-  const canonicalInstructionContent = normalizeLineEndings(await readTextFile(CANONICAL_INSTRUCTION_PATH));
-  const requiredBootstrapReceiptSnippets = [
-    'Bootstrap Receipt',
-    'loaded_files',
-    'selected_rules',
-    'skipped_rules',
-    'unreachable_files',
-    'validation_plan',
-  ];
-  const instructionFootprintLimits = [
-    { path: 'AGENTS.md', maxLines: 180 },
-    { path: '.agent-context/prompts/bootstrap-design.md', maxLines: 80 },
-    { path: '.agent-context/rules/frontend-architecture.md', maxLines: 180 },
-  ];
-
-  for (const requiredBootstrapReceiptSnippet of requiredBootstrapReceiptSnippets) {
-    if (canonicalInstructionContent.includes(requiredBootstrapReceiptSnippet)) {
-      pass(`AGENTS.md includes bootstrap receipt snippet: ${requiredBootstrapReceiptSnippet}`);
-    } else {
-      fail(`AGENTS.md is missing bootstrap receipt snippet: ${requiredBootstrapReceiptSnippet}`);
-    }
-  }
-
-
-
-  for (const footprintLimit of instructionFootprintLimits) {
-    const absoluteFootprintPath = join(ROOT_DIR, footprintLimit.path);
-    if (!(await fileExists(absoluteFootprintPath))) {
-      fail(`Missing instruction footprint source: ${footprintLimit.path}`);
-      continue;
-    }
-
-    const footprintContent = await readTextFile(absoluteFootprintPath);
-    const footprintLineCount = footprintContent.split(/\r?\n/u).length;
-    if (footprintLineCount <= footprintLimit.maxLines) {
-      pass(`${footprintLimit.path} stays compact (${footprintLineCount}/${footprintLimit.maxLines} lines)`);
-    } else {
-      fail(`${footprintLimit.path} is too long for the active instruction surface (${footprintLineCount}/${footprintLimit.maxLines} lines)`);
-    }
-  }
-
-  for (const thinAdapterPath of THIN_ADAPTER_PATHS) {
-    const absoluteAdapterPath = join(ROOT_DIR, thinAdapterPath);
-
-    if (!(await fileExists(absoluteAdapterPath))) {
-      fail(`Missing thin adapter file: ${thinAdapterPath}`);
-      continue;
-    }
-
-    const thinAdapterContent = await readTextFile(absoluteAdapterPath);
-
-    if (thinAdapterContent.trim() === '@AGENTS.md') {
-      pass(`${thinAdapterPath} imports AGENTS.md`);
-    } else {
-      fail(`${thinAdapterPath} must be exactly @AGENTS.md`);
-    }
-
-    const thinAdapterLineCount = thinAdapterContent.split(/\r?\n/u).length;
-    if (thinAdapterLineCount <= 2) {
-      pass(`${thinAdapterPath} remains thin (${thinAdapterLineCount} lines)`);
-    } else {
-      fail(`${thinAdapterPath} is too large for thin-adapter mode (${thinAdapterLineCount} lines)`);
-    }
-  }
-}
-
-export async function validateSkillPurgeSurface(context) {
-  const { ROOT_DIR, AGENT_CONTEXT_DIR, fileExists, pass, fail } = context;
-
-  console.log('\nChecking skill and tier purge surface...');
-
-  const skillDirectoryPath = join(AGENT_CONTEXT_DIR, 'skills');
-  if (await fileExists(skillDirectoryPath)) {
-    fail('Skills directory must be removed: .agent-context/skills');
-  } else {
-    pass('Skills directory removed: .agent-context/skills');
-  }
-
-  const retiredFiles = [
-    join(ROOT_DIR, 'lib', 'cli', 'skill-selector.mjs'),
-    join(ROOT_DIR, 'scripts', 'skill-tier-policy.mjs'),
-    join(ROOT_DIR, 'scripts', 'trust-scorer.mjs'),
-  ];
-
-  for (const retiredFilePath of retiredFiles) {
-    const relativeRetiredPath = relative(ROOT_DIR, retiredFilePath).replace(/\\/g, '/');
-    if (await fileExists(retiredFilePath)) {
-      fail(`Retired file still present: ${relativeRetiredPath}`);
-    } else {
-      pass(`Retired file removed: ${relativeRetiredPath}`);
-    }
-  }
-}

package/scripts/validate/file-structure.mjs

@@ -1,158 +0,0 @@
-import { join } from 'node:path';
-import { readdir } from 'node:fs/promises';
-
-export async function validateRequiredFiles(context) {
-  const { ROOT_DIR, fileExists, pass, fail } = context;
-  console.log('\nChecking required files...');
-
-  const requiredFiles = [
-    'bin/agentic-senior-core.js',
-    'scripts/validate.mjs',
-    'scripts/llm-judge.mjs',
-    'scripts/detection-benchmark.mjs',
-    'scripts/benchmark-evidence-bundle.mjs',
-    'scripts/benchmark-writer-judge-matrix.mjs',
-    'scripts/benchmark-gate.mjs',
-    'scripts/benchmark-intelligence.mjs',
-    'scripts/memory-continuity-benchmark.mjs',
-    'scripts/docs-quality-drift-report.mjs',
-    'scripts/governance-weekly-report.mjs',
-    'scripts/mcp-server.mjs',
-    'scripts/mcp-server/constants.mjs',
-    'scripts/mcp-server/tool-registry.mjs',
-    'scripts/mcp-server/tools.mjs',
-    'scripts/frontend-usability-audit.mjs',
-    'scripts/ui-design-judge.mjs',
-    'scripts/documentation-boundary-audit.mjs',
-    'scripts/context-triggered-audit.mjs',
-    'scripts/rules-guardian-audit.mjs',
-    'scripts/explain-on-demand-audit.mjs',
-    'scripts/single-source-lazy-loading-audit.mjs',
-    'scripts/sync-thin-adapters.mjs',
-    'scripts/release-gate.mjs',
-    'scripts/generate-sbom.mjs',
-    '.agent-context/policies/llm-judge-threshold.json',
-    '.agent-context/prompts/compact-natural-mode.md',
-    'mcp.json',
-    'AGENTS.md',
-    'CLAUDE.md',
-    'GEMINI.md',
-    'README.md',
-    'CHANGELOG.md',
-    'docs/doc-index.md',
-    'docs/project-brief.md',
-    'docs/flow-overview.md',
-    'docs/api-contract.md',
-    'docs/faq.md',
-    'docs/deep-dive.md',
-    'docs/archive/HISTORY.md',
-    'docs/archive/CHANGELOG-archive.md',
-    '.agent-context/state/benchmark-reproducibility.json',
-    '.agent-context/state/benchmark-writer-judge-config.json',
-    '.agent-context/state/memory-schema-v1.json',
-    '.agent-context/state/memory-adapter-contract.json',
-    '.vscode/mcp.json',
-    '.github/workflows/release-gate.yml',
-    '.github/workflows/sbom-compliance.yml',
-    '.github/workflows/benchmark-intelligence.yml',
-    '.github/workflows/docs-quality-drift-report.yml',
-    '.github/workflows/governance-weekly-report.yml',
-    'tests/cli-smoke.test.mjs',
-    'tests/mcp-server.test.mjs',
-    'tests/llm-judge.test.mjs',
-    'tests/operations.test.mjs',
-    'LICENSE',
-    '.gitignore',
-  ];
-
-  for (const requiredFilePath of requiredFiles) {
-    const absoluteRequiredFilePath = join(ROOT_DIR, requiredFilePath);
-
-    if (await fileExists(absoluteRequiredFilePath)) {
-      pass(requiredFilePath);
-      continue;
-    }
-
-    fail(`Missing required file: ${requiredFilePath}`);
-  }
-}
-
-export async function validateRuleFiles(context) {
-  const { AGENT_CONTEXT_DIR, fileExists, readTextFile, pass, fail } = context;
-  console.log('\nChecking rule, checklist, prompt, and state files...');
-
-  const expectedPaths = [
-    'rules/architecture.md',
-    'rules/security.md',
-    'rules/performance.md',
-    'rules/error-handling.md',
-    'rules/testing.md',
-    'rules/api-docs.md',
-    'rules/microservices.md',
-    'rules/event-driven.md',
-    'rules/database-design.md',
-    'rules/realtime.md',
-    'rules/frontend-architecture.md',
-    'rules/docker-runtime.md',
-    'rules/observability.md',
-    'rules/resilience.md',
-    'rules/migrations.md',
-    'rules/background-jobs.md',
-    'rules/config-and-flags.md',
-    'rules/api-versioning.md',
-    'review-checklists/pr-checklist.md',
-    'review-checklists/architecture-review.md',
-    'prompts/init-project.md',
-    'prompts/compact-natural-mode.md',
-    'prompts/bootstrap-design.md',
-    'prompts/refactor.md',
-    'prompts/review-code.md',
-    'state/architecture-map.md',
-    'state/dependency-map.md',
-  ];
-
-  for (const expectedPath of expectedPaths) {
-    const absoluteExpectedPath = join(AGENT_CONTEXT_DIR, expectedPath);
-
-    if (!(await fileExists(absoluteExpectedPath))) {
-      fail(`Missing agent context file: .agent-context/${expectedPath}`);
-      continue;
-    }
-
-    const fileContent = await readTextFile(absoluteExpectedPath);
-    if (fileContent.trim().length < 100) {
-      fail(`Agent context file is suspiciously short: .agent-context/${expectedPath}`);
-      continue;
-    }
-
-    pass(`.agent-context/${expectedPath}`);
-  }
-}
-
-export async function validateChecklistConsolidation(context) {
-  const { AGENT_CONTEXT_DIR, pass, fail } = context;
-  console.log('\nChecking review checklist consolidation...');
-
-  const reviewChecklistDirectoryPath = join(AGENT_CONTEXT_DIR, 'review-checklists');
-  const checklistEntries = await readdir(reviewChecklistDirectoryPath, { withFileTypes: true });
-  const checklistFileNames = checklistEntries
-    .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
-    .map((entry) => entry.name)
-    .sort((leftName, rightName) => leftName.localeCompare(rightName));
-
-  const expectedChecklistFileNames = ['architecture-review.md', 'pr-checklist.md'];
-
-  if (checklistFileNames.length <= 2) {
-    pass(`Checklist count is consolidated (${checklistFileNames.length}/2)`);
-  } else {
-    fail(`Checklist count exceeds limit (${checklistFileNames.length}/2): ${checklistFileNames.join(', ')}`);
-  }
-
-  for (const expectedChecklistFileName of expectedChecklistFileNames) {
-    if (checklistFileNames.includes(expectedChecklistFileName)) {
-      pass(`Checklist exists: .agent-context/review-checklists/${expectedChecklistFileName}`);
-    } else {
-      fail(`Missing consolidated checklist: .agent-context/review-checklists/${expectedChecklistFileName}`);
-    }
-  }
-}