@ryuenn3123/agentic-senior-core 2.0.26 → 2.0.27

package/scripts/benchmark-evidence-bundle.mjs

@@ -3,15 +3,14 @@
 /**
  * benchmark-evidence-bundle.mjs
  *
- * V2.5.1 reproducibility baseline artifact.
- * Aggregates benchmark inputs, rubric, command examples, and outputs
- * into a single machine-readable evidence bundle.
+ * Benchmark evidence bundle with reproducibility, trend history,
+ * security signals, and reliability early warnings.
  */
 
 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 { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const SCRIPT_FILE_PATH = fileURLToPath(import.meta.url);
@@ -20,10 +19,23 @@ const REPOSITORY_ROOT = resolve(SCRIPT_DIR, '..');
 const ARGUMENT_FLAGS = new Set(process.argv.slice(2));
 const isStdoutOnlyMode = ARGUMENT_FLAGS.has('--stdout-only');
 
+const PACKAGE_JSON_PATH = join(REPOSITORY_ROOT, 'package.json');
 const REPRO_PROFILE_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'benchmark-reproducibility.json');
 const BENCHMARK_THRESHOLD_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'benchmark-thresholds.json');
 const BENCHMARK_WATCHLIST_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'benchmark-watchlist.json');
+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', 'benchmark-evidence-bundle.json');
+const HISTORY_OUTPUT_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'benchmark-history.json');
+const TREND_JSON_OUTPUT_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'benchmark-trend-report.json');
+const TREND_CSV_OUTPUT_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'benchmark-trend-report.csv');
+
+const MAX_HISTORY_ENTRIES = 90;
+const RELIABILITY_THRESHOLDS = {
+  minimumConfidenceGap: 0.1,
+  maximumLowConfidenceRate: 0.2,
+  maximumIncorrectDetectionRate: 0.1,
+};
 
 function readJsonOrNull(filePath) {
   if (!existsSync(filePath)) {
@@ -37,6 +49,47 @@ function readJsonOrNull(filePath) {
   }
 }
 
+function toRelativePath(filePath) {
+  return relative(REPOSITORY_ROOT, filePath).replace(/\\/g, '/');
+}
+
+function toFiniteNumber(rawValue, fallbackValue = null) {
+  const parsedValue = Number(rawValue);
+  if (!Number.isFinite(parsedValue)) {
+    return fallbackValue;
+  }
+
+  return parsedValue;
+}
+
+function parseJsonPayload(rawPayload) {
+  const payloadText = String(rawPayload || '').trim();
+  if (!payloadText) {
+    return { parsed: null, error: 'Payload is empty' };
+  }
+
+  try {
+    return { parsed: JSON.parse(payloadText), error: null };
+  } catch {
+    const firstCurlyBracketIndex = payloadText.indexOf('{');
+    const lastCurlyBracketIndex = payloadText.lastIndexOf('}');
+
+    if (firstCurlyBracketIndex !== -1 && lastCurlyBracketIndex > firstCurlyBracketIndex) {
+      const candidatePayload = payloadText.slice(firstCurlyBracketIndex, lastCurlyBracketIndex + 1);
+      try {
+        return { parsed: JSON.parse(candidatePayload), error: null };
+      } catch (secondError) {
+        return {
+          parsed: null,
+          error: secondError instanceof Error ? secondError.message : String(secondError),
+        };
+      }
+    }
+
+    return { parsed: null, error: 'No JSON object found in payload' };
+  }
+}
+
 function runJsonScript(scriptRelativePath) {
   const absoluteScriptPath = join(REPOSITORY_ROOT, scriptRelativePath);
   const executionResult = spawnSync('node', [absoluteScriptPath], {
@@ -79,6 +132,74 @@ function runJsonScript(scriptRelativePath) {
   }
 }
 
+function runNodeScript(scriptRelativePath, argumentsList = []) {
+  const absoluteScriptPath = join(REPOSITORY_ROOT, scriptRelativePath);
+  const executionResult = spawnSync('node', [absoluteScriptPath, ...argumentsList], {
+    cwd: REPOSITORY_ROOT,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024 * 10,
+  });
+
+  return {
+    scriptPath: scriptRelativePath,
+    exitCode: typeof executionResult.status === 'number' ? executionResult.status : 1,
+    stdout: (executionResult.stdout || '').trim(),
+    stderr: (executionResult.stderr || '').trim(),
+  };
+}
+
+function runNpmAuditIndicator() {
+  const executionResult = spawnSync('npm', ['audit', '--json', '--omit=dev'], {
+    cwd: REPOSITORY_ROOT,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024 * 10,
+  });
+
+  const combinedOutput = [executionResult.stdout, executionResult.stderr].filter(Boolean).join('\n').trim();
+  const { parsed: parsedAuditReport, error: parseError } = parseJsonPayload(combinedOutput);
+  const exitCode = typeof executionResult.status === 'number' ? executionResult.status : 1;
+
+  if (!parsedAuditReport || parseError) {
+    return {
+      isAvailable: false,
+      exitCode,
+      severityCounts: null,
+      hasKnownVulnerabilities: null,
+      error: parseError || 'Unable to parse npm audit output',
+    };
+  }
+
+  const vulnerabilityMetadata = parsedAuditReport.metadata?.vulnerabilities || null;
+  const severityCounts = vulnerabilityMetadata
+    ? {
+        info: toFiniteNumber(vulnerabilityMetadata.info, 0),
+        low: toFiniteNumber(vulnerabilityMetadata.low, 0),
+        moderate: toFiniteNumber(vulnerabilityMetadata.moderate, 0),
+        high: toFiniteNumber(vulnerabilityMetadata.high, 0),
+        critical: toFiniteNumber(vulnerabilityMetadata.critical, 0),
+        total: toFiniteNumber(vulnerabilityMetadata.total, 0),
+      }
+    : null;
+
+  if (!severityCounts) {
+    return {
+      isAvailable: false,
+      exitCode,
+      severityCounts: null,
+      hasKnownVulnerabilities: null,
+      error: parsedAuditReport.error?.summary || 'npm audit report does not include vulnerability metadata',
+    };
+  }
+
+  return {
+    isAvailable: true,
+    exitCode,
+    severityCounts,
+    hasKnownVulnerabilities: severityCounts.total > 0,
+    error: null,
+  };
+}
+
 function summarizeExecution(scriptExecutionResult) {
   return {
     scriptPath: scriptExecutionResult.scriptPath,
@@ -92,7 +213,18 @@ function summarizeExecution(scriptExecutionResult) {
   };
 }
 
-function buildRubricSummary(thresholdConfiguration, intelligenceReport) {
+function appendUniqueTextValues(baseValues, additionalValues) {
+  const mergedValues = [...baseValues];
+  for (const additionalValue of additionalValues) {
+    if (!mergedValues.includes(additionalValue)) {
+      mergedValues.push(additionalValue);
+    }
+  }
+
+  return mergedValues;
+}
+
+function buildRubricSummary(thresholdConfiguration, intelligenceReport, memoryContinuityReport) {
   return {
     benchmarkThresholds: {
       minimumTop1Accuracy: thresholdConfiguration?.minimumTop1Accuracy ?? null,
@@ -101,25 +233,296 @@ function buildRubricSummary(thresholdConfiguration, intelligenceReport) {
       maximumManualCorrectionIncrease: thresholdConfiguration?.maximumManualCorrectionIncrease ?? null,
     },
     intelligenceSlaDays: intelligenceReport?.reviewSlaDays ?? null,
+    reliabilityThresholds: RELIABILITY_THRESHOLDS,
+    continuityThresholds: memoryContinuityReport?.thresholds || null,
+  };
+}
+
+function buildReliabilitySignals(detectionBenchmarkReport) {
+  const fixtureResults = Array.isArray(detectionBenchmarkReport?.fixtures) ? detectionBenchmarkReport.fixtures : [];
+  const fixtureCount = fixtureResults.length;
+
+  const incorrectFixtures = fixtureResults.filter((fixtureResult) => fixtureResult?.isCorrect === false);
+  const lowConfidenceFixtures = fixtureResults.filter((fixtureResult) => {
+    const confidenceGap = toFiniteNumber(fixtureResult?.confidenceGap, 0);
+    return confidenceGap < RELIABILITY_THRESHOLDS.minimumConfidenceGap;
+  });
+  const manualCorrectionFixtures = fixtureResults.filter((fixtureResult) => fixtureResult?.needsManualCorrection === true);
+
+  const incorrectDetectionRate = fixtureCount === 0
+    ? 0
+    : Number((incorrectFixtures.length / fixtureCount).toFixed(4));
+  const lowConfidenceRate = fixtureCount === 0
+    ? 0
+    : Number((lowConfidenceFixtures.length / fixtureCount).toFixed(4));
+  const manualCorrectionRate = fixtureCount === 0
+    ? 0
+    : Number((manualCorrectionFixtures.length / fixtureCount).toFixed(4));
+
+  const reliabilityChecks = [
+    {
+      checkName: 'incorrect-detection-rate',
+      passed: incorrectDetectionRate <= RELIABILITY_THRESHOLDS.maximumIncorrectDetectionRate,
+      details: `incorrectRate=${incorrectDetectionRate} max=${RELIABILITY_THRESHOLDS.maximumIncorrectDetectionRate}`,
+    },
+    {
+      checkName: 'low-confidence-rate',
+      passed: lowConfidenceRate <= RELIABILITY_THRESHOLDS.maximumLowConfidenceRate,
+      details: `lowConfidenceRate=${lowConfidenceRate} max=${RELIABILITY_THRESHOLDS.maximumLowConfidenceRate}`,
+    },
+    {
+      checkName: 'manual-correction-early-warning',
+      passed: manualCorrectionRate <= 0.12,
+      details: `manualCorrectionRate=${manualCorrectionRate} warningThreshold=0.12`,
+    },
+  ];
+
+  const failureCount = reliabilityChecks.filter((reliabilityCheck) => !reliabilityCheck.passed).length;
+  const riskLevel = failureCount === 0
+    ? (incorrectFixtures.length > 0 || lowConfidenceFixtures.length > 0 ? 'monitor' : 'stable')
+    : (failureCount >= 2 ? 'high' : 'elevated');
+
+  return {
+    passed: failureCount === 0,
+    failureCount,
+    riskLevel,
+    thresholds: RELIABILITY_THRESHOLDS,
+    metrics: {
+      fixtureCount,
+      incorrectFixtureCount: incorrectFixtures.length,
+      lowConfidenceFixtureCount: lowConfidenceFixtures.length,
+      manualCorrectionFixtureCount: manualCorrectionFixtures.length,
+      incorrectDetectionRate,
+      lowConfidenceRate,
+      manualCorrectionRate,
+    },
+    checks: reliabilityChecks,
+    flaggedFixtures: fixtureResults
+      .filter((fixtureResult) => fixtureResult?.isCorrect === false || fixtureResult?.needsManualCorrection === true)
+      .map((fixtureResult) => ({
+        fixtureName: fixtureResult.fixtureName,
+        confidenceGap: fixtureResult.confidenceGap,
+        detectedStack: fixtureResult.detectedStack,
+        expectedStack: fixtureResult.expectedStack,
+        isCorrect: fixtureResult.isCorrect,
+        needsManualCorrection: fixtureResult.needsManualCorrection,
+      })),
+  };
+}
+
+function buildBugIndicators(reliabilitySignals) {
+  return {
+    incorrectFixtureCount: reliabilitySignals.metrics.incorrectFixtureCount,
+    incorrectDetectionRate: reliabilitySignals.metrics.incorrectDetectionRate,
+    manualCorrectionFixtureCount: reliabilitySignals.metrics.manualCorrectionFixtureCount,
+    manualCorrectionRate: reliabilitySignals.metrics.manualCorrectionRate,
+    lowConfidenceFixtureCount: reliabilitySignals.metrics.lowConfidenceFixtureCount,
+    lowConfidenceRate: reliabilitySignals.metrics.lowConfidenceRate,
+    flaggedFixtures: reliabilitySignals.flaggedFixtures,
+  };
+}
+
+function buildSecurityIndicators(forbiddenContentExecution, npmAuditIndicator) {
+  const forbiddenContentPassed = forbiddenContentExecution.exitCode === 0;
+
+  return {
+    forbiddenContent: {
+      checkName: 'forbidden-content-scan',
+      passed: forbiddenContentPassed,
+      exitCode: forbiddenContentExecution.exitCode,
+      details: forbiddenContentPassed
+        ? 'No forbidden content detected'
+        : 'Forbidden content scan found one or more violations',
+    },
+    vulnerabilityScan: {
+      checkName: 'npm-audit-indicator',
+      isAvailable: npmAuditIndicator.isAvailable,
+      hasKnownVulnerabilities: npmAuditIndicator.hasKnownVulnerabilities,
+      severityCounts: npmAuditIndicator.severityCounts,
+      exitCode: npmAuditIndicator.exitCode,
+      error: npmAuditIndicator.error,
+    },
+  };
+}
+
+function readReleaseVersion() {
+  const packageJson = readJsonOrNull(PACKAGE_JSON_PATH);
+  return typeof packageJson?.version === 'string' && packageJson.version.trim().length > 0
+    ? packageJson.version.trim()
+    : 'unknown';
+}
+
+function loadBenchmarkHistory() {
+  const historyPayload = readJsonOrNull(HISTORY_OUTPUT_PATH);
+
+  if (Array.isArray(historyPayload?.history)) {
+    return historyPayload.history;
+  }
+
+  if (Array.isArray(historyPayload)) {
+    return historyPayload;
+  }
+
+  return [];
+}
+
+function mergeBenchmarkHistory(previousHistoryEntries, currentSnapshot) {
+  const mergedHistoryEntries = [...previousHistoryEntries, currentSnapshot];
+  if (mergedHistoryEntries.length <= MAX_HISTORY_ENTRIES) {
+    return mergedHistoryEntries;
+  }
+
+  return mergedHistoryEntries.slice(mergedHistoryEntries.length - MAX_HISTORY_ENTRIES);
+}
+
+function buildHistorySnapshot({
+  generatedAt,
+  releaseVersion,
+  detectionBenchmarkReport,
+  benchmarkGateReport,
+  benchmarkIntelligenceReport,
+  reliabilitySignals,
+  securityIndicators,
+}) {
+  const staleWatchlistCount = Array.isArray(benchmarkIntelligenceReport?.watchlist)
+    ? benchmarkIntelligenceReport.watchlist.filter((watchlistEntry) => watchlistEntry?.stale === true).length
+    : null;
+
+  return {
+    generatedAt,
+    releaseVersion,
+    fixtureCount: toFiniteNumber(detectionBenchmarkReport?.fixtureCount, 0),
+    top1Accuracy: toFiniteNumber(detectionBenchmarkReport?.top1Accuracy, 0),
+    manualCorrectionRate: toFiniteNumber(detectionBenchmarkReport?.manualCorrectionRate, 0),
+    benchmarkGatePassed: benchmarkGateReport?.passed === true,
+    intelligencePassed: benchmarkIntelligenceReport?.passed === true,
+    staleWatchlistCount,
+    reliabilityPassed: reliabilitySignals.passed,
+    reliabilityRiskLevel: reliabilitySignals.riskLevel,
+    incorrectDetectionRate: reliabilitySignals.metrics.incorrectDetectionRate,
+    lowConfidenceRate: reliabilitySignals.metrics.lowConfidenceRate,
+    vulnerabilityTotal: securityIndicators.vulnerabilityScan.severityCounts?.total ?? null,
+    criticalVulnerabilityCount: securityIndicators.vulnerabilityScan.severityCounts?.critical ?? null,
+    forbiddenContentPassed: securityIndicators.forbiddenContent.passed,
   };
 }
 
+function buildReleaseDelta(historyEntries, currentSnapshot) {
+  const previousSnapshots = historyEntries.slice(0, -1);
+  if (previousSnapshots.length === 0) {
+    return null;
+  }
+
+  const previousReleaseSnapshot = [...previousSnapshots].reverse().find(
+    (historyEntry) => historyEntry.releaseVersion !== currentSnapshot.releaseVersion
+  ) || previousSnapshots[previousSnapshots.length - 1];
+
+  const top1AccuracyDelta = Number((currentSnapshot.top1Accuracy - previousReleaseSnapshot.top1Accuracy).toFixed(4));
+  const manualCorrectionDelta = Number((currentSnapshot.manualCorrectionRate - previousReleaseSnapshot.manualCorrectionRate).toFixed(4));
+  const staleWatchlistDelta =
+    (toFiniteNumber(currentSnapshot.staleWatchlistCount, 0) - toFiniteNumber(previousReleaseSnapshot.staleWatchlistCount, 0));
+  const vulnerabilityDelta =
+    (toFiniteNumber(currentSnapshot.vulnerabilityTotal, 0) - toFiniteNumber(previousReleaseSnapshot.vulnerabilityTotal, 0));
+
+  return {
+    currentReleaseVersion: currentSnapshot.releaseVersion,
+    previousReleaseVersion: previousReleaseSnapshot.releaseVersion,
+    comparedSnapshot: {
+      currentGeneratedAt: currentSnapshot.generatedAt,
+      previousGeneratedAt: previousReleaseSnapshot.generatedAt,
+    },
+    top1AccuracyDelta,
+    manualCorrectionRateDelta: manualCorrectionDelta,
+    staleWatchlistCountDelta: staleWatchlistDelta,
+    vulnerabilityTotalDelta: vulnerabilityDelta,
+    summary: [
+      `top1Accuracy: ${top1AccuracyDelta >= 0 ? '+' : ''}${top1AccuracyDelta}`,
+      `manualCorrectionRate: ${manualCorrectionDelta >= 0 ? '+' : ''}${manualCorrectionDelta}`,
+      `staleWatchlistCount: ${staleWatchlistDelta >= 0 ? '+' : ''}${staleWatchlistDelta}`,
+      `vulnerabilityTotal: ${vulnerabilityDelta >= 0 ? '+' : ''}${vulnerabilityDelta}`,
+    ],
+  };
+}
+
+function buildTrendTable(historyEntries) {
+  return historyEntries.map((historyEntry, index) => ({
+    snapshotIndex: index + 1,
+    generatedAt: historyEntry.generatedAt,
+    releaseVersion: historyEntry.releaseVersion,
+    top1Accuracy: historyEntry.top1Accuracy,
+    manualCorrectionRate: historyEntry.manualCorrectionRate,
+    incorrectDetectionRate: historyEntry.incorrectDetectionRate,
+    lowConfidenceRate: historyEntry.lowConfidenceRate,
+    staleWatchlistCount: historyEntry.staleWatchlistCount,
+    vulnerabilityTotal: historyEntry.vulnerabilityTotal,
+    criticalVulnerabilityCount: historyEntry.criticalVulnerabilityCount,
+    benchmarkGatePassed: historyEntry.benchmarkGatePassed,
+    intelligencePassed: historyEntry.intelligencePassed,
+    reliabilityPassed: historyEntry.reliabilityPassed,
+    reliabilityRiskLevel: historyEntry.reliabilityRiskLevel,
+  }));
+}
+
+function buildChartSeries(historyEntries) {
+  return {
+    generatedAt: historyEntries.map((historyEntry) => historyEntry.generatedAt),
+    top1Accuracy: historyEntries.map((historyEntry) => historyEntry.top1Accuracy),
+    manualCorrectionRate: historyEntries.map((historyEntry) => historyEntry.manualCorrectionRate),
+    incorrectDetectionRate: historyEntries.map((historyEntry) => historyEntry.incorrectDetectionRate),
+    lowConfidenceRate: historyEntries.map((historyEntry) => historyEntry.lowConfidenceRate),
+    staleWatchlistCount: historyEntries.map((historyEntry) => historyEntry.staleWatchlistCount),
+    vulnerabilityTotal: historyEntries.map((historyEntry) => historyEntry.vulnerabilityTotal),
+  };
+}
+
+function convertTrendTableToCsv(trendTable) {
+  if (trendTable.length === 0) {
+    return '';
+  }
+
+  const headers = Object.keys(trendTable[0]);
+  const csvRows = [headers.join(',')];
+
+  for (const trendRow of trendTable) {
+    const rowValues = headers.map((header) => {
+      const rawValue = trendRow[header];
+      if (rawValue === null || rawValue === undefined) {
+        return '';
+      }
+
+      const normalizedValue = String(rawValue).replace(/"/g, '""');
+      return `"${normalizedValue}"`;
+    });
+
+    csvRows.push(rowValues.join(','));
+  }
+
+  return `${csvRows.join('\n')}\n`;
+}
+
 async function runBenchmarkEvidenceBundle() {
   const reproducibilityProfile = readJsonOrNull(REPRO_PROFILE_PATH);
   const thresholdConfiguration = readJsonOrNull(BENCHMARK_THRESHOLD_PATH);
   const watchlistConfiguration = readJsonOrNull(BENCHMARK_WATCHLIST_PATH);
+  const memorySchemaConfiguration = readJsonOrNull(MEMORY_SCHEMA_PATH);
+  const memoryAdapterContractConfiguration = readJsonOrNull(MEMORY_ADAPTER_CONTRACT_PATH);
+  const releaseVersion = readReleaseVersion();
 
   const detectionBenchmarkExecution = runJsonScript('scripts/detection-benchmark.mjs');
   const benchmarkGateExecution = runJsonScript('scripts/benchmark-gate.mjs');
   const benchmarkIntelligenceExecution = runJsonScript('scripts/benchmark-intelligence.mjs');
+  const memoryContinuityExecution = runJsonScript('scripts/memory-continuity-benchmark.mjs');
+  const forbiddenContentExecution = runNodeScript('scripts/forbidden-content-check.mjs');
+  const npmAuditIndicator = runNpmAuditIndicator();
 
   const executionSummaries = [
     summarizeExecution(detectionBenchmarkExecution),
     summarizeExecution(benchmarkGateExecution),
     summarizeExecution(benchmarkIntelligenceExecution),
+    summarizeExecution(memoryContinuityExecution),
   ];
 
-  const failureCount = executionSummaries.filter((executionSummary) => {
+  const executionFailureCount = executionSummaries.filter((executionSummary) => {
     if (executionSummary.parseError) {
       return true;
     }
@@ -131,41 +534,115 @@ async function runBenchmarkEvidenceBundle() {
     return executionSummary.exitCode !== 0;
   }).length;
 
+  const reliabilitySignals = buildReliabilitySignals(detectionBenchmarkExecution.parsedReport);
+  const reliabilityFailureCount = reliabilitySignals.failureCount > 0 ? 1 : 0;
+  const failureCount = executionFailureCount + reliabilityFailureCount;
+  const securityIndicators = buildSecurityIndicators(forbiddenContentExecution, npmAuditIndicator);
+  const bugIndicators = buildBugIndicators(reliabilitySignals);
+
+  const generatedAt = new Date().toISOString();
+  const currentSnapshot = buildHistorySnapshot({
+    generatedAt,
+    releaseVersion,
+    detectionBenchmarkReport: detectionBenchmarkExecution.parsedReport,
+    benchmarkGateReport: benchmarkGateExecution.parsedReport,
+    benchmarkIntelligenceReport: benchmarkIntelligenceExecution.parsedReport,
+    reliabilitySignals,
+    securityIndicators,
+  });
+  const previousHistoryEntries = loadBenchmarkHistory();
+  const historyEntries = mergeBenchmarkHistory(previousHistoryEntries, currentSnapshot);
+  const releaseDelta = buildReleaseDelta(historyEntries, currentSnapshot);
+  const trendTable = buildTrendTable(historyEntries);
+  const chartSeries = buildChartSeries(historyEntries);
+
+  const trendReport = {
+    generatedAt,
+    reportName: 'benchmark-trend-report',
+    releaseVersion,
+    historyCount: historyEntries.length,
+    releaseDelta,
+    trendTable,
+    chartSeries,
+    artifacts: {
+      historyPath: toRelativePath(HISTORY_OUTPUT_PATH),
+      jsonPath: toRelativePath(TREND_JSON_OUTPUT_PATH),
+      csvPath: toRelativePath(TREND_CSV_OUTPUT_PATH),
+      writeMode: isStdoutOnlyMode ? 'stdout-only' : 'stdout-and-file',
+    },
+  };
+
+  const historyPayload = {
+    generatedAt,
+    reportName: 'benchmark-history',
+    maxEntries: MAX_HISTORY_ENTRIES,
+    history: historyEntries,
+  };
+
+  const trendCsvPayload = convertTrendTableToCsv(trendTable);
+  const baseRerunInstructions = Array.isArray(reproducibilityProfile?.rerunInstructions)
+    ? reproducibilityProfile.rerunInstructions
+    : [];
+  const baseCommandExamples = Array.isArray(reproducibilityProfile?.commandExamples)
+    ? reproducibilityProfile.commandExamples
+    : [];
+  const rerunInstructions = appendUniqueTextValues(baseRerunInstructions, [
+    'Run npm run benchmark:continuity to validate cross-agent memory hydration, privacy redaction, and token-savings behavior.',
+  ]);
+  const commandExamples = appendUniqueTextValues(baseCommandExamples, [
+    'npm run benchmark:continuity',
+    'node ./scripts/memory-continuity-benchmark.mjs --stdout-only',
+  ]);
+
   const evidenceBundleReport = {
-    generatedAt: new Date().toISOString(),
+    generatedAt,
     reportName: 'benchmark-evidence-bundle',
-    phase: 'v2.5.1',
+    phase: 'v2.5.2',
+    releaseVersion,
     passed: failureCount === 0,
     failureCount,
     methodology: {
       deterministicRuntime: reproducibilityProfile?.deterministicRuntime || null,
       scenarioCount: Array.isArray(reproducibilityProfile?.scenarios) ? reproducibilityProfile.scenarios.length : 0,
-      commandCount: Array.isArray(reproducibilityProfile?.commandExamples) ? reproducibilityProfile.commandExamples.length : 0,
+      commandCount: commandExamples.length,
     },
-    rerunInstructions: Array.isArray(reproducibilityProfile?.rerunInstructions)
-      ? reproducibilityProfile.rerunInstructions
-      : [],
-    commandExamples: Array.isArray(reproducibilityProfile?.commandExamples)
-      ? reproducibilityProfile.commandExamples
-      : [],
+    rerunInstructions,
+    commandExamples,
     rawInputs: {
       scenarios: Array.isArray(reproducibilityProfile?.scenarios) ? reproducibilityProfile.scenarios : [],
       benchmarkThresholds: thresholdConfiguration,
       benchmarkWatchlist: Array.isArray(watchlistConfiguration?.repositories)
         ? watchlistConfiguration.repositories
         : [],
+      memorySchema: memorySchemaConfiguration,
+      memoryAdapterContract: memoryAdapterContractConfiguration,
     },
-    rubric: buildRubricSummary(thresholdConfiguration, benchmarkIntelligenceExecution.parsedReport),
+    rubric: buildRubricSummary(
+      thresholdConfiguration,
+      benchmarkIntelligenceExecution.parsedReport,
+      memoryContinuityExecution.parsedReport
+    ),
+    bugIndicators,
+    reliabilitySignals,
+    securityIndicators,
+    releaseDelta,
+    history: historyEntries,
+    trendReport,
     outputs: {
       detectionBenchmark: detectionBenchmarkExecution.parsedReport,
       benchmarkGate: benchmarkGateExecution.parsedReport,
       benchmarkIntelligence: benchmarkIntelligenceExecution.parsedReport,
+      memoryContinuityBenchmark: memoryContinuityExecution.parsedReport,
     },
     executions: executionSummaries,
   };
 
   if (!isStdoutOnlyMode) {
+    await fs.mkdir(join(REPOSITORY_ROOT, '.agent-context', 'state'), { recursive: true });
     await fs.writeFile(OUTPUT_PATH, JSON.stringify(evidenceBundleReport, null, 2) + '\n', 'utf8');
+    await fs.writeFile(HISTORY_OUTPUT_PATH, JSON.stringify(historyPayload, null, 2) + '\n', 'utf8');
+    await fs.writeFile(TREND_JSON_OUTPUT_PATH, JSON.stringify(trendReport, null, 2) + '\n', 'utf8');
+    await fs.writeFile(TREND_CSV_OUTPUT_PATH, trendCsvPayload, 'utf8');
   }
 
   console.log(JSON.stringify(evidenceBundleReport, null, 2));