pumuki 6.3.7

package/scripts/mark-phase5-escalation-submitted.sh

@@ -0,0 +1,49 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+if [[ $# -lt 3 ]]; then
+  echo "Usage: $0 <support_ticket_id> <submitted_by> <follow_up_eta> [submitted_at_utc]" >&2
+  exit 1
+fi
+
+SUPPORT_TICKET_ID="$1"
+SUBMITTED_BY="$2"
+FOLLOW_UP_ETA="$3"
+SUBMITTED_AT_UTC="${4:-$(date -u +"%Y-%m-%dT%H:%M:%SZ")}"
+
+HANDOFF_FILE="docs/validation/consumer-startup-escalation-handoff-latest.md"
+
+if [[ ! -f "${HANDOFF_FILE}" ]]; then
+  echo "[mark-phase5-escalation-submitted] ERROR: file not found: ${HANDOFF_FILE}" >&2
+  exit 1
+fi
+
+awk \
+  -v support_ticket_id="${SUPPORT_TICKET_ID}" \
+  -v submitted_by="${SUBMITTED_BY}" \
+  -v follow_up_eta="${FOLLOW_UP_ETA}" \
+  -v submitted_at_utc="${SUBMITTED_AT_UTC}" '
+  {
+    if ($0 ~ /^- support_ticket_id:/) {
+      print "- support_ticket_id: `" support_ticket_id "`";
+    } else if ($0 ~ /^- submitted_at_utc:/) {
+      print "- submitted_at_utc: `" submitted_at_utc "`";
+    } else if ($0 ~ /^- submitted_by:/) {
+      print "- submitted_by: `" submitted_by "`";
+    } else if ($0 ~ /^- follow_up_eta:/) {
+      print "- follow_up_eta: `" follow_up_eta "`";
+    } else if ($0 ~ /^- submission_blocker:/) {
+      print "- submission_blocker: `NONE`";
+    } else {
+      print $0;
+    }
+  }
+' "${HANDOFF_FILE}" > "${HANDOFF_FILE}.tmp"
+
+mv "${HANDOFF_FILE}.tmp" "${HANDOFF_FILE}"
+
+echo "[mark-phase5-escalation-submitted] updated ${HANDOFF_FILE}"
+echo "[mark-phase5-escalation-submitted] support_ticket_id=${SUPPORT_TICKET_ID}"
+echo "[mark-phase5-escalation-submitted] submitted_at_utc=${SUBMITTED_AT_UTC}"
+echo "[mark-phase5-escalation-submitted] submitted_by=${SUBMITTED_BY}"
+echo "[mark-phase5-escalation-submitted] follow_up_eta=${FOLLOW_UP_ETA}"

package/scripts/mark-phase8-followup-posted-now.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF' >&2
+Usage:
+  bash scripts/mark-phase8-followup-posted-now.sh \
+    <follow_up_posted_by> \
+    [support_ticket_id] \
+    [follow_up_last_posted_at_utc]
+EOF
+}
+
+if [[ $# -lt 1 ]]; then
+  usage
+  exit 1
+fi
+
+FOLLOW_UP_POSTED_BY="$1"
+SUPPORT_TICKET_ID="${2:-4077449}"
+FOLLOW_UP_LAST_POSTED_AT_UTC="${3:-$(date -u +"%Y-%m-%dT%H:%M:%SZ")}"
+
+bash scripts/mark-phase8-support-followup-state.sh \
+  "${SUPPORT_TICKET_ID}" \
+  "${FOLLOW_UP_POSTED_BY}" \
+  "POSTED_WAITING_REPLY" \
+  "${FOLLOW_UP_LAST_POSTED_AT_UTC}" \
+  "PENDING_SUPPORT_REPLY" \
+  "PENDING_SUPPORT_REPLY"
+
+echo "[mark-phase8-followup-posted-now] support_ticket_id=${SUPPORT_TICKET_ID}"
+echo "[mark-phase8-followup-posted-now] follow_up_last_posted_by=${FOLLOW_UP_POSTED_BY}"
+echo "[mark-phase8-followup-posted-now] follow_up_last_posted_at_utc=${FOLLOW_UP_LAST_POSTED_AT_UTC}"

package/scripts/mark-phase8-followup-replied-now.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF' >&2
+Usage:
+  bash scripts/mark-phase8-followup-replied-now.sh \
+    <follow_up_posted_by> \
+    <support_reply_summary> \
+    [support_ticket_id] \
+    [follow_up_last_posted_at_utc] \
+    [support_reply_received_at_utc]
+EOF
+}
+
+if [[ $# -lt 2 ]]; then
+  usage
+  exit 1
+fi
+
+FOLLOW_UP_POSTED_BY="$1"
+SUPPORT_REPLY_SUMMARY="$2"
+SUPPORT_TICKET_ID="${3:-4077449}"
+FOLLOW_UP_LAST_POSTED_AT_UTC="${4:-}"
+SUPPORT_REPLY_RECEIVED_AT_UTC="${5:-$(date -u +"%Y-%m-%dT%H:%M:%SZ")}"
+HANDOFF_FILE="docs/validation/consumer-startup-escalation-handoff-latest.md"
+
+if [[ -z "${FOLLOW_UP_LAST_POSTED_AT_UTC}" ]]; then
+  FOLLOW_UP_LAST_POSTED_AT_UTC="$(
+    rg -n "^- follow_up_last_posted_at_utc:" "${HANDOFF_FILE}" \
+      | head -n 1 \
+      | sed -E 's/^[0-9]+:- follow_up_last_posted_at_utc:[[:space:]]*//; s/`//g; s/\r//g' \
+      | xargs || true
+  )"
+fi
+
+if [[ -z "${FOLLOW_UP_LAST_POSTED_AT_UTC}" || "${FOLLOW_UP_LAST_POSTED_AT_UTC}" == "PENDING_MANUAL_POST" ]]; then
+  FOLLOW_UP_LAST_POSTED_AT_UTC="${SUPPORT_REPLY_RECEIVED_AT_UTC}"
+fi
+
+bash scripts/mark-phase8-support-followup-state.sh \
+  "${SUPPORT_TICKET_ID}" \
+  "${FOLLOW_UP_POSTED_BY}" \
+  "SUPPORT_REPLIED" \
+  "${FOLLOW_UP_LAST_POSTED_AT_UTC}" \
+  "${SUPPORT_REPLY_RECEIVED_AT_UTC}" \
+  "${SUPPORT_REPLY_SUMMARY}"
+
+echo "[mark-phase8-followup-replied-now] support_ticket_id=${SUPPORT_TICKET_ID}"
+echo "[mark-phase8-followup-replied-now] follow_up_last_posted_by=${FOLLOW_UP_POSTED_BY}"
+echo "[mark-phase8-followup-replied-now] follow_up_last_posted_at_utc=${FOLLOW_UP_LAST_POSTED_AT_UTC}"
+echo "[mark-phase8-followup-replied-now] support_reply_received_at_utc=${SUPPORT_REPLY_RECEIVED_AT_UTC}"

package/scripts/mark-phase8-support-followup-state.sh

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF' >&2
+Usage:
+  bash scripts/mark-phase8-support-followup-state.sh \
+    <support_ticket_id> \
+    <follow_up_posted_by> \
+    <follow_up_state: POSTED_WAITING_REPLY|SUPPORT_REPLIED> \
+    [follow_up_last_posted_at_utc] \
+    [support_reply_received_at_utc] \
+    [support_reply_summary]
+EOF
+}
+
+if [[ $# -lt 3 ]]; then
+  usage
+  exit 1
+fi
+
+SUPPORT_TICKET_ID="$1"
+FOLLOW_UP_POSTED_BY="$2"
+FOLLOW_UP_STATE="$3"
+FOLLOW_UP_LAST_POSTED_AT_UTC="${4:-$(date -u +"%Y-%m-%dT%H:%M:%SZ")}"
+SUPPORT_REPLY_RECEIVED_AT_UTC="${5:-PENDING}"
+SUPPORT_REPLY_SUMMARY="${6:-PENDING}"
+
+case "${FOLLOW_UP_STATE}" in
+  POSTED_WAITING_REPLY|SUPPORT_REPLIED) ;;
+  *)
+    echo "[mark-phase8-followup] invalid follow_up_state: ${FOLLOW_UP_STATE}" >&2
+    usage
+    exit 1
+    ;;
+esac
+
+HANDOFF_FILE="docs/validation/consumer-startup-escalation-handoff-latest.md"
+
+if [[ ! -f "${HANDOFF_FILE}" ]]; then
+  echo "[mark-phase8-followup] ERROR: file not found: ${HANDOFF_FILE}" >&2
+  exit 1
+fi
+
+update_or_append_field() {
+  local key="$1"
+  local value="$2"
+  local file="$3"
+
+  awk \
+    -v key="${key}" \
+    -v value="${value}" '
+    BEGIN { updated = 0 }
+    {
+      if ($0 ~ "^- " key ":") {
+        print "- " key ": `" value "`";
+        updated = 1;
+      } else {
+        print $0;
+      }
+    }
+    END {
+      if (!updated) {
+        print "- " key ": `" value "`";
+      }
+    }
+  ' "${file}" > "${file}.tmp"
+
+  mv "${file}.tmp" "${file}"
+}
+
+update_or_append_field "support_ticket_id" "${SUPPORT_TICKET_ID}" "${HANDOFF_FILE}"
+update_or_append_field "follow_up_last_posted_at_utc" "${FOLLOW_UP_LAST_POSTED_AT_UTC}" "${HANDOFF_FILE}"
+update_or_append_field "follow_up_last_posted_by" "${FOLLOW_UP_POSTED_BY}" "${HANDOFF_FILE}"
+update_or_append_field "follow_up_state" "${FOLLOW_UP_STATE}" "${HANDOFF_FILE}"
+update_or_append_field "support_reply_received_at_utc" "${SUPPORT_REPLY_RECEIVED_AT_UTC}" "${HANDOFF_FILE}"
+update_or_append_field "support_reply_summary" "${SUPPORT_REPLY_SUMMARY}" "${HANDOFF_FILE}"
+
+if [[ "${FOLLOW_UP_STATE}" == "SUPPORT_REPLIED" ]]; then
+  update_or_append_field "loop_guard_next_refresh_not_before_utc" "${FOLLOW_UP_LAST_POSTED_AT_UTC}" "${HANDOFF_FILE}"
+fi
+
+echo "[mark-phase8-followup] updated ${HANDOFF_FILE}"
+echo "[mark-phase8-followup] support_ticket_id=${SUPPORT_TICKET_ID}"
+echo "[mark-phase8-followup] follow_up_last_posted_at_utc=${FOLLOW_UP_LAST_POSTED_AT_UTC}"
+echo "[mark-phase8-followup] follow_up_last_posted_by=${FOLLOW_UP_POSTED_BY}"
+echo "[mark-phase8-followup] follow_up_state=${FOLLOW_UP_STATE}"
+echo "[mark-phase8-followup] support_reply_received_at_utc=${SUPPORT_REPLY_RECEIVED_AT_UTC}"
+echo "[mark-phase8-followup] support_reply_summary=${SUPPORT_REPLY_SUMMARY}"

package/scripts/mock-consumer-ab-blockers-lib.ts

@@ -0,0 +1,36 @@
+import { isEvidenceHealthy } from './mock-consumer-ab-evidence-lib';
+import type { MockConsumerAbMarkdownParams } from './mock-consumer-ab-markdown-contract';
+
+export const buildMockConsumerAbBlockers = (
+  params: MockConsumerAbMarkdownParams
+): ReadonlyArray<string> => {
+  const blockers: string[] = [];
+
+  if (!params.blockReady) {
+    blockers.push('Package smoke block mode summary is not in expected blocking state');
+  }
+  if (!params.minimalReady) {
+    blockers.push('Package smoke minimal mode summary is not in expected pass state');
+  }
+  if (!isEvidenceHealthy(params.blockEvidence, 'BLOCK')) {
+    if (!params.blockEvidence.exists) {
+      blockers.push('block evidence file is missing');
+    } else if (params.blockEvidence.parseError) {
+      blockers.push('block evidence file is not valid JSON');
+    } else {
+      blockers.push('block evidence does not expose expected v2.1 CI BLOCK snapshot');
+    }
+  }
+
+  if (!isEvidenceHealthy(params.minimalEvidence, 'PASS')) {
+    if (!params.minimalEvidence.exists) {
+      blockers.push('minimal evidence file is missing');
+    } else if (params.minimalEvidence.parseError) {
+      blockers.push('minimal evidence file is not valid JSON');
+    } else {
+      blockers.push('minimal evidence does not expose expected v2.1 CI PASS snapshot');
+    }
+  }
+
+  return blockers;
+};

package/scripts/mock-consumer-ab-cli-arg-setters-lib.ts

@@ -0,0 +1,46 @@
+import type { MockConsumerAbCliOptions } from './mock-consumer-ab-contract';
+
+export type MockConsumerAbValueArg =
+  | '--repo'
+  | '--out'
+  | '--block-summary'
+  | '--minimal-summary'
+  | '--block-evidence'
+  | '--minimal-evidence';
+
+type MockConsumerAbValueSetter = (
+  options: MockConsumerAbCliOptions,
+  value: string
+) => void;
+
+type MockConsumerAbFlagSetter = (options: MockConsumerAbCliOptions) => void;
+
+export const MOCK_CONSUMER_AB_VALUE_ARG_SETTERS: Record<
+  MockConsumerAbValueArg,
+  MockConsumerAbValueSetter
+> = {
+  '--repo': (options, value) => {
+    options.repo = value;
+  },
+  '--out': (options, value) => {
+    options.outFile = value;
+  },
+  '--block-summary': (options, value) => {
+    options.blockSummaryFile = value;
+  },
+  '--minimal-summary': (options, value) => {
+    options.minimalSummaryFile = value;
+  },
+  '--block-evidence': (options, value) => {
+    options.blockEvidenceFile = value;
+  },
+  '--minimal-evidence': (options, value) => {
+    options.minimalEvidenceFile = value;
+  },
+};
+
+export const MOCK_CONSUMER_AB_FLAG_ARG_SETTERS: Record<'--dry-run', MockConsumerAbFlagSetter> = {
+  '--dry-run': (options) => {
+    options.dryRun = true;
+  },
+};

package/scripts/mock-consumer-ab-cli-defaults-lib.ts

@@ -0,0 +1,19 @@
+import {
+  DEFAULT_MOCK_CONSUMER_AB_BLOCK_EVIDENCE_FILE,
+  DEFAULT_MOCK_CONSUMER_AB_BLOCK_SUMMARY,
+  DEFAULT_MOCK_CONSUMER_AB_MINIMAL_EVIDENCE_FILE,
+  DEFAULT_MOCK_CONSUMER_AB_MINIMAL_SUMMARY,
+  DEFAULT_MOCK_CONSUMER_AB_OUT_FILE,
+  DEFAULT_MOCK_CONSUMER_AB_REPO,
+  type MockConsumerAbCliOptions,
+} from './mock-consumer-ab-contract';
+
+export const createMockConsumerAbDefaultCliOptions = (): MockConsumerAbCliOptions => ({
+  repo: DEFAULT_MOCK_CONSUMER_AB_REPO,
+  outFile: DEFAULT_MOCK_CONSUMER_AB_OUT_FILE,
+  blockSummaryFile: DEFAULT_MOCK_CONSUMER_AB_BLOCK_SUMMARY,
+  minimalSummaryFile: DEFAULT_MOCK_CONSUMER_AB_MINIMAL_SUMMARY,
+  blockEvidenceFile: DEFAULT_MOCK_CONSUMER_AB_BLOCK_EVIDENCE_FILE,
+  minimalEvidenceFile: DEFAULT_MOCK_CONSUMER_AB_MINIMAL_EVIDENCE_FILE,
+  dryRun: false,
+});

package/scripts/mock-consumer-ab-cli-lib.ts

@@ -0,0 +1,46 @@
+import {
+  MOCK_CONSUMER_AB_FLAG_ARG_SETTERS,
+  MOCK_CONSUMER_AB_VALUE_ARG_SETTERS,
+  type MockConsumerAbValueArg,
+} from './mock-consumer-ab-cli-arg-setters-lib';
+import { createMockConsumerAbDefaultCliOptions } from './mock-consumer-ab-cli-defaults-lib';
+import type { MockConsumerAbCliOptions } from './mock-consumer-ab-contract';
+
+const readRequiredArgValue = (
+  args: ReadonlyArray<string>,
+  index: number,
+  option: string
+): string => {
+  const value = args[index + 1];
+  if (!value) {
+    throw new Error(`Missing value for ${option}`);
+  }
+  return value;
+};
+
+export const parseMockConsumerAbArgs = (
+  args: ReadonlyArray<string>
+): MockConsumerAbCliOptions => {
+  const options: MockConsumerAbCliOptions = createMockConsumerAbDefaultCliOptions();
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg in MOCK_CONSUMER_AB_VALUE_ARG_SETTERS) {
+      const value = readRequiredArgValue(args, index, arg);
+      const setter = MOCK_CONSUMER_AB_VALUE_ARG_SETTERS[arg as MockConsumerAbValueArg];
+      setter(options, value);
+      index += 1;
+      continue;
+    }
+
+    if (arg in MOCK_CONSUMER_AB_FLAG_ARG_SETTERS) {
+      const setter = MOCK_CONSUMER_AB_FLAG_ARG_SETTERS[arg as '--dry-run'];
+      setter(options);
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+};

package/scripts/mock-consumer-ab-contract.ts

@@ -0,0 +1,30 @@
+export type MockConsumerAbCliOptions = {
+  repo: string;
+  outFile: string;
+  blockSummaryFile: string;
+  minimalSummaryFile: string;
+  blockEvidenceFile: string;
+  minimalEvidenceFile: string;
+  dryRun: boolean;
+};
+
+export type EvidenceAssessment = {
+  file: string;
+  exists: boolean;
+  parseError?: string;
+  version?: string;
+  stage?: string;
+  outcome?: string;
+};
+
+export const DEFAULT_MOCK_CONSUMER_AB_REPO = 'owner/repo';
+export const DEFAULT_MOCK_CONSUMER_AB_OUT_FILE =
+  '.audit-reports/mock-consumer/mock-consumer-ab-report.md';
+export const DEFAULT_MOCK_CONSUMER_AB_BLOCK_SUMMARY =
+  '.audit-reports/package-smoke/block/summary.md';
+export const DEFAULT_MOCK_CONSUMER_AB_MINIMAL_SUMMARY =
+  '.audit-reports/package-smoke/minimal/summary.md';
+export const DEFAULT_MOCK_CONSUMER_AB_BLOCK_EVIDENCE_FILE =
+  '.audit-reports/package-smoke/block/ci.ai_evidence.json';
+export const DEFAULT_MOCK_CONSUMER_AB_MINIMAL_EVIDENCE_FILE =
+  '.audit-reports/package-smoke/minimal/ci.ai_evidence.json';

package/scripts/mock-consumer-ab-evidence-lib.ts

@@ -0,0 +1,50 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { EvidenceAssessment } from './mock-consumer-ab-contract';
+
+export const assessEvidenceFile = (pathLike: string): EvidenceAssessment => {
+  const absolute = resolve(process.cwd(), pathLike);
+
+  if (!existsSync(absolute)) {
+    return {
+      file: pathLike,
+      exists: false,
+    };
+  }
+
+  try {
+    const raw = readFileSync(absolute, 'utf8');
+    const parsed = JSON.parse(raw) as {
+      version?: string;
+      snapshot?: {
+        stage?: string;
+        outcome?: string;
+      };
+    };
+
+    return {
+      file: pathLike,
+      exists: true,
+      version: typeof parsed.version === 'string' ? parsed.version : undefined,
+      stage: typeof parsed.snapshot?.stage === 'string' ? parsed.snapshot.stage : undefined,
+      outcome:
+        typeof parsed.snapshot?.outcome === 'string' ? parsed.snapshot.outcome : undefined,
+    };
+  } catch (error) {
+    return {
+      file: pathLike,
+      exists: true,
+      parseError: error instanceof Error ? error.message : 'invalid json',
+    };
+  }
+};
+
+export const isEvidenceHealthy = (
+  assessment: EvidenceAssessment,
+  expectedOutcome: 'PASS' | 'BLOCK'
+): boolean =>
+  assessment.exists &&
+  !assessment.parseError &&
+  assessment.version === '2.1' &&
+  assessment.stage === 'CI' &&
+  assessment.outcome === expectedOutcome;

package/scripts/mock-consumer-ab-markdown-assertions-lib.ts

@@ -0,0 +1,24 @@
+import { isEvidenceHealthy } from './mock-consumer-ab-evidence-lib';
+import type { MockConsumerAbMarkdownParams } from './mock-consumer-ab-markdown-contract';
+
+export const buildMockConsumerAbAssertionsLines = (
+  source: MockConsumerAbMarkdownParams
+): ReadonlyArray<string> => [
+  '## Assertions',
+  '',
+  `- smoke_block_expected: ${source.blockReady ? 'PASS' : 'FAIL'}`,
+  `- smoke_minimal_expected: ${source.minimalReady ? 'PASS' : 'FAIL'}`,
+  `- block_evidence_schema_v2_1: ${
+    isEvidenceHealthy(source.blockEvidence, 'BLOCK') ? 'PASS' : 'FAIL'
+  }`,
+  `- minimal_evidence_schema_v2_1: ${
+    isEvidenceHealthy(source.minimalEvidence, 'PASS') ? 'PASS' : 'FAIL'
+  }`,
+  `- block_evidence_version: ${source.blockEvidence.version ?? 'missing'}`,
+  `- block_evidence_snapshot_stage: ${source.blockEvidence.stage ?? 'missing'}`,
+  `- block_evidence_snapshot_outcome: ${source.blockEvidence.outcome ?? 'missing'}`,
+  `- minimal_evidence_version: ${source.minimalEvidence.version ?? 'missing'}`,
+  `- minimal_evidence_snapshot_stage: ${source.minimalEvidence.stage ?? 'missing'}`,
+  `- minimal_evidence_snapshot_outcome: ${source.minimalEvidence.outcome ?? 'missing'}`,
+  '',
+];

package/scripts/mock-consumer-ab-markdown-blockers-lib.ts

@@ -0,0 +1,9 @@
+export const buildMockConsumerAbBlockersLines = (
+  blockers: ReadonlyArray<string>
+): ReadonlyArray<string> => {
+  if (blockers.length === 0) {
+    return ['## Blockers', '', '- none', ''];
+  }
+
+  return ['## Blockers', '', ...blockers.map((blocker) => `- ${blocker}`), ''];
+};

package/scripts/mock-consumer-ab-markdown-contract.ts

@@ -0,0 +1,16 @@
+import type { EvidenceAssessment } from './mock-consumer-ab-contract';
+
+export type MockConsumerAbMarkdownParams = {
+  generatedAt: string;
+  repo: string;
+  blockSummaryFile: string;
+  minimalSummaryFile: string;
+  blockEvidenceFile: string;
+  minimalEvidenceFile: string;
+  blockReady: boolean;
+  minimalReady: boolean;
+  blockEvidence: EvidenceAssessment;
+  minimalEvidence: EvidenceAssessment;
+};
+
+export type MockConsumerAbVerdict = 'READY' | 'BLOCKED';

package/scripts/mock-consumer-ab-markdown-header-inputs-lib.ts

@@ -0,0 +1,21 @@
+import type { MockConsumerAbMarkdownParams } from './mock-consumer-ab-markdown-contract';
+
+export const buildMockConsumerAbHeaderAndInputs = (
+  source: MockConsumerAbMarkdownParams,
+  verdict: 'READY' | 'BLOCKED'
+): ReadonlyArray<string> => [
+  '# Mock Consumer A/B Validation Report',
+  '',
+  `- generated_at: ${source.generatedAt}`,
+  `- target_repo: \`${source.repo}\``,
+  '- source: local_mock_consumer_validation',
+  `- verdict: ${verdict}`,
+  '',
+  '## Inputs',
+  '',
+  `- block_summary: \`${source.blockSummaryFile}\``,
+  `- minimal_summary: \`${source.minimalSummaryFile}\``,
+  `- block_evidence: \`${source.blockEvidenceFile}\``,
+  `- minimal_evidence: \`${source.minimalEvidenceFile}\``,
+  '',
+];

package/scripts/mock-consumer-ab-markdown-lib.ts

@@ -0,0 +1,24 @@
+import { buildMockConsumerAbBlockers } from './mock-consumer-ab-blockers-lib';
+import type {
+  MockConsumerAbMarkdownParams,
+  MockConsumerAbVerdict,
+} from './mock-consumer-ab-markdown-contract';
+import { buildMockConsumerAbMarkdownLines } from './mock-consumer-ab-markdown-sections-lib';
+
+export const buildMockConsumerAbMarkdown = (
+  params: MockConsumerAbMarkdownParams
+): { markdown: string; verdict: MockConsumerAbVerdict; blockers: ReadonlyArray<string> } => {
+  const blockers = buildMockConsumerAbBlockers(params);
+  const verdict: MockConsumerAbVerdict = blockers.length === 0 ? 'READY' : 'BLOCKED';
+  const lines = buildMockConsumerAbMarkdownLines({
+    source: params,
+    verdict,
+    blockers,
+  });
+
+  return {
+    markdown: `${lines.join('\n')}\n`,
+    verdict,
+    blockers,
+  };
+};

package/scripts/mock-consumer-ab-markdown-next-actions-lib.ts

@@ -0,0 +1,22 @@
+import type { MockConsumerAbVerdict } from './mock-consumer-ab-markdown-contract';
+
+export const buildMockConsumerAbNextActionsLines = (
+  verdict: MockConsumerAbVerdict
+): ReadonlyArray<string> => {
+  if (verdict === 'READY') {
+    return [
+      '## Next Actions',
+      '',
+      '- Mock consumer A/B validation is stable and ready for rollout evidence.',
+      '',
+    ];
+  }
+
+  return [
+    '## Next Actions',
+    '',
+    '- Regenerate package smoke summaries and rerun this report.',
+    '- Ensure block/minimal CI evidence files exist and follow v2.1 schema.',
+    '',
+  ];
+};

package/scripts/mock-consumer-ab-markdown-sections-lib.ts

@@ -0,0 +1,21 @@
+import { buildMockConsumerAbAssertionsLines } from './mock-consumer-ab-markdown-assertions-lib';
+import { buildMockConsumerAbBlockersLines } from './mock-consumer-ab-markdown-blockers-lib';
+import type {
+  MockConsumerAbMarkdownParams,
+  MockConsumerAbVerdict,
+} from './mock-consumer-ab-markdown-contract';
+import { buildMockConsumerAbHeaderAndInputs } from './mock-consumer-ab-markdown-header-inputs-lib';
+import { buildMockConsumerAbNextActionsLines } from './mock-consumer-ab-markdown-next-actions-lib';
+
+export const buildMockConsumerAbMarkdownLines = (params: {
+  source: MockConsumerAbMarkdownParams;
+  verdict: MockConsumerAbVerdict;
+  blockers: ReadonlyArray<string>;
+}): ReadonlyArray<string> => {
+  return [
+    ...buildMockConsumerAbHeaderAndInputs(params.source, params.verdict),
+    ...buildMockConsumerAbAssertionsLines(params.source),
+    ...buildMockConsumerAbBlockersLines(params.blockers),
+    ...buildMockConsumerAbNextActionsLines(params.verdict),
+  ];
+};

package/scripts/mock-consumer-ab-report-lib.ts

@@ -0,0 +1,12 @@
+export {
+  DEFAULT_MOCK_CONSUMER_AB_BLOCK_EVIDENCE_FILE,
+  DEFAULT_MOCK_CONSUMER_AB_BLOCK_SUMMARY,
+  DEFAULT_MOCK_CONSUMER_AB_MINIMAL_EVIDENCE_FILE,
+  DEFAULT_MOCK_CONSUMER_AB_MINIMAL_SUMMARY,
+  DEFAULT_MOCK_CONSUMER_AB_OUT_FILE,
+  DEFAULT_MOCK_CONSUMER_AB_REPO,
+  type EvidenceAssessment,
+} from './mock-consumer-ab-contract';
+export { assessEvidenceFile, isEvidenceHealthy } from './mock-consumer-ab-evidence-lib';
+export { buildMockConsumerAbMarkdown } from './mock-consumer-ab-markdown-lib';
+export { parseMockConsumerAbArgs } from './mock-consumer-ab-cli-lib';

package/scripts/mock-consumer-ab-runner-lib.ts

@@ -0,0 +1,51 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { assessSmokeSummary, isExpectedModeResult } from './mock-consumer-smoke-lib';
+import { assessEvidenceFile, buildMockConsumerAbMarkdown } from './mock-consumer-ab-report-lib';
+import type { MockConsumerAbCliOptions } from './mock-consumer-ab-contract';
+import type { MockConsumerAbVerdict } from './mock-consumer-ab-markdown-contract';
+
+export const buildMockConsumerAbReportFromOptions = (params: {
+  options: MockConsumerAbCliOptions;
+  generatedAt: string;
+}): { markdown: string; verdict: MockConsumerAbVerdict } => {
+  const blockAssessment = assessSmokeSummary('block', params.options.blockSummaryFile);
+  const minimalAssessment = assessSmokeSummary('minimal', params.options.minimalSummaryFile);
+  const blockEvidenceAssessment = assessEvidenceFile(params.options.blockEvidenceFile);
+  const minimalEvidenceAssessment = assessEvidenceFile(params.options.minimalEvidenceFile);
+
+  const blockReady = isExpectedModeResult(blockAssessment);
+  const minimalReady = isExpectedModeResult(minimalAssessment);
+
+  const report = buildMockConsumerAbMarkdown({
+    generatedAt: params.generatedAt,
+    repo: params.options.repo,
+    blockSummaryFile: params.options.blockSummaryFile,
+    minimalSummaryFile: params.options.minimalSummaryFile,
+    blockEvidenceFile: params.options.blockEvidenceFile,
+    minimalEvidenceFile: params.options.minimalEvidenceFile,
+    blockReady,
+    minimalReady,
+    blockEvidence: blockEvidenceAssessment,
+    minimalEvidence: minimalEvidenceAssessment,
+  });
+
+  return {
+    markdown: report.markdown,
+    verdict: report.verdict,
+  };
+};
+
+export const persistMockConsumerAbReport = (params: {
+  outFile: string;
+  markdown: string;
+  dryRun: boolean;
+}): void => {
+  if (params.dryRun) {
+    return;
+  }
+
+  const outPath = resolve(process.cwd(), params.outFile);
+  mkdirSync(dirname(outPath), { recursive: true });
+  writeFileSync(outPath, params.markdown, 'utf8');
+};