pumuki 6.3.7

package/scripts/phase5-execution-closure-runner-arg-value-handlers-lib.ts

@@ -0,0 +1,62 @@
+import type { Phase5ExecutionClosureCliOptions } from './phase5-execution-closure-runner-contract';
+
+export type Phase5ExecutionClosureValueArg =
+  '--repo'
+  | '--limit'
+  | '--out-dir'
+  | '--repo-path'
+  | '--actionlint-bin';
+
+export const isPhase5ExecutionClosureValueArg = (
+  arg: string
+): arg is Phase5ExecutionClosureValueArg =>
+  arg === '--repo' ||
+  arg === '--limit' ||
+  arg === '--out-dir' ||
+  arg === '--repo-path' ||
+  arg === '--actionlint-bin';
+
+const assignPhase5ExecutionClosureStringArg = (params: {
+  options: Phase5ExecutionClosureCliOptions;
+  arg: Exclude<Phase5ExecutionClosureValueArg, '--limit'>;
+  value: string;
+}): void => {
+  if (params.arg === '--repo') {
+    params.options.repo = params.value;
+    return;
+  }
+  if (params.arg === '--out-dir') {
+    params.options.outDir = params.value;
+    return;
+  }
+  if (params.arg === '--repo-path') {
+    params.options.repoPath = params.value;
+    return;
+  }
+  params.options.actionlintBin = params.value;
+};
+
+const parsePositiveInteger = (value: string, flag: string): number => {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`Invalid ${flag} value: ${value}`);
+  }
+  return parsed;
+};
+
+export const applyPhase5ExecutionClosureValueArg = (params: {
+  options: Phase5ExecutionClosureCliOptions;
+  arg: Phase5ExecutionClosureValueArg;
+  value: string;
+}): void => {
+  if (params.arg === '--limit') {
+    params.options.limit = parsePositiveInteger(params.value, '--limit');
+    return;
+  }
+
+  assignPhase5ExecutionClosureStringArg({
+    options: params.options,
+    arg: params.arg,
+    value: params.value,
+  });
+};

package/scripts/phase5-execution-closure-runner-arg-values-lib.ts

@@ -0,0 +1,39 @@
+import type { Phase5ExecutionClosureCliOptions } from './phase5-execution-closure-runner-contract';
+import {
+  applyPhase5ExecutionClosureValueArg,
+  isPhase5ExecutionClosureValueArg,
+} from './phase5-execution-closure-runner-arg-value-handlers-lib';
+
+const readRequiredValue = (params: {
+  args: ReadonlyArray<string>;
+  index: number;
+  flag: string;
+}): string => {
+  const value = params.args[params.index + 1];
+  if (!value) {
+    throw new Error(`Missing value for ${params.flag}`);
+  }
+  return value;
+};
+
+export const assignPhase5ExecutionClosureArgWithValue = (params: {
+  options: Phase5ExecutionClosureCliOptions;
+  args: ReadonlyArray<string>;
+  index: number;
+  arg: string;
+}): boolean => {
+  if (isPhase5ExecutionClosureValueArg(params.arg)) {
+    applyPhase5ExecutionClosureValueArg({
+      options: params.options,
+      arg: params.arg,
+      value: readRequiredValue({
+        args: params.args,
+        index: params.index,
+        flag: params.arg,
+      }),
+    });
+    return true;
+  }
+
+  return false;
+};

package/scripts/phase5-execution-closure-runner-contract.ts

@@ -0,0 +1,31 @@
+export type Phase5ExecutionClosureCliOptions = {
+  repo: string;
+  limit: number;
+  outDir: string;
+  runWorkflowLint: boolean;
+  includeAuthPreflight: boolean;
+  repoPath?: string;
+  actionlintBin?: string;
+  includeAdapter: boolean;
+  requireAdapterReadiness: boolean;
+  useMockConsumerTriage: boolean;
+  dryRun: boolean;
+};
+
+export const DEFAULT_PHASE5_EXECUTION_CLOSURE_LIMIT = 20;
+export const DEFAULT_PHASE5_EXECUTION_CLOSURE_OUT_DIR = '.audit-reports/phase5';
+
+export const createDefaultPhase5ExecutionClosureCliOptions =
+  (): Phase5ExecutionClosureCliOptions => {
+    return {
+      repo: '',
+      limit: DEFAULT_PHASE5_EXECUTION_CLOSURE_LIMIT,
+      outDir: DEFAULT_PHASE5_EXECUTION_CLOSURE_OUT_DIR,
+      runWorkflowLint: true,
+      includeAuthPreflight: true,
+      includeAdapter: true,
+      requireAdapterReadiness: false,
+      useMockConsumerTriage: false,
+      dryRun: false,
+    };
+  };

package/scripts/phase5-execution-closure-runner-exec-command-lib.ts

@@ -0,0 +1,20 @@
+import { execFileSync } from 'node:child_process';
+import { resolve } from 'node:path';
+import type {
+  Phase5ExecutionClosureCommand,
+  Phase5ExecutionClosureExecution,
+} from './phase5-execution-closure-lib';
+
+export const executePhase5ExecutionClosureCommand = (
+  command: Phase5ExecutionClosureCommand
+): Phase5ExecutionClosureExecution => {
+  const scriptPath = resolve(process.cwd(), command.script);
+  execFileSync('npx', ['--yes', 'tsx@4.21.0', scriptPath, ...command.args], {
+    stdio: 'inherit',
+  });
+  return {
+    command,
+    exitCode: 0,
+    ok: true,
+  };
+};

package/scripts/phase5-execution-closure-runner-exec-error-lib.ts

@@ -0,0 +1,32 @@
+import type { Phase5ExecutionClosureCommand } from './phase5-execution-closure-lib';
+
+export const resolvePhase5ExecutionClosureCommandFailure = (params: {
+  command: Phase5ExecutionClosureCommand;
+  error: unknown;
+}) => {
+  const status =
+    params.error && typeof params.error === 'object' && 'status' in params.error
+      ? Number((params.error as { status?: number }).status ?? 1)
+      : 1;
+
+  return {
+    command: params.command,
+    exitCode: Number.isFinite(status) ? status : 1,
+    ok: false as const,
+    error:
+      params.error instanceof Error ? params.error.message : 'unknown command failure',
+  };
+};
+
+export const shouldStopPhase5ExecutionClosureAfterFailure = (
+  command: Phase5ExecutionClosureCommand
+): boolean => command.id === 'consumer-auth-preflight';
+
+export const printPhase5ExecutionClosureFailureNotice = (
+  command: Phase5ExecutionClosureCommand
+): void => {
+  if (!shouldStopPhase5ExecutionClosureAfterFailure(command)) {
+    return;
+  }
+  process.stdout.write('phase5 execution closure halted: consumer auth preflight failed\n');
+};

package/scripts/phase5-execution-closure-runner-exec-lib.ts

@@ -0,0 +1,35 @@
+import type {
+  Phase5ExecutionClosureCommand,
+  Phase5ExecutionClosureExecution,
+} from './phase5-execution-closure-lib';
+import { executePhase5ExecutionClosureCommand } from './phase5-execution-closure-runner-exec-command-lib';
+import {
+  printPhase5ExecutionClosureFailureNotice,
+  resolvePhase5ExecutionClosureCommandFailure,
+  shouldStopPhase5ExecutionClosureAfterFailure,
+} from './phase5-execution-closure-runner-exec-error-lib';
+
+export const executePhase5ExecutionClosureCommands = (
+  commands: ReadonlyArray<Phase5ExecutionClosureCommand>
+): ReadonlyArray<Phase5ExecutionClosureExecution> => {
+  const executions: Phase5ExecutionClosureExecution[] = [];
+
+  for (const command of commands) {
+    try {
+      executions.push(executePhase5ExecutionClosureCommand(command));
+    } catch (error) {
+      executions.push(
+        resolvePhase5ExecutionClosureCommandFailure({
+          command,
+          error,
+        })
+      );
+      printPhase5ExecutionClosureFailureNotice(command);
+      if (shouldStopPhase5ExecutionClosureAfterFailure(command)) {
+        break;
+      }
+    }
+  }
+
+  return executions;
+};

package/scripts/phase5-execution-closure-runner-lib.ts

@@ -0,0 +1,8 @@
+export type { Phase5ExecutionClosureCliOptions } from './phase5-execution-closure-runner-contract';
+export {
+  DEFAULT_PHASE5_EXECUTION_CLOSURE_LIMIT,
+  DEFAULT_PHASE5_EXECUTION_CLOSURE_OUT_DIR,
+} from './phase5-execution-closure-runner-contract';
+export { parsePhase5ExecutionClosureArgs } from './phase5-execution-closure-runner-parse-lib';
+export { buildPhase5ExecutionClosureDryRunPlan } from './phase5-execution-closure-runner-plan-lib';
+export { executePhase5ExecutionClosureCommands } from './phase5-execution-closure-runner-exec-lib';

package/scripts/phase5-execution-closure-runner-mappers-lib.ts

@@ -0,0 +1,30 @@
+import type { Phase5ExecutionClosureCliOptions } from './phase5-execution-closure-runner-contract';
+
+export const toPhase5ExecutionClosureCommandOptions = (
+  options: Phase5ExecutionClosureCliOptions
+) => ({
+  repo: options.repo,
+  limit: options.limit,
+  outDir: options.outDir,
+  runWorkflowLint: options.runWorkflowLint,
+  includeAuthPreflight: options.includeAuthPreflight,
+  repoPath: options.repoPath,
+  actionlintBin: options.actionlintBin,
+  includeAdapter: options.includeAdapter,
+  requireAdapterReadiness: options.requireAdapterReadiness,
+  useMockConsumerTriage: options.useMockConsumerTriage,
+});
+
+export const toPhase5ExecutionClosureRunReportOptions = (
+  options: Phase5ExecutionClosureCliOptions
+) => ({
+  outDir: options.outDir,
+  limit: options.limit,
+  runWorkflowLint: options.runWorkflowLint,
+  includeAuthPreflight: options.includeAuthPreflight,
+  includeAdapter: options.includeAdapter,
+  requireAdapterReadiness: options.requireAdapterReadiness,
+  useMockConsumerTriage: options.useMockConsumerTriage,
+  repoPathProvided: Boolean(options.repoPath?.trim()),
+  actionlintBinProvided: Boolean(options.actionlintBin?.trim()),
+});

package/scripts/phase5-execution-closure-runner-options-normalizer-lib.ts

@@ -0,0 +1,19 @@
+import type { Phase5ExecutionClosureCliOptions } from './phase5-execution-closure-runner-contract';
+
+export const normalizePhase5ExecutionClosureOptions = (
+  options: Phase5ExecutionClosureCliOptions
+): Phase5ExecutionClosureCliOptions => {
+  if (!options.repo) {
+    throw new Error('Missing required argument --repo <owner/repo>');
+  }
+
+  if (options.useMockConsumerTriage) {
+    options.includeAuthPreflight = false;
+    options.runWorkflowLint = false;
+    if (!options.requireAdapterReadiness) {
+      options.includeAdapter = false;
+    }
+  }
+
+  return options;
+};

package/scripts/phase5-execution-closure-runner-parse-lib.ts

@@ -0,0 +1,23 @@
+import {
+  createDefaultPhase5ExecutionClosureCliOptions,
+  type Phase5ExecutionClosureCliOptions,
+} from './phase5-execution-closure-runner-contract';
+import { applyPhase5ExecutionClosureArg } from './phase5-execution-closure-runner-arg-handlers-lib';
+import { normalizePhase5ExecutionClosureOptions } from './phase5-execution-closure-runner-options-normalizer-lib';
+
+export const parsePhase5ExecutionClosureArgs = (
+  args: ReadonlyArray<string>
+): Phase5ExecutionClosureCliOptions => {
+  const options: Phase5ExecutionClosureCliOptions =
+    createDefaultPhase5ExecutionClosureCliOptions();
+
+  for (let index = 0; index < args.length; index += 1) {
+    index = applyPhase5ExecutionClosureArg({
+      options,
+      args,
+      index,
+    });
+  }
+
+  return normalizePhase5ExecutionClosureOptions(options);
+};

package/scripts/phase5-execution-closure-runner-plan-lib.ts

@@ -0,0 +1,14 @@
+import type { Phase5ExecutionClosureCommand } from './phase5-execution-closure-lib';
+
+export const buildPhase5ExecutionClosureDryRunPlan = (
+  commands: ReadonlyArray<Phase5ExecutionClosureCommand>
+): string => {
+  const lines = ['phase5 execution closure dry-run plan:'];
+  for (const command of commands) {
+    lines.push(
+      `- ${command.id}: npx --yes tsx@4.21.0 ${command.script} ${command.args.join(' ')}`
+    );
+  }
+
+  return `${lines.join('\n')}\n`;
+};

package/scripts/phase5-execution-closure-runner-report-writer-lib.ts

@@ -0,0 +1,12 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+
+export const writePhase5ExecutionClosureRunReport = (params: {
+  outputPath: string;
+  reportMarkdown: string;
+}): string => {
+  const reportPath = resolve(process.cwd(), params.outputPath);
+  mkdirSync(dirname(reportPath), { recursive: true });
+  writeFileSync(reportPath, params.reportMarkdown, 'utf8');
+  return reportPath;
+};

package/scripts/phase5-execution-closure-status-arg-flags-lib.ts

@@ -0,0 +1,13 @@
+import type { Phase5ExecutionClosureStatusCliOptions } from './phase5-execution-closure-status-cli-contract';
+
+export type Phase5ExecutionClosureStatusFlagArg = '--require-adapter-readiness';
+
+export const isPhase5ExecutionClosureStatusFlagArg = (
+  arg: string
+): arg is Phase5ExecutionClosureStatusFlagArg => arg === '--require-adapter-readiness';
+
+export const applyPhase5ExecutionClosureStatusFlagArg = (params: {
+  options: Phase5ExecutionClosureStatusCliOptions;
+}): void => {
+  params.options.requireAdapterReadiness = true;
+};

package/scripts/phase5-execution-closure-status-arg-values-lib.ts

@@ -0,0 +1,35 @@
+import type { Phase5ExecutionClosureStatusCliOptions } from './phase5-execution-closure-status-cli-contract';
+
+export type Phase5ExecutionClosureStatusValueArg =
+  '--phase5-blockers-report'
+  | '--consumer-unblock-report'
+  | '--adapter-readiness-report'
+  | '--out';
+
+export const isPhase5ExecutionClosureStatusValueArg = (
+  arg: string
+): arg is Phase5ExecutionClosureStatusValueArg =>
+  arg === '--phase5-blockers-report' ||
+  arg === '--consumer-unblock-report' ||
+  arg === '--adapter-readiness-report' ||
+  arg === '--out';
+
+export const applyPhase5ExecutionClosureStatusValueArg = (params: {
+  options: Phase5ExecutionClosureStatusCliOptions;
+  arg: Phase5ExecutionClosureStatusValueArg;
+  value: string;
+}): void => {
+  if (params.arg === '--phase5-blockers-report') {
+    params.options.phase5BlockersReportFile = params.value;
+    return;
+  }
+  if (params.arg === '--consumer-unblock-report') {
+    params.options.consumerUnblockReportFile = params.value;
+    return;
+  }
+  if (params.arg === '--adapter-readiness-report') {
+    params.options.adapterReadinessReportFile = params.value;
+    return;
+  }
+  params.options.outFile = params.value;
+};

package/scripts/phase5-execution-closure-status-blockers-lib.ts

@@ -0,0 +1,47 @@
+import type { SummarizePhase5ExecutionClosureParams } from './phase5-execution-closure-status-contract';
+
+const normalizeVerdict = (value?: string): string => (value ?? '').toUpperCase();
+
+export const collectPhase5ExecutionClosureBlockers = (
+  params: SummarizePhase5ExecutionClosureParams
+): string[] => {
+  const blockers: string[] = [];
+
+  if (normalizeVerdict(params.phase5BlockersVerdict) !== 'READY') {
+    blockers.push(
+      `Phase 5 blockers readiness verdict is ${params.phase5BlockersVerdict ?? 'unknown'}`
+    );
+  }
+  if (normalizeVerdict(params.consumerUnblockVerdict) !== 'READY_FOR_RETEST') {
+    blockers.push(
+      `Consumer startup unblock verdict is ${params.consumerUnblockVerdict ?? 'unknown'}`
+    );
+  }
+
+  if (
+    params.requireAdapterReadiness &&
+    normalizeVerdict(params.adapterReadinessVerdict) !== 'READY'
+  ) {
+    blockers.push(
+      `Adapter readiness verdict is ${params.adapterReadinessVerdict ?? 'unknown'}`
+    );
+  }
+
+  return blockers;
+};
+
+export const collectPhase5ExecutionClosureWarnings = (
+  params: SummarizePhase5ExecutionClosureParams
+): string[] => {
+  if (params.requireAdapterReadiness || !params.hasAdapterReadinessReport) {
+    return [];
+  }
+
+  if (normalizeVerdict(params.adapterReadinessVerdict) === 'READY') {
+    return [];
+  }
+
+  return [
+    `Adapter readiness is ${params.adapterReadinessVerdict ?? 'unknown'} (not required in current mode)`,
+  ];
+};

package/scripts/phase5-execution-closure-status-cli-contract.ts

@@ -0,0 +1,24 @@
+export type Phase5ExecutionClosureStatusCliOptions = {
+  phase5BlockersReportFile: string;
+  consumerUnblockReportFile: string;
+  adapterReadinessReportFile: string;
+  outFile: string;
+  requireAdapterReadiness: boolean;
+};
+
+export const DEFAULT_PHASE5_BLOCKERS_REPORT_FILE =
+  '.audit-reports/phase5/phase5-blockers-readiness.md';
+export const DEFAULT_CONSUMER_UNBLOCK_REPORT_FILE =
+  '.audit-reports/consumer-triage/consumer-startup-unblock-status.md';
+export const DEFAULT_ADAPTER_READINESS_REPORT_FILE = '.audit-reports/adapter/adapter-readiness.md';
+export const DEFAULT_PHASE5_EXECUTION_CLOSURE_STATUS_OUT_FILE =
+  '.audit-reports/phase5/phase5-execution-closure-status.md';
+
+export const createDefaultPhase5ExecutionClosureStatusCliOptions =
+  (): Phase5ExecutionClosureStatusCliOptions => ({
+    phase5BlockersReportFile: DEFAULT_PHASE5_BLOCKERS_REPORT_FILE,
+    consumerUnblockReportFile: DEFAULT_CONSUMER_UNBLOCK_REPORT_FILE,
+    adapterReadinessReportFile: DEFAULT_ADAPTER_READINESS_REPORT_FILE,
+    outFile: DEFAULT_PHASE5_EXECUTION_CLOSURE_STATUS_OUT_FILE,
+    requireAdapterReadiness: false,
+  });

package/scripts/phase5-execution-closure-status-cli-input-lib.ts

@@ -0,0 +1,17 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+export const readPhase5ExecutionClosureStatusInput = (
+  cwd: string,
+  pathLike: string
+): { exists: boolean; content?: string } => {
+  const absolute = resolve(cwd, pathLike);
+  if (!existsSync(absolute)) {
+    return { exists: false };
+  }
+
+  return {
+    exists: true,
+    content: readFileSync(absolute, 'utf8'),
+  };
+};

package/scripts/phase5-execution-closure-status-cli-lib.ts

@@ -0,0 +1,10 @@
+export type { Phase5ExecutionClosureStatusCliOptions } from './phase5-execution-closure-status-cli-contract';
+export {
+  DEFAULT_ADAPTER_READINESS_REPORT_FILE,
+  DEFAULT_CONSUMER_UNBLOCK_REPORT_FILE,
+  DEFAULT_PHASE5_BLOCKERS_REPORT_FILE,
+  DEFAULT_PHASE5_EXECUTION_CLOSURE_STATUS_OUT_FILE,
+  createDefaultPhase5ExecutionClosureStatusCliOptions,
+} from './phase5-execution-closure-status-cli-contract';
+export { parsePhase5ExecutionClosureStatusArgs } from './phase5-execution-closure-status-cli-parse-lib';
+export { readPhase5ExecutionClosureStatusInput } from './phase5-execution-closure-status-cli-input-lib';

package/scripts/phase5-execution-closure-status-cli-parse-lib.ts

@@ -0,0 +1,59 @@
+import {
+  createDefaultPhase5ExecutionClosureStatusCliOptions,
+  type Phase5ExecutionClosureStatusCliOptions,
+} from './phase5-execution-closure-status-cli-contract';
+import {
+  applyPhase5ExecutionClosureStatusFlagArg,
+  isPhase5ExecutionClosureStatusFlagArg,
+} from './phase5-execution-closure-status-arg-flags-lib';
+import {
+  applyPhase5ExecutionClosureStatusValueArg,
+  isPhase5ExecutionClosureStatusValueArg,
+} from './phase5-execution-closure-status-arg-values-lib';
+
+const readRequiredArgValue = (params: {
+  args: ReadonlyArray<string>;
+  index: number;
+  arg: string;
+}): string => {
+  const value = params.args[params.index + 1];
+  if (!value) {
+    throw new Error(`Missing value for ${params.arg}`);
+  }
+  return value;
+};
+
+export const parsePhase5ExecutionClosureStatusArgs = (
+  args: ReadonlyArray<string>
+): Phase5ExecutionClosureStatusCliOptions => {
+  const options = createDefaultPhase5ExecutionClosureStatusCliOptions();
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (isPhase5ExecutionClosureStatusValueArg(arg)) {
+      applyPhase5ExecutionClosureStatusValueArg({
+        options,
+        arg,
+        value: readRequiredArgValue({
+          args,
+          index,
+          arg,
+        }),
+      });
+      index += 1;
+      continue;
+    }
+
+    if (isPhase5ExecutionClosureStatusFlagArg(arg)) {
+      applyPhase5ExecutionClosureStatusFlagArg({
+        options,
+      });
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+};

package/scripts/phase5-execution-closure-status-contract.ts

@@ -0,0 +1,48 @@
+export type Phase5ExecutionClosureSummary = {
+  verdict: 'READY' | 'BLOCKED' | 'MISSING_INPUTS';
+  blockers: ReadonlyArray<string>;
+  missingInputs: ReadonlyArray<string>;
+  warnings: ReadonlyArray<string>;
+  phase5BlockersVerdict?: string;
+  consumerUnblockVerdict?: string;
+  adapterReadinessVerdict?: string;
+  requireAdapterReadiness: boolean;
+};
+
+export type SummarizePhase5ExecutionClosureParams = {
+  hasPhase5BlockersReport: boolean;
+  hasConsumerUnblockReport: boolean;
+  hasAdapterReadinessReport: boolean;
+  phase5BlockersVerdict?: string;
+  consumerUnblockVerdict?: string;
+  adapterReadinessVerdict?: string;
+  requireAdapterReadiness: boolean;
+};
+
+export type BuildPhase5ExecutionClosureStatusMarkdownParams = {
+  generatedAt: string;
+  phase5BlockersReportPath: string;
+  consumerUnblockReportPath: string;
+  adapterReadinessReportPath: string;
+  hasPhase5BlockersReport: boolean;
+  hasConsumerUnblockReport: boolean;
+  hasAdapterReadinessReport: boolean;
+  summary: Phase5ExecutionClosureSummary;
+};
+
+export const dedupePhase5ExecutionClosureValues = (
+  values: ReadonlyArray<string>
+): string[] => {
+  const seen = new Set<string>();
+  const output: string[] = [];
+
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    output.push(value);
+  }
+
+  return output;
+};

package/scripts/phase5-execution-closure-status-lib.ts

@@ -0,0 +1,8 @@
+export type {
+  BuildPhase5ExecutionClosureStatusMarkdownParams,
+  Phase5ExecutionClosureSummary,
+  SummarizePhase5ExecutionClosureParams,
+} from './phase5-execution-closure-status-contract';
+export { parseVerdictFromMarkdown } from './phase5-execution-closure-status-parser-lib';
+export { summarizePhase5ExecutionClosure } from './phase5-execution-closure-status-summary-lib';
+export { buildPhase5ExecutionClosureStatusMarkdown } from './phase5-execution-closure-status-markdown-lib';

package/scripts/phase5-execution-closure-status-markdown-lib.ts

@@ -0,0 +1,22 @@
+import type { BuildPhase5ExecutionClosureStatusMarkdownParams } from './phase5-execution-closure-status-contract';
+import {
+  appendPhase5ExecutionClosureStatusFindings,
+  appendPhase5ExecutionClosureStatusHeader,
+  appendPhase5ExecutionClosureStatusInputs,
+  appendPhase5ExecutionClosureStatusNextActions,
+  appendPhase5ExecutionClosureStatusVerdicts,
+} from './phase5-execution-closure-status-markdown-sections-lib';
+
+export const buildPhase5ExecutionClosureStatusMarkdown = (
+  params: BuildPhase5ExecutionClosureStatusMarkdownParams
+): string => {
+  const lines: string[] = [];
+
+  appendPhase5ExecutionClosureStatusHeader(lines, params);
+  appendPhase5ExecutionClosureStatusInputs(lines, params);
+  appendPhase5ExecutionClosureStatusVerdicts(lines, params.summary);
+  appendPhase5ExecutionClosureStatusFindings(lines, params.summary);
+  appendPhase5ExecutionClosureStatusNextActions(lines, params.summary);
+
+  return `${lines.join('\n')}\n`;
+};

package/scripts/phase5-execution-closure-status-markdown-list-lib.ts

@@ -0,0 +1,16 @@
+export const appendPhase5ExecutionClosureStatusList = (
+  lines: string[],
+  title: string,
+  values: ReadonlyArray<string>
+): void => {
+  lines.push(title);
+  lines.push('');
+  if (values.length === 0) {
+    lines.push('- none');
+  } else {
+    for (const value of values) {
+      lines.push(`- ${value}`);
+    }
+  }
+  lines.push('');
+};