pumuki 6.3.7

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

@@ -0,0 +1,29 @@
+import { buildFrameworkMenuTsxCommandPrefix } from './framework-menu-builders-shared-lib';
+
+export const buildAdapterRealSessionReportCommandArgs = (params: {
+  scriptPath: string;
+  statusReportFile: string;
+  outFile: string;
+}): string[] => {
+  return [
+    ...buildFrameworkMenuTsxCommandPrefix(params.scriptPath),
+    '--status-report',
+    params.statusReportFile,
+    '--out',
+    params.outFile,
+  ];
+};
+
+export const buildAdapterReadinessCommandArgs = (params: {
+  scriptPath: string;
+  adapterReportFile: string;
+  outFile: string;
+}): string[] => {
+  return [
+    ...buildFrameworkMenuTsxCommandPrefix(params.scriptPath),
+    '--adapter-report',
+    params.adapterReportFile,
+    '--out',
+    params.outFile,
+  ];
+};

package/scripts/framework-menu-builders-consumer-contract.ts

@@ -0,0 +1,19 @@
+export type ConsumerStartupTriageCommandParams = {
+  scriptPath: string;
+  repo: string;
+  limit: number;
+  outDir: string;
+  runWorkflowLint: boolean;
+  repoPath?: string;
+  actionlintBin?: string;
+};
+
+export type MockConsumerAbReportCommandParams = {
+  scriptPath: string;
+  repo: string;
+  outFile: string;
+  blockSummaryFile: string;
+  minimalSummaryFile: string;
+  blockEvidenceFile: string;
+  minimalEvidenceFile: string;
+};

package/scripts/framework-menu-builders-consumer-mock-ab-lib.ts

@@ -0,0 +1,22 @@
+import type { MockConsumerAbReportCommandParams } from './framework-menu-builders-consumer-contract';
+import { buildFrameworkMenuTsxCommandPrefix } from './framework-menu-builders-shared-lib';
+
+export const buildMockConsumerAbReportCommandArgs = (
+  params: MockConsumerAbReportCommandParams
+): string[] => {
+  return [
+    ...buildFrameworkMenuTsxCommandPrefix(params.scriptPath),
+    '--repo',
+    params.repo,
+    '--out',
+    params.outFile,
+    '--block-summary',
+    params.blockSummaryFile,
+    '--minimal-summary',
+    params.minimalSummaryFile,
+    '--block-evidence',
+    params.blockEvidenceFile,
+    '--minimal-evidence',
+    params.minimalEvidenceFile,
+  ];
+};

package/scripts/framework-menu-builders-consumer-triage-lib.ts

@@ -0,0 +1,31 @@
+import type { ConsumerStartupTriageCommandParams } from './framework-menu-builders-consumer-contract';
+import { buildFrameworkMenuTsxCommandPrefix } from './framework-menu-builders-shared-lib';
+
+export const buildConsumerStartupTriageCommandArgs = (
+  params: ConsumerStartupTriageCommandParams
+): string[] => {
+  const args = [
+    ...buildFrameworkMenuTsxCommandPrefix(params.scriptPath),
+    '--repo',
+    params.repo,
+    '--limit',
+    String(params.limit),
+    '--out-dir',
+    params.outDir,
+  ];
+
+  if (!params.runWorkflowLint) {
+    args.push('--skip-workflow-lint');
+    return args;
+  }
+
+  if (params.repoPath) {
+    args.push('--repo-path', params.repoPath);
+  }
+
+  if (params.actionlintBin) {
+    args.push('--actionlint-bin', params.actionlintBin);
+  }
+
+  return args;
+};

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

@@ -0,0 +1,6 @@
+export type {
+  ConsumerStartupTriageCommandParams,
+  MockConsumerAbReportCommandParams,
+} from './framework-menu-builders-consumer-contract';
+export { buildConsumerStartupTriageCommandArgs } from './framework-menu-builders-consumer-triage-lib';
+export { buildMockConsumerAbReportCommandArgs } from './framework-menu-builders-consumer-mock-ab-lib';

package/scripts/framework-menu-builders-maintenance.ts

@@ -0,0 +1,24 @@
+import { buildFrameworkMenuTsxCommandPrefix } from './framework-menu-builders-shared-lib';
+
+export const buildValidationDocsHygieneCommandArgs = (params: {
+  scriptPath: string;
+}): string[] => {
+  return buildFrameworkMenuTsxCommandPrefix(params.scriptPath);
+};
+
+export const buildCleanValidationArtifactsCommandArgs = (params: {
+  scriptPath: string;
+  dryRun: boolean;
+}): string[] => {
+  const args = buildFrameworkMenuTsxCommandPrefix(params.scriptPath);
+
+  if (params.dryRun) {
+    args.push('--dry-run');
+  }
+
+  return args;
+};
+
+export const buildSkillsLockCheckCommandArgs = (): string[] => {
+  return ['run', 'skills:lock:check'];
+};

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

@@ -0,0 +1,16 @@
+import type { Phase5BlockersReadinessCommandParams } from './framework-menu-builders-phase5-contract';
+import { buildFrameworkMenuTsxCommandPrefix } from './framework-menu-builders-shared-lib';
+
+export const buildPhase5BlockersReadinessCommandArgs = (
+  params: Phase5BlockersReadinessCommandParams
+): string[] => {
+  return [
+    ...buildFrameworkMenuTsxCommandPrefix(params.scriptPath),
+    '--adapter-report',
+    params.adapterReportFile,
+    '--consumer-triage-report',
+    params.consumerTriageReportFile,
+    '--out',
+    params.outFile,
+  ];
+};

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

@@ -0,0 +1,46 @@
+import type { Phase5ExecutionClosureCommandParams } from './framework-menu-builders-phase5-contract';
+import { buildFrameworkMenuTsxCommandPrefix } from './framework-menu-builders-shared-lib';
+
+export const buildPhase5ExecutionClosureCommandArgs = (
+  params: Phase5ExecutionClosureCommandParams
+): string[] => {
+  const args = [
+    ...buildFrameworkMenuTsxCommandPrefix(params.scriptPath),
+    '--repo',
+    params.repo,
+    '--limit',
+    String(params.limit),
+    '--out-dir',
+    params.outDir,
+  ];
+
+  if (!params.runWorkflowLint) {
+    args.push('--skip-workflow-lint');
+  } else {
+    if (params.repoPath) {
+      args.push('--repo-path', params.repoPath);
+    }
+
+    if (params.actionlintBin) {
+      args.push('--actionlint-bin', params.actionlintBin);
+    }
+  }
+
+  if (!params.includeAuthPreflight) {
+    args.push('--skip-auth-preflight');
+  }
+
+  if (!params.includeAdapter) {
+    args.push('--skip-adapter');
+  }
+
+  if (params.requireAdapterReadiness) {
+    args.push('--require-adapter-readiness');
+  }
+
+  if (params.useMockConsumerTriage) {
+    args.push('--mock-consumer');
+  }
+
+  return args;
+};

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

@@ -0,0 +1,43 @@
+export type Phase5BlockersReadinessCommandParams = {
+  scriptPath: string;
+  adapterReportFile: string;
+  consumerTriageReportFile: string;
+  outFile: string;
+};
+
+export type Phase5ExecutionClosureStatusCommandParams = {
+  scriptPath: string;
+  phase5BlockersReportFile: string;
+  consumerUnblockReportFile: string;
+  adapterReadinessReportFile: string;
+  outFile: string;
+  requireAdapterReadiness: boolean;
+};
+
+export type Phase5ExternalHandoffCommandParams = {
+  scriptPath: string;
+  repo: string;
+  phase5StatusReportFile: string;
+  phase5BlockersReportFile: string;
+  consumerUnblockReportFile: string;
+  mockAbReportFile: string;
+  runReportFile: string;
+  outFile: string;
+  artifactUrls: ReadonlyArray<string>;
+  requireArtifactUrls: boolean;
+  requireMockAbReport: boolean;
+};
+
+export type Phase5ExecutionClosureCommandParams = {
+  scriptPath: string;
+  repo: string;
+  limit: number;
+  outDir: string;
+  runWorkflowLint: boolean;
+  includeAuthPreflight: boolean;
+  repoPath?: string;
+  actionlintBin?: string;
+  includeAdapter: boolean;
+  requireAdapterReadiness: boolean;
+  useMockConsumerTriage: boolean;
+};

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

@@ -0,0 +1,38 @@
+import type { Phase5ExternalHandoffCommandParams } from './framework-menu-builders-phase5-contract';
+import { buildFrameworkMenuTsxCommandPrefix } from './framework-menu-builders-shared-lib';
+
+export const buildPhase5ExternalHandoffCommandArgs = (
+  params: Phase5ExternalHandoffCommandParams
+): string[] => {
+  const args = [
+    ...buildFrameworkMenuTsxCommandPrefix(params.scriptPath),
+    '--repo',
+    params.repo,
+    '--phase5-status-report',
+    params.phase5StatusReportFile,
+    '--phase5-blockers-report',
+    params.phase5BlockersReportFile,
+    '--consumer-unblock-report',
+    params.consumerUnblockReportFile,
+    '--mock-ab-report',
+    params.mockAbReportFile,
+    '--run-report',
+    params.runReportFile,
+    '--out',
+    params.outFile,
+  ];
+
+  for (const url of params.artifactUrls) {
+    args.push('--artifact-url', url);
+  }
+
+  if (params.requireArtifactUrls) {
+    args.push('--require-artifact-urls');
+  }
+
+  if (params.requireMockAbReport) {
+    args.push('--require-mock-ab-report');
+  }
+
+  return args;
+};

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

@@ -0,0 +1,24 @@
+import type { Phase5ExecutionClosureStatusCommandParams } from './framework-menu-builders-phase5-contract';
+import { buildFrameworkMenuTsxCommandPrefix } from './framework-menu-builders-shared-lib';
+
+export const buildPhase5ExecutionClosureStatusCommandArgs = (
+  params: Phase5ExecutionClosureStatusCommandParams
+): string[] => {
+  const args = [
+    ...buildFrameworkMenuTsxCommandPrefix(params.scriptPath),
+    '--phase5-blockers-report',
+    params.phase5BlockersReportFile,
+    '--consumer-unblock-report',
+    params.consumerUnblockReportFile,
+    '--adapter-readiness-report',
+    params.adapterReadinessReportFile,
+    '--out',
+    params.outFile,
+  ];
+
+  if (params.requireAdapterReadiness) {
+    args.push('--require-adapter-readiness');
+  }
+
+  return args;
+};

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

@@ -0,0 +1,12 @@
+export type {
+  Phase5BlockersReadinessCommandParams,
+  Phase5ExecutionClosureCommandParams,
+  Phase5ExecutionClosureStatusCommandParams,
+  Phase5ExternalHandoffCommandParams,
+} from './framework-menu-builders-phase5-contract';
+
+export { buildPhase5BlockersReadinessCommandArgs } from './framework-menu-builders-phase5-blockers-lib';
+export { buildPhase5ExecutionClosureStatusCommandArgs } from './framework-menu-builders-phase5-status-lib';
+export { buildPhase5ExternalHandoffCommandArgs } from './framework-menu-builders-phase5-handoff-lib';
+
+export { buildPhase5ExecutionClosureCommandArgs } from './framework-menu-builders-phase5-closure-lib';

package/scripts/framework-menu-builders-shared-lib.ts

@@ -0,0 +1,3 @@
+export const buildFrameworkMenuTsxCommandPrefix = (scriptPath: string): string[] => {
+  return ['--yes', 'tsx@4.21.0', scriptPath];
+};

package/scripts/framework-menu-builders.ts

@@ -0,0 +1,19 @@
+export {
+  buildAdapterReadinessCommandArgs,
+  buildAdapterRealSessionReportCommandArgs,
+} from './framework-menu-builders-adapter';
+export {
+  buildConsumerStartupTriageCommandArgs,
+  buildMockConsumerAbReportCommandArgs,
+} from './framework-menu-builders-consumer';
+export {
+  buildPhase5BlockersReadinessCommandArgs,
+  buildPhase5ExecutionClosureCommandArgs,
+  buildPhase5ExecutionClosureStatusCommandArgs,
+  buildPhase5ExternalHandoffCommandArgs,
+} from './framework-menu-builders-phase5';
+export {
+  buildCleanValidationArtifactsCommandArgs,
+  buildSkillsLockCheckCommandArgs,
+  buildValidationDocsHygieneCommandArgs,
+} from './framework-menu-builders-maintenance';

package/scripts/framework-menu-gate-lib.ts

@@ -0,0 +1,53 @@
+import { resolvePolicyForStage } from '../integrations/gate/stagePolicies';
+import { runPlatformGate } from '../integrations/git/runPlatformGate';
+import { runAndPrintExitCode } from './framework-menu-runners';
+
+export type MenuStage = 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+
+export type MenuScope =
+  | { kind: 'staged' }
+  | {
+      kind: 'range';
+      fromRef: string;
+      toRef: string;
+    };
+
+export const buildMenuGateParams = (params: {
+  stage: MenuStage;
+  scope: MenuScope;
+  repoRoot?: string;
+}) => {
+  const resolved = resolvePolicyForStage(params.stage, params.repoRoot);
+
+  return {
+    policy: resolved.policy,
+    policyTrace: resolved.trace,
+    scope: params.scope,
+  };
+};
+
+export const runStagedGate = async (): Promise<void> => {
+  const gateParams = buildMenuGateParams({
+    stage: 'PRE_COMMIT',
+    scope: { kind: 'staged' },
+  });
+
+  await runAndPrintExitCode(() => runPlatformGate(gateParams));
+};
+
+export const runRangeGate = async (params: {
+  fromRef: string;
+  toRef: string;
+  stage: 'PRE_PUSH' | 'CI';
+}): Promise<void> => {
+  const gateParams = buildMenuGateParams({
+    stage: params.stage,
+    scope: {
+      kind: 'range',
+      fromRef: params.fromRef,
+      toRef: params.toRef,
+    },
+  });
+
+  await runAndPrintExitCode(() => runPlatformGate(gateParams));
+};

package/scripts/framework-menu-prompt-types.ts

@@ -0,0 +1,12 @@
+import type { Interface } from 'node:readline/promises';
+
+export type Questioner = Pick<Interface, 'question'>;
+
+export const parsePositive = (value: string): boolean => {
+  return value.trim().toLowerCase().startsWith('y');
+};
+
+export const parseInteger = (value: string, fallback: number): number => {
+  const parsed = Number.parseInt(value.trim(), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};

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

@@ -0,0 +1,50 @@
+import type { Questioner } from './framework-menu-prompt-types';
+
+export const createAdapterPrompts = (rl: Questioner) => {
+  const askAdapterSessionStatusReport = async (): Promise<{ outFile: string }> => {
+    const outPrompt = await rl.question(
+      'output path [.audit-reports/adapter/adapter-session-status.md]: '
+    );
+
+    return {
+      outFile: outPrompt.trim() || '.audit-reports/adapter/adapter-session-status.md',
+    };
+  };
+
+  const askAdapterRealSessionReport = async (): Promise<{
+    statusReportFile: string;
+    outFile: string;
+  }> => {
+    const statusPrompt = await rl.question(
+      'status report path [.audit-reports/adapter/adapter-session-status.md]: '
+    );
+    const outPrompt = await rl.question(
+      'output path [.audit-reports/adapter/adapter-real-session-report.md]: '
+    );
+
+    return {
+      statusReportFile:
+        statusPrompt.trim() || '.audit-reports/adapter/adapter-session-status.md',
+      outFile: outPrompt.trim() || '.audit-reports/adapter/adapter-real-session-report.md',
+    };
+  };
+
+  const askAdapterReadiness = async (): Promise<{ adapterReportFile: string; outFile: string }> => {
+    const adapterPrompt = await rl.question(
+      'adapter report path [.audit-reports/adapter/adapter-real-session-report.md]: '
+    );
+    const outPrompt = await rl.question('output path [.audit-reports/adapter/adapter-readiness.md]: ');
+
+    return {
+      adapterReportFile:
+        adapterPrompt.trim() || '.audit-reports/adapter/adapter-real-session-report.md',
+      outFile: outPrompt.trim() || '.audit-reports/adapter/adapter-readiness.md',
+    };
+  };
+
+  return {
+    askAdapterSessionStatusReport,
+    askAdapterRealSessionReport,
+    askAdapterReadiness,
+  };
+};

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

@@ -0,0 +1,36 @@
+import { parseInteger, type Questioner } from './framework-menu-prompt-types';
+import type {
+  ConsumerCiAuthCheckPromptResult,
+  ConsumerCiScanPromptResult,
+} from './framework-menu-prompts-consumer-contract';
+
+export const askConsumerCiScanPrompt = async (
+  rl: Questioner
+): Promise<ConsumerCiScanPromptResult> => {
+  const repoPrompt = await rl.question('consumer repo (owner/repo) [owner/repo]: ');
+  const limitPrompt = await rl.question('runs to inspect [20]: ');
+  const outPrompt = await rl.question(
+    'output path [.audit-reports/consumer-triage/consumer-ci-artifacts-report.md]: '
+  );
+
+  return {
+    repo: repoPrompt.trim() || 'owner/repo',
+    limit: parseInteger(limitPrompt, 20),
+    outFile:
+      outPrompt.trim() || '.audit-reports/consumer-triage/consumer-ci-artifacts-report.md',
+  };
+};
+
+export const askConsumerCiAuthCheckPrompt = async (
+  rl: Questioner
+): Promise<ConsumerCiAuthCheckPromptResult> => {
+  const repoPrompt = await rl.question('consumer repo (owner/repo) [owner/repo]: ');
+  const outPrompt = await rl.question(
+    'output path [.audit-reports/consumer-triage/consumer-ci-auth-check.md]: '
+  );
+
+  return {
+    repo: repoPrompt.trim() || 'owner/repo',
+    outFile: outPrompt.trim() || '.audit-reports/consumer-triage/consumer-ci-auth-check.md',
+  };
+};

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

@@ -0,0 +1,46 @@
+export type ConsumerCiScanPromptResult = {
+  repo: string;
+  limit: number;
+  outFile: string;
+};
+
+export type ConsumerWorkflowLintPromptResult = {
+  repoPath: string;
+  actionlintBin: string;
+  outFile: string;
+};
+
+export type ConsumerCiAuthCheckPromptResult = {
+  repo: string;
+  outFile: string;
+};
+
+export type ConsumerSupportBundlePromptResult = {
+  repo: string;
+  limit: number;
+  outFile: string;
+};
+
+export type ConsumerSupportTicketDraftPromptResult = {
+  repo: string;
+  supportBundleFile: string;
+  authReportFile: string;
+  outFile: string;
+};
+
+export type ConsumerStartupUnblockStatusPromptResult = {
+  repo: string;
+  supportBundleFile: string;
+  authReportFile: string;
+  workflowLintReportFile: string;
+  outFile: string;
+};
+
+export type ConsumerStartupTriagePromptResult = {
+  repo: string;
+  limit: number;
+  outDir: string;
+  runWorkflowLint: boolean;
+  repoPath?: string;
+  actionlintBin?: string;
+};

package/scripts/framework-menu-prompts-consumer-startup-triage-lib.ts

@@ -0,0 +1,69 @@
+import {
+  DEFAULT_ACTIONLINT_BIN,
+  DEFAULT_CONSUMER_REPO_PATH,
+} from './framework-menu-runners';
+import {
+  parseInteger,
+  parsePositive,
+  type Questioner,
+} from './framework-menu-prompt-types';
+import type { ConsumerStartupTriagePromptResult } from './framework-menu-prompts-consumer-contract';
+
+const askConsumerStartupTriageWithoutWorkflowLintPrompt = async (params: {
+  repo: string;
+  limit: number;
+  outDir: string;
+}): Promise<ConsumerStartupTriagePromptResult> => {
+  return {
+    repo: params.repo,
+    limit: params.limit,
+    outDir: params.outDir,
+    runWorkflowLint: false,
+  };
+};
+
+const askConsumerStartupTriageWithWorkflowLintPrompt = async (
+  rl: Questioner,
+  params: {
+    repo: string;
+    limit: number;
+    outDir: string;
+  }
+): Promise<ConsumerStartupTriagePromptResult> => {
+  const repoPathPrompt = await rl.question(
+    `consumer repo path [${DEFAULT_CONSUMER_REPO_PATH}]: `
+  );
+  const actionlintBinPrompt = await rl.question(
+    `actionlint binary [${DEFAULT_ACTIONLINT_BIN}]: `
+  );
+
+  return {
+    repo: params.repo,
+    limit: params.limit,
+    outDir: params.outDir,
+    runWorkflowLint: true,
+    repoPath: repoPathPrompt.trim() || DEFAULT_CONSUMER_REPO_PATH,
+    actionlintBin: actionlintBinPrompt.trim() || DEFAULT_ACTIONLINT_BIN,
+  };
+};
+
+export const askConsumerStartupTriagePrompt = async (
+  rl: Questioner
+): Promise<ConsumerStartupTriagePromptResult> => {
+  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/consumer-triage]: ');
+  const workflowLintPrompt = await rl.question('include workflow lint? [no]: ');
+
+  const params = {
+    repo: repoPrompt.trim() || 'owner/repo',
+    limit: parseInteger(limitPrompt, 20),
+    outDir: outDirPrompt.trim() || '.audit-reports/consumer-triage',
+  };
+
+  if (!parsePositive(workflowLintPrompt)) {
+    return askConsumerStartupTriageWithoutWorkflowLintPrompt(params);
+  }
+
+  return askConsumerStartupTriageWithWorkflowLintPrompt(rl, params);
+};

package/scripts/framework-menu-prompts-consumer-support-bundle-lib.ts

@@ -0,0 +1,20 @@
+import { parseInteger, type Questioner } from './framework-menu-prompt-types';
+import type { ConsumerSupportBundlePromptResult } from './framework-menu-prompts-consumer-contract';
+
+export const askConsumerSupportBundlePrompt = async (
+  rl: Questioner
+): Promise<ConsumerSupportBundlePromptResult> => {
+  const repoPrompt = await rl.question('consumer repo (owner/repo) [owner/repo]: ');
+  const limitPrompt = await rl.question('runs to inspect [20]: ');
+  const outPrompt = await rl.question(
+    'output path [.audit-reports/consumer-triage/consumer-startup-failure-support-bundle.md]: '
+  );
+
+  return {
+    repo: repoPrompt.trim() || 'owner/repo',
+    limit: parseInteger(limitPrompt, 20),
+    outFile:
+      outPrompt.trim() ||
+      '.audit-reports/consumer-triage/consumer-startup-failure-support-bundle.md',
+  };
+};

package/scripts/framework-menu-prompts-consumer-support-ticket-lib.ts

@@ -0,0 +1,27 @@
+import type { Questioner } from './framework-menu-prompt-types';
+import type { ConsumerSupportTicketDraftPromptResult } from './framework-menu-prompts-consumer-contract';
+
+export const askConsumerSupportTicketDraftPrompt = async (
+  rl: Questioner
+): Promise<ConsumerSupportTicketDraftPromptResult> => {
+  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 outPrompt = await rl.question(
+    'output path [.audit-reports/consumer-triage/consumer-support-ticket-draft.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',
+    outFile: outPrompt.trim() || '.audit-reports/consumer-triage/consumer-support-ticket-draft.md',
+  };
+};