@ryuenn3123/agentic-senior-core 4.4.0 → 5.2.0

package/scripts/memory-continuity-benchmark.mjs

@@ -1,322 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * memory-continuity-benchmark.mjs
- *
- * Provider-agnostic continuity benchmark for cross-agent memory retrieval.
- * Measures new-session hydration relevance, token savings, and privacy redaction safety.
- */
-
-import { existsSync, readFileSync } from 'node:fs';
-import fs from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import {
-  MEMORY_SCHEMA_VERSION,
-  SUPPORTED_MEMORY_ADAPTER_IDS,
-  normalizeMemoryObservation,
-  buildSessionStartIndex,
-  hydrateIndexedObservations,
-  estimateTokenUsage,
-} from '../lib/cli/memory-continuity.mjs';
-
-const SCRIPT_FILE_PATH = fileURLToPath(import.meta.url);
-const SCRIPT_DIR = dirname(SCRIPT_FILE_PATH);
-const REPOSITORY_ROOT = resolve(SCRIPT_DIR, '..');
-const ARGUMENT_FLAGS = new Set(process.argv.slice(2));
-const isStdoutOnlyMode = ARGUMENT_FLAGS.has('--stdout-only');
-
-const MEMORY_SCHEMA_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'memory-schema-v1.json');
-const MEMORY_ADAPTER_CONTRACT_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'memory-adapter-contract.json');
-const OUTPUT_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'memory-continuity-benchmark.json');
-
-const THRESHOLDS = {
-  minimumRelevantRecall: 0.8,
-  minimumSessionStartTokenSavingsPercent: 35,
-  maximumUnsafeObservationCount: 0,
-};
-
-const MEMORY_FIXTURES = [
-  {
-    id: 'obs-001',
-    adapterId: 'claude-code',
-    eventType: 'decision',
-    projectId: 'agentic-senior-core',
-    sessionId: 'session-a',
-    timestamp: '2026-04-17T02:30:00.000Z',
-    title: 'Docker development lane agreed',
-    summary: 'Team agreed Docker for development and production lanes with separate optimization priorities.',
-    detail: 'Use compose for local build loop. Production images must stay minimal. api_key=prod-key-placeholder should be stored outside code.',
-    tags: ['docker', 'dev-prod-split', 'runtime'],
-    privacyLevel: 'internal',
-  },
-  {
-    id: 'obs-002',
-    adapterId: 'gemini-cli',
-    eventType: 'context',
-    projectId: 'agentic-senior-core',
-    sessionId: 'session-b',
-    timestamp: '2026-04-17T02:31:00.000Z',
-    title: 'Runtime environment policy',
-    summary: 'Windows and Linux or WSL command context should be explicit in generated guidance.',
-    detail: 'Runtime hint: prefer linux-wsl for container tasks on Windows hosts. <private>internal machine hostname and user alias</private>',
-    tags: ['runtime', 'linux-wsl', 'windows'],
-    privacyLevel: 'restricted',
-  },
-  {
-    id: 'obs-003',
-    adapterId: 'vscode-chat',
-    eventType: 'summary',
-    projectId: 'agentic-senior-core',
-    sessionId: 'session-c',
-    timestamp: '2026-04-17T02:32:00.000Z',
-    title: 'Frontend excellence baseline',
-    summary: 'Frontend rubric must enforce visual direction, typography intent, and responsive behavior checks.',
-    detail: 'Use diversity checks for layout and style systems, and avoid template output repetition.',
-    tags: ['frontend', 'rubric', 'quality'],
-    privacyLevel: 'internal',
-  },
-  {
-    id: 'obs-004',
-    adapterId: 'claude-code',
-    eventType: 'issue',
-    projectId: 'agentic-senior-core',
-    sessionId: 'session-d',
-    timestamp: '2026-04-17T02:33:00.000Z',
-    title: 'Nested template conditional issue',
-    summary: 'Nested conditional blocks caused unresolved placeholders in generated docs.',
-    detail: 'Fix by precomputing placeholder text before rendering template.',
-    tags: ['template', 'rendering', 'fix'],
-    privacyLevel: 'internal',
-  },
-  {
-    id: 'obs-005',
-    adapterId: 'gemini-cli',
-    eventType: 'tool-use',
-    projectId: 'agentic-senior-core',
-    sessionId: 'session-e',
-    timestamp: '2026-04-17T02:34:00.000Z',
-    title: 'Benchmark trend report generated',
-    summary: 'History and trend csv outputs are generated each run for release-over-release review.',
-    detail: 'Artifacts include benchmark-history json and benchmark-trend-report csv for quick chart ingestion.',
-    tags: ['benchmark', 'trend', 'history'],
-    privacyLevel: 'internal',
-  },
-];
-
-const CONTINUITY_SCENARIOS = [
-  {
-    scenarioId: 'docker-lane-hydration',
-    query: 'what is docker strategy for development and production',
-    expectedObservationIds: ['obs-001'],
-  },
-  {
-    scenarioId: 'runtime-hydration',
-    query: 'which runtime target should we prefer on windows with wsl',
-    expectedObservationIds: ['obs-002'],
-  },
-  {
-    scenarioId: 'frontend-quality-hydration',
-    query: 'show frontend rubric quality decisions',
-    expectedObservationIds: ['obs-003'],
-  },
-];
-
-function readJsonOrNull(filePath) {
-  if (!existsSync(filePath)) {
-    return null;
-  }
-
-  try {
-    return JSON.parse(readFileSync(filePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function calculateRecall(expectedObservationIds, selectedIds) {
-  if (!Array.isArray(expectedObservationIds) || expectedObservationIds.length === 0) {
-    return 1;
-  }
-
-  const selectedIdSet = new Set(selectedIds);
-  const matchedCount = expectedObservationIds.filter((expectedId) => selectedIdSet.has(expectedId)).length;
-  return Number((matchedCount / expectedObservationIds.length).toFixed(4));
-}
-
-function summarizePrivacyControls(normalizedObservations) {
-  const redactedObservationCount = normalizedObservations.filter(
-    (normalizedObservation) => normalizedObservation.privacy.redactionApplied
-  ).length;
-
-  const privateTagRedactionCount = normalizedObservations.reduce(
-    (countAccumulator, normalizedObservation) => countAccumulator + normalizedObservation.privacy.privateTagRedactionCount,
-    0
-  );
-
-  const inlineRedactionCount = normalizedObservations.reduce(
-    (countAccumulator, normalizedObservation) => countAccumulator + normalizedObservation.privacy.inlineRedactionCount,
-    0
-  );
-
-  const unsafeObservationCount = normalizedObservations.filter((normalizedObservation) => {
-    const detailText = String(normalizedObservation.detail || '');
-    return /<private>/i.test(detailText);
-  }).length;
-
-  return {
-    redactedObservationCount,
-    privateTagRedactionCount,
-    inlineRedactionCount,
-    unsafeObservationCount,
-  };
-}
-
-function buildAdapterCoverage(adapterContract) {
-  const requiredAdapterIds = Array.isArray(adapterContract?.requiredAdapters)
-    ? adapterContract.requiredAdapters
-    : [...SUPPORTED_MEMORY_ADAPTER_IDS];
-
-  const declaredAdapters = Array.isArray(adapterContract?.adapters)
-    ? adapterContract.adapters.map((adapterEntry) => adapterEntry.adapterId)
-    : [];
-
-  const availableAdapterIds = Array.from(new Set([
-    ...SUPPORTED_MEMORY_ADAPTER_IDS,
-    ...declaredAdapters,
-  ])).sort();
-
-  const missingAdapterIds = requiredAdapterIds.filter(
-    (requiredAdapterId) => !availableAdapterIds.includes(requiredAdapterId)
-  );
-
-  return {
-    requiredAdapterIds,
-    availableAdapterIds,
-    missingAdapterIds,
-    passed: missingAdapterIds.length === 0,
-  };
-}
-
-async function runMemoryContinuityBenchmark() {
-  const memorySchema = readJsonOrNull(MEMORY_SCHEMA_PATH);
-  const memoryAdapterContract = readJsonOrNull(MEMORY_ADAPTER_CONTRACT_PATH);
-
-  const normalizedObservations = MEMORY_FIXTURES.map((memoryFixture) => normalizeMemoryObservation(memoryFixture));
-
-  const fullContextTokenEstimate = normalizedObservations.reduce(
-    (tokenAccumulator, normalizedObservation) => tokenAccumulator
-      + estimateTokenUsage(normalizedObservation.title)
-      + estimateTokenUsage(normalizedObservation.summary)
-      + estimateTokenUsage(normalizedObservation.detail),
-    0
-  );
-
-  const scenarioResults = CONTINUITY_SCENARIOS.map((continuityScenario) => {
-    const sessionStartIndex = buildSessionStartIndex(normalizedObservations, {
-      queryText: continuityScenario.query,
-      limit: 5,
-    });
-
-    const hydration = hydrateIndexedObservations(
-      sessionStartIndex.indexEntries,
-      normalizedObservations,
-      { fullFetchLimit: 1 }
-    );
-
-    const recall = calculateRecall(continuityScenario.expectedObservationIds, hydration.selectedIds);
-    const sessionStartTokenEstimate = sessionStartIndex.totalTokenEstimate + hydration.hydrationTokenEstimate;
-    const tokenSavingsPercent = fullContextTokenEstimate === 0
-      ? 0
-      : Number((((fullContextTokenEstimate - sessionStartTokenEstimate) / fullContextTokenEstimate) * 100).toFixed(2));
-
-    return {
-      scenarioId: continuityScenario.scenarioId,
-      query: continuityScenario.query,
-      expectedObservationIds: continuityScenario.expectedObservationIds,
-      indexObservationIds: sessionStartIndex.indexEntries.map((indexEntry) => indexEntry.id),
-      hydratedObservationIds: hydration.selectedIds,
-      relevantRecall: recall,
-      fullContextTokenEstimate,
-      sessionStartTokenEstimate,
-      sessionStartTokenSavingsPercent: tokenSavingsPercent,
-    };
-  });
-
-  const averageRelevantRecall = Number((
-    scenarioResults.reduce((sum, scenarioResult) => sum + scenarioResult.relevantRecall, 0)
-    / scenarioResults.length
-  ).toFixed(4));
-
-  const averageSessionStartTokenSavingsPercent = Number((
-    scenarioResults.reduce((sum, scenarioResult) => sum + scenarioResult.sessionStartTokenSavingsPercent, 0)
-    / scenarioResults.length
-  ).toFixed(2));
-
-  const privacyControls = summarizePrivacyControls(normalizedObservations);
-  const adapterCoverage = buildAdapterCoverage(memoryAdapterContract);
-
-  const checks = [
-    {
-      checkName: 'adapter-coverage',
-      passed: adapterCoverage.passed,
-      details: `required=${adapterCoverage.requiredAdapterIds.length} missing=${adapterCoverage.missingAdapterIds.length}`,
-    },
-    {
-      checkName: 'continuity-recall-threshold',
-      passed: averageRelevantRecall >= THRESHOLDS.minimumRelevantRecall,
-      details: `averageRelevantRecall=${averageRelevantRecall} minimum=${THRESHOLDS.minimumRelevantRecall}`,
-    },
-    {
-      checkName: 'session-start-token-savings-threshold',
-      passed: averageSessionStartTokenSavingsPercent >= THRESHOLDS.minimumSessionStartTokenSavingsPercent,
-      details: `averageSessionStartTokenSavingsPercent=${averageSessionStartTokenSavingsPercent} minimum=${THRESHOLDS.minimumSessionStartTokenSavingsPercent}`,
-    },
-    {
-      checkName: 'privacy-redaction-safety',
-      passed: privacyControls.unsafeObservationCount <= THRESHOLDS.maximumUnsafeObservationCount,
-      details: `unsafeObservationCount=${privacyControls.unsafeObservationCount} max=${THRESHOLDS.maximumUnsafeObservationCount}`,
-    },
-  ];
-
-  const failureCount = checks.filter((checkResult) => !checkResult.passed).length;
-
-  const reportPayload = {
-    generatedAt: new Date().toISOString(),
-    reportName: 'memory-continuity-benchmark',
-    schemaVersion: MEMORY_SCHEMA_VERSION,
-    passed: failureCount === 0,
-    failureCount,
-    thresholds: THRESHOLDS,
-    adapterCoverage,
-    privacyControls,
-    continuitySummary: {
-      totalObservationCount: normalizedObservations.length,
-      scenarioCount: scenarioResults.length,
-      averageRelevantRecall,
-      averageSessionStartTokenSavingsPercent,
-    },
-    scenarios: scenarioResults,
-    references: {
-      memorySchemaPath: '.agent-context/state/memory-schema-v1.json',
-      memoryAdapterContractPath: '.agent-context/state/memory-adapter-contract.json',
-      benchmarkOutputPath: '.agent-context/state/memory-continuity-benchmark.json',
-      schemaDeclaredVersion: memorySchema?.schemaVersion || null,
-      adapterContractVersion: memoryAdapterContract?.schemaVersion || null,
-    },
-    checks,
-  };
-
-  if (!isStdoutOnlyMode) {
-    await fs.writeFile(OUTPUT_PATH, JSON.stringify(reportPayload, null, 2) + '\n', 'utf8');
-  }
-
-  console.log(JSON.stringify(reportPayload, null, 2));
-  process.exit(reportPayload.passed ? 0 : 1);
-}
-
-runMemoryContinuityBenchmark().catch((benchmarkError) => {
-  const errorMessage = benchmarkError instanceof Error ? benchmarkError.message : String(benchmarkError);
-  console.error(`Memory continuity benchmark failed: ${errorMessage}`);
-  process.exit(1);
-});

package/scripts/quality-trend-report.mjs

@@ -1,289 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * quality-trend-report.mjs
- *
- * Generates a machine-readable quality trend artifact that summarizes
- * governance gate pass rates, rejection categories, rollback frequency,
- * and token-efficiency signals.
- */
-
-import { existsSync, readFileSync } from 'node:fs';
-import fs from 'node:fs/promises';
-import { spawnSync } from 'node:child_process';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const SCRIPT_FILE_PATH = fileURLToPath(import.meta.url);
-const SCRIPT_DIR = dirname(SCRIPT_FILE_PATH);
-const REPOSITORY_ROOT = resolve(SCRIPT_DIR, '..');
-const REPORT_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'quality-trend-report.json');
-const TOKEN_BENCHMARK_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'token-optimization-benchmark.json');
-const ARGUMENT_FLAGS = new Set(process.argv.slice(2));
-const isStdoutOnlyMode = ARGUMENT_FLAGS.has('--stdout-only');
-const MAX_SNAPSHOT_HISTORY = 30;
-const ROLLBACK_WINDOW_DAYS = 30;
-
-function runJsonScript(scriptRelativePath) {
-  const absoluteScriptPath = join(REPOSITORY_ROOT, scriptRelativePath);
-  const commandResult = spawnSync('node', [absoluteScriptPath], {
-    cwd: REPOSITORY_ROOT,
-    encoding: 'utf8',
-    maxBuffer: 1024 * 1024 * 10,
-  });
-
-  const standardOutput = (commandResult.stdout || '').trim();
-  const standardError = (commandResult.stderr || '').trim();
-  const exitCode = typeof commandResult.status === 'number' ? commandResult.status : 1;
-
-  if (!standardOutput) {
-    return {
-      scriptPath: scriptRelativePath,
-      exitCode,
-      parsedReport: null,
-      parseError: 'Script produced no stdout JSON payload',
-      stderr: standardError,
-    };
-  }
-
-  try {
-    const parsedReport = JSON.parse(standardOutput);
-    return {
-      scriptPath: scriptRelativePath,
-      exitCode,
-      parsedReport,
-      parseError: null,
-      stderr: standardError,
-    };
-  } catch (jsonParseError) {
-    const errorMessage = jsonParseError instanceof Error ? jsonParseError.message : String(jsonParseError);
-    return {
-      scriptPath: scriptRelativePath,
-      exitCode,
-      parsedReport: null,
-      parseError: errorMessage,
-      stderr: standardError,
-    };
-  }
-}
-
-function readJsonFileOrNull(filePath) {
-  if (!existsSync(filePath)) {
-    return null;
-  }
-
-  try {
-    return JSON.parse(readFileSync(filePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function summarizeGateExecution(gateExecutionResults) {
-  const gateSummaries = gateExecutionResults.map((gateExecutionResult) => {
-    const gateReport = gateExecutionResult.parsedReport;
-    return {
-      scriptPath: gateExecutionResult.scriptPath,
-      gateName: gateReport?.gateName || gateReport?.reportName || gateExecutionResult.scriptPath,
-      exitCode: gateExecutionResult.exitCode,
-      passed: typeof gateReport?.passed === 'boolean' ? gateReport.passed : false,
-      parseError: gateExecutionResult.parseError,
-      failureCount: typeof gateReport?.failureCount === 'number' ? gateReport.failureCount : null,
-      generatedAt: gateReport?.generatedAt || null,
-    };
-  });
-
-  const availableGateCount = gateSummaries.length;
-  const passedGateCount = gateSummaries.filter((gateSummary) => gateSummary.passed).length;
-  const gatePassRatePercent = availableGateCount === 0
-    ? 0
-    : Number(((passedGateCount / availableGateCount) * 100).toFixed(2));
-
-  return {
-    gateSummaries,
-    availableGateCount,
-    passedGateCount,
-    gatePassRatePercent,
-  };
-}
-
-function collectRejectionCategories(gateExecutionResults) {
-  const rejectionCategoryMap = new Map();
-
-  for (const gateExecutionResult of gateExecutionResults) {
-    const gateReport = gateExecutionResult.parsedReport;
-    const gateName = gateReport?.gateName || gateReport?.reportName || gateExecutionResult.scriptPath;
-    const gateResults = Array.isArray(gateReport?.results) ? gateReport.results : [];
-
-    for (const checkResult of gateResults) {
-      if (checkResult?.passed === true) {
-        continue;
-      }
-
-      const checkName = typeof checkResult?.checkName === 'string' ? checkResult.checkName : 'unknown-check';
-      const existingCategory = rejectionCategoryMap.get(checkName) || {
-        checkName,
-        count: 0,
-        gates: new Set(),
-      };
-
-      existingCategory.count += 1;
-      existingCategory.gates.add(gateName);
-      rejectionCategoryMap.set(checkName, existingCategory);
-    }
-  }
-
-  return Array.from(rejectionCategoryMap.values())
-    .map((rejectionCategory) => ({
-      checkName: rejectionCategory.checkName,
-      count: rejectionCategory.count,
-      gates: Array.from(rejectionCategory.gates),
-    }))
-    .sort((firstCategory, secondCategory) => secondCategory.count - firstCategory.count);
-}
-
-function calculateRollbackFrequencySnapshot() {
-  const gitLogResult = spawnSync('git', ['log', `--since=${ROLLBACK_WINDOW_DAYS}.days`, '--pretty=format:%s'], {
-    cwd: REPOSITORY_ROOT,
-    encoding: 'utf8',
-    maxBuffer: 1024 * 1024,
-  });
-
-  if (gitLogResult.status !== 0) {
-    return {
-      windowDays: ROLLBACK_WINDOW_DAYS,
-      commitCount: 0,
-      rollbackCommitCount: 0,
-      rollbackFrequencyPercent: null,
-      source: 'git-log',
-      error: (gitLogResult.stderr || 'Failed to read git log').trim(),
-    };
-  }
-
-  const commitSubjects = (gitLogResult.stdout || '')
-    .split(/\r?\n/u)
-    .map((subjectLine) => subjectLine.trim())
-    .filter((subjectLine) => subjectLine.length > 0);
-
-  const rollbackCommitCount = commitSubjects.filter((subjectLine) => /rollback/i.test(subjectLine)).length;
-  const commitCount = commitSubjects.length;
-  const rollbackFrequencyPercent = commitCount === 0
-    ? 0
-    : Number(((rollbackCommitCount / commitCount) * 100).toFixed(2));
-
-  return {
-    windowDays: ROLLBACK_WINDOW_DAYS,
-    commitCount,
-    rollbackCommitCount,
-    rollbackFrequencyPercent,
-    source: 'git-log',
-    error: null,
-  };
-}
-
-function summarizeTokenBenchmark() {
-  const tokenBenchmarkReport = readJsonFileOrNull(TOKEN_BENCHMARK_PATH);
-  if (!tokenBenchmarkReport) {
-    return {
-      isAvailable: false,
-      generatedAt: null,
-      averageNativeSavingsPercent: null,
-      averageRtkSavingsPercent: null,
-      scenarioCount: 0,
-    };
-  }
-
-  return {
-    isAvailable: true,
-    generatedAt: tokenBenchmarkReport.generatedAt || null,
-    averageNativeSavingsPercent: tokenBenchmarkReport.summary?.averageNativeSavingsPercent ?? null,
-    averageRtkSavingsPercent: tokenBenchmarkReport.summary?.averageRtkSavingsPercent ?? null,
-    scenarioCount: Array.isArray(tokenBenchmarkReport.scenarios) ? tokenBenchmarkReport.scenarios.length : 0,
-  };
-}
-
-function loadPreviousTrendHistory() {
-  const previousReport = readJsonFileOrNull(REPORT_PATH);
-  if (!previousReport || !Array.isArray(previousReport.history)) {
-    return [];
-  }
-
-  return previousReport.history;
-}
-
-function buildHistoryEntry(currentSnapshot) {
-  return {
-    generatedAt: currentSnapshot.generatedAt,
-    gatePassRatePercent: currentSnapshot.governanceHealth.gatePassRatePercent,
-    passedGateCount: currentSnapshot.governanceHealth.passedGateCount,
-    availableGateCount: currentSnapshot.governanceHealth.availableGateCount,
-    rollbackFrequencyPercent: currentSnapshot.rollbackSignals.rollbackFrequencyPercent,
-    averageNativeSavingsPercent: currentSnapshot.tokenEfficiency.averageNativeSavingsPercent,
-    averageRtkSavingsPercent: currentSnapshot.tokenEfficiency.averageRtkSavingsPercent,
-    rejectionCategoryCount: currentSnapshot.rejectionCategories.length,
-  };
-}
-
-function mergeHistory(previousHistoryEntries, currentHistoryEntry) {
-  const mergedHistoryEntries = [...previousHistoryEntries, currentHistoryEntry];
-  if (mergedHistoryEntries.length <= MAX_SNAPSHOT_HISTORY) {
-    return mergedHistoryEntries;
-  }
-
-  return mergedHistoryEntries.slice(mergedHistoryEntries.length - MAX_SNAPSHOT_HISTORY);
-}
-
-async function runQualityTrendReport() {
-  const releaseGateExecution = runJsonScript('scripts/release-gate.mjs');
-  const benchmarkGateExecution = runJsonScript('scripts/benchmark-gate.mjs');
-  const benchmarkIntelligenceExecution = runJsonScript('scripts/benchmark-intelligence.mjs');
-  const gateExecutionResults = [releaseGateExecution, benchmarkGateExecution, benchmarkIntelligenceExecution];
-
-  const governanceHealth = summarizeGateExecution(gateExecutionResults);
-  const rejectionCategories = collectRejectionCategories(gateExecutionResults);
-  const rollbackSignals = calculateRollbackFrequencySnapshot();
-  const tokenEfficiency = summarizeTokenBenchmark();
-
-  const qualityTrendSnapshot = {
-    generatedAt: new Date().toISOString(),
-    reportName: 'quality-trend-report',
-    methodology: {
-      gateSources: gateExecutionResults.map((gateExecutionResult) => gateExecutionResult.scriptPath),
-      rollbackSource: 'git log commit subjects within 30-day window',
-      tokenSource: '.agent-context/state/token-optimization-benchmark.json',
-    },
-    governanceHealth,
-    rejectionCategories,
-    rollbackSignals,
-    tokenEfficiency,
-    artifact: {
-      path: REPORT_PATH,
-      writeMode: isStdoutOnlyMode ? 'stdout-only' : 'stdout-and-file',
-    },
-  };
-
-  const previousHistoryEntries = loadPreviousTrendHistory();
-  const currentHistoryEntry = buildHistoryEntry(qualityTrendSnapshot);
-  const history = mergeHistory(previousHistoryEntries, currentHistoryEntry);
-  const qualityTrendReport = {
-    ...qualityTrendSnapshot,
-    history,
-  };
-
-  if (!isStdoutOnlyMode) {
-    await fs.mkdir(dirname(REPORT_PATH), { recursive: true });
-    await fs.writeFile(REPORT_PATH, JSON.stringify(qualityTrendReport, null, 2) + '\n', 'utf8');
-  }
-
-  return qualityTrendReport;
-}
-
-runQualityTrendReport()
-  .then((qualityTrendReport) => {
-    console.log(JSON.stringify(qualityTrendReport, null, 2));
-  })
-  .catch((qualityTrendError) => {
-    const errorMessage = qualityTrendError instanceof Error ? qualityTrendError.message : String(qualityTrendError);
-    console.error(`Quality trend report failed: ${errorMessage}`);
-    process.exit(1);
-  });