pumuki 6.3.7

package/scripts/consumer-workflow-lint-markdown-lib.ts

@@ -0,0 +1,39 @@
+import { resolve } from 'node:path';
+import type {
+  ConsumerWorkflowLintCliOptions,
+  ConsumerWorkflowLintResult,
+} from './consumer-workflow-lint-contract';
+
+export const buildConsumerWorkflowLintMarkdown = (params: {
+  options: ConsumerWorkflowLintCliOptions;
+  lintResult: ConsumerWorkflowLintResult;
+  generatedAtIso?: string;
+}): string => {
+  const now = params.generatedAtIso ?? new Date().toISOString();
+  const lines: string[] = [];
+  lines.push('# Consumer Workflow Lint Report');
+  lines.push('');
+  lines.push(`- generated_at: ${now}`);
+  lines.push(`- repo_path: \`${resolve(params.options.repoPath)}\``);
+  lines.push(`- actionlint_bin: \`${params.options.actionlintBin}\``);
+  lines.push(`- workflow_glob: \`${params.lintResult.workflowPath}\``);
+  lines.push(`- exit_code: ${params.lintResult.exitCode}`);
+  lines.push('');
+
+  if (params.lintResult.output.trim().length === 0) {
+    lines.push('## Result');
+    lines.push('');
+    lines.push('- No issues reported by actionlint.');
+    lines.push('');
+    return `${lines.join('\n')}\n`;
+  }
+
+  lines.push('## Raw Output');
+  lines.push('');
+  lines.push('```text');
+  lines.push(params.lintResult.output.trimEnd());
+  lines.push('```');
+  lines.push('');
+
+  return `${lines.join('\n')}\n`;
+};

package/scripts/consumer-workflow-lint-runner-lib.ts

@@ -0,0 +1,52 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type {
+  ConsumerWorkflowLintCliOptions,
+  ConsumerWorkflowLintResult,
+} from './consumer-workflow-lint-contract';
+import { executeConsumerWorkflowLintCommand } from './consumer-workflow-lint-command-lib';
+
+export const assertConsumerWorkflowLintBinary = (
+  actionlintBin: string,
+  cwd: string
+): void => {
+  if (
+    actionlintBin.includes('/') &&
+    !existsSync(resolve(cwd, actionlintBin)) &&
+    !existsSync(actionlintBin)
+  ) {
+    throw new Error(`actionlint binary not found: ${actionlintBin}`);
+  }
+};
+
+export const listConsumerWorkflowFiles = (
+  repoPath: string
+): ReadonlyArray<string> => {
+  const workflowsDir = resolve(repoPath, '.github/workflows');
+  return readdirSync(workflowsDir)
+    .filter((name) => name.endsWith('.yml') || name.endsWith('.yaml'))
+    .map((name) => resolve(workflowsDir, name))
+    .sort();
+};
+
+export const runConsumerWorkflowLint = (
+  options: ConsumerWorkflowLintCliOptions
+): ConsumerWorkflowLintResult => {
+  const workflowsDir = resolve(options.repoPath, '.github/workflows');
+  const workflowPath = `${workflowsDir}/*.{yml,yaml}`;
+  const workflowFiles = listConsumerWorkflowFiles(options.repoPath);
+
+  if (workflowFiles.length === 0) {
+    return {
+      exitCode: 0,
+      output: 'No workflow files found under .github/workflows',
+      workflowPath,
+    };
+  }
+
+  return executeConsumerWorkflowLintCommand({
+    options,
+    workflowFiles,
+    workflowPath,
+  });
+};

package/scripts/fill-adapter-external-ide-replay-closeout.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  cat <<'EOF'
+Usage:
+  bash scripts/fill-adapter-external-ide-replay-closeout.sh \
+    <out_file> \
+    <replay_executed_at_utc> \
+    <operator> \
+    <ide_client> \
+    <action_id_or_prompt> \
+    <trace_1> \
+    <trace_2> \
+    <trace_window_utc> \
+    <adapter_session_status> \
+    <adapter_real_session_report> \
+    <adapter_readiness> \
+    [seed_bundle] \
+    [payload_doc] \
+    [template_doc]
+
+Example:
+  bash scripts/fill-adapter-external-ide-replay-closeout.sh \
+    .audit-reports/adapter/adapter-external-ide-replay-closeout-2026-02-14.md \
+    2026-02-14T20:30:00Z \
+    SwiftEnProfundidad \
+    cursor \
+    "replay-one-shot-001" \
+    .audit_tmp/cascade-hook-runtime-pre.log \
+    .audit_tmp/cascade-hook-runtime-post.log \
+    "2026-02-14T20:29:40Z/2026-02-14T20:31:10Z" \
+    PASS \
+    PASS \
+    READY
+EOF
+}
+
+if [[ $# -lt 11 ]]; then
+  usage >&2
+  exit 1
+fi
+
+OUT_FILE="$1"
+REPLAY_EXECUTED_AT_UTC="$2"
+OPERATOR="$3"
+IDE_CLIENT="$4"
+ACTION_ID_OR_PROMPT="$5"
+TRACE_1="$6"
+TRACE_2="$7"
+TRACE_WINDOW_UTC="$8"
+ADAPTER_SESSION_STATUS="$9"
+ADAPTER_REAL_SESSION_REPORT="${10}"
+ADAPTER_READINESS="${11}"
+SEED_BUNDLE="${12:-.audit-reports/adapter/adapter-external-ide-replay-seed-2026-02-14.tgz}"
+PAYLOAD_DOC="${13:-.audit-reports/adapter/adapter-external-ide-replay-payload-2026-02-14.md}"
+TEMPLATE_DOC="${14:-.audit-reports/adapter/adapter-external-ide-replay-closeout-template-2026-02-14.md}"
+
+mkdir -p "$(dirname "${OUT_FILE}")"
+
+cat >"${OUT_FILE}" <<EOF
+# Adapter External IDE Replay Closeout
+
+## Scope
+Close \`P8-5b2b2\` with one real IDE-originated replay evidence set.
+
+## Replay Session Metadata
+- replay_executed_at_utc: \`${REPLAY_EXECUTED_AT_UTC}\`
+- operator: \`${OPERATOR}\`
+- ide_client: \`${IDE_CLIENT}\`
+- action_id_or_prompt: \`${ACTION_ID_OR_PROMPT}\`
+
+## Captured Runtime Traces
+- trace_1: \`${TRACE_1}\`
+- trace_2: \`${TRACE_2}\`
+- trace_window_utc: \`${TRACE_WINDOW_UTC}\`
+
+## Adapter Reports (post-replay)
+- adapter_session_status: \`${ADAPTER_SESSION_STATUS}\`
+- adapter_real_session_report: \`${ADAPTER_REAL_SESSION_REPORT}\`
+- adapter_readiness: \`${ADAPTER_READINESS}\`
+
+## Evidence Links
+- seed_bundle: \`${SEED_BUNDLE}\`
+- payload_doc: \`${PAYLOAD_DOC}\`
+- template_doc: \`${TEMPLATE_DOC}\`
+EOF
+
+echo "[adapter-replay-closeout] out_file=${OUT_FILE}"
+shasum -a 256 "${OUT_FILE}"

package/scripts/framework-menu-action-contract.ts

@@ -0,0 +1,17 @@
+import type { createFrameworkMenuPrompts } from './framework-menu-prompts';
+
+type FrameworkMenuPrompts = ReturnType<typeof createFrameworkMenuPrompts>;
+
+export type MenuAction = {
+  id: string;
+  label: string;
+  execute: () => Promise<void>;
+};
+
+export type FrameworkMenuActionContext = {
+  prompts: FrameworkMenuPrompts;
+  runStaged: () => Promise<void>;
+  runRange: (params: { fromRef: string; toRef: string; stage: 'PRE_PUSH' | 'CI' }) => Promise<void>;
+  resolveDefaultRangeFrom: () => string;
+  printActiveSkillsBundles: () => void;
+};

package/scripts/framework-menu-actions-diagnostics-adapter-lib.ts

@@ -0,0 +1,31 @@
+import {
+  runAdapterRealSessionReport,
+  runAdapterSessionStatusReport,
+} from './framework-menu-runners';
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+
+export const createFrameworkMenuDiagnosticsAdapterActions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    {
+      id: '9',
+      label: 'Build adapter session status report (optional diagnostics)',
+      execute: async () => {
+        const report = await params.prompts.askAdapterSessionStatusReport();
+        await runAdapterSessionStatusReport(report);
+      },
+    },
+    {
+      id: '16',
+      label: 'Build adapter real-session report (optional diagnostics)',
+      execute: async () => {
+        const report = await params.prompts.askAdapterRealSessionReport();
+        await runAdapterRealSessionReport(report);
+      },
+    },
+  ];
+};

package/scripts/framework-menu-actions-diagnostics-ci-lib.ts

@@ -0,0 +1,40 @@
+import {
+  runConsumerCiArtifactsScan,
+  runConsumerCiAuthCheck,
+  runConsumerWorkflowLintScan,
+} from './framework-menu-runners';
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+
+export const createFrameworkMenuDiagnosticsCiActions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    {
+      id: '10',
+      label: 'Collect consumer CI artifacts report',
+      execute: async () => {
+        const scan = await params.prompts.askConsumerCiScan();
+        await runConsumerCiArtifactsScan(scan);
+      },
+    },
+    {
+      id: '11',
+      label: 'Run consumer CI auth check report',
+      execute: async () => {
+        const check = await params.prompts.askConsumerCiAuthCheck();
+        await runConsumerCiAuthCheck(check);
+      },
+    },
+    {
+      id: '12',
+      label: 'Run consumer workflow lint report',
+      execute: async () => {
+        const lint = await params.prompts.askConsumerWorkflowLint();
+        await runConsumerWorkflowLintScan(lint);
+      },
+    },
+  ];
+};

package/scripts/framework-menu-actions-diagnostics-maintenance-lib.ts

@@ -0,0 +1,22 @@
+import { runAndPrintExitCode, runSkillsLockCheck, runValidationDocsHygiene } from './framework-menu-runners';
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+
+export const createFrameworkMenuDiagnosticsMaintenanceActions = (
+  _params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    {
+      id: '17',
+      label: 'Run docs/validation hygiene check',
+      execute: async () => runAndPrintExitCode(runValidationDocsHygiene),
+    },
+    {
+      id: '18',
+      label: 'Run skills lock freshness check',
+      execute: async () => runAndPrintExitCode(runSkillsLockCheck),
+    },
+  ];
+};

package/scripts/framework-menu-actions-diagnostics-support-core-lib.ts

@@ -0,0 +1,40 @@
+import {
+  runConsumerStartupUnblockStatus,
+  runConsumerSupportBundle,
+  runConsumerSupportTicketDraft,
+} from './framework-menu-runners';
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+
+export const createFrameworkMenuDiagnosticsSupportCoreActions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    {
+      id: '13',
+      label: 'Build consumer startup-failure support bundle',
+      execute: async () => {
+        const bundle = await params.prompts.askConsumerSupportBundle();
+        await runConsumerSupportBundle(bundle);
+      },
+    },
+    {
+      id: '14',
+      label: 'Build consumer support ticket draft',
+      execute: async () => {
+        const draft = await params.prompts.askConsumerSupportTicketDraft();
+        await runConsumerSupportTicketDraft(draft);
+      },
+    },
+    {
+      id: '15',
+      label: 'Build consumer startup-unblock status report',
+      execute: async () => {
+        const status = await params.prompts.askConsumerStartupUnblockStatus();
+        await runConsumerStartupUnblockStatus(status);
+      },
+    },
+  ];
+};

package/scripts/framework-menu-actions-diagnostics-support-lib.ts

@@ -0,0 +1,15 @@
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+import { createFrameworkMenuDiagnosticsSupportCoreActions } from './framework-menu-actions-diagnostics-support-core-lib';
+import { createFrameworkMenuDiagnosticsSupportTriageActions } from './framework-menu-actions-diagnostics-support-triage-lib';
+
+export const createFrameworkMenuDiagnosticsSupportActions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    ...createFrameworkMenuDiagnosticsSupportCoreActions(params),
+    ...createFrameworkMenuDiagnosticsSupportTriageActions(params),
+  ];
+};

package/scripts/framework-menu-actions-diagnostics-support-triage-lib.ts

@@ -0,0 +1,28 @@
+import { runConsumerStartupTriage, runMockConsumerAbReport } from './framework-menu-runners';
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+
+export const createFrameworkMenuDiagnosticsSupportTriageActions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    {
+      id: '19',
+      label: 'Run consumer startup triage bundle',
+      execute: async () => {
+        const triage = await params.prompts.askConsumerStartupTriage();
+        await runConsumerStartupTriage(triage);
+      },
+    },
+    {
+      id: '20',
+      label: 'Build mock consumer A/B validation report',
+      execute: async () => {
+        const report = await params.prompts.askMockConsumerAbReport();
+        await runMockConsumerAbReport(report);
+      },
+    },
+  ];
+};

package/scripts/framework-menu-actions-diagnostics.ts

@@ -0,0 +1,19 @@
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+import { createFrameworkMenuDiagnosticsAdapterActions } from './framework-menu-actions-diagnostics-adapter-lib';
+import { createFrameworkMenuDiagnosticsCiActions } from './framework-menu-actions-diagnostics-ci-lib';
+import { createFrameworkMenuDiagnosticsMaintenanceActions } from './framework-menu-actions-diagnostics-maintenance-lib';
+import { createFrameworkMenuDiagnosticsSupportActions } from './framework-menu-actions-diagnostics-support-lib';
+
+export const createFrameworkMenuDiagnosticsActions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    ...createFrameworkMenuDiagnosticsAdapterActions(params),
+    ...createFrameworkMenuDiagnosticsCiActions(params),
+    ...createFrameworkMenuDiagnosticsSupportActions(params),
+    ...createFrameworkMenuDiagnosticsMaintenanceActions(params),
+  ];
+};

package/scripts/framework-menu-actions-gates-ci-lib.ts

@@ -0,0 +1,30 @@
+import { runCiBackend } from '../integrations/git/ciBackend';
+import { runCiFrontend } from '../integrations/git/ciFrontend';
+import { runCiIOS } from '../integrations/git/ciIOS';
+import { runAndPrintExitCode } from './framework-menu-runners';
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+
+export const createFrameworkMenuGateCiActions = (
+  _params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    {
+      id: '4',
+      label: 'Run iOS CI gate',
+      execute: async () => runAndPrintExitCode(runCiIOS),
+    },
+    {
+      id: '5',
+      label: 'Run Backend CI gate',
+      execute: async () => runAndPrintExitCode(runCiBackend),
+    },
+    {
+      id: '6',
+      label: 'Run Frontend CI gate',
+      execute: async () => runAndPrintExitCode(runCiFrontend),
+    },
+  ];
+};

package/scripts/framework-menu-actions-gates-stage-lib.ts

@@ -0,0 +1,32 @@
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+
+export const createFrameworkMenuGateStageActions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    {
+      id: '1',
+      label: 'Evaluate staged changes (PRE_COMMIT policy)',
+      execute: params.runStaged,
+    },
+    {
+      id: '2',
+      label: 'Evaluate commit range (PRE_PUSH policy)',
+      execute: async () => {
+        const range = await params.prompts.askRange(params.resolveDefaultRangeFrom());
+        await params.runRange({ ...range, stage: 'PRE_PUSH' });
+      },
+    },
+    {
+      id: '3',
+      label: 'Evaluate commit range (CI policy)',
+      execute: async () => {
+        const range = await params.prompts.askRange(params.resolveDefaultRangeFrom());
+        await params.runRange({ ...range, stage: 'CI' });
+      },
+    },
+  ];
+};

package/scripts/framework-menu-actions-gates-tools-lib.ts

@@ -0,0 +1,26 @@
+import { printEvidence } from './framework-menu-runners';
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+
+export const createFrameworkMenuGateToolsActions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    {
+      id: '7',
+      label: 'Show active skills bundles (version + hash)',
+      execute: async () => {
+        params.printActiveSkillsBundles();
+      },
+    },
+    {
+      id: '8',
+      label: 'Read current .ai_evidence.json',
+      execute: async () => {
+        printEvidence();
+      },
+    },
+  ];
+};

package/scripts/framework-menu-actions-gates.ts

@@ -0,0 +1,17 @@
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+import { createFrameworkMenuGateCiActions } from './framework-menu-actions-gates-ci-lib';
+import { createFrameworkMenuGateStageActions } from './framework-menu-actions-gates-stage-lib';
+import { createFrameworkMenuGateToolsActions } from './framework-menu-actions-gates-tools-lib';
+
+export const createFrameworkMenuGateActions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    ...createFrameworkMenuGateStageActions(params),
+    ...createFrameworkMenuGateCiActions(params),
+    ...createFrameworkMenuGateToolsActions(params),
+  ];
+};

package/scripts/framework-menu-actions-phase5-exec-lib.ts

@@ -0,0 +1,32 @@
+import {
+  runAndPrintExitCode,
+  runPhase5ExecutionClosure,
+  runValidationArtifactsCleanup,
+} from './framework-menu-runners';
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+
+export const createFrameworkMenuPhase5ExecutionActions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    {
+      id: '24',
+      label: 'Run phase5 execution closure (one-shot orchestration)',
+      execute: async () => {
+        const runParams = await params.prompts.askPhase5ExecutionClosure();
+        await runPhase5ExecutionClosure(runParams);
+      },
+    },
+    {
+      id: '26',
+      label: 'Clean local validation artifacts',
+      execute: async () => {
+        const cleanParams = await params.prompts.askValidationArtifactsCleanup();
+        await runAndPrintExitCode(() => runValidationArtifactsCleanup(cleanParams));
+      },
+    },
+  ];
+};

package/scripts/framework-menu-actions-phase5-exit-lib.ts

@@ -0,0 +1,16 @@
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+
+export const createFrameworkMenuPhase5ExitAction = (
+  _params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    {
+      id: '27',
+      label: 'Exit',
+      execute: async () => {},
+    },
+  ];
+};

package/scripts/framework-menu-actions-phase5-reports-lib.ts

@@ -0,0 +1,49 @@
+import {
+  runAdapterReadiness,
+  runPhase5BlockersReadiness,
+  runPhase5ExecutionClosureStatus,
+  runPhase5ExternalHandoff,
+} from './framework-menu-runners';
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+
+export const createFrameworkMenuPhase5ReportActions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    {
+      id: '21',
+      label: 'Build phase5 blockers readiness report',
+      execute: async () => {
+        const report = await params.prompts.askPhase5BlockersReadiness();
+        await runPhase5BlockersReadiness(report);
+      },
+    },
+    {
+      id: '22',
+      label: 'Build adapter readiness report',
+      execute: async () => {
+        const report = await params.prompts.askAdapterReadiness();
+        await runAdapterReadiness(report);
+      },
+    },
+    {
+      id: '23',
+      label: 'Build phase5 execution closure status report',
+      execute: async () => {
+        const report = await params.prompts.askPhase5ExecutionClosureStatus();
+        await runPhase5ExecutionClosureStatus(report);
+      },
+    },
+    {
+      id: '25',
+      label: 'Build phase5 external handoff report',
+      execute: async () => {
+        const reportParams = await params.prompts.askPhase5ExternalHandoff();
+        await runPhase5ExternalHandoff(reportParams);
+      },
+    },
+  ];
+};

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

@@ -0,0 +1,17 @@
+import type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+import { createFrameworkMenuPhase5ExecutionActions } from './framework-menu-actions-phase5-exec-lib';
+import { createFrameworkMenuPhase5ExitAction } from './framework-menu-actions-phase5-exit-lib';
+import { createFrameworkMenuPhase5ReportActions } from './framework-menu-actions-phase5-reports-lib';
+
+export const createFrameworkMenuPhase5Actions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    ...createFrameworkMenuPhase5ReportActions(params),
+    ...createFrameworkMenuPhase5ExecutionActions(params),
+    ...createFrameworkMenuPhase5ExitAction(params),
+  ];
+};

package/scripts/framework-menu-actions.ts

@@ -0,0 +1,22 @@
+import {
+  type FrameworkMenuActionContext,
+  type MenuAction,
+} from './framework-menu-action-contract';
+import { createFrameworkMenuDiagnosticsActions } from './framework-menu-actions-diagnostics';
+import { createFrameworkMenuGateActions } from './framework-menu-actions-gates';
+import { createFrameworkMenuPhase5Actions } from './framework-menu-actions-phase5';
+
+export type {
+  FrameworkMenuActionContext,
+  MenuAction,
+} from './framework-menu-action-contract';
+
+export const createFrameworkMenuActions = (
+  params: FrameworkMenuActionContext
+): ReadonlyArray<MenuAction> => {
+  return [
+    ...createFrameworkMenuGateActions(params),
+    ...createFrameworkMenuDiagnosticsActions(params),
+    ...createFrameworkMenuPhase5Actions(params),
+  ];
+};