pumuki 6.3.7

package/scripts/adapter-real-session-analysis-messages-lib.ts

@@ -0,0 +1,58 @@
+import type { AdapterRealSessionSignals } from './adapter-real-session-analysis-signals-lib';
+import type { AdapterRealSessionReportParams } from './adapter-real-session-contract';
+
+type EvaluationMessageSet = {
+  summary: string;
+  rootCause: string;
+  correctiveAction: string;
+};
+
+export const buildAdapterRealSessionEvaluationMessages = (params: {
+  validationPass: boolean;
+  signals: AdapterRealSessionSignals;
+  report: AdapterRealSessionReportParams;
+}): EvaluationMessageSet => {
+  const missingWriteEvents = !params.signals.preWriteObserved || !params.signals.postWriteObserved;
+  const strictAssessmentPass = params.report.parsedStatus.strictAssessmentPass;
+
+  if (params.validationPass) {
+    return {
+      summary:
+        'Real Adapter session signals look healthy, with strict session assessment passing.',
+      rootCause: 'none',
+      correctiveAction: 'No corrective action required. Keep monitoring in regular validation runs.',
+    };
+  }
+
+  if (params.signals.nodeCommandMissing) {
+    return {
+      summary: 'Runtime still reports missing Node in hook shell environment.',
+      rootCause: 'Hook runtime shell cannot resolve Node binary (`node: command not found`).',
+      correctiveAction:
+        'Fix shell PATH/runtime setup for Adapter hooks and rerun the validation playbook.',
+    };
+  }
+
+  if (missingWriteEvents) {
+    return {
+      summary: 'Real pre/post write events were not fully observed in available logs.',
+      rootCause: 'Incomplete real IDE event coverage in the captured diagnostics.',
+      correctiveAction:
+        'Execute full real-session validation steps and capture fresh `.audit_tmp` logs.',
+    };
+  }
+
+  if (strictAssessmentPass) {
+    return {
+      summary: 'Strict assessment passed but other required runtime signals are incomplete.',
+      rootCause: 'Session-level strict assessment not satisfied with current evidence.',
+      correctiveAction: 'Repeat strict real-session run and verify both pre/post events are captured.',
+    };
+  }
+
+  return {
+    summary: 'Strict real-session assessment is not yet passing.',
+    rootCause: 'Session-level strict assessment not satisfied with current evidence.',
+    correctiveAction: 'Repeat strict real-session run and verify both pre/post events are captured.',
+  };
+};

package/scripts/adapter-real-session-analysis-signals-lib.ts

@@ -0,0 +1,59 @@
+import type { AdapterRealSessionReportParams } from './adapter-real-session-contract';
+
+export type AdapterRealSessionSignals = {
+  preWriteObserved: boolean;
+  postWriteObserved: boolean;
+  nodeBinResolved: boolean;
+  nodeCommandMissing: boolean;
+  normalWriteTriggered: boolean;
+  blockedWriteTriggered: boolean;
+  strictNodeTriggered: boolean;
+};
+
+export const collectAdapterRealSessionSignals = (
+  params: AdapterRealSessionReportParams
+): AdapterRealSessionSignals => {
+  const combinedCorpus = [
+    params.statusReport,
+    params.runtimeLogContent,
+    params.smokeLogContent,
+    params.hookLogContent,
+    params.writesLogContent,
+  ]
+    .filter((chunk): chunk is string => Boolean(chunk))
+    .join('\n');
+
+  const hasPositiveCounter = (pattern: RegExp): boolean => {
+    const match = combinedCorpus.match(pattern);
+    if (!match?.[1]) {
+      return false;
+    }
+
+    const value = Number.parseInt(match[1], 10);
+    return Number.isFinite(value) && value > 0;
+  };
+
+  const preWriteObserved =
+    /pre_write_code/.test(combinedCorpus) ||
+    hasPositiveCounter(/pre_write\.(?:analyzing|blocked|allowed)_effective=(\d+)/);
+  const postWriteObserved =
+    /post_write_code/.test(combinedCorpus) ||
+    hasPositiveCounter(/post_write\.entries_effective=(\d+)/);
+  const nodeBinResolved = /node_bin\s*=/.test(combinedCorpus);
+  const nodeCommandMissing = /(?:bash:\s*)?node:\s*command not found/.test(combinedCorpus);
+
+  const hookLog = params.hookLogContent ?? '';
+  const normalWriteTriggered = /ALLOWED:/.test(hookLog);
+  const blockedWriteTriggered = /BLOCKED:/.test(hookLog);
+  const strictNodeTriggered = params.parsedStatus.strictAssessmentPass;
+
+  return {
+    preWriteObserved,
+    postWriteObserved,
+    nodeBinResolved,
+    nodeCommandMissing,
+    normalWriteTriggered,
+    blockedWriteTriggered,
+    strictNodeTriggered,
+  };
+};

package/scripts/adapter-real-session-analysis-status-lib.ts

@@ -0,0 +1,29 @@
+import type { AdapterRealSessionReportParams } from './adapter-real-session-contract';
+import type { AdapterRealSessionSignals } from './adapter-real-session-analysis-signals-lib';
+
+export type PassFailUnknown = 'PASS' | 'FAIL' | 'UNKNOWN';
+
+export const deriveAdapterRealSessionVerifyStatus = (
+  verifyExitCode?: number
+): PassFailUnknown => {
+  if (verifyExitCode === undefined) {
+    return 'UNKNOWN';
+  }
+
+  return verifyExitCode === 0 ? 'PASS' : 'FAIL';
+};
+
+export const deriveAdapterRealSessionInstallStatus = (params: {
+  report: AdapterRealSessionReportParams;
+}): 'PASS' | 'FAIL' => (params.report.hookConfigExists ? 'PASS' : 'FAIL');
+
+export const deriveAdapterRealSessionValidationPass = (params: {
+  verifyStatus: PassFailUnknown;
+  report: AdapterRealSessionReportParams;
+  signals: AdapterRealSessionSignals;
+}): boolean =>
+  params.verifyStatus === 'PASS' &&
+  params.signals.preWriteObserved &&
+  params.signals.postWriteObserved &&
+  !params.signals.nodeCommandMissing &&
+  params.report.parsedStatus.strictAssessmentPass;

package/scripts/adapter-real-session-arg-values-lib.ts

@@ -0,0 +1,47 @@
+import type { AdapterRealSessionCliOptions } from './adapter-real-session-contract';
+
+export type AdapterRealSessionValueArg =
+  '--out'
+  | '--status-report'
+  | '--operator'
+  | '--adapter-version'
+  | '--tail-lines';
+
+export const isAdapterRealSessionValueArg = (arg: string): arg is AdapterRealSessionValueArg =>
+  arg === '--out' ||
+  arg === '--status-report' ||
+  arg === '--operator' ||
+  arg === '--adapter-version' ||
+  arg === '--tail-lines';
+
+const parsePositiveInteger = (value: string, label: string): number => {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${label} value: ${value}`);
+  }
+  return parsed;
+};
+
+export const applyAdapterRealSessionValueArg = (params: {
+  options: AdapterRealSessionCliOptions;
+  arg: AdapterRealSessionValueArg;
+  value: string;
+}): void => {
+  if (params.arg === '--out') {
+    params.options.outFile = params.value;
+    return;
+  }
+  if (params.arg === '--status-report') {
+    params.options.statusReportFile = params.value;
+    return;
+  }
+  if (params.arg === '--operator') {
+    params.options.operator = params.value;
+    return;
+  }
+  if (params.arg === '--adapter-version') {
+    params.options.adapterVersion = params.value;
+    return;
+  }
+  params.options.tailLines = parsePositiveInteger(params.value, '--tail-lines');
+};

package/scripts/adapter-real-session-args-lib.ts

@@ -0,0 +1,46 @@
+import {
+  DEFAULT_ADAPTER_REAL_SESSION_OPERATOR,
+  DEFAULT_ADAPTER_REAL_SESSION_OUT_FILE,
+  DEFAULT_ADAPTER_REAL_SESSION_TAIL_LINES,
+  DEFAULT_ADAPTER_REAL_SESSION_VERSION,
+  DEFAULT_ADAPTER_STATUS_REPORT_FILE,
+  type AdapterRealSessionCliOptions,
+} from './adapter-real-session-contract';
+import {
+  applyAdapterRealSessionValueArg,
+  isAdapterRealSessionValueArg,
+} from './adapter-real-session-arg-values-lib';
+
+export const parseAdapterRealSessionArgs = (
+  args: ReadonlyArray<string>
+): AdapterRealSessionCliOptions => {
+  const options: AdapterRealSessionCliOptions = {
+    outFile: DEFAULT_ADAPTER_REAL_SESSION_OUT_FILE,
+    statusReportFile: DEFAULT_ADAPTER_STATUS_REPORT_FILE,
+    operator: DEFAULT_ADAPTER_REAL_SESSION_OPERATOR,
+    adapterVersion: DEFAULT_ADAPTER_REAL_SESSION_VERSION,
+    tailLines: DEFAULT_ADAPTER_REAL_SESSION_TAIL_LINES,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (isAdapterRealSessionValueArg(arg)) {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      applyAdapterRealSessionValueArg({
+        options,
+        arg,
+        value,
+      });
+      index += 1;
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+};

package/scripts/adapter-real-session-audit-snapshot-lib.ts

@@ -0,0 +1,70 @@
+import {
+  findLatestAuditFileRelativePath,
+  readFileIfExists,
+} from './adapter-real-session-fs-lib';
+import { tailFromContent } from './adapter-real-session-markdown-lib';
+
+export const loadAdapterAuditSnapshot = (params: {
+  cwd: string;
+  tailLines: number;
+}): {
+  runtimeLogPath?: string;
+  runtimeLogContent?: string;
+  runtimeLogTail: string;
+  smokeLogPath?: string;
+  smokeLogContent?: string;
+  smokeLogTail: string;
+  hookLogPath: string;
+  hookLogContent?: string;
+  hookLogTail: string;
+  writesLogPath: string;
+  writesLogContent?: string;
+  writesLogTail: string;
+  hasRuntimeLog: boolean;
+  hasSmokeLog: boolean;
+  hasHookLog: boolean;
+  hasWritesLog: boolean;
+} => {
+  const runtimeLogPath = findLatestAuditFileRelativePath({
+    cwd: params.cwd,
+    directory: '.audit_tmp',
+    prefix: 'cascade-hook-runtime-',
+    suffix: '.log',
+  });
+  const smokeLogPath = findLatestAuditFileRelativePath({
+    cwd: params.cwd,
+    directory: '.audit_tmp',
+    prefix: 'cascade-hook-smoke-',
+    suffix: '.log',
+  });
+  const hookLogPath = '.audit_tmp/cascade-hook.log';
+  const writesLogPath = '.audit_tmp/cascade-writes.log';
+
+  const runtimeLogContent = runtimeLogPath
+    ? readFileIfExists(params.cwd, runtimeLogPath)
+    : undefined;
+  const smokeLogContent = smokeLogPath
+    ? readFileIfExists(params.cwd, smokeLogPath)
+    : undefined;
+  const hookLogContent = readFileIfExists(params.cwd, hookLogPath);
+  const writesLogContent = readFileIfExists(params.cwd, writesLogPath);
+
+  return {
+    runtimeLogPath,
+    runtimeLogContent,
+    runtimeLogTail: tailFromContent(runtimeLogContent, params.tailLines),
+    smokeLogPath,
+    smokeLogContent,
+    smokeLogTail: tailFromContent(smokeLogContent, params.tailLines),
+    hookLogPath,
+    hookLogContent,
+    hookLogTail: tailFromContent(hookLogContent, params.tailLines),
+    writesLogPath,
+    writesLogContent,
+    writesLogTail: tailFromContent(writesLogContent, params.tailLines),
+    hasRuntimeLog: Boolean(runtimeLogPath && runtimeLogContent),
+    hasSmokeLog: Boolean(smokeLogPath && smokeLogContent),
+    hasHookLog: Boolean(hookLogContent),
+    hasWritesLog: Boolean(writesLogContent),
+  };
+};

package/scripts/adapter-real-session-context-lib.ts

@@ -0,0 +1,7 @@
+export { loadAdapterAuditSnapshot } from './adapter-real-session-audit-snapshot-lib';
+export { runGitOrUnknown } from './adapter-real-session-git-lib';
+export { loadAdapterHookConfigSnapshot } from './adapter-real-session-hook-config-lib';
+export {
+  findLatestAuditFileRelativePath,
+  readFileIfExists,
+} from './adapter-real-session-fs-lib';

package/scripts/adapter-real-session-contract.ts

@@ -0,0 +1,54 @@
+export type AdapterRealSessionCliOptions = {
+  outFile: string;
+  statusReportFile: string;
+  operator: string;
+  adapterVersion: string;
+  tailLines: number;
+};
+
+export type AdapterParsedStatusReport = {
+  verdict?: string;
+  verifyExitCode?: number;
+  strictExitCode?: number;
+  anyExitCode?: number;
+  strictAssessmentPass: boolean;
+  anyAssessmentPass: boolean;
+};
+
+export type AdapterRealSessionReportParams = {
+  options: AdapterRealSessionCliOptions;
+  nowIso: string;
+  branch: string;
+  repository: string;
+  nodeRuntime: string;
+  hookConfigPath: string;
+  hookConfigContent?: string;
+  statusReportPath: string;
+  statusReport?: string;
+  parsedStatus: AdapterParsedStatusReport;
+  runtimeLogPath?: string;
+  runtimeLogContent?: string;
+  runtimeLogTail: string;
+  smokeLogPath?: string;
+  smokeLogContent?: string;
+  smokeLogTail: string;
+  hookLogPath: string;
+  hookLogContent?: string;
+  hookLogTail: string;
+  writesLogPath: string;
+  writesLogContent?: string;
+  writesLogTail: string;
+  hasRuntimeLog: boolean;
+  hasSmokeLog: boolean;
+  hasHookLog: boolean;
+  hasWritesLog: boolean;
+  hookConfigExists: boolean;
+};
+
+export const DEFAULT_ADAPTER_REAL_SESSION_OUT_FILE =
+  '.audit-reports/adapter/adapter-real-session-report.md';
+export const DEFAULT_ADAPTER_STATUS_REPORT_FILE =
+  '.audit-reports/adapter/adapter-session-status.md';
+export const DEFAULT_ADAPTER_REAL_SESSION_OPERATOR = 'unknown';
+export const DEFAULT_ADAPTER_REAL_SESSION_VERSION = 'unknown';
+export const DEFAULT_ADAPTER_REAL_SESSION_TAIL_LINES = 120;

package/scripts/adapter-real-session-fs-lib.ts

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+export const readFileIfExists = (
+  cwd: string,
+  pathLike: string
+): string | undefined => {
+  const absolute = resolve(cwd, pathLike);
+  if (!existsSync(absolute)) {
+    return undefined;
+  }
+
+  return readFileSync(absolute, 'utf8');
+};
+
+export const findLatestAuditFileRelativePath = (params: {
+  cwd: string;
+  directory: string;
+  prefix: string;
+  suffix: string;
+}): string | undefined => {
+  const absoluteDirectory = resolve(params.cwd, params.directory);
+  if (!existsSync(absoluteDirectory)) {
+    return undefined;
+  }
+
+  const matches = readdirSync(absoluteDirectory)
+    .filter((entry) => entry.startsWith(params.prefix) && entry.endsWith(params.suffix))
+    .sort((left, right) => right.localeCompare(left));
+
+  if (matches.length === 0) {
+    return undefined;
+  }
+
+  return join(params.directory, matches[0]);
+};

package/scripts/adapter-real-session-git-lib.ts

@@ -0,0 +1,13 @@
+import { execFileSync } from 'node:child_process';
+
+export const runGitOrUnknown = (cwd: string, args: ReadonlyArray<string>): string => {
+  try {
+    return execFileSync('git', [...args], {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch {
+    return 'unknown';
+  }
+};

package/scripts/adapter-real-session-hook-config-lib.ts

@@ -0,0 +1,24 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+export const loadAdapterHookConfigSnapshot = (params: {
+  cwd: string;
+  homeDir?: string;
+}): {
+  hookConfigPath: string;
+  hookConfigExists: boolean;
+  hookConfigContent?: string;
+} => {
+  const hookConfigPath = '~/.codeium/adapter/hooks.json';
+  const homeDir = params.homeDir ?? process.env.HOME ?? params.cwd;
+  const absoluteHookConfigPath = resolve(homeDir, '.codeium/adapter/hooks.json');
+  const hookConfigExists = existsSync(absoluteHookConfigPath);
+
+  return {
+    hookConfigPath,
+    hookConfigExists,
+    hookConfigContent: hookConfigExists
+      ? readFileSync(absoluteHookConfigPath, 'utf8')
+      : undefined,
+  };
+};

package/scripts/adapter-real-session-markdown-core-sections-lib.ts

@@ -0,0 +1,11 @@
+export {
+  appendHeaderSection,
+  appendPreconditionsSection,
+  appendSourcesSection,
+} from './adapter-real-session-markdown-sections-context-lib';
+export {
+  appendCapturedEvidenceSection,
+  appendObservedRuntimeSignalsSection,
+  appendOutcomeSection,
+  appendRealSessionStepsSection,
+} from './adapter-real-session-markdown-sections-evaluation-lib';

package/scripts/adapter-real-session-markdown-lib.ts

@@ -0,0 +1,25 @@
+import type { AdapterRealSessionReportParams } from './adapter-real-session-contract';
+import {
+  collectAdapterRealSessionSignals,
+  evaluateAdapterRealSessionSignals,
+} from './adapter-real-session-analysis-lib';
+import { buildAdapterRealSessionReportLines } from './adapter-real-session-markdown-sections-lib';
+export { tailFromContent } from './adapter-real-session-markdown-snippets-lib';
+
+export const buildAdapterRealSessionReportMarkdown = (
+  params: AdapterRealSessionReportParams
+): string => {
+  const signals = collectAdapterRealSessionSignals(params);
+  const evaluation = evaluateAdapterRealSessionSignals({
+    report: params,
+    signals,
+  });
+
+  const lines = buildAdapterRealSessionReportLines({
+    report: params,
+    signals,
+    evaluation,
+  });
+
+  return `${lines.join('\n')}\n`;
+};

package/scripts/adapter-real-session-markdown-sections-context-lib.ts

@@ -0,0 +1,56 @@
+import type { AdapterRealSessionReportParams } from './adapter-real-session-contract';
+import type { AdapterRealSessionEvaluation } from './adapter-real-session-analysis-lib';
+
+export const appendHeaderSection = (
+  lines: string[],
+  params: AdapterRealSessionReportParams
+): void => {
+  lines.push('# Adapter Hook Runtime - Real Session Report');
+  lines.push('');
+  lines.push('_Generated automatically from local status report and runtime logs._');
+  lines.push('');
+  lines.push('## Metadata');
+  lines.push('');
+  lines.push(`- Date: ${params.nowIso}`);
+  lines.push(`- Operator: ${params.options.operator}`);
+  lines.push(`- Branch: ${params.branch}`);
+  lines.push(`- Repository: ${params.repository}`);
+  lines.push(`- Adapter version: ${params.options.adapterVersion}`);
+  lines.push(`- Node runtime: ${params.nodeRuntime}`);
+  lines.push(`- Hook config path: ${params.hookConfigPath}`);
+  lines.push('');
+};
+
+export const appendPreconditionsSection = (
+  lines: string[],
+  evaluation: AdapterRealSessionEvaluation
+): void => {
+  lines.push('## Preconditions Check');
+  lines.push('');
+  lines.push(`- \`npm run install:adapter-hooks-config\`: ${evaluation.installStatus}`);
+  lines.push(`- \`npm run verify:adapter-hooks-runtime\`: ${evaluation.verifyStatus}`);
+  lines.push(
+    `- \`PUMUKI_HOOK_DIAGNOSTIC=1\`: ${process.env.PUMUKI_HOOK_DIAGNOSTIC === '1' ? 'ON' : 'OFF'}`
+  );
+  lines.push(
+    `- \`PUMUKI_HOOK_STRICT_NODE=1\`: ${process.env.PUMUKI_HOOK_STRICT_NODE === '1' ? 'ON' : 'OFF'}`
+  );
+  lines.push('');
+};
+
+export const appendSourcesSection = (
+  lines: string[],
+  params: AdapterRealSessionReportParams
+): void => {
+  lines.push('## Sources');
+  lines.push('');
+  lines.push(`- Status report: \`${params.statusReportPath}\``);
+  lines.push(`- Parsed status verdict: ${params.parsedStatus.verdict ?? 'UNKNOWN'}`);
+  lines.push(
+    `- Parsed strict assessment pass: ${params.parsedStatus.strictAssessmentPass ? 'YES' : 'NO'}`
+  );
+  lines.push(
+    `- Parsed include-simulated assessment pass: ${params.parsedStatus.anyAssessmentPass ? 'YES' : 'NO'}`
+  );
+  lines.push('');
+};

package/scripts/adapter-real-session-markdown-sections-evaluation-lib.ts

@@ -0,0 +1,71 @@
+import type { AdapterRealSessionReportParams } from './adapter-real-session-contract';
+import type {
+  AdapterRealSessionEvaluation,
+  AdapterRealSessionSignals,
+} from './adapter-real-session-analysis-lib';
+import {
+  toPassFail,
+  toYesNo,
+} from './adapter-real-session-markdown-value-formatters-lib';
+
+export const appendRealSessionStepsSection = (
+  lines: string[],
+  signals: AdapterRealSessionSignals
+): void => {
+  lines.push('## Real Session Steps');
+  lines.push('');
+  lines.push(`1. Normal write action triggered in Adapter: ${toPassFail(signals.normalWriteTriggered)}`);
+  lines.push(`2. Blocked candidate write action triggered in Adapter: ${toPassFail(signals.blockedWriteTriggered)}`);
+  lines.push(`3. Strict-node validation write action triggered: ${toPassFail(signals.strictNodeTriggered)}`);
+  lines.push('');
+};
+
+export const appendObservedRuntimeSignalsSection = (
+  lines: string[],
+  signals: AdapterRealSessionSignals
+): void => {
+  lines.push('## Observed Runtime Signals');
+  lines.push('');
+  lines.push(`- \`pre_write_code\` event observed: ${toYesNo(signals.preWriteObserved)}`);
+  lines.push(`- \`post_write_code\` event observed: ${toYesNo(signals.postWriteObserved)}`);
+  lines.push(`- \`node_bin\` resolved in runtime logs: ${toYesNo(signals.nodeBinResolved)}`);
+  lines.push(
+    `- Missing runtime events: ${toYesNo(!signals.preWriteObserved || !signals.postWriteObserved)}`
+  );
+  lines.push(`- Any \`bash: node: command not found\`: ${toYesNo(signals.nodeCommandMissing)}`);
+  lines.push('');
+};
+
+export const appendCapturedEvidenceSection = (
+  lines: string[],
+  params: AdapterRealSessionReportParams
+): void => {
+  lines.push('## Captured Evidence');
+  lines.push('');
+  lines.push(
+    `- \`~/.codeium/adapter/hooks.json\` snippet attached: ${toYesNo(Boolean(params.hookConfigContent))}`
+  );
+  lines.push(
+    `- \`.audit_tmp/cascade-hook-runtime-*.log\` tail attached: ${toYesNo(params.hasRuntimeLog)}`
+  );
+  lines.push(
+    `- \`.audit_tmp/cascade-hook-smoke-*.log\` tail attached: ${toYesNo(params.hasSmokeLog)}`
+  );
+  lines.push(`- \`.audit_tmp/cascade-hook.log\` tail attached: ${toYesNo(params.hasHookLog)}`);
+  lines.push(`- \`.audit_tmp/cascade-writes.log\` tail attached: ${toYesNo(params.hasWritesLog)}`);
+  lines.push('');
+};
+
+export const appendOutcomeSection = (
+  lines: string[],
+  evaluation: AdapterRealSessionEvaluation
+): void => {
+  lines.push('## Outcome');
+  lines.push('');
+  lines.push(`- Validation result: ${evaluation.validationPass ? 'PASS' : 'FAIL'}`);
+  lines.push(`- Summary: ${evaluation.summary}`);
+  lines.push(`- Root cause (if failed): ${evaluation.rootCause}`);
+  lines.push(`- Corrective action: ${evaluation.correctiveAction}`);
+  lines.push(`- Re-test required: ${evaluation.validationPass ? 'NO' : 'YES'}`);
+  lines.push('');
+};

package/scripts/adapter-real-session-markdown-sections-lib.ts

@@ -0,0 +1,34 @@
+import type { AdapterRealSessionReportParams } from './adapter-real-session-contract';
+import type {
+  AdapterRealSessionEvaluation,
+  AdapterRealSessionSignals,
+} from './adapter-real-session-analysis-lib';
+import {
+  appendCapturedEvidenceSection,
+  appendHeaderSection,
+  appendObservedRuntimeSignalsSection,
+  appendOutcomeSection,
+  appendPreconditionsSection,
+  appendRealSessionStepsSection,
+  appendSourcesSection,
+} from './adapter-real-session-markdown-core-sections-lib';
+import { appendAttachedSnippetsSection } from './adapter-real-session-markdown-snippet-section-lib';
+
+export const buildAdapterRealSessionReportLines = (params: {
+  report: AdapterRealSessionReportParams;
+  signals: AdapterRealSessionSignals;
+  evaluation: AdapterRealSessionEvaluation;
+}): ReadonlyArray<string> => {
+  const lines: string[] = [];
+
+  appendHeaderSection(lines, params.report);
+  appendPreconditionsSection(lines, params.evaluation);
+  appendRealSessionStepsSection(lines, params.signals);
+  appendObservedRuntimeSignalsSection(lines, params.signals);
+  appendCapturedEvidenceSection(lines, params.report);
+  appendOutcomeSection(lines, params.evaluation);
+  appendSourcesSection(lines, params.report);
+  appendAttachedSnippetsSection(lines, params.report);
+
+  return lines;
+};