pumuki 6.3.129 → 6.3.130

package/integrations/mcp/alignedPlatformGate.ts

@@ -0,0 +1,232 @@
+import type { AiGateStage } from '../gate/evaluateAiGate';
+import { resolvePolicyForStage } from '../gate/stagePolicies';
+import type { SddDecision } from '../sdd';
+import { GitService } from '../git/GitService';
+import { runPlatformGate } from '../git/runPlatformGate';
+import type { GateScope } from '../git/runPlatformGateFacts';
+import { readMcpPrePushStdin } from './readMcpPrePushStdin';
+
+const ZERO_HASH = /^0+$/;
+
+const runGit = (repoRoot: string, args: ReadonlyArray<string>): string | null => {
+  try {
+    return new GitService().runGit(args, repoRoot).trim();
+  } catch {
+    return null;
+  }
+};
+
+const resolveUpstreamRefInRepo = (repoRoot: string): string | null =>
+  runGit(repoRoot, ['rev-parse', '@{u}']);
+
+const resolveHeadOidInRepo = (repoRoot: string): string | null =>
+  runGit(repoRoot, ['rev-parse', 'HEAD']);
+
+const resolveCiBaseRefInRepo = (repoRoot: string): string => {
+  const fromEnv = process.env.GITHUB_BASE_REF?.trim();
+  if (fromEnv) {
+    if (runGit(repoRoot, ['rev-parse', '--verify', fromEnv])) {
+      return fromEnv;
+    }
+    const remoteRef = `origin/${fromEnv}`;
+    if (runGit(repoRoot, ['rev-parse', '--verify', remoteRef])) {
+      return remoteRef;
+    }
+  }
+
+  for (const candidate of ['origin/main', 'main', 'HEAD']) {
+    if (runGit(repoRoot, ['rev-parse', '--verify', candidate])) {
+      return candidate;
+    }
+  }
+
+  return 'HEAD';
+};
+
+const resolvePrePushBootstrapBaseRefInRepo = (repoRoot: string): string => {
+  const candidates = ['origin/develop', 'develop', resolveCiBaseRefInRepo(repoRoot)];
+  for (const candidate of candidates) {
+    if (runGit(repoRoot, ['rev-parse', '--verify', candidate])) {
+      return candidate;
+    }
+  }
+
+  return 'HEAD';
+};
+
+const shouldAllowBootstrapPrePush = (rawInput: string): boolean => {
+  const lines = rawInput
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+
+  for (const line of lines) {
+    const [localRef, localOid, remoteRef, remoteOid] = line.split(/\s+/);
+    if (!localRef || !localOid || !remoteRef || !remoteOid) {
+      continue;
+    }
+    const localIsBranch = localRef.startsWith('refs/heads/');
+    const remoteIsBranch = remoteRef.startsWith('refs/heads/');
+    const localIsDeletion = ZERO_HASH.test(localOid);
+    const remoteIsNewBranch = ZERO_HASH.test(remoteOid);
+
+    if (localIsBranch && remoteIsBranch && !localIsDeletion && remoteIsNewBranch) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+const resolveExplicitPrePushRange = (
+  rawInput: string
+): { fromRef: string; toRef: string } | undefined => {
+  const lines = rawInput
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0);
+
+  const eligibleRanges = lines
+    .map((line) => {
+      const [localRef, localOid, remoteRef, remoteOid] = line.split(/\s+/);
+      if (!localRef || !localOid || !remoteRef || !remoteOid) {
+        return undefined;
+      }
+      const localIsDeletion = ZERO_HASH.test(localOid);
+      const remoteIsNewBranch = ZERO_HASH.test(remoteOid);
+      if (localIsDeletion || remoteIsNewBranch) {
+        return undefined;
+      }
+      return {
+        fromRef: remoteOid,
+        toRef: localOid,
+      };
+    })
+    .filter((value): value is { fromRef: string; toRef: string } => Boolean(value));
+
+  if (eligibleRanges.length !== 1) {
+    return undefined;
+  }
+
+  return eligibleRanges[0];
+};
+
+type PrePushScopeResolution =
+  | { kind: 'scope'; scope: GateScope; sddDecisionOverride?: Pick<SddDecision, 'allowed' | 'code' | 'message'> }
+  | { kind: 'upstream_missing' };
+
+const resolvePrePushScopeForMcp = (params: { repoRoot: string }): PrePushScopeResolution => {
+  const prePushInput = readMcpPrePushStdin();
+  const upstreamRef = resolveUpstreamRefInRepo(params.repoRoot);
+  if (!upstreamRef) {
+    const bootstrapBaseRef = resolvePrePushBootstrapBaseRefInRepo(params.repoRoot);
+    const bootstrapByPrePushStdIn = shouldAllowBootstrapPrePush(prePushInput);
+    const bootstrapByFallbackBase = !bootstrapByPrePushStdIn && bootstrapBaseRef !== 'HEAD';
+    const manualInvocationFallback =
+      !bootstrapByPrePushStdIn &&
+      !bootstrapByFallbackBase &&
+      prePushInput.trim().length === 0;
+    if (bootstrapByPrePushStdIn || bootstrapByFallbackBase) {
+      return {
+        kind: 'scope',
+        scope: {
+          kind: 'range',
+          fromRef: bootstrapBaseRef,
+          toRef: 'HEAD',
+        },
+      };
+    }
+    if (manualInvocationFallback) {
+      return { kind: 'scope', scope: { kind: 'workingTree' } };
+    }
+    return { kind: 'upstream_missing' };
+  }
+  const explicitPrePushRange = resolveExplicitPrePushRange(prePushInput);
+  const prePushFromRef = explicitPrePushRange?.fromRef ?? upstreamRef;
+  const prePushToRef = explicitPrePushRange?.toRef ?? 'HEAD';
+  const headOid = resolveHeadOidInRepo(params.repoRoot);
+  const sddDecisionOverride =
+    explicitPrePushRange && headOid && explicitPrePushRange.toRef !== headOid
+      ? ({
+        allowed: true,
+        code: 'ALLOWED',
+        message:
+          `SDD enforcement suspended for PRE_PUSH historical publish targeting ${explicitPrePushRange.toRef.slice(0, 12)} ` +
+          `instead of current HEAD ${headOid.slice(0, 12)}.`,
+      } as Pick<SddDecision, 'allowed' | 'code' | 'message'>)
+      : undefined;
+  return {
+    kind: 'scope',
+    scope: {
+      kind: 'range',
+      fromRef: prePushFromRef,
+      toRef: prePushToRef,
+    },
+    sddDecisionOverride,
+  };
+};
+
+type RunAlignedParams = {
+  repoRoot: string;
+  stage: AiGateStage;
+};
+
+export const runMcpAlignedPlatformGate = async (
+  params: RunAlignedParams
+): Promise<{ exitCode: number; aligned: boolean; skipReason: string | null }> => {
+  const git = new GitService();
+  const resolved = resolvePolicyForStage(params.stage, params.repoRoot);
+  if (params.stage === 'PRE_WRITE') {
+    const exitCode = await runPlatformGate({
+      policy: resolved.policy,
+      policyTrace: resolved.trace,
+      scope: { kind: 'workingTree' },
+      silent: true,
+      services: { git },
+    });
+    return { exitCode, aligned: true, skipReason: null };
+  }
+  if (params.stage === 'PRE_COMMIT') {
+    const exitCode = await runPlatformGate({
+      policy: resolved.policy,
+      policyTrace: resolved.trace,
+      scope: { kind: 'staged' },
+      silent: true,
+      services: { git },
+    });
+    return { exitCode, aligned: true, skipReason: null };
+  }
+  if (params.stage === 'CI') {
+    const ciBaseRef = resolveCiBaseRefInRepo(params.repoRoot);
+    const exitCode = await runPlatformGate({
+      policy: resolved.policy,
+      policyTrace: resolved.trace,
+      scope: {
+        kind: 'range',
+        fromRef: ciBaseRef,
+        toRef: 'HEAD',
+      },
+      silent: true,
+      services: { git },
+    });
+    return { exitCode, aligned: true, skipReason: null };
+  }
+  if (params.stage === 'PRE_PUSH') {
+    const scopeResolution = resolvePrePushScopeForMcp({ repoRoot: params.repoRoot });
+    if (scopeResolution.kind === 'upstream_missing') {
+      return { exitCode: 1, aligned: false, skipReason: 'PRE_PUSH_UPSTREAM_MISSING' };
+    }
+    const exitCode = await runPlatformGate({
+      policy: resolved.policy,
+      policyTrace: resolved.trace,
+      scope: scopeResolution.scope,
+      silent: true,
+      services: { git },
+      ...(scopeResolution.sddDecisionOverride
+        ? { sddDecisionOverride: scopeResolution.sddDecisionOverride }
+        : {}),
+    });
+    return { exitCode, aligned: true, skipReason: null };
+  }
+  throw new Error(`Unsupported MCP aligned stage: ${String(params.stage)}`);
+};

package/integrations/mcp/enterpriseServer.ts

@@ -10,7 +10,7 @@ import { resolveMcpEnterpriseExperimentalFeature } from '../policy/experimentalF
 import { evaluateSddPolicy, readSddStatus } from '../sdd';
 import type { SddStage } from '../sdd';
 import { toStatusPayload } from './evidencePayloads';
-import { runEnterpriseAiGateCheck } from './aiGateCheck';
+import { runEnterpriseAiGateCheckAsync } from './aiGateCheck';
 import { runEnterprisePreFlightCheck } from './preFlightCheck';
 import { runEnterpriseAutoExecuteAiStart } from './autoExecuteAiStart';
 import { writeMcpAiGateReceipt } from './aiGateReceipt';
@@ -40,6 +40,14 @@ type EnterpriseStatusPayload = {
   evidence: ReturnType<typeof toStatusPayload>;
 };
 
+type EnterpriseHealthPayload = {
+  status: 'ok';
+  repoRoot: string;
+  experimentalFeatures: {
+    mcp_enterprise: ReturnType<typeof resolveMcpEnterpriseExperimentalFeature>;
+  };
+};
+
 const ENTERPRISE_RESOURCES = [
   'evidence://status',
   'gitflow://state',
@@ -443,7 +451,7 @@ const executeEnterpriseTool = async (
     }
     case 'ai_gate_check': {
       const stage = toSddStage(args.stage, 'PRE_COMMIT');
-      const execution = runEnterpriseAiGateCheck({
+      const execution = await runEnterpriseAiGateCheckAsync({
         repoRoot,
         stage,
       });
@@ -702,6 +710,14 @@ const buildStatusPayload = (repoRoot: string): EnterpriseStatusPayload => ({
   evidence: toStatusPayload(repoRoot),
 });
 
+const buildHealthPayload = (repoRoot: string): EnterpriseHealthPayload => ({
+  status: 'ok',
+  repoRoot,
+  experimentalFeatures: {
+    mcp_enterprise: readMcpEnterpriseExperimentalState(),
+  },
+});
+
 export const startEnterpriseMcpServer = (
   options: EnterpriseServerOptions = {}
 ): EnterpriseServerHandle => {
@@ -732,7 +748,7 @@ export const startEnterpriseMcpServer = (
         sendJson(res, 405, { error: 'Method not allowed' });
         return;
       }
-      sendJson(res, 200, { status: 'ok' });
+      sendJson(res, 200, buildHealthPayload(repoRoot));
       return;
     }
 

package/integrations/mcp/preFlightCheck.ts

@@ -1,6 +1,12 @@
+import {
+  resolveGovernanceCatalogAction,
+  type GovernanceCatalogNextAction,
+} from '../gate/governanceActionCatalog';
 import { evaluateAiGate, type AiGateStage, type AiGateViolation } from '../gate/evaluateAiGate';
 import { collectWorktreeAtomicSlices } from '../git/worktreeAtomicSlices';
+import { readLifecyclePolicyValidationSnapshot } from '../lifecycle/policyValidationSnapshot';
 import { resolveLearningContextExperimentalFeature } from '../policy/experimentalFeatures';
+import { resolvePreWriteEnforcement } from '../policy/preWriteEnforcement';
 import { readSddLearningContext, type SddLearningContext } from '../sdd/learningInsights';
 
 const ACTIONABLE_HINTS_BY_CODE: Readonly<Record<string, string>> = {
@@ -39,6 +45,28 @@ const ACTIONABLE_HINTS_BY_CODE: Readonly<Record<string, string>> = {
     'Mapea todas las reglas AUTO a detectores AST antes de continuar.',
   EVIDENCE_TIMESTAMP_FUTURE: 'Corrige la hora del sistema y regenera evidencia.',
   GITFLOW_PROTECTED_BRANCH: 'Evita trabajo directo en ramas protegidas (usa feature/*).',
+  GITFLOW_BRANCH_NAMING_INVALID:
+    'La rama actual no cumple GitFlow. Usa feature/*, bugfix/*, hotfix/*, release/*, chore/*, refactor/* o docs/*.',
+  TRACKING_CANONICAL_SOURCE_CONFLICT:
+    'AGENTS.md y los README del repo no apuntan a la misma fuente canónica de tracking.',
+  TRACKING_CANONICAL_FILE_MISSING:
+    'El repo declara un MD de tracking canónico que ahora mismo no existe.',
+  TRACKING_CANONICAL_IN_PROGRESS_INVALID:
+    'El MD canónico de tracking debe dejar exactamente una task o fase en construcción.',
+};
+
+const normalizeGovernanceCatalogCode = (code: string): string => {
+  switch (code) {
+    case 'EVIDENCE_INVALID':
+    case 'EVIDENCE_CHAIN_INVALID':
+      return 'EVIDENCE_INVALID_OR_CHAIN';
+    case 'GITFLOW_PROTECTED_BRANCH':
+      return 'GITFLOW_PROTECTED_BRANCH_CONTEXT';
+    case 'GITFLOW_BRANCH_NAMING_INVALID':
+      return 'GITFLOW_BRANCH_NAMING_INVALID_CONTEXT';
+    default:
+      return code;
+  }
 };
 
 const buildPreFlightHints = (params: {
@@ -115,6 +143,14 @@ export type EnterprisePreFlightCheckResult = {
     phase: 'GREEN' | 'RED';
     message: string;
     instruction: string;
+    reason_code: string;
+    prewrite_effective: {
+      mode: ReturnType<typeof resolvePreWriteEnforcement>['mode'];
+      source: ReturnType<typeof resolvePreWriteEnforcement>['source'];
+      blocking: boolean;
+      strict_policy: boolean;
+    };
+    next_action: GovernanceCatalogNextAction;
     stage: ReturnType<typeof evaluateAiGate>['stage'];
     policy: ReturnType<typeof evaluateAiGate>['policy'];
     violations: ReturnType<typeof evaluateAiGate>['violations'];
@@ -145,6 +181,8 @@ export const runEnterprisePreFlightCheck = (params: {
     : readSddLearningContext({
       repoRoot: params.repoRoot,
     });
+  const preWriteEnforcement = resolvePreWriteEnforcement();
+  const policyValidation = readLifecyclePolicyValidationSnapshot(params.repoRoot);
 
   const hints = buildPreFlightHints({
     repoRoot: params.repoRoot,
@@ -154,13 +192,30 @@ export const runEnterprisePreFlightCheck = (params: {
     upstream: evaluation.repo_state.git.upstream,
     learningContext,
   });
+  const firstViolation = evaluation.violations[0];
+  const reasonCode = firstViolation?.code ?? 'READY';
+  const governanceAction = firstViolation
+    ? resolveGovernanceCatalogAction({
+      code: normalizeGovernanceCatalogCode(firstViolation.code),
+      stage: evaluation.stage,
+    })
+    : resolveGovernanceCatalogAction({
+      code: 'READY',
+      stage: evaluation.stage,
+    });
   const phase: 'GREEN' | 'RED' = evaluation.allowed ? 'GREEN' : 'RED';
   const message = evaluation.allowed
     ? '✅ Pre-flight aprobado: puedes continuar con la implementación.'
-    : `🔴 Pre-flight bloqueado: corrige ${evaluation.violations[0]?.code ?? 'la causa'} y vuelve a ejecutar.`;
-  const instruction = evaluation.allowed
+    : `🔴 Pre-flight bloqueado: corrige ${reasonCode} y vuelve a ejecutar.`;
+  const instruction = !firstViolation && evaluation.allowed
     ? 'Implementa el cambio mínimo para pasar en verde y vuelve a validar.'
-    : hints[0] ?? 'Corrige la causa bloqueante y vuelve a ejecutar el pre-flight.';
+    : governanceAction.instruction;
+  const nextAction: GovernanceCatalogNextAction = evaluation.allowed
+    ? {
+      kind: 'info',
+      message: governanceAction.next_action.message,
+    }
+    : governanceAction.next_action;
 
   return {
     tool: 'pre_flight_check',
@@ -173,6 +228,14 @@ export const runEnterprisePreFlightCheck = (params: {
       phase,
       message,
       instruction,
+      reason_code: reasonCode,
+      prewrite_effective: {
+        mode: preWriteEnforcement.mode,
+        source: preWriteEnforcement.source,
+        blocking: preWriteEnforcement.blocking,
+        strict_policy: policyValidation.stages.PRE_WRITE.strict,
+      },
+      next_action: nextAction,
       stage: evaluation.stage,
       policy: evaluation.policy,
       violations: evaluation.violations,

package/integrations/mcp/readMcpPrePushStdin.ts

@@ -0,0 +1,7 @@
+export const readMcpPrePushStdin = (): string => {
+  const envInput = process.env.PUMUKI_PRE_PUSH_STDIN;
+  if (typeof envInput === 'string' && envInput.trim().length > 0) {
+    return envInput;
+  }
+  return '';
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.129",
+  "version": "6.3.130",
   "description": "Enterprise-grade AST Intelligence System with multi-platform support (iOS, Android, Backend, Frontend) and Feature-First + DDD + Clean Architecture enforcement. Includes dynamic violations API for intelligent querying.",
   "main": "index.js",
   "bin": {

package/scripts/build-ruralgo-s1-evidence-pack.ts

@@ -0,0 +1,85 @@
+import {
+  buildRuralGoS1EvidencePackMarkdown,
+  writeRuralGoS1EvidencePack,
+} from './ruralgo-s1-evidence-pack-lib';
+
+type CliOptions = {
+  consumerRoot: string;
+  outFile: string;
+  packageVersion: string;
+  generatedAt: string;
+};
+
+const parseArgs = (argv: ReadonlyArray<string>): CliOptions => {
+  const options: CliOptions = {
+    consumerRoot: '<RURALGO_REPO_ROOT>',
+    outFile: '.audit-reports/ruralgo-s1/ruralgo-s1-evidence-pack.md',
+    packageVersion: 'unknown',
+    generatedAt: new Date().toISOString(),
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    const next = argv[index + 1];
+    switch (token) {
+      case '--consumer-root':
+        if (!next) {
+          throw new Error('missing value for --consumer-root');
+        }
+        options.consumerRoot = next;
+        index += 1;
+        break;
+      case '--out':
+        if (!next) {
+          throw new Error('missing value for --out');
+        }
+        options.outFile = next;
+        index += 1;
+        break;
+      case '--package-version':
+        if (!next) {
+          throw new Error('missing value for --package-version');
+        }
+        options.packageVersion = next;
+        index += 1;
+        break;
+      case '--generated-at':
+        if (!next) {
+          throw new Error('missing value for --generated-at');
+        }
+        options.generatedAt = next;
+        index += 1;
+        break;
+      default:
+        throw new Error(`unknown argument: ${token}`);
+    }
+  }
+
+  return options;
+};
+
+const main = (): number => {
+  const cwd = process.cwd();
+  const options = parseArgs(process.argv.slice(2));
+  const markdown = buildRuralGoS1EvidencePackMarkdown({
+    cwd,
+    consumerRoot: options.consumerRoot,
+    packageVersion: options.packageVersion,
+    generatedAt: options.generatedAt,
+  });
+  const outputPath = writeRuralGoS1EvidencePack({
+    cwd,
+    outFile: options.outFile,
+    markdown,
+  });
+  process.stdout.write(`ruralgo s1 evidence pack generated at ${outputPath}\n`);
+  return 0;
+};
+
+try {
+  process.exitCode = main();
+} catch (error) {
+  const message = error instanceof Error ? error.message : 'unknown error';
+  process.stderr.write(`ruralgo s1 evidence pack failed: ${message}\n`);
+  process.exitCode = 1;
+}

package/scripts/check-tracking-single-active.sh

@@ -31,7 +31,7 @@ for FILE in "${FILES[@]}"; do
   fi
 
   if [[ "${FILE}" == "PUMUKI-RESET-MASTER-PLAN.md" ]]; then
-    ACTIVE_PATTERN='^- Estado: 🚧'
+    ACTIVE_PATTERN='(^- Estado:\s*🚧(?:\s|$))|(^`?\[\s*🚧\s*\]\s*-`?)|(^\|\s*[^|]+\|\s*`?\[\s*🚧\s*\]\s*-`?)|(^\|\s*🚧(?:\s|\|))'
   else
     ACTIVE_PATTERN='^- 🚧 (`?P[0-9A-Za-z.-]+`?)'
   fi

package/scripts/framework-menu-advanced-view-lib.ts

@@ -19,20 +19,47 @@ import {
   renderActionRow,
   renderBadge,
 } from './framework-menu-ui-components-lib';
+import {
+  buildGovernanceConsoleSummaryLines,
+  type GovernanceConsoleSnapshot,
+} from '../integrations/lifecycle/cliGovernanceConsole';
+import type { ConsumerPreflightResult } from './framework-menu-consumer-preflight-types';
 
 export const formatAdvancedMenuView = (
   actions: ReadonlyArray<MenuAction>,
   options?: {
     evidenceSummary?: FrameworkMenuEvidenceSummary;
+    preflight?: ConsumerPreflightResult | null;
+    governanceConsole?: GovernanceConsoleSnapshot | null;
   }
 ): string => {
   const evidenceSummary = options?.evidenceSummary ?? readEvidenceSummaryForMenu(process.cwd());
   const tokens = buildCliDesignTokens();
   const statusBadge = resolveAdvancedStatusBadge(evidenceSummary, tokens);
   const groupedActions = resolveAdvancedMenuLayout(actions);
+  const governanceConsole = options?.preflight
+    ? {
+      governanceObservation: options.preflight.governanceObservation,
+      governanceNextAction: options.preflight.governanceNextAction,
+      policyValidation: options.preflight.policyValidation,
+      experimentalFeatures: options.preflight.experimentalFeatures,
+    }
+    : (options?.governanceConsole ?? null);
   const lines = [
     'Pumuki Framework Menu (Advanced)',
     `Status: ${statusBadge}`,
+    ...(governanceConsole
+      ? [
+        'Governance Console',
+        ...buildGovernanceConsoleSummaryLines({
+          governanceObservation: governanceConsole.governanceObservation,
+          governanceNextAction: governanceConsole.governanceNextAction,
+          policyValidation: governanceConsole.policyValidation,
+          experimentalFeatures: governanceConsole.experimentalFeatures,
+        }).map((line) => `  ${line}`),
+        '',
+      ]
+      : []),
     'C. Switch to consumer menu',
     '',
     ...groupedActions.flatMap((group, groupIndex) => [
@@ -60,11 +87,33 @@ export const formatAdvancedMenuClassicView = (
   actions: ReadonlyArray<MenuAction>,
   options?: {
     evidenceSummary?: FrameworkMenuEvidenceSummary;
+    preflight?: ConsumerPreflightResult | null;
+    governanceConsole?: GovernanceConsoleSnapshot | null;
   }
 ): string => {
   const evidenceSummary = options?.evidenceSummary ?? readEvidenceSummaryForMenu(process.cwd());
+  const governanceConsole = options?.preflight
+    ? {
+      governanceObservation: options.preflight.governanceObservation,
+      governanceNextAction: options.preflight.governanceNextAction,
+      policyValidation: options.preflight.policyValidation,
+      experimentalFeatures: options.preflight.experimentalFeatures,
+    }
+    : (options?.governanceConsole ?? null);
   const lines = [
     'Pumuki Framework Menu (Advanced)',
+    ...(governanceConsole
+      ? [
+        'Governance Console',
+        ...buildGovernanceConsoleSummaryLines({
+          governanceObservation: governanceConsole.governanceObservation,
+          governanceNextAction: governanceConsole.governanceNextAction,
+          policyValidation: governanceConsole.policyValidation,
+          experimentalFeatures: governanceConsole.experimentalFeatures,
+        }).map((line) => `  ${line}`),
+        '',
+      ]
+      : []),
     'C. Switch to consumer menu',
     ...actions.map((action) => {
       const help = ADVANCED_MENU_HELP[action.id];