pumuki 6.3.44 → 6.3.46

package/integrations/git/stageRunners.ts

@@ -22,6 +22,7 @@ import { readFileSync } from 'node:fs';
 import { readEvidence, readEvidenceResult } from '../evidence/readEvidence';
 import type { EvidenceReadResult } from '../evidence/readEvidence';
 import { ensureRuntimeArtifactsIgnored } from '../lifecycle/artifacts';
+import { runPolicyReconcile } from '../lifecycle/policyReconcile';
 
 const PRE_PUSH_UPSTREAM_REQUIRED_MESSAGE =
   'pumuki pre-push blocked: branch has no upstream tracking reference. Configure upstream first (for example: git push --set-upstream origin <branch>) and retry.';
@@ -54,6 +55,14 @@ const BLOCKED_REMEDIATION_BY_CODE: Readonly<Record<string, string>> = {
     'Alinea upstream con la rama actual: git branch --unset-upstream && git push --set-upstream origin <branch>',
 };
 
+const HOOK_POLICY_RECONCILE_CODES = new Set<string>([
+  'SKILLS_PLATFORM_COVERAGE_INCOMPLETE_HIGH',
+  'SKILLS_SCOPE_COMPLIANCE_INCOMPLETE_HIGH',
+  'EVIDENCE_PLATFORM_SKILLS_SCOPE_INCOMPLETE',
+  'EVIDENCE_PLATFORM_SKILLS_BUNDLES_MISSING',
+  'EVIDENCE_CROSS_PLATFORM_CRITICAL_ENFORCEMENT_INCOMPLETE',
+]);
+
 type StageRunnerDependencies = {
   resolvePolicyForStage: typeof resolvePolicyForStage;
   resolveUpstreamRef: typeof resolveUpstreamRef;
@@ -89,6 +98,7 @@ type StageRunnerDependencies = {
   writeHookGateSummary: (message: string) => void;
   isQuietMode: () => boolean;
   ensureRuntimeArtifactsIgnored: (repoRoot: string) => void;
+  runPolicyReconcile: typeof runPolicyReconcile;
 };
 
 const defaultDependencies: StageRunnerDependencies = {
@@ -144,6 +154,7 @@ const defaultDependencies: StageRunnerDependencies = {
     } catch {
     }
   },
+  runPolicyReconcile,
 };
 
 const getDependencies = (
@@ -196,6 +207,93 @@ const notifyGateBlockedForStage = (params: {
   });
 };
 
+const isHookPolicyAutoReconcileEnabled = (): boolean =>
+  process.env.PUMUKI_HOOK_POLICY_AUTO_RECONCILE !== '0';
+
+const shouldRetryAfterPolicyReconcile = (params: {
+  dependencies: StageRunnerDependencies;
+  repoRoot: string;
+  stage: 'PRE_COMMIT' | 'PRE_PUSH';
+}): boolean => {
+  const evidence = params.dependencies.readEvidence(params.repoRoot);
+  if (!evidence) {
+    return false;
+  }
+  const stageCodes = new Set<string>();
+  if (evidence.snapshot.stage === params.stage) {
+    for (const finding of evidence.snapshot.findings) {
+      stageCodes.add(finding.code);
+    }
+  }
+  for (const violation of evidence.ai_gate.violations) {
+    stageCodes.add(violation.code);
+  }
+  for (const code of stageCodes) {
+    if (HOOK_POLICY_RECONCILE_CODES.has(code)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+type HookStage = 'PRE_COMMIT' | 'PRE_PUSH';
+type HookPolicyTrace = NonNullable<ReturnType<typeof resolvePolicyForStage>['trace']>;
+
+const runHookGateAttempt = async (params: {
+  dependencies: StageRunnerDependencies;
+  stage: HookStage;
+  scope: Parameters<typeof runPlatformGate>[0]['scope'];
+}): Promise<{ exitCode: number; policyTrace: HookPolicyTrace }> => {
+  const resolved = params.dependencies.resolvePolicyForStage(params.stage);
+  const exitCode = await params.dependencies.runPlatformGate({
+    policy: resolved.policy,
+    policyTrace: resolved.trace,
+    scope: params.scope,
+  });
+  return {
+    exitCode,
+    policyTrace: resolved.trace,
+  };
+};
+
+const runHookGateWithPolicyRetry = async (params: {
+  dependencies: StageRunnerDependencies;
+  repoRoot: string;
+  stage: HookStage;
+  scope: Parameters<typeof runPlatformGate>[0]['scope'];
+}): Promise<{ exitCode: number; policyTrace: HookPolicyTrace }> => {
+  const firstAttempt = await runHookGateAttempt({
+    dependencies: params.dependencies,
+    stage: params.stage,
+    scope: params.scope,
+  });
+  if (firstAttempt.exitCode === 0) {
+    return firstAttempt;
+  }
+  if (!isHookPolicyAutoReconcileEnabled()) {
+    return firstAttempt;
+  }
+  if (
+    !shouldRetryAfterPolicyReconcile({
+      dependencies: params.dependencies,
+      repoRoot: params.repoRoot,
+      stage: params.stage,
+    })
+  ) {
+    return firstAttempt;
+  }
+  params.dependencies.runPolicyReconcile({
+    repoRoot: params.repoRoot,
+    strict: true,
+    apply: true,
+  });
+  return runHookGateAttempt({
+    dependencies: params.dependencies,
+    stage: params.stage,
+    scope: params.scope,
+  });
+};
+
 const ZERO_HASH = /^0+$/;
 
 const toEvidenceAgeSeconds = (
@@ -367,10 +465,10 @@ export async function runPreCommitStage(
   ) {
     return 1;
   }
-  const resolved = activeDependencies.resolvePolicyForStage('PRE_COMMIT');
-  const exitCode = await activeDependencies.runPlatformGate({
-    policy: resolved.policy,
-    policyTrace: resolved.trace,
+  const result = await runHookGateWithPolicyRetry({
+    dependencies: activeDependencies,
+    repoRoot,
+    stage: 'PRE_COMMIT',
     scope: {
       kind: 'staged',
     },
@@ -378,10 +476,10 @@ export async function runPreCommitStage(
   emitSuccessfulHookGateSummary({
     dependencies: activeDependencies,
     stage: 'PRE_COMMIT',
-    policyTrace: resolved.trace,
-    exitCode,
+    policyTrace: result.policyTrace,
+    exitCode: result.exitCode,
   });
-  if (exitCode !== 0) {
+  if (result.exitCode !== 0) {
     notifyGateBlockedForStage({
       dependencies: activeDependencies,
       stage: 'PRE_COMMIT',
@@ -391,7 +489,7 @@ export async function runPreCommitStage(
     });
   }
   notifyAuditSummaryForStage(activeDependencies, 'PRE_COMMIT');
-  return exitCode;
+  return result.exitCode;
 }
 
 export async function runPrePushStage(
@@ -427,10 +525,10 @@ export async function runPrePushStage(
       ) {
         return 1;
       }
-      const resolved = activeDependencies.resolvePolicyForStage('PRE_PUSH');
-      const exitCode = await activeDependencies.runPlatformGate({
-        policy: resolved.policy,
-        policyTrace: resolved.trace,
+      const result = await runHookGateWithPolicyRetry({
+        dependencies: activeDependencies,
+        repoRoot,
+        stage: 'PRE_PUSH',
         scope: {
           kind: 'range',
           fromRef: bootstrapBaseRef,
@@ -440,18 +538,18 @@ export async function runPrePushStage(
       emitSuccessfulHookGateSummary({
         dependencies: activeDependencies,
         stage: 'PRE_PUSH',
-        policyTrace: resolved.trace,
-        exitCode,
+        policyTrace: result.policyTrace,
+        exitCode: result.exitCode,
       });
       notifyAuditSummaryForStage(activeDependencies, 'PRE_PUSH');
-      return exitCode;
+      return result.exitCode;
     }
     if (manualInvocationFallback) {
       process.stderr.write(`${PRE_PUSH_MANUAL_FALLBACK_MESSAGE}\n`);
-      const resolved = activeDependencies.resolvePolicyForStage('PRE_PUSH');
-      const exitCode = await activeDependencies.runPlatformGate({
-        policy: resolved.policy,
-        policyTrace: resolved.trace,
+      const result = await runHookGateWithPolicyRetry({
+        dependencies: activeDependencies,
+        repoRoot,
+        stage: 'PRE_PUSH',
         scope: {
           kind: 'workingTree',
         },
@@ -459,11 +557,11 @@ export async function runPrePushStage(
       emitSuccessfulHookGateSummary({
         dependencies: activeDependencies,
         stage: 'PRE_PUSH',
-        policyTrace: resolved.trace,
-        exitCode,
+        policyTrace: result.policyTrace,
+        exitCode: result.exitCode,
       });
       notifyAuditSummaryForStage(activeDependencies, 'PRE_PUSH');
-      return exitCode;
+      return result.exitCode;
     }
     process.stderr.write(`${PRE_PUSH_UPSTREAM_REQUIRED_MESSAGE}\n`);
     notifyGateBlockedForStage({
@@ -506,10 +604,10 @@ export async function runPrePushStage(
     return 1;
   }
 
-  const resolved = activeDependencies.resolvePolicyForStage('PRE_PUSH');
-  const exitCode = await activeDependencies.runPlatformGate({
-    policy: resolved.policy,
-    policyTrace: resolved.trace,
+  const result = await runHookGateWithPolicyRetry({
+    dependencies: activeDependencies,
+    repoRoot,
+    stage: 'PRE_PUSH',
     scope: {
       kind: 'range',
       fromRef: upstreamRef,
@@ -519,10 +617,10 @@ export async function runPrePushStage(
   emitSuccessfulHookGateSummary({
     dependencies: activeDependencies,
     stage: 'PRE_PUSH',
-    policyTrace: resolved.trace,
-    exitCode,
+    policyTrace: result.policyTrace,
+    exitCode: result.exitCode,
   });
-  if (exitCode !== 0) {
+  if (result.exitCode !== 0) {
     notifyGateBlockedForStage({
       dependencies: activeDependencies,
       stage: 'PRE_PUSH',
@@ -532,7 +630,7 @@ export async function runPrePushStage(
     });
   }
   notifyAuditSummaryForStage(activeDependencies, 'PRE_PUSH');
-  return exitCode;
+  return result.exitCode;
 }
 
 export async function runCiStage(

package/integrations/lifecycle/watch.ts

@@ -15,6 +15,7 @@ import {
   emitGateBlockedNotification,
 } from '../notifications/emitAuditSummaryNotification';
 import { runPolicyReconcile } from './policyReconcile';
+import { resolvePumukiVersionMetadata, type PumukiVersionMetadata } from './packageInfo';
 
 export type LifecycleWatchStage = 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
 export type LifecycleWatchScope = 'workingTree' | 'staged' | 'repoAndStaged' | 'repo';
@@ -49,6 +50,14 @@ export type LifecycleWatchTickResult = {
 export type LifecycleWatchResult = {
   command: 'pumuki watch';
   repoRoot: string;
+  version: {
+    effective: string;
+    runtime: string;
+    consumerInstalled: string | null;
+    source: PumukiVersionMetadata['source'];
+    driftFromRuntime: boolean;
+    driftWarning: string | null;
+  };
   stage: LifecycleWatchStage;
   scope: LifecycleWatchScope;
   intervalMs: number;
@@ -73,6 +82,7 @@ type LifecycleWatchDependencies = {
   emitAuditSummaryNotificationFromEvidence: typeof emitAuditSummaryNotificationFromEvidence;
   emitGateBlockedNotification: typeof emitGateBlockedNotification;
   runPolicyReconcile: typeof runPolicyReconcile;
+  resolvePumukiVersionMetadata: (params?: { repoRoot?: string }) => PumukiVersionMetadata;
   nowMs: () => number;
   sleep: (ms: number) => Promise<void>;
 };
@@ -96,6 +106,7 @@ const defaultDependencies: LifecycleWatchDependencies = {
   emitAuditSummaryNotificationFromEvidence,
   emitGateBlockedNotification,
   runPolicyReconcile,
+  resolvePumukiVersionMetadata,
   nowMs: () => Date.now(),
   sleep: async (ms) => {
     await sleepTimer(ms);
@@ -231,6 +242,12 @@ export const runLifecycleWatch = async (
     ...dependencies,
   };
   const repoRoot = params?.repoRoot ?? activeDependencies.resolveRepoRoot();
+  const versionMetadata = activeDependencies.resolvePumukiVersionMetadata({ repoRoot });
+  const driftFromRuntime = versionMetadata.resolvedVersion !== versionMetadata.runtimeVersion;
+  const driftWarning = driftFromRuntime
+    ? `Version drift detectado: effective=${versionMetadata.resolvedVersion} runtime=${versionMetadata.runtimeVersion}. ` +
+      'Actualiza el consumer para alinear el binario local con @latest y evitar diagnósticos inconsistentes.'
+    : null;
   const stage = params?.stage ?? 'PRE_COMMIT';
   const scope = params?.scope ?? 'workingTree';
   const intervalMs = Math.max(250, Math.trunc(params?.intervalMs ?? 3000));
@@ -309,6 +326,7 @@ export const runLifecycleWatch = async (
           policy: resolvedPolicy.policy,
           policyTrace: resolvedPolicy.trace,
           scope: gateScope,
+          silent: true,
         });
         const evidence = activeDependencies.readEvidence(repoRoot);
         const allFindings = evidence?.snapshot.findings ?? [];
@@ -449,6 +467,14 @@ export const runLifecycleWatch = async (
       return {
         command: 'pumuki watch',
         repoRoot,
+        version: {
+          effective: versionMetadata.resolvedVersion,
+          runtime: versionMetadata.runtimeVersion,
+          consumerInstalled: versionMetadata.consumerInstalledVersion,
+          source: versionMetadata.source,
+          driftFromRuntime,
+          driftWarning,
+        },
         stage,
         scope,
         intervalMs,

package/integrations/mcp/aiGateCheck.ts

@@ -1,4 +1,5 @@
 import { evaluateAiGate, type AiGateStage } from '../gate/evaluateAiGate';
+import { readSddLearningContext, type SddLearningContext } from '../sdd/learningInsights';
 
 const AUTO_FIX_BY_CODE: Readonly<Record<string, string>> = {
   EVIDENCE_MISSING: 'Ejecuta una auditoría para generar .ai_evidence.json.',
@@ -28,6 +29,7 @@ export type EnterpriseAiGateCheckResult = {
     violations: ReturnType<typeof evaluateAiGate>['violations'];
     warnings: ReadonlyArray<string>;
     auto_fixes: ReadonlyArray<string>;
+    learning_context: SddLearningContext | null;
     evidence: ReturnType<typeof evaluateAiGate>['evidence'];
     mcp_receipt: ReturnType<typeof evaluateAiGate>['mcp_receipt'];
     skills_contract: ReturnType<typeof evaluateAiGate>['skills_contract'];
@@ -99,7 +101,10 @@ const buildWarnings = (evaluation: ReturnType<typeof evaluateAiGate>): ReadonlyA
   return warnings;
 };
 
-const buildAutoFixes = (evaluation: ReturnType<typeof evaluateAiGate>): ReadonlyArray<string> => {
+const buildAutoFixes = (
+  evaluation: ReturnType<typeof evaluateAiGate>,
+  learningContext: SddLearningContext | null
+): ReadonlyArray<string> => {
   const fixes: string[] = [];
   const emittedCodes = new Set<string>();
   for (const violation of evaluation.violations) {
@@ -113,6 +118,11 @@ const buildAutoFixes = (evaluation: ReturnType<typeof evaluateAiGate>): Readonly
     fixes.push(fix);
     emittedCodes.add(violation.code);
   }
+  for (const recommendation of learningContext?.recommended_actions ?? []) {
+    if (!fixes.includes(recommendation)) {
+      fixes.push(recommendation);
+    }
+  }
   return fixes;
 };
 
@@ -143,8 +153,11 @@ export const runEnterpriseAiGateCheck = (params: {
   });
   const branch = evaluation.repo_state.git.branch;
   const timestamp = evaluation.evidence.source.generated_at;
+  const learningContext = readSddLearningContext({
+    repoRoot: params.repoRoot,
+  });
   const warnings = buildWarnings(evaluation);
-  const autoFixes = buildAutoFixes(evaluation);
+  const autoFixes = buildAutoFixes(evaluation, learningContext);
   const message = buildMessage(evaluation);
 
   return {
@@ -163,6 +176,7 @@ export const runEnterpriseAiGateCheck = (params: {
       violations: evaluation.violations,
       warnings,
       auto_fixes: autoFixes,
+      learning_context: learningContext,
       evidence: evaluation.evidence,
       mcp_receipt: evaluation.mcp_receipt,
       skills_contract: evaluation.skills_contract,

package/integrations/mcp/autoExecuteAiStart.ts

@@ -1,5 +1,6 @@
 import { evaluateAiGate, type AiGateStage, type AiGateViolation } from '../gate/evaluateAiGate';
 import { collectWorktreeAtomicSlices } from '../git/worktreeAtomicSlices';
+import { readSddLearningContext, type SddLearningContext } from '../sdd/learningInsights';
 
 type AutoExecuteAction = 'proceed' | 'ask';
 type AutoExecutePhase = 'GREEN' | 'RED';
@@ -154,6 +155,7 @@ export type EnterpriseAutoExecuteAiStartResult = {
     confidence_pct: number;
     reason_code: string;
     next_action: AutoExecuteNextAction;
+    learning_context: SddLearningContext | null;
     gate: {
       stage: ReturnType<typeof evaluateAiGate>['stage'];
       status: ReturnType<typeof evaluateAiGate>['status'];
@@ -174,6 +176,9 @@ export const runEnterpriseAutoExecuteAiStart = (params: {
     stage,
     requireMcpReceipt: params.requireMcpReceipt ?? false,
   });
+  const learningContext = readSddLearningContext({
+    repoRoot: params.repoRoot,
+  });
   const firstViolation = evaluation.violations[0];
   const reasonCode = firstViolation?.code ?? 'READY';
   const action: AutoExecuteAction = evaluation.allowed ? 'proceed' : 'ask';
@@ -186,12 +191,16 @@ export const runEnterpriseAutoExecuteAiStart = (params: {
     }
     : nextActionFromViolation(firstViolation, params.repoRoot);
 
-  const message = toHumanMessage({
+  let message = toHumanMessage({
     action,
     confidencePct,
     reasonCode,
   });
-  const instruction = nextAction.message;
+  let instruction = nextAction.message;
+  if (learningContext?.recommended_actions[0]) {
+    message = `${message} Learning: ${learningContext.recommended_actions[0]}`;
+    instruction = `${instruction} Learning: ${learningContext.recommended_actions[0]}`;
+  }
   const force = action === 'ask' && confidencePct < 50;
 
   return {
@@ -210,6 +219,7 @@ export const runEnterpriseAutoExecuteAiStart = (params: {
       confidence_pct: confidencePct,
       reason_code: reasonCode,
       next_action: nextAction,
+      learning_context: learningContext,
       gate: {
         stage: evaluation.stage,
         status: evaluation.status,

package/integrations/mcp/preFlightCheck.ts

@@ -1,5 +1,6 @@
 import { evaluateAiGate, type AiGateStage, type AiGateViolation } from '../gate/evaluateAiGate';
 import { collectWorktreeAtomicSlices } from '../git/worktreeAtomicSlices';
+import { readSddLearningContext, type SddLearningContext } from '../sdd/learningInsights';
 
 const ACTIONABLE_HINTS_BY_CODE: Readonly<Record<string, string>> = {
   EVIDENCE_MISSING: 'Ejecuta una auditoría (1/2/3/4) para regenerar .ai_evidence.json.',
@@ -44,6 +45,7 @@ const buildPreFlightHints = (params: {
   status: ReturnType<typeof evaluateAiGate>['status'];
   violations: ReadonlyArray<AiGateViolation>;
   upstream: string | null;
+  learningContext: SddLearningContext | null;
 }): ReadonlyArray<string> => {
   const hints: string[] = [];
   const emittedCodes = new Set<string>();
@@ -89,6 +91,14 @@ const buildPreFlightHints = (params: {
       hints.push('Corrige la causa bloqueante y vuelve a ejecutar el pre-flight.');
     }
   }
+  if (params.learningContext) {
+    hints.push(
+      `LEARNING_CONTEXT: change=${params.learningContext.change} file=${params.learningContext.path}`
+    );
+    if (params.learningContext.recommended_actions[0]) {
+      hints.push(`LEARNING_NEXT_ACTION: ${params.learningContext.recommended_actions[0]}`);
+    }
+  }
   return hints;
 };
 
@@ -111,6 +121,7 @@ export type EnterprisePreFlightCheckResult = {
     skills_contract: ReturnType<typeof evaluateAiGate>['skills_contract'];
     repo_state: ReturnType<typeof evaluateAiGate>['repo_state'];
     hints: ReadonlyArray<string>;
+    learning_context: SddLearningContext | null;
     ast_analysis: null;
     tdd_status: null;
   };
@@ -126,6 +137,9 @@ export const runEnterprisePreFlightCheck = (params: {
     stage: params.stage,
     requireMcpReceipt: params.requireMcpReceipt ?? false,
   });
+  const learningContext = readSddLearningContext({
+    repoRoot: params.repoRoot,
+  });
 
   const hints = buildPreFlightHints({
     repoRoot: params.repoRoot,
@@ -133,6 +147,7 @@ export const runEnterprisePreFlightCheck = (params: {
     status: evaluation.status,
     violations: evaluation.violations,
     upstream: evaluation.repo_state.git.upstream,
+    learningContext,
   });
   const phase: 'GREEN' | 'RED' = evaluation.allowed ? 'GREEN' : 'RED';
   const message = evaluation.allowed
@@ -161,6 +176,7 @@ export const runEnterprisePreFlightCheck = (params: {
       skills_contract: evaluation.skills_contract,
       repo_state: evaluation.repo_state,
       hints,
+      learning_context: learningContext,
       ast_analysis: null,
       tdd_status: null,
     },

package/integrations/sdd/learningInsights.ts

@@ -0,0 +1,91 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { readSddSession } from './sessionStore';
+
+type LearningArtifact = {
+  generated_at?: unknown;
+  failed_patterns?: unknown;
+  successful_patterns?: unknown;
+  rule_updates?: unknown;
+  gate_anomalies?: unknown;
+};
+
+export type SddLearningContext = {
+  change: string;
+  path: string;
+  generated_at: string | null;
+  failed_patterns: string[];
+  successful_patterns: string[];
+  rule_updates: string[];
+  gate_anomalies: string[];
+  recommended_actions: string[];
+};
+
+const toStringArray = (value: unknown): string[] => {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item): item is string => typeof item === 'string');
+};
+
+const toRecommendedActions = (ruleUpdates: string[]): string[] => {
+  const actions: string[] = [];
+  for (const rule of ruleUpdates) {
+    if (rule === 'evidence.bootstrap.required' || rule === 'evidence.rebuild.required') {
+      actions.push(
+        'Regenera evidencia y vuelve a validar PRE_WRITE para estabilizar el gate.'
+      );
+      continue;
+    }
+    if (rule.startsWith('ai-gate.violation.')) {
+      actions.push('Corrige la violación de gate indicada y reejecuta validate/hook.');
+      continue;
+    }
+    if (rule.startsWith('sdd.')) {
+      actions.push('Completa el contrato SDD del cambio activo antes de cerrar stage.');
+      continue;
+    }
+  }
+  return [...new Set(actions)];
+};
+
+export const readSddLearningContext = (params: {
+  repoRoot: string;
+  change?: string | null;
+}): SddLearningContext | null => {
+  const repoRoot = resolve(params.repoRoot);
+  const explicitChange = params.change?.trim().toLowerCase() ?? null;
+  const session = readSddSession(repoRoot);
+  const change = explicitChange ?? session.changeId ?? null;
+  if (!change) {
+    return null;
+  }
+
+  const relativePath = `openspec/changes/${change}/learning.json`;
+  const absolutePath = resolve(repoRoot, relativePath);
+  if (!existsSync(absolutePath)) {
+    return null;
+  }
+
+  let parsed: LearningArtifact;
+  try {
+    parsed = JSON.parse(readFileSync(absolutePath, 'utf8')) as LearningArtifact;
+  } catch {
+    return null;
+  }
+
+  const ruleUpdates = toStringArray(parsed.rule_updates);
+  return {
+    change,
+    path: relativePath,
+    generated_at:
+      typeof parsed.generated_at === 'string' && parsed.generated_at.trim().length > 0
+        ? parsed.generated_at
+        : null,
+    failed_patterns: toStringArray(parsed.failed_patterns),
+    successful_patterns: toStringArray(parsed.successful_patterns),
+    rule_updates: ruleUpdates,
+    gate_anomalies: toStringArray(parsed.gate_anomalies),
+    recommended_actions: toRecommendedActions(ruleUpdates),
+  };
+};