pumuki 6.3.7

package/scripts/framework-menu-prompts-consumer-unblock-status-lib.ts

@@ -0,0 +1,33 @@
+import type { Questioner } from './framework-menu-prompt-types';
+import type { ConsumerStartupUnblockStatusPromptResult } from './framework-menu-prompts-consumer-contract';
+
+export const askConsumerStartupUnblockStatusPrompt = async (
+  rl: Questioner
+): Promise<ConsumerStartupUnblockStatusPromptResult> => {
+  const repoPrompt = await rl.question('consumer repo (owner/repo) [owner/repo]: ');
+  const supportBundlePrompt = await rl.question(
+    'support bundle path [.audit-reports/consumer-triage/consumer-startup-failure-support-bundle.md]: '
+  );
+  const authReportPrompt = await rl.question(
+    'auth report path [.audit-reports/consumer-triage/consumer-ci-auth-check.md]: '
+  );
+  const workflowLintPrompt = await rl.question(
+    'workflow lint report path [.audit-reports/consumer-triage/consumer-workflow-lint-report.md]: '
+  );
+  const outPrompt = await rl.question(
+    'output path [.audit-reports/consumer-triage/consumer-startup-unblock-status.md]: '
+  );
+
+  return {
+    repo: repoPrompt.trim() || 'owner/repo',
+    supportBundleFile:
+      supportBundlePrompt.trim() ||
+      '.audit-reports/consumer-triage/consumer-startup-failure-support-bundle.md',
+    authReportFile:
+      authReportPrompt.trim() || '.audit-reports/consumer-triage/consumer-ci-auth-check.md',
+    workflowLintReportFile:
+      workflowLintPrompt.trim() ||
+      '.audit-reports/consumer-triage/consumer-workflow-lint-report.md',
+    outFile: outPrompt.trim() || '.audit-reports/consumer-triage/consumer-startup-unblock-status.md',
+  };
+};

package/scripts/framework-menu-prompts-consumer-workflow-lint-lib.ts

@@ -0,0 +1,27 @@
+import {
+  DEFAULT_ACTIONLINT_BIN,
+  DEFAULT_CONSUMER_REPO_PATH,
+} from './framework-menu-runners';
+import type { Questioner } from './framework-menu-prompt-types';
+import type { ConsumerWorkflowLintPromptResult } from './framework-menu-prompts-consumer-contract';
+
+export const askConsumerWorkflowLintPrompt = async (
+  rl: Questioner
+): Promise<ConsumerWorkflowLintPromptResult> => {
+  const repoPathPrompt = await rl.question(
+    `consumer repo path [${DEFAULT_CONSUMER_REPO_PATH}]: `
+  );
+  const actionlintBinPrompt = await rl.question(
+    `actionlint binary [${DEFAULT_ACTIONLINT_BIN}]: `
+  );
+  const outPrompt = await rl.question(
+    'output path [.audit-reports/consumer-triage/consumer-workflow-lint-report.md]: '
+  );
+
+  return {
+    repoPath: repoPathPrompt.trim() || DEFAULT_CONSUMER_REPO_PATH,
+    actionlintBin: actionlintBinPrompt.trim() || DEFAULT_ACTIONLINT_BIN,
+    outFile:
+      outPrompt.trim() || '.audit-reports/consumer-triage/consumer-workflow-lint-report.md',
+  };
+};

package/scripts/framework-menu-prompts-consumer.ts

@@ -0,0 +1,26 @@
+import type { Questioner } from './framework-menu-prompt-types';
+import {
+  askConsumerCiAuthCheckPrompt,
+  askConsumerCiScanPrompt,
+} from './framework-menu-prompts-consumer-ci-lib';
+import {
+  askConsumerStartupTriagePrompt,
+} from './framework-menu-prompts-consumer-startup-triage-lib';
+import { askConsumerWorkflowLintPrompt } from './framework-menu-prompts-consumer-workflow-lint-lib';
+import {
+  askConsumerSupportBundlePrompt,
+} from './framework-menu-prompts-consumer-support-bundle-lib';
+import { askConsumerSupportTicketDraftPrompt } from './framework-menu-prompts-consumer-support-ticket-lib';
+import { askConsumerStartupUnblockStatusPrompt } from './framework-menu-prompts-consumer-unblock-status-lib';
+
+export const createConsumerPrompts = (rl: Questioner) => {
+  return {
+    askConsumerCiScan: () => askConsumerCiScanPrompt(rl),
+    askConsumerWorkflowLint: () => askConsumerWorkflowLintPrompt(rl),
+    askConsumerCiAuthCheck: () => askConsumerCiAuthCheckPrompt(rl),
+    askConsumerSupportBundle: () => askConsumerSupportBundlePrompt(rl),
+    askConsumerSupportTicketDraft: () => askConsumerSupportTicketDraftPrompt(rl),
+    askConsumerStartupUnblockStatus: () => askConsumerStartupUnblockStatusPrompt(rl),
+    askConsumerStartupTriage: () => askConsumerStartupTriagePrompt(rl),
+  };
+};

package/scripts/framework-menu-prompts-phase5-blockers-lib.ts

@@ -0,0 +1,24 @@
+import type { Questioner } from './framework-menu-prompt-types';
+import type { Phase5BlockersReadinessPromptResult } from './framework-menu-prompts-phase5-contract';
+
+export const askPhase5BlockersReadinessPrompt = async (
+  rl: Questioner
+): Promise<Phase5BlockersReadinessPromptResult> => {
+  const adapterPrompt = await rl.question(
+    'adapter report path [.audit-reports/adapter/adapter-real-session-report.md]: '
+  );
+  const consumerPrompt = await rl.question(
+    'consumer triage report path [.audit-reports/consumer-triage/consumer-startup-triage-report.md]: '
+  );
+  const outPrompt = await rl.question(
+    'output path [.audit-reports/phase5/phase5-blockers-readiness.md]: '
+  );
+
+  return {
+    adapterReportFile:
+      adapterPrompt.trim() || '.audit-reports/adapter/adapter-real-session-report.md',
+    consumerTriageReportFile:
+      consumerPrompt.trim() || '.audit-reports/consumer-triage/consumer-startup-triage-report.md',
+    outFile: outPrompt.trim() || '.audit-reports/phase5/phase5-blockers-readiness.md',
+  };
+};

package/scripts/framework-menu-prompts-phase5-closure-lib.ts

@@ -0,0 +1,17 @@
+import type { Questioner } from './framework-menu-prompt-types';
+import type { Phase5ExecutionClosurePromptResult } from './framework-menu-prompts-phase5-contract';
+import { askLiveConsumerPhase5ExecutionClosurePrompt } from './framework-menu-prompts-phase5-closure-live-lib';
+import { askMockConsumerPhase5ExecutionClosurePrompt } from './framework-menu-prompts-phase5-closure-mock-lib';
+import { askPhase5ExecutionClosureBasePrompt } from './framework-menu-prompts-phase5-closure-shared-lib';
+
+export const askPhase5ExecutionClosurePrompt = async (
+  rl: Questioner
+): Promise<Phase5ExecutionClosurePromptResult> => {
+  const params = await askPhase5ExecutionClosureBasePrompt(rl);
+
+  if (params.useMockConsumerTriage) {
+    return askMockConsumerPhase5ExecutionClosurePrompt(rl, params);
+  }
+
+  return askLiveConsumerPhase5ExecutionClosurePrompt(rl, params);
+};

package/scripts/framework-menu-prompts-phase5-closure-live-lib.ts

@@ -0,0 +1,51 @@
+import { DEFAULT_ACTIONLINT_BIN, DEFAULT_CONSUMER_REPO_PATH } from './framework-menu-runners';
+import { parsePositive, type Questioner } from './framework-menu-prompt-types';
+import type { Phase5ExecutionClosurePromptResult } from './framework-menu-prompts-phase5-contract';
+import type { Phase5ExecutionClosureBasePrompt } from './framework-menu-prompts-phase5-closure-shared-lib';
+
+export const askLiveConsumerPhase5ExecutionClosurePrompt = async (
+  rl: Questioner,
+  params: Phase5ExecutionClosureBasePrompt
+): Promise<Phase5ExecutionClosurePromptResult> => {
+  const workflowLintPrompt = await rl.question('include workflow lint? [yes]: ');
+  const authPreflightPrompt = await rl.question(
+    'run auth preflight and fail-fast on auth block? [yes]: '
+  );
+  const includeAdapterPrompt = await rl.question('include adapter diagnostics? [yes]: ');
+  const requireAdapterPrompt = await rl.question('require adapter readiness verdict READY? [no]: ');
+
+  const runWorkflowLint = !workflowLintPrompt.trim() ? true : parsePositive(workflowLintPrompt);
+  const includeAuthPreflight = !authPreflightPrompt.trim()
+    ? true
+    : parsePositive(authPreflightPrompt);
+  const includeAdapter = !includeAdapterPrompt.trim() ? true : parsePositive(includeAdapterPrompt);
+  const requireAdapterReadiness = includeAdapter && parsePositive(requireAdapterPrompt);
+
+  let repoPath: string | undefined;
+  let actionlintBin: string | undefined;
+
+  if (runWorkflowLint) {
+    const repoPathPrompt = await rl.question(
+      `consumer repo path [${DEFAULT_CONSUMER_REPO_PATH}]: `
+    );
+    const actionlintBinPrompt = await rl.question(
+      `actionlint binary [${DEFAULT_ACTIONLINT_BIN}]: `
+    );
+
+    repoPath = repoPathPrompt.trim() || DEFAULT_CONSUMER_REPO_PATH;
+    actionlintBin = actionlintBinPrompt.trim() || DEFAULT_ACTIONLINT_BIN;
+  }
+
+  return {
+    repo: params.repo,
+    limit: params.limit,
+    outDir: params.outDir,
+    runWorkflowLint,
+    includeAuthPreflight,
+    repoPath,
+    actionlintBin,
+    includeAdapter,
+    requireAdapterReadiness,
+    useMockConsumerTriage: false,
+  };
+};

package/scripts/framework-menu-prompts-phase5-closure-mock-lib.ts

@@ -0,0 +1,23 @@
+import { parsePositive, type Questioner } from './framework-menu-prompt-types';
+import type { Phase5ExecutionClosurePromptResult } from './framework-menu-prompts-phase5-contract';
+import type { Phase5ExecutionClosureBasePrompt } from './framework-menu-prompts-phase5-closure-shared-lib';
+
+export const askMockConsumerPhase5ExecutionClosurePrompt = async (
+  rl: Questioner,
+  params: Phase5ExecutionClosureBasePrompt
+): Promise<Phase5ExecutionClosurePromptResult> => {
+  const includeAdapterPrompt = await rl.question('include adapter diagnostics? [no]: ');
+  const includeAdapter = parsePositive(includeAdapterPrompt);
+  const requireAdapterPrompt = await rl.question('require adapter readiness verdict READY? [no]: ');
+
+  return {
+    repo: params.repo,
+    limit: params.limit,
+    outDir: params.outDir,
+    runWorkflowLint: false,
+    includeAuthPreflight: false,
+    includeAdapter,
+    requireAdapterReadiness: includeAdapter && parsePositive(requireAdapterPrompt),
+    useMockConsumerTriage: true,
+  };
+};

package/scripts/framework-menu-prompts-phase5-closure-shared-lib.ts

@@ -0,0 +1,24 @@
+import { parseInteger, parsePositive, type Questioner } from './framework-menu-prompt-types';
+
+export type Phase5ExecutionClosureBasePrompt = {
+  repo: string;
+  limit: number;
+  outDir: string;
+  useMockConsumerTriage: boolean;
+};
+
+export const askPhase5ExecutionClosureBasePrompt = async (
+  rl: Questioner
+): Promise<Phase5ExecutionClosureBasePrompt> => {
+  const repoPrompt = await rl.question('consumer repo (owner/repo) [owner/repo]: ');
+  const limitPrompt = await rl.question('runs to inspect [20]: ');
+  const outDirPrompt = await rl.question('output directory [.audit-reports/phase5]: ');
+  const mockConsumerPrompt = await rl.question('use local mock-consumer package-smoke mode? [no]: ');
+
+  return {
+    repo: repoPrompt.trim() || 'owner/repo',
+    limit: parseInteger(limitPrompt, 20),
+    outDir: outDirPrompt.trim() || '.audit-reports/phase5',
+    useMockConsumerTriage: parsePositive(mockConsumerPrompt),
+  };
+};

package/scripts/framework-menu-prompts-phase5-contract.ts

@@ -0,0 +1,48 @@
+export type Phase5BlockersReadinessPromptResult = {
+  adapterReportFile: string;
+  consumerTriageReportFile: string;
+  outFile: string;
+};
+
+export type MockConsumerAbReportPromptResult = {
+  repo: string;
+  outFile: string;
+  blockSummaryFile: string;
+  minimalSummaryFile: string;
+  blockEvidenceFile: string;
+  minimalEvidenceFile: string;
+};
+
+export type Phase5ExecutionClosureStatusPromptResult = {
+  phase5BlockersReportFile: string;
+  consumerUnblockReportFile: string;
+  adapterReadinessReportFile: string;
+  outFile: string;
+  requireAdapterReadiness: boolean;
+};
+
+export type Phase5ExternalHandoffPromptResult = {
+  repo: string;
+  phase5StatusReportFile: string;
+  phase5BlockersReportFile: string;
+  consumerUnblockReportFile: string;
+  mockAbReportFile: string;
+  runReportFile: string;
+  outFile: string;
+  artifactUrls: string[];
+  requireArtifactUrls: boolean;
+  requireMockAbReport: boolean;
+};
+
+export type Phase5ExecutionClosurePromptResult = {
+  repo: string;
+  limit: number;
+  outDir: string;
+  runWorkflowLint: boolean;
+  includeAuthPreflight: boolean;
+  repoPath?: string;
+  actionlintBin?: string;
+  includeAdapter: boolean;
+  requireAdapterReadiness: boolean;
+  useMockConsumerTriage: boolean;
+};

package/scripts/framework-menu-prompts-phase5-handoff-lib.ts

@@ -0,0 +1,54 @@
+import { parsePositive, type Questioner } from './framework-menu-prompt-types';
+import type { Phase5ExternalHandoffPromptResult } from './framework-menu-prompts-phase5-contract';
+
+const parseArtifactUrlsPrompt = (artifactUrlsPrompt: string): string[] => {
+  return artifactUrlsPrompt
+    .split(',')
+    .map((value) => value.trim())
+    .filter((value) => value.length > 0);
+};
+
+export const askPhase5ExternalHandoffPrompt = async (
+  rl: Questioner
+): Promise<Phase5ExternalHandoffPromptResult> => {
+  const repoPrompt = await rl.question('consumer repo (owner/repo) [owner/repo]: ');
+  const statusPrompt = await rl.question(
+    'phase5 status report path [.audit-reports/phase5/phase5-execution-closure-status.md]: '
+  );
+  const blockersPrompt = await rl.question(
+    'phase5 blockers report path [.audit-reports/phase5/phase5-blockers-readiness.md]: '
+  );
+  const consumerPrompt = await rl.question(
+    'consumer unblock report path [.audit-reports/phase5/consumer-startup-unblock-status.md]: '
+  );
+  const mockAbPrompt = await rl.question(
+    'mock A/B report path [.audit-reports/phase5/mock-consumer-ab-report.md]: '
+  );
+  const runReportPrompt = await rl.question(
+    'phase5 run report path [.audit-reports/phase5/phase5-execution-closure-run-report.md]: '
+  );
+  const outPrompt = await rl.question(
+    'output path [.audit-reports/phase5/phase5-external-handoff.md]: '
+  );
+  const artifactUrlsPrompt = await rl.question('artifact URLs (comma-separated) [none]: ');
+  const requireArtifactPrompt = await rl.question('require artifact URLs? [no]: ');
+  const requireMockAbPrompt = await rl.question('require mock A/B report READY? [no]: ');
+
+  return {
+    repo: repoPrompt.trim() || 'owner/repo',
+    phase5StatusReportFile:
+      statusPrompt.trim() || '.audit-reports/phase5/phase5-execution-closure-status.md',
+    phase5BlockersReportFile:
+      blockersPrompt.trim() || '.audit-reports/phase5/phase5-blockers-readiness.md',
+    consumerUnblockReportFile:
+      consumerPrompt.trim() || '.audit-reports/phase5/consumer-startup-unblock-status.md',
+    mockAbReportFile:
+      mockAbPrompt.trim() || '.audit-reports/phase5/mock-consumer-ab-report.md',
+    runReportFile:
+      runReportPrompt.trim() || '.audit-reports/phase5/phase5-execution-closure-run-report.md',
+    outFile: outPrompt.trim() || '.audit-reports/phase5/phase5-external-handoff.md',
+    artifactUrls: parseArtifactUrlsPrompt(artifactUrlsPrompt),
+    requireArtifactUrls: parsePositive(requireArtifactPrompt),
+    requireMockAbReport: parsePositive(requireMockAbPrompt),
+  };
+};

package/scripts/framework-menu-prompts-phase5-mock-ab-lib.ts

@@ -0,0 +1,36 @@
+import type { Questioner } from './framework-menu-prompt-types';
+import type { MockConsumerAbReportPromptResult } from './framework-menu-prompts-phase5-contract';
+
+export const askMockConsumerAbReportPrompt = async (
+  rl: Questioner
+): Promise<MockConsumerAbReportPromptResult> => {
+  const repoPrompt = await rl.question('consumer repo (owner/repo) [owner/repo]: ');
+  const outPrompt = await rl.question(
+    'output path [.audit-reports/mock-consumer/mock-consumer-ab-report.md]: '
+  );
+  const blockPrompt = await rl.question(
+    'block summary path [.audit-reports/package-smoke/block/summary.md]: '
+  );
+  const minimalPrompt = await rl.question(
+    'minimal summary path [.audit-reports/package-smoke/minimal/summary.md]: '
+  );
+  const blockEvidencePrompt = await rl.question(
+    'block CI evidence path [.audit-reports/package-smoke/block/ci.ai_evidence.json]: '
+  );
+  const minimalEvidencePrompt = await rl.question(
+    'minimal CI evidence path [.audit-reports/package-smoke/minimal/ci.ai_evidence.json]: '
+  );
+
+  return {
+    repo: repoPrompt.trim() || 'owner/repo',
+    outFile: outPrompt.trim() || '.audit-reports/mock-consumer/mock-consumer-ab-report.md',
+    blockSummaryFile: blockPrompt.trim() || '.audit-reports/package-smoke/block/summary.md',
+    minimalSummaryFile:
+      minimalPrompt.trim() || '.audit-reports/package-smoke/minimal/summary.md',
+    blockEvidenceFile:
+      blockEvidencePrompt.trim() || '.audit-reports/package-smoke/block/ci.ai_evidence.json',
+    minimalEvidenceFile:
+      minimalEvidencePrompt.trim() ||
+      '.audit-reports/package-smoke/minimal/ci.ai_evidence.json',
+  };
+};

package/scripts/framework-menu-prompts-phase5-status-lib.ts

@@ -0,0 +1,31 @@
+import { parsePositive, type Questioner } from './framework-menu-prompt-types';
+import type { Phase5ExecutionClosureStatusPromptResult } from './framework-menu-prompts-phase5-contract';
+
+export const askPhase5ExecutionClosureStatusPrompt = async (
+  rl: Questioner
+): Promise<Phase5ExecutionClosureStatusPromptResult> => {
+  const blockersPrompt = await rl.question(
+    'phase5 blockers report path [.audit-reports/phase5/phase5-blockers-readiness.md]: '
+  );
+  const consumerPrompt = await rl.question(
+    'consumer unblock report path [.audit-reports/consumer-triage/consumer-startup-unblock-status.md]: '
+  );
+  const adapterPrompt = await rl.question(
+    'adapter readiness report path [.audit-reports/adapter/adapter-readiness.md]: '
+  );
+  const requireAdapterPrompt = await rl.question('require adapter readiness verdict READY? [no]: ');
+  const outPrompt = await rl.question(
+    'output path [.audit-reports/phase5/phase5-execution-closure-status.md]: '
+  );
+
+  return {
+    phase5BlockersReportFile:
+      blockersPrompt.trim() || '.audit-reports/phase5/phase5-blockers-readiness.md',
+    consumerUnblockReportFile:
+      consumerPrompt.trim() || '.audit-reports/consumer-triage/consumer-startup-unblock-status.md',
+    adapterReadinessReportFile:
+      adapterPrompt.trim() || '.audit-reports/adapter/adapter-readiness.md',
+    outFile: outPrompt.trim() || '.audit-reports/phase5/phase5-execution-closure-status.md',
+    requireAdapterReadiness: parsePositive(requireAdapterPrompt),
+  };
+};

package/scripts/framework-menu-prompts-phase5.ts

@@ -0,0 +1,16 @@
+import type { Questioner } from './framework-menu-prompt-types';
+import { askMockConsumerAbReportPrompt } from './framework-menu-prompts-phase5-mock-ab-lib';
+import { askPhase5BlockersReadinessPrompt } from './framework-menu-prompts-phase5-blockers-lib';
+import { askPhase5ExecutionClosureStatusPrompt } from './framework-menu-prompts-phase5-status-lib';
+import { askPhase5ExternalHandoffPrompt } from './framework-menu-prompts-phase5-handoff-lib';
+import { askPhase5ExecutionClosurePrompt } from './framework-menu-prompts-phase5-closure-lib';
+
+export const createPhase5Prompts = (rl: Questioner) => {
+  return {
+    askPhase5BlockersReadiness: () => askPhase5BlockersReadinessPrompt(rl),
+    askMockConsumerAbReport: () => askMockConsumerAbReportPrompt(rl),
+    askPhase5ExecutionClosureStatus: () => askPhase5ExecutionClosureStatusPrompt(rl),
+    askPhase5ExternalHandoff: () => askPhase5ExternalHandoffPrompt(rl),
+    askPhase5ExecutionClosure: () => askPhase5ExecutionClosurePrompt(rl),
+  };
+};

package/scripts/framework-menu-prompts.ts

@@ -0,0 +1,32 @@
+import { createAdapterPrompts } from './framework-menu-prompts-adapter';
+import { createConsumerPrompts } from './framework-menu-prompts-consumer';
+import { createPhase5Prompts } from './framework-menu-prompts-phase5';
+import { parsePositive, type Questioner } from './framework-menu-prompt-types';
+
+export const createFrameworkMenuPrompts = (rl: Questioner) => {
+  const askRange = async (fromDefault: string = 'HEAD~1'): Promise<{ fromRef: string; toRef: string }> => {
+    const fromPrompt = await rl.question(`fromRef [${fromDefault}]: `);
+    const toPrompt = await rl.question('toRef [HEAD]: ');
+
+    return {
+      fromRef: fromPrompt.trim() || fromDefault,
+      toRef: toPrompt.trim() || 'HEAD',
+    };
+  };
+
+  const askValidationArtifactsCleanup = async (): Promise<{ dryRun: boolean }> => {
+    const dryRunPrompt = await rl.question('dry-run only? [yes]: ');
+
+    return {
+      dryRun: !dryRunPrompt.trim() ? true : parsePositive(dryRunPrompt),
+    };
+  };
+
+  return {
+    askRange,
+    ...createAdapterPrompts(rl),
+    ...createConsumerPrompts(rl),
+    ...createPhase5Prompts(rl),
+    askValidationArtifactsCleanup,
+  };
+};

package/scripts/framework-menu-runner-common.ts

@@ -0,0 +1,13 @@
+export {
+  DEFAULT_ACTIONLINT_BIN,
+  DEFAULT_CONSUMER_REPO_PATH,
+} from './framework-menu-runner-constants';
+export { resolveDefaultRangeFrom } from './framework-menu-runner-git-lib';
+export {
+  getExitCode,
+  runAndPrintExitCode,
+  runNpm,
+  runNpx,
+} from './framework-menu-runner-process-lib';
+export { resolveScriptOrReportMissing } from './framework-menu-runner-path-lib';
+export { printEvidence } from './framework-menu-runner-evidence-lib';

package/scripts/framework-menu-runner-constants.ts

@@ -0,0 +1,3 @@
+export const DEFAULT_ACTIONLINT_BIN = '/tmp/actionlint-bin/actionlint';
+export const DEFAULT_CONSUMER_REPO_PATH =
+  process.env.PUMUKI_CONSUMER_REPO_PATH?.trim() || '/path/to/consumer-repo';

package/scripts/framework-menu-runner-evidence-lib.ts

@@ -0,0 +1,14 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+export const printEvidence = (): void => {
+  const evidencePath = resolve(process.cwd(), '.ai_evidence.json');
+  if (!existsSync(evidencePath)) {
+    process.stdout.write('\n.ai_evidence.json not found in repository root.\n');
+    return;
+  }
+
+  process.stdout.write('\n');
+  process.stdout.write(readFileSync(evidencePath, 'utf8'));
+  process.stdout.write('\n');
+};

package/scripts/framework-menu-runner-git-lib.ts

@@ -0,0 +1,13 @@
+import { execFileSync } from 'node:child_process';
+
+const runGit = (args: ReadonlyArray<string>): string => {
+  return execFileSync('git', args, { encoding: 'utf8' }).trim();
+};
+
+export const resolveDefaultRangeFrom = (): string => {
+  try {
+    return runGit(['rev-parse', '@{u}']);
+  } catch {
+    return 'HEAD~1';
+  }
+};

package/scripts/framework-menu-runner-path-lib.ts

@@ -0,0 +1,12 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+export const resolveScriptOrReportMissing = (relativePath: string): string | undefined => {
+  const scriptPath = resolve(process.cwd(), relativePath);
+  if (existsSync(scriptPath)) {
+    return scriptPath;
+  }
+
+  process.stdout.write(`\nCould not find ${relativePath} in current repository.\n`);
+  return undefined;
+};

package/scripts/framework-menu-runner-process-lib.ts

@@ -0,0 +1,27 @@
+import { execFileSync } from 'node:child_process';
+
+export const runAndPrintExitCode = async (run: () => Promise<number>): Promise<void> => {
+  const code = await run();
+  process.stdout.write(`\nExit code: ${code}\n`);
+};
+
+export const runNpx = (args: string[]): void => {
+  execFileSync('npx', args, {
+    stdio: 'inherit',
+  });
+};
+
+export const runNpm = (args: string[]): void => {
+  execFileSync('npm', args, {
+    stdio: 'inherit',
+  });
+};
+
+export const getExitCode = (error: unknown): number => {
+  if (error && typeof error === 'object' && 'status' in error) {
+    const status = Number((error as { status?: number }).status ?? 1);
+    return Number.isFinite(status) ? status : 1;
+  }
+
+  return 1;
+};

package/scripts/framework-menu-runners-adapter-contract.ts

@@ -0,0 +1,13 @@
+export type AdapterSessionStatusRunnerParams = {
+  outFile: string;
+};
+
+export type AdapterRealSessionRunnerParams = {
+  statusReportFile: string;
+  outFile: string;
+};
+
+export type AdapterReadinessRunnerParams = {
+  adapterReportFile: string;
+  outFile: string;
+};

package/scripts/framework-menu-runners-adapter-readiness-lib.ts

@@ -0,0 +1,20 @@
+import { buildAdapterReadinessCommandArgs } from './framework-menu-builders';
+import type { AdapterReadinessRunnerParams } from './framework-menu-runners-adapter-contract';
+import { resolveScriptOrReportMissing, runNpx } from './framework-menu-runner-common';
+
+export const runAdapterReadiness = async (
+  params: AdapterReadinessRunnerParams
+): Promise<void> => {
+  const scriptPath = resolveScriptOrReportMissing('scripts/build-adapter-readiness.ts');
+  if (!scriptPath) {
+    return;
+  }
+
+  runNpx(
+    buildAdapterReadinessCommandArgs({
+      scriptPath,
+      adapterReportFile: params.adapterReportFile,
+      outFile: params.outFile,
+    })
+  );
+};

package/scripts/framework-menu-runners-adapter-real-session-lib.ts

@@ -0,0 +1,20 @@
+import { buildAdapterRealSessionReportCommandArgs } from './framework-menu-builders';
+import type { AdapterRealSessionRunnerParams } from './framework-menu-runners-adapter-contract';
+import { resolveScriptOrReportMissing, runNpx } from './framework-menu-runner-common';
+
+export const runAdapterRealSessionReport = async (
+  params: AdapterRealSessionRunnerParams
+): Promise<void> => {
+  const scriptPath = resolveScriptOrReportMissing('scripts/build-adapter-real-session-report.ts');
+  if (!scriptPath) {
+    return;
+  }
+
+  runNpx(
+    buildAdapterRealSessionReportCommandArgs({
+      scriptPath,
+      statusReportFile: params.statusReportFile,
+      outFile: params.outFile,
+    })
+  );
+};

package/scripts/framework-menu-runners-adapter-session-lib.ts

@@ -0,0 +1,19 @@
+import type { AdapterSessionStatusRunnerParams } from './framework-menu-runners-adapter-contract';
+import { resolveScriptOrReportMissing, runNpx } from './framework-menu-runner-common';
+
+export const runAdapterSessionStatusReport = async (
+  params: AdapterSessionStatusRunnerParams
+): Promise<void> => {
+  const scriptPath = resolveScriptOrReportMissing('scripts/build-adapter-session-status.ts');
+  if (!scriptPath) {
+    return;
+  }
+
+  runNpx([
+    '--yes',
+    'tsx@4.21.0',
+    scriptPath,
+    '--out',
+    params.outFile,
+  ]);
+};

package/scripts/framework-menu-runners-adapter.ts

@@ -0,0 +1,9 @@
+export type {
+  AdapterReadinessRunnerParams,
+  AdapterRealSessionRunnerParams,
+  AdapterSessionStatusRunnerParams,
+} from './framework-menu-runners-adapter-contract';
+
+export { runAdapterSessionStatusReport } from './framework-menu-runners-adapter-session-lib';
+export { runAdapterRealSessionReport } from './framework-menu-runners-adapter-real-session-lib';
+export { runAdapterReadiness } from './framework-menu-runners-adapter-readiness-lib';

package/scripts/framework-menu-runners-consumer-artifacts-lib.ts

@@ -0,0 +1,11 @@
+import type { ConsumerCiArtifactsScanParams } from './framework-menu-runners-consumer-contract';
+import { runConsumerMenuScript } from './framework-menu-runners-consumer-exec-lib';
+
+export const runConsumerCiArtifactsScan = async (
+  params: ConsumerCiArtifactsScanParams
+): Promise<void> => {
+  runConsumerMenuScript({
+    relativeScriptPath: 'scripts/collect-consumer-ci-artifacts.ts',
+    args: ['--repo', params.repo, '--limit', String(params.limit), '--out', params.outFile],
+  });
+};