pumuki 6.3.7

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

@@ -0,0 +1,41 @@
+import type {
+  Phase5ExecutionClosureCommand,
+  Phase5ExecutionClosureOptions,
+  Phase5ExecutionClosureOutputs,
+} from './phase5-execution-closure-plan-contract';
+
+export const buildAdapterSessionStatusCommand = (
+  options: Phase5ExecutionClosureOptions,
+  outputs: Phase5ExecutionClosureOutputs
+): Phase5ExecutionClosureCommand => ({
+  id: 'adapter-session-status',
+  description: 'Generate adapter session status report',
+  script: 'scripts/build-adapter-session-status.ts',
+  args: ['--out', outputs.adapterSessionStatus],
+  required: options.requireAdapterReadiness,
+  outputFiles: [outputs.adapterSessionStatus],
+});
+
+export const buildAdapterRealSessionCommand = (
+  options: Phase5ExecutionClosureOptions,
+  outputs: Phase5ExecutionClosureOutputs
+): Phase5ExecutionClosureCommand => ({
+  id: 'adapter-real-session-report',
+  description: 'Generate adapter real-session report',
+  script: 'scripts/build-adapter-real-session-report.ts',
+  args: ['--status-report', outputs.adapterSessionStatus, '--out', outputs.adapterRealSessionReport],
+  required: options.requireAdapterReadiness,
+  outputFiles: [outputs.adapterRealSessionReport],
+});
+
+export const buildAdapterReadinessCommand = (
+  options: Phase5ExecutionClosureOptions,
+  outputs: Phase5ExecutionClosureOutputs
+): Phase5ExecutionClosureCommand => ({
+  id: 'adapter-readiness',
+  description: 'Generate adapter readiness report',
+  script: 'scripts/build-adapter-readiness.ts',
+  args: ['--adapter-report', outputs.adapterRealSessionReport, '--out', outputs.adapterReadiness],
+  required: options.requireAdapterReadiness,
+  outputFiles: [outputs.adapterReadiness],
+});

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

@@ -0,0 +1,25 @@
+import type {
+  Phase5ExecutionClosureCommand,
+  Phase5ExecutionClosureOptions,
+  Phase5ExecutionClosureOutputs,
+} from './phase5-execution-closure-plan-contract';
+import {
+  buildAdapterReadinessCommand,
+  buildAdapterRealSessionCommand,
+  buildAdapterSessionStatusCommand,
+} from './phase5-execution-closure-plan-adapter-commands-lib';
+
+export const buildAdapterCommands = (
+  options: Phase5ExecutionClosureOptions,
+  outputs: Phase5ExecutionClosureOutputs
+): Phase5ExecutionClosureCommand[] => {
+  if (!options.includeAdapter) {
+    return [];
+  }
+
+  return [
+    buildAdapterSessionStatusCommand(options, outputs),
+    buildAdapterRealSessionCommand(options, outputs),
+    buildAdapterReadinessCommand(options, outputs),
+  ];
+};

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

@@ -0,0 +1,5 @@
+export {
+  buildAuthPreflightCommand,
+  buildMockConsumerAbCommand,
+} from './phase5-execution-closure-plan-consumer-preflight-lib';
+export { buildTriageCommand } from './phase5-execution-closure-plan-consumer-triage-lib';

package/scripts/phase5-execution-closure-plan-consumer-preflight-lib.ts

@@ -0,0 +1,58 @@
+import type {
+  Phase5ExecutionClosureCommand,
+  Phase5ExecutionClosureOptions,
+  Phase5ExecutionClosureOutputs,
+} from './phase5-execution-closure-plan-contract';
+
+export const buildAuthPreflightCommand = (
+  options: Phase5ExecutionClosureOptions,
+  outputs: Phase5ExecutionClosureOutputs
+): Phase5ExecutionClosureCommand[] => {
+  if (!options.includeAuthPreflight || options.useMockConsumerTriage) {
+    return [];
+  }
+
+  return [
+    {
+      id: 'consumer-auth-preflight',
+      description: 'Preflight GitHub auth/scopes and billing probe',
+      script: 'scripts/check-consumer-ci-auth.ts',
+      args: ['--repo', options.repo, '--out', outputs.consumerCiAuthCheck],
+      required: true,
+      outputFiles: [outputs.consumerCiAuthCheck],
+    },
+  ];
+};
+
+export const buildMockConsumerAbCommand = (
+  options: Phase5ExecutionClosureOptions,
+  outputs: Phase5ExecutionClosureOutputs
+): Phase5ExecutionClosureCommand[] => {
+  if (!options.useMockConsumerTriage) {
+    return [];
+  }
+
+  return [
+    {
+      id: 'mock-consumer-ab-report',
+      description: 'Generate mock consumer A/B validation report',
+      script: 'scripts/build-mock-consumer-ab-report.ts',
+      args: [
+        '--repo',
+        options.repo,
+        '--out',
+        outputs.mockConsumerAbReport,
+        '--block-summary',
+        '.audit-reports/package-smoke/block/summary.md',
+        '--minimal-summary',
+        '.audit-reports/package-smoke/minimal/summary.md',
+        '--block-evidence',
+        '.audit-reports/package-smoke/block/ci.ai_evidence.json',
+        '--minimal-evidence',
+        '.audit-reports/package-smoke/minimal/ci.ai_evidence.json',
+      ],
+      required: true,
+      outputFiles: [outputs.mockConsumerAbReport],
+    },
+  ];
+};

package/scripts/phase5-execution-closure-plan-consumer-triage-lib.ts

@@ -0,0 +1,62 @@
+import type {
+  Phase5ExecutionClosureCommand,
+  Phase5ExecutionClosureOptions,
+  Phase5ExecutionClosureOutputs,
+} from './phase5-execution-closure-plan-contract';
+
+const resolveTriageCommandConfig = (options: Phase5ExecutionClosureOptions): {
+  script: string;
+  args: string[];
+} => {
+  const triageArgs = ['--repo', options.repo, '--out-dir', options.outDir];
+
+  if (options.useMockConsumerTriage) {
+    return {
+      script: 'scripts/build-mock-consumer-startup-triage.ts',
+      args: triageArgs,
+    };
+  }
+
+  triageArgs.push('--limit', String(options.limit));
+
+  if (options.runWorkflowLint) {
+    const repoPath = options.repoPath?.trim();
+    const actionlintBin = options.actionlintBin?.trim();
+    if (!repoPath || !actionlintBin) {
+      throw new Error(
+        'Workflow lint requires --repo-path and --actionlint-bin (or use --skip-workflow-lint).'
+      );
+    }
+    triageArgs.push('--repo-path', repoPath, '--actionlint-bin', actionlintBin);
+  } else {
+    triageArgs.push('--skip-workflow-lint');
+  }
+
+  if (options.includeAuthPreflight) {
+    triageArgs.push('--skip-auth-check');
+  }
+
+  return {
+    script: 'scripts/build-consumer-startup-triage.ts',
+    args: triageArgs,
+  };
+};
+
+export const buildTriageCommand = (
+  options: Phase5ExecutionClosureOptions,
+  outputs: Phase5ExecutionClosureOutputs
+): Phase5ExecutionClosureCommand => {
+  const triage = resolveTriageCommandConfig(options);
+
+  return {
+    id: 'consumer-startup-triage',
+    description: 'Generate consumer startup triage bundle',
+    script: triage.script,
+    args: triage.args,
+    required: true,
+    outputFiles: [
+      outputs.consumerStartupTriageReport,
+      outputs.consumerStartupUnblockStatus,
+    ],
+  };
+};

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

@@ -0,0 +1,42 @@
+export type Phase5ExecutionClosureOptions = {
+  repo: string;
+  limit: number;
+  outDir: string;
+  runWorkflowLint: boolean;
+  includeAuthPreflight: boolean;
+  repoPath?: string;
+  actionlintBin?: string;
+  includeAdapter: boolean;
+  requireAdapterReadiness: boolean;
+  useMockConsumerTriage?: boolean;
+};
+
+export type Phase5ExecutionClosureOutputs = {
+  adapterSessionStatus: string;
+  adapterRealSessionReport: string;
+  adapterReadiness: string;
+  consumerCiAuthCheck: string;
+  mockConsumerAbReport: string;
+  consumerStartupTriageReport: string;
+  consumerStartupUnblockStatus: string;
+  phase5BlockersReadiness: string;
+  phase5ExecutionClosureStatus: string;
+  closureRunReport: string;
+};
+
+export type Phase5ExecutionClosureCommand = {
+  id:
+    | 'adapter-session-status'
+    | 'adapter-real-session-report'
+    | 'adapter-readiness'
+    | 'consumer-auth-preflight'
+    | 'mock-consumer-ab-report'
+    | 'consumer-startup-triage'
+    | 'phase5-blockers-readiness'
+    | 'phase5-execution-closure-status';
+  description: string;
+  script: string;
+  args: string[];
+  required: boolean;
+  outputFiles: string[];
+};

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

@@ -0,0 +1,7 @@
+export type {
+  Phase5ExecutionClosureCommand,
+  Phase5ExecutionClosureOptions,
+  Phase5ExecutionClosureOutputs,
+} from './phase5-execution-closure-plan-contract';
+export { resolvePhase5ExecutionClosureOutputs } from './phase5-execution-closure-outputs-lib';
+export { buildPhase5ExecutionClosureCommands } from './phase5-execution-closure-commands-lib';

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

@@ -0,0 +1,52 @@
+import type {
+  Phase5ExecutionClosureOptions,
+  Phase5ExecutionClosureOutputs,
+} from './phase5-execution-closure-plan-contract';
+
+export const buildBlockersArgs = (
+  options: Phase5ExecutionClosureOptions,
+  outputs: Phase5ExecutionClosureOutputs
+): string[] => {
+  const blockersArgs = [
+    '--consumer-triage-report',
+    outputs.consumerStartupTriageReport,
+    '--out',
+    outputs.phase5BlockersReadiness,
+  ];
+
+  if (options.requireAdapterReadiness) {
+    blockersArgs.push(
+      '--require-adapter-report',
+      '--adapter-report',
+      outputs.adapterRealSessionReport
+    );
+  }
+
+  return blockersArgs;
+};
+
+export const buildClosureStatusArgs = (
+  options: Phase5ExecutionClosureOptions,
+  outputs: Phase5ExecutionClosureOutputs
+): string[] => {
+  const closureStatusArgs = [
+    '--phase5-blockers-report',
+    outputs.phase5BlockersReadiness,
+    '--consumer-unblock-report',
+    outputs.consumerStartupUnblockStatus,
+    '--out',
+    outputs.phase5ExecutionClosureStatus,
+  ];
+
+  if (options.requireAdapterReadiness) {
+    closureStatusArgs.push(
+      '--adapter-readiness-report',
+      outputs.adapterReadiness,
+      '--require-adapter-readiness'
+    );
+  } else if (options.includeAdapter) {
+    closureStatusArgs.push('--adapter-readiness-report', outputs.adapterReadiness);
+  }
+
+  return closureStatusArgs;
+};

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

@@ -0,0 +1,37 @@
+import type {
+  Phase5ExecutionClosureCommand,
+  Phase5ExecutionClosureOptions,
+  Phase5ExecutionClosureOutputs,
+} from './phase5-execution-closure-plan-contract';
+import {
+  buildBlockersArgs,
+  buildClosureStatusArgs,
+} from './phase5-execution-closure-plan-phase5-args-lib';
+
+export const buildBlockersCommand = (
+  options: Phase5ExecutionClosureOptions,
+  outputs: Phase5ExecutionClosureOutputs
+): Phase5ExecutionClosureCommand => {
+  return {
+    id: 'phase5-blockers-readiness',
+    description: 'Generate Phase 5 blockers readiness report',
+    script: 'scripts/build-phase5-blockers-readiness.ts',
+    args: buildBlockersArgs(options, outputs),
+    required: true,
+    outputFiles: [outputs.phase5BlockersReadiness],
+  };
+};
+
+export const buildClosureStatusCommand = (
+  options: Phase5ExecutionClosureOptions,
+  outputs: Phase5ExecutionClosureOutputs
+): Phase5ExecutionClosureCommand => {
+  return {
+    id: 'phase5-execution-closure-status',
+    description: 'Generate Phase 5 execution closure status snapshot',
+    script: 'scripts/build-phase5-execution-closure-status.ts',
+    args: buildClosureStatusArgs(options, outputs),
+    required: true,
+    outputFiles: [outputs.phase5ExecutionClosureStatus],
+  };
+};

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

@@ -0,0 +1,15 @@
+import type { Phase5ExecutionClosureOptions } from './phase5-execution-closure-plan-contract';
+
+export const validatePhase5ExecutionClosureOptions = (
+  options: Phase5ExecutionClosureOptions
+): void => {
+  if (!options.repo.trim()) {
+    throw new Error('Missing required option: repo');
+  }
+
+  if (options.requireAdapterReadiness && !options.includeAdapter) {
+    throw new Error(
+      'Cannot require adapter readiness when adapter flow is disabled (--skip-adapter).'
+    );
+  }
+};

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

@@ -0,0 +1,22 @@
+import type {
+  Phase5ExecutionClosureCommand,
+  Phase5ExecutionClosureOptions,
+} from './phase5-execution-closure-plan-lib';
+
+export type Phase5ExecutionClosureExecution = {
+  command: Phase5ExecutionClosureCommand;
+  exitCode: number;
+  ok: boolean;
+  error?: string;
+};
+
+export type Phase5ExecutionClosureRunReportParams = {
+  generatedAt: string;
+  repo: string;
+  options: Omit<
+    Phase5ExecutionClosureOptions,
+    'repoPath' | 'actionlintBin'
+  > & { repoPathProvided: boolean; actionlintBinProvided: boolean };
+  commands: ReadonlyArray<Phase5ExecutionClosureCommand>;
+  executions: ReadonlyArray<Phase5ExecutionClosureExecution>;
+};

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

@@ -0,0 +1,35 @@
+import type {
+  Phase5ExecutionClosureExecution,
+  Phase5ExecutionClosureRunReportParams,
+} from './phase5-execution-closure-report-contract';
+
+export const appendPhase5ExecutionClosureExecutionTableLines = (params: {
+  lines: string[];
+  executions: ReadonlyArray<Phase5ExecutionClosureExecution>;
+}): void => {
+  params.lines.push('## Executions');
+  params.lines.push('');
+  params.lines.push('| id | required | exit_code | status | outputs |');
+  params.lines.push('| --- | --- | --- | --- | --- |');
+  for (const execution of params.executions) {
+    params.lines.push(
+      `| ${execution.command.id} | ${execution.command.required ? 'yes' : 'no'} | ${execution.exitCode} | ${execution.ok ? 'ok' : 'failed'} | ${execution.command.outputFiles.map((file) => `\`${file}\``).join(', ')} |`
+    );
+  }
+  params.lines.push('');
+};
+
+export const appendPhase5ExecutionClosureCommandPlanLines = (params: {
+  lines: string[];
+  source: Phase5ExecutionClosureRunReportParams;
+}): void => {
+  params.lines.push('## Command Plan');
+  params.lines.push('');
+  for (const command of params.source.commands) {
+    params.lines.push(`- ${command.id}: ${command.description}`);
+    params.lines.push(
+      `  - run: \`npx --yes tsx@4.21.0 ${command.script} ${command.args.join(' ')}\``
+    );
+  }
+  params.lines.push('');
+};

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

@@ -0,0 +1,38 @@
+import type {
+  Phase5ExecutionClosureExecution,
+  Phase5ExecutionClosureRunReportParams,
+} from './phase5-execution-closure-report-contract';
+
+export const appendPhase5ExecutionClosureReportHeaderLines = (params: {
+  lines: string[];
+  source: Phase5ExecutionClosureRunReportParams;
+  hasRequiredFailures: boolean;
+}): void => {
+  params.lines.push('# Phase 5 Execution Closure Run Report');
+  params.lines.push('');
+  params.lines.push(`- generated_at: ${params.source.generatedAt}`);
+  params.lines.push(`- target_repo: \`${params.source.repo}\``);
+  params.lines.push(`- out_dir: \`${params.source.options.outDir}\``);
+  params.lines.push(`- include_adapter: ${params.source.options.includeAdapter ? 'YES' : 'NO'}`);
+  params.lines.push(
+    `- include_auth_preflight: ${params.source.options.includeAuthPreflight ? 'YES' : 'NO'}`
+  );
+  params.lines.push(
+    `- use_mock_consumer_triage: ${params.source.options.useMockConsumerTriage ? 'YES' : 'NO'}`
+  );
+  params.lines.push(
+    `- require_adapter_readiness: ${params.source.options.requireAdapterReadiness ? 'YES' : 'NO'}`
+  );
+  params.lines.push(`- run_workflow_lint: ${params.source.options.runWorkflowLint ? 'YES' : 'NO'}`);
+  params.lines.push(`- repo_path_provided: ${params.source.options.repoPathProvided ? 'YES' : 'NO'}`);
+  params.lines.push(
+    `- actionlint_bin_provided: ${params.source.options.actionlintBinProvided ? 'YES' : 'NO'}`
+  );
+  params.lines.push(`- verdict: ${params.hasRequiredFailures ? 'BLOCKED' : 'READY'}`);
+  params.lines.push('');
+};
+
+export const listPhase5RequiredFailures = (
+  executions: ReadonlyArray<Phase5ExecutionClosureExecution>
+): ReadonlyArray<Phase5ExecutionClosureExecution> =>
+  executions.filter((entry) => entry.command.required && !entry.ok);

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

@@ -0,0 +1,31 @@
+import type {
+  Phase5ExecutionClosureExecution,
+  Phase5ExecutionClosureRunReportParams,
+} from './phase5-execution-closure-report-contract';
+import {
+  appendPhase5ExecutionClosureCommandPlan,
+  appendPhase5ExecutionClosureExecutionTable,
+  appendPhase5ExecutionClosureNextActions,
+  appendPhase5ExecutionClosureReportHeader,
+} from './phase5-execution-closure-report-sections-lib';
+
+export type { Phase5ExecutionClosureExecution } from './phase5-execution-closure-report-contract';
+
+const listRequiredFailures = (
+  executions: ReadonlyArray<Phase5ExecutionClosureExecution>
+): ReadonlyArray<Phase5ExecutionClosureExecution> =>
+  executions.filter((entry) => entry.command.required && !entry.ok);
+
+export const buildPhase5ExecutionClosureRunReportMarkdown = (
+  params: Phase5ExecutionClosureRunReportParams
+): string => {
+  const lines: string[] = [];
+  const requiredFailures = listRequiredFailures(params.executions);
+
+  appendPhase5ExecutionClosureReportHeader(lines, params, requiredFailures);
+  appendPhase5ExecutionClosureExecutionTable(lines, params.executions);
+  appendPhase5ExecutionClosureCommandPlan(lines, params);
+  appendPhase5ExecutionClosureNextActions(lines, requiredFailures);
+
+  return `${lines.join('\n')}\n`;
+};

package/scripts/phase5-execution-closure-report-next-actions-lib.ts

@@ -0,0 +1,19 @@
+import type { Phase5ExecutionClosureExecution } from './phase5-execution-closure-report-contract';
+
+export const appendPhase5ExecutionClosureNextActionLines = (params: {
+  lines: string[];
+  requiredFailures: ReadonlyArray<Phase5ExecutionClosureExecution>;
+}): void => {
+  params.lines.push('## Next Actions');
+  params.lines.push('');
+  if (params.requiredFailures.length === 0) {
+    params.lines.push('- Closure run completed. Review generated reports and attach artifact links.');
+  } else {
+    for (const failure of params.requiredFailures) {
+      params.lines.push(
+        `- Resolve failed required step \`${failure.command.id}\` and rerun this command.`
+      );
+    }
+  }
+  params.lines.push('');
+};

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

@@ -0,0 +1,51 @@
+import type {
+  Phase5ExecutionClosureExecution,
+  Phase5ExecutionClosureRunReportParams,
+} from './phase5-execution-closure-report-contract';
+import { appendPhase5ExecutionClosureCommandPlanLines, appendPhase5ExecutionClosureExecutionTableLines } from './phase5-execution-closure-report-executions-lib';
+import { appendPhase5ExecutionClosureReportHeaderLines } from './phase5-execution-closure-report-header-lib';
+import { appendPhase5ExecutionClosureNextActionLines } from './phase5-execution-closure-report-next-actions-lib';
+
+type RequiredFailure = Phase5ExecutionClosureExecution;
+
+export const appendPhase5ExecutionClosureReportHeader = (
+  lines: string[],
+  params: Phase5ExecutionClosureRunReportParams,
+  requiredFailures: ReadonlyArray<RequiredFailure>
+): void => {
+  appendPhase5ExecutionClosureReportHeaderLines({
+    lines,
+    source: params,
+    hasRequiredFailures: requiredFailures.length > 0,
+  });
+};
+
+export const appendPhase5ExecutionClosureExecutionTable = (
+  lines: string[],
+  executions: ReadonlyArray<Phase5ExecutionClosureExecution>
+): void => {
+  appendPhase5ExecutionClosureExecutionTableLines({
+    lines,
+    executions,
+  });
+};
+
+export const appendPhase5ExecutionClosureCommandPlan = (
+  lines: string[],
+  params: Phase5ExecutionClosureRunReportParams
+): void => {
+  appendPhase5ExecutionClosureCommandPlanLines({
+    lines,
+    source: params,
+  });
+};
+
+export const appendPhase5ExecutionClosureNextActions = (
+  lines: string[],
+  requiredFailures: ReadonlyArray<RequiredFailure>
+): void => {
+  appendPhase5ExecutionClosureNextActionLines({
+    lines,
+    requiredFailures,
+  });
+};

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

@@ -0,0 +1,32 @@
+import type { Phase5ExecutionClosureCliOptions } from './phase5-execution-closure-runner-contract';
+
+export const assignPhase5ExecutionClosureBooleanArg = (params: {
+  options: Phase5ExecutionClosureCliOptions;
+  arg: string;
+}): boolean => {
+  if (params.arg === '--skip-workflow-lint') {
+    params.options.runWorkflowLint = false;
+    return true;
+  }
+  if (params.arg === '--skip-auth-preflight') {
+    params.options.includeAuthPreflight = false;
+    return true;
+  }
+  if (params.arg === '--skip-adapter') {
+    params.options.includeAdapter = false;
+    return true;
+  }
+  if (params.arg === '--require-adapter-readiness') {
+    params.options.requireAdapterReadiness = true;
+    return true;
+  }
+  if (params.arg === '--mock-consumer') {
+    params.options.useMockConsumerTriage = true;
+    return true;
+  }
+  if (params.arg === '--dry-run') {
+    params.options.dryRun = true;
+    return true;
+  }
+  return false;
+};

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

@@ -0,0 +1,33 @@
+import type { Phase5ExecutionClosureCliOptions } from './phase5-execution-closure-runner-contract';
+import { assignPhase5ExecutionClosureBooleanArg } from './phase5-execution-closure-runner-arg-flags-lib';
+import { assignPhase5ExecutionClosureArgWithValue } from './phase5-execution-closure-runner-arg-values-lib';
+
+export const applyPhase5ExecutionClosureArg = (params: {
+  options: Phase5ExecutionClosureCliOptions;
+  args: ReadonlyArray<string>;
+  index: number;
+}): number => {
+  const arg = params.args[params.index];
+
+  if (
+    assignPhase5ExecutionClosureArgWithValue({
+      options: params.options,
+      args: params.args,
+      index: params.index,
+      arg,
+    })
+  ) {
+    return params.index + 1;
+  }
+
+  if (
+    assignPhase5ExecutionClosureBooleanArg({
+      options: params.options,
+      arg,
+    })
+  ) {
+    return params.index;
+  }
+
+  throw new Error(`Unknown argument: ${arg}`);
+};