pumuki 6.3.7

package/scripts/phase5-blockers-contract.ts

@@ -0,0 +1,36 @@
+export type ParsedAdapterRealSessionReport = {
+  validationResult?: 'PASS' | 'FAIL';
+  reTestRequired?: boolean;
+  nodeCommandNotFound: boolean;
+};
+
+export type ParsedConsumerStartupTriageReport = {
+  verdict?: 'READY' | 'BLOCKED';
+  requiredFailedSteps: ReadonlyArray<string>;
+};
+
+export type Phase5BlockersSummary = {
+  verdict: 'READY' | 'BLOCKED' | 'MISSING_INPUTS';
+  blockers: ReadonlyArray<string>;
+  adapterValidationResult?: 'PASS' | 'FAIL';
+  consumerTriageVerdict?: 'READY' | 'BLOCKED';
+  adapterRequired: boolean;
+  missingInputs: ReadonlyArray<string>;
+};
+
+export const dedupePhase5BlockersValues = (
+  values: ReadonlyArray<string>
+): string[] => {
+  const seen = new Set<string>();
+  const result: string[] = [];
+
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    result.push(value);
+  }
+
+  return result;
+};

package/scripts/phase5-blockers-detected-blockers-lib.ts

@@ -0,0 +1,35 @@
+import type {
+  ParsedAdapterRealSessionReport,
+  ParsedConsumerStartupTriageReport,
+} from './phase5-blockers-contract';
+import { dedupePhase5BlockersValues } from './phase5-blockers-contract';
+
+export const collectPhase5DetectedBlockers = (params: {
+  hasAdapterReport: boolean;
+  adapter?: ParsedAdapterRealSessionReport;
+  consumer?: ParsedConsumerStartupTriageReport;
+}): string[] => {
+  const blockers: string[] = [];
+
+  if (params.hasAdapterReport && params.adapter?.validationResult !== 'PASS') {
+    blockers.push(
+      `Adapter real-session validation is ${params.adapter?.validationResult ?? 'unknown'}`
+    );
+  }
+
+  if (params.hasAdapterReport && params.adapter?.nodeCommandNotFound) {
+    blockers.push('Adapter runtime still reports node command resolution failures');
+  }
+
+  if (params.consumer?.verdict !== 'READY') {
+    blockers.push(
+      `Consumer startup triage verdict is ${params.consumer?.verdict ?? 'unknown'}`
+    );
+  }
+
+  for (const step of params.consumer?.requiredFailedSteps ?? []) {
+    blockers.push(`Consumer triage required step failed: ${step}`);
+  }
+
+  return dedupePhase5BlockersValues(blockers);
+};

package/scripts/phase5-blockers-markdown-header-inputs-signals-lib.ts

@@ -0,0 +1,48 @@
+import type { Phase5BlockersSummary } from './phase5-blockers-contract';
+
+export const appendPhase5BlockersHeaderSection = (params: {
+  lines: string[];
+  generatedAt: string;
+  summary: Phase5BlockersSummary;
+}): void => {
+  params.lines.push('# Phase 5 Blockers Readiness');
+  params.lines.push('');
+  params.lines.push(`- generated_at: ${params.generatedAt}`);
+  params.lines.push(`- verdict: ${params.summary.verdict}`);
+  params.lines.push('');
+};
+
+export const appendPhase5BlockersInputsSection = (params: {
+  lines: string[];
+  adapterReportPath: string;
+  consumerTriageReportPath: string;
+  hasAdapterReport: boolean;
+  hasConsumerTriageReport: boolean;
+  requireAdapterReport: boolean;
+}): void => {
+  params.lines.push('## Inputs');
+  params.lines.push('');
+  params.lines.push(
+    `- adapter_report: \`${params.adapterReportPath}\` (${params.hasAdapterReport ? 'found' : 'missing'})`
+  );
+  params.lines.push(`- adapter_required: ${params.requireAdapterReport ? 'YES' : 'NO'}`);
+  params.lines.push(
+    `- consumer_triage_report: \`${params.consumerTriageReportPath}\` (${params.hasConsumerTriageReport ? 'found' : 'missing'})`
+  );
+  params.lines.push('');
+};
+
+export const appendPhase5BlockersSignalsSection = (params: {
+  lines: string[];
+  summary: Phase5BlockersSummary;
+}): void => {
+  params.lines.push('## Signals');
+  params.lines.push('');
+  params.lines.push(
+    `- adapter_validation_result: ${params.summary.adapterValidationResult ?? 'unknown'}`
+  );
+  params.lines.push(
+    `- consumer_triage_verdict: ${params.summary.consumerTriageVerdict ?? 'unknown'}`
+  );
+  params.lines.push('');
+};

package/scripts/phase5-blockers-markdown-lib.ts

@@ -0,0 +1,51 @@
+import type { Phase5BlockersSummary } from './phase5-blockers-contract';
+import {
+  appendPhase5BlockersHeaderSection,
+  appendPhase5BlockersInputsSection,
+  appendPhase5BlockersListSection,
+  appendPhase5BlockersNextActionsSection,
+  appendPhase5BlockersSignalsSection,
+} from './phase5-blockers-markdown-sections-lib';
+
+export const buildPhase5BlockersReadinessMarkdown = (params: {
+  generatedAt: string;
+  adapterReportPath: string;
+  consumerTriageReportPath: string;
+  hasAdapterReport: boolean;
+  hasConsumerTriageReport: boolean;
+  requireAdapterReport: boolean;
+  summary: Phase5BlockersSummary;
+}): string => {
+  const lines: string[] = [];
+
+  appendPhase5BlockersHeaderSection({
+    lines,
+    generatedAt: params.generatedAt,
+    summary: params.summary,
+  });
+  appendPhase5BlockersInputsSection({
+    lines,
+    adapterReportPath: params.adapterReportPath,
+    consumerTriageReportPath: params.consumerTriageReportPath,
+    hasAdapterReport: params.hasAdapterReport,
+    hasConsumerTriageReport: params.hasConsumerTriageReport,
+    requireAdapterReport: params.requireAdapterReport,
+  });
+  appendPhase5BlockersSignalsSection({
+    lines,
+    summary: params.summary,
+  });
+  appendPhase5BlockersListSection({
+    lines,
+    summary: params.summary,
+  });
+  appendPhase5BlockersNextActionsSection({
+    lines,
+    summary: params.summary,
+    hasAdapterReport: params.hasAdapterReport,
+    hasConsumerTriageReport: params.hasConsumerTriageReport,
+    requireAdapterReport: params.requireAdapterReport,
+  });
+
+  return `${lines.join('\n')}\n`;
+};

package/scripts/phase5-blockers-markdown-list-utils-lib.ts

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

package/scripts/phase5-blockers-markdown-next-actions-blocked-lib.ts

@@ -0,0 +1,46 @@
+import type { Phase5BlockersSummary } from './phase5-blockers-contract';
+
+const hasAdapterRuntimeBlocker = (summary: Phase5BlockersSummary): boolean =>
+  summary.blockers.some((item) => item.includes('Adapter runtime'));
+
+const hasConsumerTriageBlocker = (summary: Phase5BlockersSummary): boolean =>
+  summary.blockers.some(
+    (item) =>
+      item.includes('Consumer startup triage') ||
+      item.includes('Consumer triage required step failed')
+  );
+
+export const appendPhase5BlockersBlockedNextActions = (params: {
+  lines: string[];
+  summary: Phase5BlockersSummary;
+  hasAdapterReport: boolean;
+  hasConsumerTriageReport: boolean;
+  requireAdapterReport: boolean;
+}): void => {
+  if (!params.hasAdapterReport && params.requireAdapterReport) {
+    params.lines.push(
+      '- Generate Adapter report: `npm run validation:adapter-real-session-report -- --status-report .audit-reports/adapter/adapter-session-status.md --out .audit-reports/adapter/adapter-real-session-report.md`'
+    );
+  }
+  if (!params.hasConsumerTriageReport) {
+    params.lines.push(
+      '- Generate consumer triage report: `npm run validation:consumer-startup-triage -- --repo <owner>/<repo> --out-dir .audit-reports/consumer-triage --skip-workflow-lint`'
+    );
+  }
+  if (hasAdapterRuntimeBlocker(params.summary)) {
+    params.lines.push(
+      '- Execute `docs/validation/adapter-hook-runtime-validation.md` in a real Adapter session and regenerate reports.'
+    );
+  }
+  if (hasConsumerTriageBlocker(params.summary)) {
+    params.lines.push(
+      '- Resolve failed consumer triage steps and rerun `validation:consumer-startup-triage` to refresh status.'
+    );
+  }
+  if (!params.hasAdapterReport && !params.requireAdapterReport) {
+    params.lines.push(
+      '- Optional: attach Adapter adapter diagnostics when validating IDE-specific integrations.'
+    );
+  }
+  params.lines.push('');
+};

package/scripts/phase5-blockers-markdown-next-actions-lib.ts

@@ -0,0 +1,29 @@
+import type { Phase5BlockersSummary } from './phase5-blockers-contract';
+import { appendPhase5BlockersBlockedNextActions } from './phase5-blockers-markdown-next-actions-blocked-lib';
+import { appendPhase5BlockersReadyNextActions } from './phase5-blockers-markdown-next-actions-ready-lib';
+
+export const appendPhase5BlockersNextActionsSection = (params: {
+  lines: string[];
+  summary: Phase5BlockersSummary;
+  hasAdapterReport: boolean;
+  hasConsumerTriageReport: boolean;
+  requireAdapterReport: boolean;
+}): void => {
+  params.lines.push('## Next Actions');
+  params.lines.push('');
+  if (params.summary.verdict === 'READY') {
+    appendPhase5BlockersReadyNextActions({
+      lines: params.lines,
+      hasAdapterReport: params.hasAdapterReport,
+    });
+    return;
+  }
+
+  appendPhase5BlockersBlockedNextActions({
+    lines: params.lines,
+    summary: params.summary,
+    hasAdapterReport: params.hasAdapterReport,
+    hasConsumerTriageReport: params.hasConsumerTriageReport,
+    requireAdapterReport: params.requireAdapterReport,
+  });
+};

package/scripts/phase5-blockers-markdown-next-actions-ready-lib.ts

@@ -0,0 +1,13 @@
+export const appendPhase5BlockersReadyNextActions = (params: {
+  lines: string[];
+  hasAdapterReport: boolean;
+}): void => {
+  params.lines.push('- Phase 5 blockers are clear for execution closure.');
+  params.lines.push('- Attach this report to release/rollout notes.');
+  if (!params.hasAdapterReport) {
+    params.lines.push(
+      '- Optional: generate Adapter report for adapter diagnostics traceability (`npm run validation:adapter-real-session-report -- --status-report .audit-reports/adapter/adapter-session-status.md --out .audit-reports/adapter/adapter-real-session-report.md`).'
+    );
+  }
+  params.lines.push('');
+};

package/scripts/phase5-blockers-markdown-sections-lib.ts

@@ -0,0 +1,7 @@
+export {
+  appendPhase5BlockersHeaderSection,
+  appendPhase5BlockersInputsSection,
+  appendPhase5BlockersListSection,
+  appendPhase5BlockersSignalsSection,
+} from './phase5-blockers-markdown-static-sections-lib';
+export { appendPhase5BlockersNextActionsSection } from './phase5-blockers-markdown-next-actions-lib';

package/scripts/phase5-blockers-markdown-static-sections-lib.ts

@@ -0,0 +1,26 @@
+import type { Phase5BlockersSummary } from './phase5-blockers-contract';
+import {
+  appendPhase5BlockersHeaderSection,
+  appendPhase5BlockersInputsSection,
+  appendPhase5BlockersSignalsSection,
+} from './phase5-blockers-markdown-header-inputs-signals-lib';
+import { appendPhase5BlockersListValues } from './phase5-blockers-markdown-list-utils-lib';
+
+export {
+  appendPhase5BlockersHeaderSection,
+  appendPhase5BlockersInputsSection,
+  appendPhase5BlockersSignalsSection,
+};
+
+export const appendPhase5BlockersListSection = (params: {
+  lines: string[];
+  summary: Phase5BlockersSummary;
+}): void => {
+  params.lines.push('## Blockers');
+  params.lines.push('');
+  appendPhase5BlockersListValues({
+    lines: params.lines,
+    values: params.summary.blockers,
+  });
+  params.lines.push('');
+};

package/scripts/phase5-blockers-missing-inputs-lib.ts

@@ -0,0 +1,16 @@
+export const collectPhase5BlockersMissingInputs = (params: {
+  hasAdapterReport: boolean;
+  hasConsumerTriageReport: boolean;
+  adapterRequired: boolean;
+}): string[] => {
+  const missingInputs: string[] = [];
+
+  if (params.adapterRequired && !params.hasAdapterReport) {
+    missingInputs.push('Missing Adapter real-session report');
+  }
+  if (!params.hasConsumerTriageReport) {
+    missingInputs.push('Missing consumer startup triage report');
+  }
+
+  return missingInputs;
+};

package/scripts/phase5-blockers-parser-adapter-lib.ts

@@ -0,0 +1,44 @@
+import type { ParsedAdapterRealSessionReport } from './phase5-blockers-contract';
+
+const parseAdapterValidationResult = (markdown: string): 'PASS' | 'FAIL' | undefined => {
+  const validationRaw = markdown
+    .match(/- Validation result:\s*([^\n]+)/)?.[1]
+    ?.trim()
+    .toUpperCase();
+
+  return validationRaw === 'PASS' || validationRaw === 'FAIL'
+    ? (validationRaw as 'PASS' | 'FAIL')
+    : undefined;
+};
+
+const parseAdapterRetestRequired = (markdown: string): boolean | undefined => {
+  const reTestRaw = markdown
+    .match(/- Re-test required:\s*([^\n]+)/)?.[1]
+    ?.trim()
+    .toUpperCase();
+
+  return reTestRaw === 'YES' ? true : reTestRaw === 'NO' ? false : undefined;
+};
+
+const parseNodeCommandNotFound = (markdown: string): boolean => {
+  const runtimeNodeRaw = markdown
+    .match(/- Any `bash: node: command not found`:\s*([^\n]+)/)?.[1]
+    ?.trim()
+    .toUpperCase();
+
+  return runtimeNodeRaw === 'YES'
+    ? true
+    : runtimeNodeRaw === 'NO'
+      ? false
+      : /node:\s*command not found/i.test(markdown);
+};
+
+export const parseAdapterRealSessionReport = (
+  markdown: string
+): ParsedAdapterRealSessionReport => {
+  return {
+    validationResult: parseAdapterValidationResult(markdown),
+    reTestRequired: parseAdapterRetestRequired(markdown),
+    nodeCommandNotFound: parseNodeCommandNotFound(markdown),
+  };
+};

package/scripts/phase5-blockers-parser-consumer-lib.ts

@@ -0,0 +1,32 @@
+import type { ParsedConsumerStartupTriageReport } from './phase5-blockers-contract';
+import { dedupePhase5BlockersValues } from './phase5-blockers-contract';
+
+const parseConsumerTriageVerdict = (
+  markdown: string
+): ParsedConsumerStartupTriageReport['verdict'] => {
+  const verdictRaw = markdown
+    .match(/- verdict:\s*([^\n]+)/)?.[1]
+    ?.trim()
+    .toUpperCase();
+
+  return verdictRaw === 'READY' || verdictRaw === 'BLOCKED'
+    ? (verdictRaw as 'READY' | 'BLOCKED')
+    : undefined;
+};
+
+const parseConsumerTriageFailedSteps = (markdown: string): ReadonlyArray<string> => {
+  return dedupePhase5BlockersValues(
+    (markdown.match(/Resolve failed required step `([^`]+)`/g) ?? [])
+      .map((line) => line.match(/`([^`]+)`/)?.[1]?.trim())
+      .filter((value): value is string => Boolean(value))
+  );
+};
+
+export const parseConsumerStartupTriageReport = (
+  markdown: string
+): ParsedConsumerStartupTriageReport => {
+  return {
+    verdict: parseConsumerTriageVerdict(markdown),
+    requiredFailedSteps: parseConsumerTriageFailedSteps(markdown),
+  };
+};

package/scripts/phase5-blockers-parser-lib.ts

@@ -0,0 +1,2 @@
+export { parseAdapterRealSessionReport } from './phase5-blockers-parser-adapter-lib';
+export { parseConsumerStartupTriageReport } from './phase5-blockers-parser-consumer-lib';

package/scripts/phase5-blockers-readiness-arg-flags-lib.ts

@@ -0,0 +1,13 @@
+import type { Phase5BlockersReadinessCliOptions } from './phase5-blockers-readiness-cli-contract';
+
+export type Phase5BlockersReadinessFlagArg = '--require-adapter-report';
+
+export const isPhase5BlockersReadinessFlagArg = (
+  arg: string
+): arg is Phase5BlockersReadinessFlagArg => arg === '--require-adapter-report';
+
+export const applyPhase5BlockersReadinessFlagArg = (params: {
+  options: Phase5BlockersReadinessCliOptions;
+}): void => {
+  params.options.requireAdapterReport = true;
+};

package/scripts/phase5-blockers-readiness-arg-values-lib.ts

@@ -0,0 +1,27 @@
+import type { Phase5BlockersReadinessCliOptions } from './phase5-blockers-readiness-cli-contract';
+
+export type Phase5BlockersReadinessValueArg =
+  '--adapter-report'
+  | '--consumer-triage-report'
+  | '--out';
+
+export const isPhase5BlockersReadinessValueArg = (
+  arg: string
+): arg is Phase5BlockersReadinessValueArg =>
+  arg === '--adapter-report' || arg === '--consumer-triage-report' || arg === '--out';
+
+export const applyPhase5BlockersReadinessValueArg = (params: {
+  options: Phase5BlockersReadinessCliOptions;
+  arg: Phase5BlockersReadinessValueArg;
+  value: string;
+}): void => {
+  if (params.arg === '--adapter-report') {
+    params.options.adapterReportFile = params.value;
+    return;
+  }
+  if (params.arg === '--consumer-triage-report') {
+    params.options.consumerTriageReportFile = params.value;
+    return;
+  }
+  params.options.outFile = params.value;
+};

package/scripts/phase5-blockers-readiness-cli-contract.ts

@@ -0,0 +1,6 @@
+export type Phase5BlockersReadinessCliOptions = {
+  adapterReportFile: string;
+  consumerTriageReportFile: string;
+  outFile: string;
+  requireAdapterReport: boolean;
+};

package/scripts/phase5-blockers-readiness-cli-lib.ts

@@ -0,0 +1,55 @@
+import {
+  applyPhase5BlockersReadinessFlagArg,
+  isPhase5BlockersReadinessFlagArg,
+} from './phase5-blockers-readiness-arg-flags-lib';
+import {
+  applyPhase5BlockersReadinessValueArg,
+  isPhase5BlockersReadinessValueArg,
+} from './phase5-blockers-readiness-arg-values-lib';
+export { readPhase5BlockersReadinessInput } from './phase5-blockers-readiness-input-lib';
+import type { Phase5BlockersReadinessCliOptions } from './phase5-blockers-readiness-cli-contract';
+
+export const DEFAULT_ADAPTER_REPORT_FILE = '.audit-reports/adapter/adapter-real-session-report.md';
+export const DEFAULT_CONSUMER_TRIAGE_FILE =
+  '.audit-reports/consumer-triage/consumer-startup-triage-report.md';
+export const DEFAULT_PHASE5_BLOCKERS_READINESS_OUT_FILE =
+  '.audit-reports/phase5/phase5-blockers-readiness.md';
+
+export const parsePhase5BlockersReadinessArgs = (
+  args: ReadonlyArray<string>
+): Phase5BlockersReadinessCliOptions => {
+  const options: Phase5BlockersReadinessCliOptions = {
+    adapterReportFile: DEFAULT_ADAPTER_REPORT_FILE,
+    consumerTriageReportFile: DEFAULT_CONSUMER_TRIAGE_FILE,
+    outFile: DEFAULT_PHASE5_BLOCKERS_READINESS_OUT_FILE,
+    requireAdapterReport: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (isPhase5BlockersReadinessValueArg(arg)) {
+      const value = args[index + 1];
+      if (!value) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      applyPhase5BlockersReadinessValueArg({
+        options,
+        arg,
+        value,
+      });
+      index += 1;
+      continue;
+    }
+
+    if (isPhase5BlockersReadinessFlagArg(arg)) {
+      applyPhase5BlockersReadinessFlagArg({
+        options,
+      });
+      continue;
+    }
+
+    throw new Error(`Unknown argument: ${arg}`);
+  }
+
+  return options;
+};

package/scripts/phase5-blockers-readiness-input-lib.ts

@@ -0,0 +1,17 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+export const readPhase5BlockersReadinessInput = (
+  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-blockers-readiness-lib.ts

@@ -0,0 +1,8 @@
+export type {
+  ParsedAdapterRealSessionReport,
+  ParsedConsumerStartupTriageReport,
+  Phase5BlockersSummary,
+} from './phase5-blockers-contract';
+export { parseAdapterRealSessionReport, parseConsumerStartupTriageReport } from './phase5-blockers-parser-lib';
+export { summarizePhase5Blockers } from './phase5-blockers-summary-lib';
+export { buildPhase5BlockersReadinessMarkdown } from './phase5-blockers-markdown-lib';

package/scripts/phase5-blockers-summary-lib.ts

@@ -0,0 +1,48 @@
+import type {
+  ParsedAdapterRealSessionReport,
+  ParsedConsumerStartupTriageReport,
+  Phase5BlockersSummary,
+} from './phase5-blockers-contract';
+import { collectPhase5DetectedBlockers } from './phase5-blockers-detected-blockers-lib';
+import { collectPhase5BlockersMissingInputs } from './phase5-blockers-missing-inputs-lib';
+
+export const summarizePhase5Blockers = (params: {
+  hasAdapterReport: boolean;
+  hasConsumerTriageReport: boolean;
+  adapter?: ParsedAdapterRealSessionReport;
+  consumer?: ParsedConsumerStartupTriageReport;
+  requireAdapterReport?: boolean;
+}): Phase5BlockersSummary => {
+  const adapterRequired = params.requireAdapterReport ?? false;
+  const missingInputs = collectPhase5BlockersMissingInputs({
+    hasAdapterReport: params.hasAdapterReport,
+    hasConsumerTriageReport: params.hasConsumerTriageReport,
+    adapterRequired,
+  });
+
+  if (missingInputs.length > 0) {
+    return {
+      verdict: 'MISSING_INPUTS',
+      blockers: missingInputs,
+      adapterValidationResult: params.adapter?.validationResult,
+      consumerTriageVerdict: params.consumer?.verdict,
+      adapterRequired,
+      missingInputs,
+    };
+  }
+
+  const blockers = collectPhase5DetectedBlockers({
+    hasAdapterReport: params.hasAdapterReport,
+    adapter: params.adapter,
+    consumer: params.consumer,
+  });
+
+  return {
+    verdict: blockers.length === 0 ? 'READY' : 'BLOCKED',
+    blockers,
+    adapterValidationResult: params.adapter?.validationResult,
+    consumerTriageVerdict: params.consumer?.verdict,
+    adapterRequired,
+    missingInputs,
+  };
+};

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

@@ -0,0 +1,32 @@
+import type {
+  Phase5ExecutionClosureCommand,
+  Phase5ExecutionClosureOptions,
+} from './phase5-execution-closure-plan-contract';
+import { buildAdapterCommands } from './phase5-execution-closure-plan-adapter-lib';
+import {
+  buildAuthPreflightCommand,
+  buildMockConsumerAbCommand,
+  buildTriageCommand,
+} from './phase5-execution-closure-plan-consumer-lib';
+import {
+  buildBlockersCommand,
+  buildClosureStatusCommand,
+} from './phase5-execution-closure-plan-phase5-lib';
+import { validatePhase5ExecutionClosureOptions } from './phase5-execution-closure-plan-validation-lib';
+import { resolvePhase5ExecutionClosureOutputs } from './phase5-execution-closure-outputs-lib';
+
+export const buildPhase5ExecutionClosureCommands = (
+  options: Phase5ExecutionClosureOptions
+): Phase5ExecutionClosureCommand[] => {
+  validatePhase5ExecutionClosureOptions(options);
+  const outputs = resolvePhase5ExecutionClosureOutputs(options.outDir);
+
+  return [
+    ...buildAdapterCommands(options, outputs),
+    ...buildAuthPreflightCommand(options, outputs),
+    ...buildMockConsumerAbCommand(options, outputs),
+    buildTriageCommand(options, outputs),
+    buildBlockersCommand(options, outputs),
+    buildClosureStatusCommand(options, outputs),
+  ];
+};

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

@@ -0,0 +1,2 @@
+export * from './phase5-execution-closure-plan-lib';
+export * from './phase5-execution-closure-report-lib';

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

@@ -0,0 +1,25 @@
+import type { Phase5ExecutionClosureOutputs } from './phase5-execution-closure-plan-contract';
+
+const joinPath = (base: string, leaf: string): string => {
+  return `${base.replace(/\/$/, '')}/${leaf}`;
+};
+
+export const resolvePhase5ExecutionClosureOutputs = (
+  outDir: string
+): Phase5ExecutionClosureOutputs => {
+  return {
+    adapterSessionStatus: joinPath(outDir, 'adapter-session-status.md'),
+    adapterRealSessionReport: joinPath(outDir, 'adapter-real-session-report.md'),
+    adapterReadiness: joinPath(outDir, 'adapter-readiness.md'),
+    consumerCiAuthCheck: joinPath(outDir, 'consumer-ci-auth-check.md'),
+    mockConsumerAbReport: joinPath(outDir, 'mock-consumer-ab-report.md'),
+    consumerStartupTriageReport: joinPath(outDir, 'consumer-startup-triage-report.md'),
+    consumerStartupUnblockStatus: joinPath(outDir, 'consumer-startup-unblock-status.md'),
+    phase5BlockersReadiness: joinPath(outDir, 'phase5-blockers-readiness.md'),
+    phase5ExecutionClosureStatus: joinPath(
+      outDir,
+      'phase5-execution-closure-status.md'
+    ),
+    closureRunReport: joinPath(outDir, 'phase5-execution-closure-run-report.md'),
+  };
+};