pumuki 6.3.97 → 6.3.99

package/integrations/gate/governanceActionCatalog.ts

@@ -1,275 +0,0 @@
-import type { AiGateStage } from './evaluateAiGate';
-
-export type GovernanceCatalogNextAction = {
-  kind: 'info' | 'run_command';
-  message: string;
-  command?: string;
-};
-
-export type GovernanceCatalogAction = {
-  reason_code: string;
-  instruction: string;
-  next_action: GovernanceCatalogNextAction;
-};
-
-const PRE_WRITE_VALIDATE_COMMAND =
-  'npx --yes --package pumuki@latest pumuki sdd validate --stage=PRE_WRITE --json';
-
-export const buildGovernanceValidateCommand = (stage: AiGateStage): string =>
-  PRE_WRITE_VALIDATE_COMMAND.replace('PRE_WRITE', stage);
-
-export const buildGovernancePolicyReconcileCommand = (stage: AiGateStage): string =>
-  `npx --yes --package pumuki@latest pumuki policy reconcile --strict --json && ${buildGovernanceValidateCommand(stage)}`;
-
-const buildFallbackAction = (code: string): GovernanceCatalogAction => ({
-  reason_code: code,
-  instruction: 'Corrige el bloqueante primario y vuelve a ejecutar la validación del stage actual.',
-  next_action: {
-    kind: 'info',
-    message: 'Corrige el bloqueante primario y vuelve a ejecutar el mismo comando.',
-  },
-});
-
-export const resolveGovernanceCatalogAction = (params: {
-  code: string;
-  stage?: AiGateStage;
-  fallback?: GovernanceCatalogAction;
-}): GovernanceCatalogAction => {
-  const stage = params.stage ?? 'PRE_WRITE';
-  const validateCommand = buildGovernanceValidateCommand(stage);
-  switch (params.code) {
-    case 'READY':
-      return {
-        reason_code: 'READY',
-        instruction: 'Puedes continuar con la siguiente slice mínima y volver a validar al cerrar.',
-        next_action: {
-          kind: 'info',
-          message: 'Gate en verde. Continúa con la implementación.',
-        },
-      };
-    case 'EVIDENCE_INVALID_OR_CHAIN':
-      return {
-        reason_code: 'EVIDENCE_INVALID_OR_CHAIN',
-        instruction: 'Regenera la evidencia canónica antes de continuar.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Regenera o corrige la evidencia canónica (.ai_evidence.json) y vuelve a validar governance.',
-          command: validateCommand,
-        },
-      };
-    case 'AI_GATE_BLOCKED':
-      return {
-        reason_code: 'AI_GATE_BLOCKED',
-        instruction: 'Corrige primero el bloqueo principal del gate antes de continuar.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Revalida el stage tras corregir la evidencia y el bloqueo principal.',
-          command: validateCommand,
-        },
-      };
-    case 'SDD_SESSION_MISSING':
-      return {
-        reason_code: 'SDD_SESSION_MISSING',
-        instruction: 'Abre una sesión SDD válida antes de seguir trabajando.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Abre la sesión SDD del cambio activo y vuelve a validar.',
-          command: 'npx --yes --package pumuki@latest pumuki sdd session --open --change=<id>',
-        },
-      };
-    case 'SDD_SESSION_INVALID':
-    case 'SDD_SESSION_INVALID_OR_EXPIRED':
-      return {
-        reason_code: 'SDD_SESSION_INVALID_OR_EXPIRED',
-        instruction: 'Refresca o reabre la sesión SDD antes de seguir trabajando.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Refresca la sesión SDD y vuelve a validar governance.',
-          command: 'npx --yes --package pumuki@latest pumuki sdd session --refresh --ttl-minutes=90',
-        },
-      };
-    case 'PRE_PUSH_UPSTREAM_MISSING':
-      return {
-        reason_code: 'PRE_PUSH_UPSTREAM_MISSING',
-        instruction: 'Configura el upstream remoto antes de continuar con PRE_PUSH.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Configura tracking remoto para la rama actual.',
-          command: 'git push --set-upstream origin <branch>',
-        },
-      };
-    case 'PRE_PUSH_UPSTREAM_MISALIGNED':
-      return {
-        reason_code: 'PRE_PUSH_UPSTREAM_MISALIGNED',
-        instruction: 'Alinea el upstream remoto con la rama actual antes de continuar.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Reconfigura el upstream remoto de la rama actual.',
-          command: 'git branch --unset-upstream && git push --set-upstream origin <branch>',
-        },
-      };
-    case 'GITFLOW_PROTECTED_BRANCH':
-    case 'GITFLOW_PROTECTED_BRANCH_CONTEXT':
-      return {
-        reason_code: 'GITFLOW_PROTECTED_BRANCH_CONTEXT',
-        instruction: 'Sal de la rama protegida y mueve el trabajo a feature/* o refactor/*.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Crea una rama válida de trabajo antes de seguir.',
-          command: 'git checkout -b feature/<descripcion-kebab-case>',
-        },
-      };
-    case 'GITFLOW_BRANCH_NAMING_INVALID':
-    case 'GITFLOW_BRANCH_NAMING_INVALID_CONTEXT':
-      return {
-        reason_code: 'GITFLOW_BRANCH_NAMING_INVALID_CONTEXT',
-        instruction:
-          'Renombra o recrea la rama actual con un prefijo GitFlow válido antes de continuar.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Crea una rama válida y mueve el trabajo a esa rama antes de seguir.',
-          command: 'git checkout -b feature/<descripcion-kebab-case>',
-        },
-      };
-    case 'TRACKING_CANONICAL_SOURCE_CONFLICT':
-      return {
-        reason_code: 'TRACKING_CANONICAL_SOURCE_CONFLICT',
-        instruction:
-          'Alinea AGENTS.md y los README canónicos para que todos apunten al mismo MD de seguimiento.',
-        next_action: {
-          kind: 'info',
-          message:
-            'Deja una única fuente canónica de tracking y elimina referencias legacy o contradictorias.',
-        },
-      };
-    case 'TRACKING_CANONICAL_FILE_MISSING':
-      return {
-        reason_code: 'TRACKING_CANONICAL_FILE_MISSING',
-        instruction:
-          'Crea o restaura el MD de seguimiento canónico declarado por el repo antes de continuar.',
-        next_action: {
-          kind: 'info',
-          message:
-            'Restaura el archivo canónico de tracking y vuelve a validar governance.',
-        },
-      };
-    case 'TRACKING_CANONICAL_IN_PROGRESS_INVALID':
-      return {
-        reason_code: 'TRACKING_CANONICAL_IN_PROGRESS_INVALID',
-        instruction:
-          'El tracking canónico debe tener exactamente una tarea o fase en construcción.',
-        next_action: {
-          kind: 'info',
-          message:
-            'Corrige el MD canónico para dejar exactamente una `🚧` antes de continuar.',
-        },
-      };
-    case 'POLICY_STAGE_NOT_STRICT':
-      return {
-        reason_code: 'POLICY_STAGE_NOT_STRICT',
-        instruction: 'Reconcilia policy/skills en modo estricto antes de seguir.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Converge policy-as-code y revalida el stage actual.',
-          command: buildGovernancePolicyReconcileCommand(stage),
-        },
-      };
-    case 'SKILLS_CONTRACT_SURFACE_INCOMPLETE':
-    case 'EVIDENCE_SKILLS_CONTRACT_INCOMPLETE':
-      return {
-        reason_code: 'SKILLS_CONTRACT_SURFACE_INCOMPLETE',
-        instruction: 'Materializa el lock/sources de skills antes de dar governance efectiva.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Reconcilia policy/skills y vuelve a validar governance.',
-          command: buildGovernancePolicyReconcileCommand(stage),
-        },
-      };
-    case 'ADAPTER_WIRING_MISSING':
-      return {
-        reason_code: 'ADAPTER_WIRING_MISSING',
-        instruction: 'Instala el adaptador canónico si quieres wiring explícito de IDE/MCP.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Genera `.pumuki/adapter.json` desde la instalación canónica.',
-          command: 'npx --yes --package pumuki@latest pumuki install --with-mcp',
-        },
-      };
-    case 'EVIDENCE_STALE':
-    case 'EVIDENCE_BRANCH_MISMATCH':
-    case 'EVIDENCE_SNAPSHOT_WARN':
-      return {
-        reason_code: params.code === 'EVIDENCE_SNAPSHOT_WARN' ? 'EVIDENCE_SNAPSHOT_WARN' : 'EVIDENCE_STALE',
-        instruction: 'Refresca evidencia y revisa hallazgos WARN antes de continuar.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Revalida el stage actual y revisa findings WARN.',
-          command: validateCommand,
-        },
-      };
-    case 'ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES_HIGH':
-    case 'EVIDENCE_ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES':
-      return {
-        reason_code: 'EVIDENCE_ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES',
-        instruction: 'Reconcilia policy/skills en modo estricto y revalida el stage actual.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Converge policy-as-code y vuelve a validar cobertura de active_rule_ids para reglas activas.',
-          command: buildGovernancePolicyReconcileCommand(stage),
-        },
-      };
-    case 'EVIDENCE_PLATFORM_SKILLS_SCOPE_INCOMPLETE':
-    case 'EVIDENCE_PLATFORM_SKILLS_BUNDLES_MISSING':
-      return {
-        reason_code: params.code,
-        instruction: 'Completa cobertura de skills por plataforma y vuelve a validar.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Completa bundles/prefijos de skills requeridos y revalida el stage actual.',
-          command: validateCommand,
-        },
-      };
-    case 'EVIDENCE_PLATFORM_CRITICAL_SKILLS_RULES_MISSING':
-    case 'EVIDENCE_CROSS_PLATFORM_CRITICAL_ENFORCEMENT_INCOMPLETE':
-      return {
-        reason_code: params.code,
-        instruction: 'Reconcilia policy/skills en modo estricto para enforcement crítico y revalida.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Materializa reglas críticas de plataforma y vuelve a validar el stage actual.',
-          command: buildGovernancePolicyReconcileCommand(stage),
-        },
-      };
-    case 'EVIDENCE_PREWRITE_WORKTREE_OVER_LIMIT':
-    case 'EVIDENCE_PREWRITE_WORKTREE_WARN':
-      return {
-        reason_code: params.code,
-        instruction: 'Particiona el worktree en slices atómicos antes de continuar.',
-        next_action: {
-          kind: 'run_command',
-          message: 'Reduce el worktree pendiente y revalida el stage actual.',
-          command: `git status --short && git add -p && ${validateCommand}`,
-        },
-      };
-    case 'SKILLS_SKILLS_FRONTEND_NO_SOLID_VIOLATIONS':
-      return {
-        reason_code: 'SKILLS_SKILLS_FRONTEND_NO_SOLID_VIOLATIONS',
-        instruction: 'Aplica refactor incremental por componente/hook y vuelve a validar.',
-        next_action: {
-          kind: 'info',
-          message: 'Aplica refactor incremental: extrae 1 componente/hook por commit y vuelve a ejecutar el gate.',
-        },
-      };
-    case 'GOVERNANCE_ATTENTION':
-      return {
-        reason_code: 'GOVERNANCE_ATTENTION',
-        instruction: 'Revisa governance truth y corrige el primer hueco del contrato antes de continuar.',
-        next_action: {
-          kind: 'info',
-          message: 'Revisa governance truth, corrige el primer gap visible y vuelve a validar.',
-        },
-      };
-    default:
-      return params.fallback ?? buildFallbackAction(params.code);
-  }
-};

package/integrations/lifecycle/bootstrapManifest.ts

@@ -1,248 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { getPumukiHooksStatus, resolvePumukiHooksDirectory } from './hookManager'
-import { LifecycleGitService, type ILifecycleGitService } from './gitService'
-import {
-  readGovernanceObservationSnapshot,
-  type GovernanceContractSurface,
-  type GovernanceObservationSnapshot,
-} from './governanceObservationSnapshot'
-import { readGovernanceNextAction, type GovernanceNextActionSummary } from './governanceNextAction'
-import { getCurrentPumukiPackageName, getCurrentPumukiVersion } from './packageInfo'
-import { readLifecycleExperimentalFeaturesSnapshot } from './experimentalFeaturesSnapshot'
-import { readLifecyclePolicyValidationSnapshot } from './policyValidationSnapshot'
-import { readLifecycleState } from './state'
-
-export const BOOTSTRAP_MANIFEST_RELATIVE_PATH = '.pumuki/bootstrap-manifest.json'
-
-type AdapterCommandContract = {
-  path: string
-  present: boolean
-  hooks: {
-    pre_write?: string
-    pre_commit?: string
-    pre_push?: string
-    ci?: string
-  }
-  mcp: {
-    enterprise?: string
-    evidence?: string
-  }
-}
-
-export type LifecycleBootstrapManifest = {
-  schema_version: '1'
-  repo_root: string
-  package: {
-    name: string
-    version: string
-  }
-  lifecycle: {
-    installed: boolean
-    version: string | null
-    installed_at: string | null
-    managed_hooks: ReadonlyArray<string>
-    openspec_managed_artifacts: ReadonlyArray<string>
-  }
-  hooks_directory: {
-    path: string
-    source: 'git-rev-parse' | 'git-config' | 'default'
-  }
-  hook_status: Record<string, { managed_block_present: boolean; exists: boolean }>
-  contract_surface: GovernanceContractSurface
-  governance: {
-    effective: GovernanceObservationSnapshot['governance_effective']
-    attention_codes: ReadonlyArray<string>
-    next_action: GovernanceNextActionSummary
-    bootstrap_hints: ReadonlyArray<string>
-  }
-  sdd: {
-    effective_mode: GovernanceObservationSnapshot['sdd']['effective_mode']
-    experimental_source: string
-    session_active: boolean
-    session_valid: boolean
-    change_id: string | null
-  }
-  policy_strict: GovernanceObservationSnapshot['policy_strict']
-  git: GovernanceObservationSnapshot['git']
-  adapter: AdapterCommandContract
-}
-
-export type LifecycleBootstrapManifestWriteResult = {
-  path: string
-  changed: boolean
-  manifest: LifecycleBootstrapManifest
-}
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null && !Array.isArray(value)
-
-const readOptionalCommand = (source: unknown): string | undefined => {
-  if (!isRecord(source)) {
-    return undefined
-  }
-  const command = source.command
-  return typeof command === 'string' && command.trim().length > 0 ? command.trim() : undefined
-}
-
-const readAdapterCommandContract = (repoRoot: string): AdapterCommandContract => {
-  const path = join(repoRoot, '.pumuki', 'adapter.json')
-  if (!existsSync(path)) {
-    return {
-      path: BOOTSTRAP_MANIFEST_RELATIVE_PATH.replace('bootstrap-manifest.json', 'adapter.json'),
-      present: false,
-      hooks: {},
-      mcp: {},
-    }
-  }
-
-  try {
-    const parsed = JSON.parse(readFileSync(path, 'utf8')) as unknown
-    const hooks = isRecord(parsed) && isRecord(parsed.hooks) ? parsed.hooks : {}
-    const mcp = isRecord(parsed) && isRecord(parsed.mcp) ? parsed.mcp : {}
-    return {
-      path: '.pumuki/adapter.json',
-      present: true,
-      hooks: {
-        pre_write: readOptionalCommand(isRecord(hooks) ? hooks.pre_write : undefined),
-        pre_commit: readOptionalCommand(isRecord(hooks) ? hooks.pre_commit : undefined),
-        pre_push: readOptionalCommand(isRecord(hooks) ? hooks.pre_push : undefined),
-        ci: readOptionalCommand(isRecord(hooks) ? hooks.ci : undefined),
-      },
-      mcp: {
-        enterprise: readOptionalCommand(isRecord(mcp) ? mcp.enterprise : undefined),
-        evidence: readOptionalCommand(isRecord(mcp) ? mcp.evidence : undefined),
-      },
-    }
-  } catch {
-    return {
-      path: '.pumuki/adapter.json',
-      present: false,
-      hooks: {},
-      mcp: {},
-    }
-  }
-}
-
-const parseManagedHooks = (raw?: string): string[] => {
-  if (typeof raw !== 'string' || raw.trim().length === 0) {
-    return []
-  }
-  return raw
-    .split(',')
-    .map((value) => value.trim())
-    .filter((value) => value.length > 0)
-}
-
-const parseManagedArtifacts = (raw?: string): string[] => {
-  if (typeof raw !== 'string' || raw.trim().length === 0) {
-    return []
-  }
-  return raw
-    .split(',')
-    .map((value) => value.trim())
-    .filter((value) => value.length > 0)
-}
-
-const toHookStatusSummary = (
-  hookStatus: ReturnType<typeof getPumukiHooksStatus>
-): Record<string, { managed_block_present: boolean; exists: boolean }> =>
-  Object.fromEntries(
-    Object.entries(hookStatus).map(([hook, entry]) => [
-      hook,
-      {
-        managed_block_present: entry.managedBlockPresent,
-        exists: entry.exists,
-      },
-    ])
-  )
-
-export const buildLifecycleBootstrapManifest = (params: {
-  repoRoot: string
-  git?: ILifecycleGitService
-}): LifecycleBootstrapManifest => {
-  const git = params.git ?? new LifecycleGitService()
-  const repoRoot = git.resolveRepoRoot(params.repoRoot)
-  const lifecycleState = readLifecycleState(git, repoRoot)
-  const experimentalFeatures = readLifecycleExperimentalFeaturesSnapshot()
-  const policyValidation = readLifecyclePolicyValidationSnapshot(repoRoot)
-  const governanceObservation = readGovernanceObservationSnapshot({
-    repoRoot,
-    experimentalFeatures,
-    policyValidation,
-    git,
-  })
-  const governanceNextAction = readGovernanceNextAction({
-    repoRoot,
-    stage: 'PRE_WRITE',
-    governanceObservation,
-  })
-  const hooksDirectory = resolvePumukiHooksDirectory(repoRoot)
-  const hookStatus = getPumukiHooksStatus(repoRoot)
-  const adapter = readAdapterCommandContract(repoRoot)
-
-  return {
-    schema_version: '1',
-    repo_root: repoRoot,
-    package: {
-      name: getCurrentPumukiPackageName(),
-      version: getCurrentPumukiVersion({ repoRoot }),
-    },
-    lifecycle: {
-      installed: lifecycleState.installed === 'true',
-      version: typeof lifecycleState.version === 'string' && lifecycleState.version.length > 0
-        ? lifecycleState.version
-        : null,
-      installed_at:
-        typeof lifecycleState.installedAt === 'string' && lifecycleState.installedAt.length > 0
-          ? lifecycleState.installedAt
-          : null,
-      managed_hooks: parseManagedHooks(lifecycleState.hooks),
-      openspec_managed_artifacts: parseManagedArtifacts(lifecycleState.openSpecManagedArtifacts),
-    },
-    hooks_directory: hooksDirectory,
-    hook_status: toHookStatusSummary(hookStatus),
-    contract_surface: governanceObservation.contract_surface,
-    governance: {
-      effective: governanceObservation.governance_effective,
-      attention_codes: governanceObservation.attention_codes,
-      next_action: governanceNextAction,
-      bootstrap_hints: governanceObservation.agent_bootstrap_hints,
-    },
-    sdd: {
-      effective_mode: governanceObservation.sdd.effective_mode,
-      experimental_source: governanceObservation.sdd.experimental_source,
-      session_active: governanceObservation.sdd_session.active,
-      session_valid: governanceObservation.sdd_session.valid,
-      change_id: governanceObservation.sdd_session.change_id,
-    },
-    policy_strict: governanceObservation.policy_strict,
-    git: governanceObservation.git,
-    adapter,
-  }
-}
-
-const serializeManifest = (manifest: LifecycleBootstrapManifest): string =>
-  `${JSON.stringify(manifest, null, 2)}\n`
-
-export const writeLifecycleBootstrapManifest = (params: {
-  repoRoot: string
-  git?: ILifecycleGitService
-}): LifecycleBootstrapManifestWriteResult => {
-  const git = params.git ?? new LifecycleGitService()
-  const repoRoot = git.resolveRepoRoot(params.repoRoot)
-  const path = join(repoRoot, BOOTSTRAP_MANIFEST_RELATIVE_PATH)
-  const manifest = buildLifecycleBootstrapManifest({ repoRoot, git })
-  const nextContents = serializeManifest(manifest)
-  const currentContents = existsSync(path) ? readFileSync(path, 'utf8') : ''
-  const changed = currentContents !== nextContents
-  if (changed) {
-    mkdirSync(dirname(path), { recursive: true })
-    writeFileSync(path, nextContents, 'utf8')
-  }
-  return {
-    path,
-    changed,
-    manifest,
-  }
-}

package/integrations/lifecycle/cliGovernanceConsole.ts

@@ -1,69 +0,0 @@
-import type { LifecycleExperimentalFeaturesSnapshot } from './experimentalFeaturesSnapshot';
-import type { GovernanceNextActionSummary } from './governanceNextAction';
-import { buildGovernanceNextActionSummaryLines } from './governanceNextAction';
-import type { GovernanceObservationSnapshot } from './governanceObservationSnapshot';
-import { buildGovernanceObservationSummaryLines } from './governanceObservationSnapshot';
-import { writeInfo } from './cliOutputs';
-import type { LifecyclePolicyValidationSnapshot } from './policyValidationSnapshot';
-
-export type GovernanceConsoleSnapshot = {
-  governanceObservation: GovernanceObservationSnapshot;
-  governanceNextAction: GovernanceNextActionSummary;
-  policyValidation: LifecyclePolicyValidationSnapshot;
-  experimentalFeatures: LifecycleExperimentalFeaturesSnapshot;
-};
-
-const GOVERNANCE_CONSOLE_FEATURE_ORDER = [
-  'analytics',
-  'heuristics',
-  'learning_context',
-  'mcp_enterprise',
-  'operational_memory',
-  'pre_write',
-  'saas_ingestion',
-  'sdd',
-] as const;
-
-const buildGovernancePolicySummaryLine = (
-  policyValidation: LifecyclePolicyValidationSnapshot
-): string =>
-  `Policy-as-code: PRE_WRITE=${policyValidation.stages.PRE_WRITE.validationCode ?? 'n/a'} strict=${policyValidation.stages.PRE_WRITE.strict ? 'yes' : 'no'} ` +
-  `PRE_COMMIT=${policyValidation.stages.PRE_COMMIT.validationCode ?? 'n/a'} strict=${policyValidation.stages.PRE_COMMIT.strict ? 'yes' : 'no'} ` +
-  `PRE_PUSH=${policyValidation.stages.PRE_PUSH.validationCode ?? 'n/a'} strict=${policyValidation.stages.PRE_PUSH.strict ? 'yes' : 'no'} ` +
-  `CI=${policyValidation.stages.CI.validationCode ?? 'n/a'} strict=${policyValidation.stages.CI.strict ? 'yes' : 'no'}`;
-
-const buildGovernanceExperimentalSummaryLines = (
-  experimentalFeatures: LifecycleExperimentalFeaturesSnapshot
-): string[] =>
-  GOVERNANCE_CONSOLE_FEATURE_ORDER.map((featureKey) => {
-    const feature = experimentalFeatures.features[featureKey];
-    return `Experimental: ${featureKey.toUpperCase()}=${feature.mode} source=${feature.source} layer=${feature.layer} blocking=${feature.blocking ? 'yes' : 'no'} env=${feature.activationVariable}`;
-  });
-
-export const buildGovernanceConsoleSummaryLines = (
-  snapshot: GovernanceConsoleSnapshot
-): string[] => {
-  const lines = ['Governance truth:'];
-  for (const line of buildGovernanceObservationSummaryLines(snapshot.governanceObservation)) {
-    lines.push(`  ${line}`);
-  }
-  for (const hint of snapshot.governanceObservation.evidence.human_summary_preview) {
-    lines.push(`  Evidence hint: ${hint}`);
-  }
-  lines.push('Governance next action:');
-  for (const line of buildGovernanceNextActionSummaryLines(snapshot.governanceNextAction)) {
-    lines.push(`  ${line}`);
-  }
-  lines.push(buildGovernancePolicySummaryLine(snapshot.policyValidation));
-  lines.push(...buildGovernanceExperimentalSummaryLines(snapshot.experimentalFeatures));
-  return lines;
-};
-
-export const printGovernanceConsoleHuman = (
-  snapshot: GovernanceConsoleSnapshot
-): void => {
-  writeInfo('[pumuki] governance console (S1 / shared status-doctor baseline):');
-  for (const line of buildGovernanceConsoleSummaryLines(snapshot)) {
-    writeInfo(`[pumuki]   ${line}`);
-  }
-};