pumuki 6.3.268 → 6.3.269

package/VERSION

@@ -1 +1 @@
-v6.3.238
+v6.3.269

package/docs/governance/CONTRIBUTING.md

@@ -89,4 +89,4 @@ npm run test:heuristics
 ## Notes for automation contributors
 
 This repository still contains legacy hooks/scripts for compatibility.
-For framework refactor commits, maintainers may use `--no-verify` to avoid unrelated legacy hook failures.
+Framework refactor commits must run through the managed hooks; bypassing verification is not an accepted maintainer workflow.

package/integrations/config/coreSkillsLock.ts

@@ -20,7 +20,8 @@ export const resolveCoreSkillsLockForPackageRoot = (
     if (compiledLock.bundles.length > 0) {
       return compiledLock;
     }
-  } catch {
+  } catch (error) {
+    void error;
   }
 
   return loadSkillsLock(packageRoot);

package/integrations/config/skillsDetectorRegistry.ts

@@ -427,6 +427,16 @@ const registryByRuleId: Record<string, SkillsDetectorBinding> = {
   'skills.frontend.no-god-classes': heuristicDetector('typescript.god-class', [
     'heuristics.ts.god-class-large-class.ast',
   ]),
+  'skills.ios.guideline.ios.verificar-que-no-viole-solid-srp-ocp-lsp-isp-dip': heuristicDetector(
+    'ios.solid',
+    [
+      'heuristics.ios.solid.srp.presentation-mixed-responsibilities.ast',
+      'heuristics.ios.solid.ocp.discriminator-switch.ast',
+      'heuristics.ios.solid.dip.concrete-framework-dependency.ast',
+      'heuristics.ios.solid.isp.fat-protocol-dependency.ast',
+      'heuristics.ios.solid.lsp.narrowed-precondition.ast',
+    ]
+  ),
   'skills.android.no-thread-sleep': heuristicDetector('android.thread-sleep', [
     'heuristics.android.thread-sleep.ast',
   ]),
@@ -505,6 +515,14 @@ const registryByRuleId: Record<string, SkillsDetectorBinding> = {
     'heuristics.android.solid.isp.fat-interface-dependency.ast',
     'heuristics.android.solid.lsp.narrowed-precondition.ast',
   ]),
+  'skills.android.guideline.android.verificar-que-no-viole-solid-srp-ocp-lsp-isp-dip':
+    heuristicDetector('android.solid', [
+      'heuristics.android.solid.srp.presentation-mixed-responsibilities.ast',
+      'heuristics.android.solid.ocp.discriminator-branching.ast',
+      'heuristics.android.solid.dip.concrete-framework-dependency.ast',
+      'heuristics.android.solid.isp.fat-interface-dependency.ast',
+      'heuristics.android.solid.lsp.narrowed-precondition.ast',
+    ]),
 };
 
 export const listSkillsDetectorBindings = (): ReadonlyArray<{

package/integrations/config/skillsRuleClassification.ts

@@ -0,0 +1,147 @@
+import type { SkillsCompiledRule, SkillsLockV1 } from './skillsLock';
+import { resolveMappedHeuristicRuleIdsForCompiledRule } from './skillsDetectorRegistry';
+
+export type SkillsRuleClassificationStatus =
+  | 'AST_IMPLEMENTED'
+  | 'IMPLEMENTABLE_AHORA'
+  | 'REQUIERE_ESTUDIO'
+  | 'NO_ES_REGLA_DE_CODIGO';
+
+export type ClassifiedSkillsRule = {
+  ruleId: string;
+  platform: SkillsCompiledRule['platform'];
+  sourceSkill: string;
+  sourcePath: string;
+  evaluationMode: 'AUTO' | 'DECLARATIVE';
+  severity: SkillsCompiledRule['severity'];
+  status: SkillsRuleClassificationStatus;
+  reason: string;
+  astNodeIds: ReadonlyArray<string>;
+};
+
+export type SkillsRuleClassificationSummary = {
+  total: number;
+  byStatus: Record<SkillsRuleClassificationStatus, number>;
+  byPlatform: Record<string, number>;
+  rules: ReadonlyArray<ClassifiedSkillsRule>;
+};
+
+const emptyStatusCounts = (): Record<SkillsRuleClassificationStatus, number> => ({
+  AST_IMPLEMENTED: 0,
+  IMPLEMENTABLE_AHORA: 0,
+  REQUIERE_ESTUDIO: 0,
+  NO_ES_REGLA_DE_CODIGO: 0,
+});
+
+const normalizeText = (value: string): string =>
+  value
+    .normalize('NFD')
+    .replace(/\p{Diacritic}/gu, '')
+    .toLowerCase();
+
+const NON_CODE_RULE_PATTERNS: ReadonlyArray<RegExp> = [
+  /\bactua como\b/,
+  /\bsiempre responder\b/,
+  /\bflujo bdd\b/,
+  /\bfeature files\b/,
+  /\bspecs\b.*\bimplementacion\b/,
+  /\bcomprobar que compile\b/,
+  /\banalizar estructura existente\b/,
+  /\bandroid profiler\b/,
+  /\bxcode instruments\b/,
+  /\bdocumentation\b/,
+  /\bdocumentacion\b/,
+  /\breadme\b/,
+  /\bci\/cd\b/,
+];
+
+const isNonCodeRule = (rule: SkillsCompiledRule): boolean => {
+  const haystack = normalizeText(`${rule.id} ${rule.description} ${rule.sourceSkill}`);
+  return NON_CODE_RULE_PATTERNS.some((pattern) => pattern.test(haystack));
+};
+
+const classifyRule = (rule: SkillsCompiledRule): ClassifiedSkillsRule => {
+  const evaluationMode = rule.evaluationMode ?? 'AUTO';
+  const astNodeIds = resolveMappedHeuristicRuleIdsForCompiledRule(rule);
+
+  if (astNodeIds.length > 0) {
+    return {
+      ruleId: rule.id,
+      platform: rule.platform,
+      sourceSkill: rule.sourceSkill,
+      sourcePath: rule.sourcePath,
+      evaluationMode,
+      severity: rule.severity,
+      status: 'AST_IMPLEMENTED',
+      reason: `Mapped to AST/nodal detector(s): ${astNodeIds.join(', ')}`,
+      astNodeIds,
+    };
+  }
+
+  if (evaluationMode === 'AUTO') {
+    return {
+      ruleId: rule.id,
+      platform: rule.platform,
+      sourceSkill: rule.sourceSkill,
+      sourcePath: rule.sourcePath,
+      evaluationMode,
+      severity: rule.severity,
+      status: 'IMPLEMENTABLE_AHORA',
+      reason: 'AUTO rule without AST/nodal detector binding; implement detector mapping.',
+      astNodeIds,
+    };
+  }
+
+  if (isNonCodeRule(rule)) {
+    return {
+      ruleId: rule.id,
+      platform: rule.platform,
+      sourceSkill: rule.sourceSkill,
+      sourcePath: rule.sourcePath,
+      evaluationMode,
+      severity: rule.severity,
+      status: 'NO_ES_REGLA_DE_CODIGO',
+      reason: 'Process, documentation, validation workflow, or operating rule; keep outside code AST runtime.',
+      astNodeIds,
+    };
+  }
+
+  return {
+    ruleId: rule.id,
+    platform: rule.platform,
+    sourceSkill: rule.sourceSkill,
+    sourcePath: rule.sourcePath,
+    evaluationMode,
+    severity: rule.severity,
+    status: 'REQUIERE_ESTUDIO',
+    reason: 'Declarative skill rule without AST/nodal detector. Study exact code pattern, AST node, and closure criterion.',
+    astNodeIds,
+  };
+};
+
+export const classifySkillsRules = (
+  lock: SkillsLockV1
+): SkillsRuleClassificationSummary => {
+  const rules = lock.bundles
+    .flatMap((bundle) => bundle.rules)
+    .filter((rule) => rule.id.startsWith('skills.'))
+    .map(classifyRule)
+    .sort((left, right) => left.ruleId.localeCompare(right.ruleId));
+
+  const byStatus = emptyStatusCounts();
+  const byPlatform: Record<string, number> = {};
+
+  for (const rule of rules) {
+    byStatus[rule.status] += 1;
+    byPlatform[rule.platform] = (byPlatform[rule.platform] ?? 0) + 1;
+  }
+
+  return {
+    total: rules.length,
+    byStatus,
+    byPlatform: Object.fromEntries(
+      Object.entries(byPlatform).sort(([left], [right]) => left.localeCompare(right))
+    ),
+    rules,
+  };
+};

package/integrations/git/runPlatformGate.ts

@@ -43,6 +43,8 @@ import {
   readPreWriteLeaseStatus,
   toPreWriteEnforcementGapFinding,
 } from '../lifecycle/preWriteLease';
+import { evaluateContextGate, type ContextGateResult } from '../context/contextGate';
+import { emitGateBlockedNotification } from '../notifications/emitAuditSummaryNotification';
 
 export type OperationalMemoryShadowRecommendation = {
   recommendedOutcome: 'ALLOW' | 'WARN' | 'BLOCK';
@@ -77,6 +79,8 @@ export type GateDependencies = {
     stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
     branch: string | null;
   }) => GateWaiverResult;
+  evaluateContextGate: typeof evaluateContextGate;
+  notifyGateBlocked: typeof emitGateBlockedNotification;
 };
 
 const defaultServices: GateServices = {
@@ -109,20 +113,8 @@ const normalizeScopedRuleEngineFindings = (params: {
   findings: ReadonlyArray<Finding>;
   scope: GateScope;
 }): ReadonlyArray<Finding> => {
-  if (params.scope.kind !== 'staged' && params.scope.kind !== 'range') {
-    return params.findings;
-  }
-
-  return params.findings.filter((finding) => {
-    if (
-      !finding.filePath ||
-      hasActionableFindingLocation(finding) ||
-      (!finding.ruleId.startsWith('skills.') && !finding.ruleId.startsWith('heuristics.'))
-    ) {
-      return true;
-    }
-    return false;
-  });
+  void params.scope;
+  return params.findings;
 };
 
 const buildDefaultMemoryShadowRecommendation = (params: {
@@ -199,6 +191,8 @@ const defaultDependencies: GateDependencies = {
       stage,
       branch,
     }),
+  evaluateContextGate,
+  notifyGateBlocked: emitGateBlockedNotification,
 };
 
 const readSymbolicBranchRef = (git: IGitService, repoRoot: string): string | null => {
@@ -287,6 +281,34 @@ const toSkillsUnsupportedAutoRulesBlockingFinding = (params: {
   };
 };
 
+const toSkillsDeclarativeRulesClassificationFinding = (params: {
+  stage: 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+  declarativeRuleIds: ReadonlyArray<string>;
+  facts: ReadonlyArray<Fact>;
+}): Finding | undefined => {
+  if (params.declarativeRuleIds.length === 0) {
+    return undefined;
+  }
+  if (collectObservedCodePathsFromFacts(params.facts).length === 0) {
+    return undefined;
+  }
+
+  const sampleRuleIds = [...params.declarativeRuleIds].sort().slice(0, 12).join(', ');
+
+  return {
+    ruleId: 'governance.skills.declarative-rules.classification-required',
+    severity: 'ERROR',
+    code: 'SKILLS_DECLARATIVE_RULES_CLASSIFICATION_REQUIRED',
+    message:
+      `Skills declarative rules require AST/nodal classification at ${params.stage}: ` +
+      `total=${params.declarativeRuleIds.length} sample_rule_ids=[${sampleRuleIds}]. ` +
+      'Classify every rule as IMPLEMENTABLE_AHORA, REQUIERE_ESTUDIO, or NO_ES_REGLA_DE_CODIGO; code skills cannot remain as hidden declarative/advisory rules.',
+    filePath: 'skills.lock.json',
+    matchedBy: 'SkillsDeclarativeRulesClassificationGuard',
+    source: 'skills-declarative-rules-classification',
+  };
+};
+
 const PLATFORM_SKILLS_RULE_PREFIXES: Record<
   'ios' | 'android' | 'backend' | 'frontend',
   string
@@ -808,6 +830,15 @@ const shouldBlockFromFinding = (finding: Finding | undefined): boolean => {
   return finding.blocking !== false;
 };
 
+const resolvePrimaryBlockingFinding = (
+  findings: ReadonlyArray<Finding>
+): Finding | undefined => (
+  findings.find((finding) => shouldBlockFromFinding(finding) && finding.severity === 'CRITICAL') ??
+  findings.find((finding) => shouldBlockFromFinding(finding) && finding.severity === 'ERROR') ??
+  findings.find((finding) => shouldBlockFromFinding(finding)) ??
+  findings[0]
+);
+
 const applySkillsFindingEnforcement = (
   finding: Finding | undefined
 ): Finding | undefined => {
@@ -830,22 +861,9 @@ const toSoftPreCommitSkillsFinding = (params: {
   enabled: boolean;
   observedCodePaths: ReadonlyArray<string>;
 }): Finding | undefined => {
-  if (!params.finding) {
-    return undefined;
-  }
-  if (!params.enabled || !shouldBlockFromFinding(params.finding)) {
-    return params.finding;
-  }
-  return {
-    ...params.finding,
-    severity: 'WARN',
-    blocking: false,
-    code: `${params.finding.code}_SOFT_PRECOMMIT`,
-    message:
-      `${params.finding.message} ` +
-      `Soft-enforced at PRE_COMMIT for low-risk scope (observed_code_paths=${params.observedCodePaths.length}). ` +
-      'Strict enforcement remains active at PRE_PUSH/CI.',
-  };
+  void params.enabled;
+  void params.observedCodePaths;
+  return params.finding;
 };
 
 export async function runPlatformGate(params: {
@@ -868,6 +886,11 @@ export async function runPlatformGate(params: {
   const repoRoot = git.resolveRepoRoot();
   const auditMode = params.auditMode ?? 'gate';
   const shouldShortCircuitSdd = params.sddShortCircuit ?? false;
+  const contextGate: ContextGateResult = dependencies.evaluateContextGate({
+    repoRoot,
+    stage: params.policy.stage,
+  });
+  const contextBlockingFinding = contextGate.finding;
   let sddDecision:
     | Pick<SddDecision, 'allowed' | 'code' | 'message'>
     | undefined;
@@ -1016,6 +1039,16 @@ export async function runPlatformGate(params: {
         unsupportedAutoRuleIds: skillsRuleSet.unsupportedAutoRuleIds ?? [],
       })
       : undefined;
+  const declarativeRulesClassificationFinding =
+    params.policy.stage === 'PRE_COMMIT' ||
+    params.policy.stage === 'PRE_PUSH' ||
+    params.policy.stage === 'CI'
+      ? toSkillsDeclarativeRulesClassificationFinding({
+          stage: params.policy.stage,
+          declarativeRuleIds: skillsRuleSet.registryCoverage?.declarativeRuleIds ?? [],
+          facts: factsForPlatformEvaluation,
+        })
+      : undefined;
   const effectiveUnsupportedSkillsMappingInput = applySkillsFindingEnforcement(
     unsupportedSkillsMappingFinding
   );
@@ -1217,6 +1250,7 @@ export async function runPlatformGate(params: {
     && !degradedModeBlocks
     && !shouldBlockFromFinding(policyAsCodeBlockingFinding)
     && !shouldBlockFromFinding(coverageBlockingFinding)
+    && !shouldBlockFromFinding(declarativeRulesClassificationFinding)
     && !shouldBlockFromFinding(activeRulesEmptyForCodeChangesFinding)
     && !shouldBlockFromFinding(effectiveIosTestsQualityFinding)
     && !shouldBlockFromFinding(astIntelligenceDualFinding)
@@ -1244,6 +1278,7 @@ export async function runPlatformGate(params: {
   });
   const effectiveFindings = sddBlockingFinding
     ? [
+      ...(contextBlockingFinding ? [contextBlockingFinding] : []),
       sddBlockingFinding,
       ...(degradedModeFinding ? [degradedModeFinding] : []),
       ...(preWriteLeaseFinding ? [preWriteLeaseFinding] : []),
@@ -1256,6 +1291,7 @@ export async function runPlatformGate(params: {
       ...(effectiveIosTestsQualityFinding ? [effectiveIosTestsQualityFinding] : []),
       ...(astIntelligenceDualFinding ? [astIntelligenceDualFinding] : []),
       ...(coverageBlockingFinding ? [coverageBlockingFinding] : []),
+      ...(declarativeRulesClassificationFinding ? [declarativeRulesClassificationFinding] : []),
       ...brownfieldHotspotFindings,
       ...tddBddEvaluation.findings,
       ...findings,
@@ -1269,11 +1305,14 @@ export async function runPlatformGate(params: {
       || effectiveIosTestsQualityFinding
       || astIntelligenceDualFinding
       || coverageBlockingFinding
+      || declarativeRulesClassificationFinding
       || brownfieldHotspotFindings.length > 0
       || policyAsCodeBlockingFinding
+      || contextBlockingFinding
       || degradedModeFinding
       || tddBddEvaluation.findings.length > 0
       ? [
+        ...(contextBlockingFinding ? [contextBlockingFinding] : []),
         ...(degradedModeFinding ? [degradedModeFinding] : []),
         ...(preWriteLeaseFinding ? [preWriteLeaseFinding] : []),
         ...(policyAsCodeBlockingFinding ? [policyAsCodeBlockingFinding] : []),
@@ -1285,6 +1324,7 @@ export async function runPlatformGate(params: {
         ...(effectiveIosTestsQualityFinding ? [effectiveIosTestsQualityFinding] : []),
         ...(astIntelligenceDualFinding ? [astIntelligenceDualFinding] : []),
         ...(coverageBlockingFinding ? [coverageBlockingFinding] : []),
+        ...(declarativeRulesClassificationFinding ? [declarativeRulesClassificationFinding] : []),
         ...brownfieldHotspotFindings,
         ...tddBddEvaluation.findings,
         ...findings,
@@ -1304,6 +1344,7 @@ export async function runPlatformGate(params: {
   );
   const baseGateOutcome =
     sddBlockingFinding ||
+    shouldBlockFromFinding(contextBlockingFinding) ||
     degradedModeBlocks ||
     shouldBlockFromFinding(preWriteLeaseFinding) ||
     shouldBlockFromFinding(policyAsCodeBlockingFinding) ||
@@ -1315,6 +1356,7 @@ export async function runPlatformGate(params: {
     shouldBlockFromFinding(effectiveIosTestsQualityFinding) ||
     hasAstIntelligenceBlockingFinding ||
     shouldBlockFromFinding(coverageBlockingFinding) ||
+    shouldBlockFromFinding(declarativeRulesClassificationFinding) ||
     brownfieldHotspotFindings.some((finding) => shouldBlockFromFinding(finding)) ||
     hasTddBddBlockingFinding
       ? 'BLOCK'
@@ -1432,6 +1474,34 @@ export async function runPlatformGate(params: {
   });
 
   if (gateOutcome === 'BLOCK') {
+    const primaryBlockingFinding = resolvePrimaryBlockingFinding(findingsWithWaiver);
+    if (
+      primaryBlockingFinding &&
+      (
+        params.policy.stage === 'PRE_COMMIT' ||
+        params.policy.stage === 'PRE_PUSH' ||
+        params.policy.stage === 'CI'
+      )
+    ) {
+      const notificationResult = dependencies.notifyGateBlocked({
+        repoRoot,
+        stage: params.policy.stage,
+        totalViolations: findingsWithWaiver.length,
+        causeCode: primaryBlockingFinding.code ?? primaryBlockingFinding.ruleId,
+        causeMessage: primaryBlockingFinding.message,
+        remediation:
+          primaryBlockingFinding.expected_fix ??
+          'Corrige la causa bloqueante y reejecuta el gate.',
+      });
+      process.stderr.write(
+        `[pumuki][blocked] code=${primaryBlockingFinding.code ?? primaryBlockingFinding.ruleId} ` +
+        `stage=${params.policy.stage} reason=${primaryBlockingFinding.message}\n`
+      );
+      process.stderr.write(
+        `[pumuki][notification] delivered=${notificationResult.delivered ? 'yes' : 'no'} ` +
+        `reason=${notificationResult.reason}\n`
+      );
+    }
     if (params.silent !== true) {
     dependencies.printGateFindings(findingsWithWaiver);
     }

package/integrations/lifecycle/cli.ts

@@ -76,6 +76,11 @@ import {
 import { runPolicyReconcile } from './policyReconcile';
 import { runLifecycleAudit, type LifecycleAuditStage } from './audit';
 import { resolvePreWriteEnforcement, type PreWriteEnforcementResolution } from '../policy/preWriteEnforcement';
+import {
+  readLocalContextStatus,
+  repairLocalContext,
+  writeLocalContext,
+} from '../context/contextGate';
 
 type LifecycleCommand =
   | 'bootstrap'
@@ -92,6 +97,7 @@ type LifecycleCommand =
   | 'adapter'
   | 'analytics'
   | 'policy'
+  | 'context'
   | 'audit';
 
 type SddCommand =
@@ -107,6 +113,7 @@ type LoopCommand = 'run' | 'status' | 'stop' | 'resume' | 'list' | 'export';
 type AnalyticsCommand = 'hotspots';
 type AnalyticsHotspotsCommand = 'report' | 'diagnose';
 type PolicyCommand = 'reconcile';
+type ContextCommand = 'init' | 'status' | 'repair';
 
 type SddSessionAction = 'open' | 'refresh' | 'close';
 
@@ -178,6 +185,7 @@ export type ParsedArgs = {
   policyCommand?: PolicyCommand;
   policyStrict?: boolean;
   policyApply?: boolean;
+  contextCommand?: ContextCommand;
   auditStage?: LifecycleAuditStage;
   auditEngine?: boolean;
 };
@@ -204,6 +212,9 @@ Pumuki lifecycle commands:
   pumuki analytics hotspots report [--top=<n>] [--since-days=<n>] [--json] [--output-json=<path>] [--output-markdown=<path>]
   pumuki analytics hotspots diagnose [--json]
   pumuki policy reconcile [--strict] [--apply] [--json]
+  pumuki context init [--json]
+  pumuki context status [--json]
+  pumuki context repair [--json]
   pumuki sdd status [--json]
   pumuki sdd validate [--stage=PRE_WRITE|PRE_COMMIT|PRE_PUSH|CI] [--json]
   pumuki sdd session --open --change=<change-id|auto> [--ttl-minutes=<n>] [--json]
@@ -239,6 +250,7 @@ const isLifecycleCommand = (value: string): value is LifecycleCommand =>
   value === 'adapter' ||
   value === 'analytics' ||
   value === 'policy' ||
+  value === 'context' ||
   value === 'audit';
 
 const parseAdapterAgent = (value?: string): AdapterAgent => {
@@ -651,6 +663,7 @@ export const parseLifecycleCliArgs = (argv: ReadonlyArray<string>): ParsedArgs =
   let analyticsSinceDays: ParsedArgs['analyticsSinceDays'];
   let analyticsJsonOutputPath: ParsedArgs['analyticsJsonOutputPath'];
   let analyticsMarkdownOutputPath: ParsedArgs['analyticsMarkdownOutputPath'];
+  let contextCommand: ParsedArgs['contextCommand'];
   let auditStage: LifecycleAuditStage | undefined;
   let auditEngine = false;
 
@@ -863,6 +876,31 @@ export const parseLifecycleCliArgs = (argv: ReadonlyArray<string>): ParsedArgs =
     };
   }
 
+  if (commandRaw === 'context') {
+    const subcommandRaw = argv[1] ?? 'status';
+    if (
+      subcommandRaw !== 'init' &&
+      subcommandRaw !== 'status' &&
+      subcommandRaw !== 'repair'
+    ) {
+      throw new Error(`Unsupported context subcommand "${subcommandRaw}".\n\n${HELP_TEXT}`);
+    }
+    contextCommand = subcommandRaw;
+    for (const arg of argv.slice(2)) {
+      if (arg === '--json') {
+        json = true;
+        continue;
+      }
+      throw new Error(`Unsupported argument "${arg}".\n\n${HELP_TEXT}`);
+    }
+    return {
+      command: commandRaw,
+      purgeArtifacts: false,
+      json,
+      contextCommand,
+    };
+  }
+
   if (commandRaw === 'loop') {
     const subcommandRaw = argv[1] ?? '';
     if (
@@ -1582,6 +1620,16 @@ const printDoctorReport = (
     `PRE_PUSH=${report.policyValidation.stages.PRE_PUSH.validationCode ?? 'n/a'} strict=${report.policyValidation.stages.PRE_PUSH.strict ? 'yes' : 'no'} ` +
     `CI=${report.policyValidation.stages.CI.validationCode ?? 'n/a'} strict=${report.policyValidation.stages.CI.strict ? 'yes' : 'no'}`
   );
+  writeInfo(
+    `[pumuki] notifications: enabled=${report.notifications.enabled ? 'yes' : 'no'} ` +
+    `deliverable=${report.notifications.deliverable ? 'yes' : 'no'} ` +
+    `channel=${report.notifications.channel} ` +
+    `blocked_dialog=${report.notifications.blockedDialogEnabled ? 'yes' : 'no'} ` +
+    `reason=${report.notifications.disabledReason ?? 'none'}`
+  );
+  if (report.notifications.remediation) {
+    writeInfo(`[pumuki] notifications remediation: ${report.notifications.remediation}`);
+  }
 
   for (const issue of report.issues) {
     writeInfo(`[pumuki] ${issue.severity.toUpperCase()}: ${issue.message}`);
@@ -2377,6 +2425,28 @@ export const runLifecycleCli = async (
         }
         return result.gate_exit_code;
       }
+      case 'context': {
+        const repoRoot = process.cwd();
+        const result =
+          parsed.contextCommand === 'init'
+            ? writeLocalContext(repoRoot)
+            : parsed.contextCommand === 'repair'
+              ? repairLocalContext(repoRoot)
+              : readLocalContextStatus(repoRoot);
+        if (parsed.json) {
+          writeInfo(JSON.stringify(result, null, 2));
+        } else {
+          writeInfo(`[pumuki][context] status=${result.status}`);
+          writeInfo(`[pumuki][context] path=${result.path}`);
+          writeInfo(`[pumuki][context] ${result.message}`);
+          if (result.document) {
+            writeInfo(`[pumuki][context] repo=${result.document.repo_root}`);
+            writeInfo(`[pumuki][context] agent=${result.document.contract.agent_instruction}`);
+            writeInfo(`[pumuki][context] user=${result.document.contract.user_remediation}`);
+          }
+        }
+        return result.status === 'ok' ? 0 : 1;
+      }
       case 'doctor': {
         const report = runLifecycleDoctor({
           deep: parsed.doctorDeep === true,
@@ -2467,6 +2537,16 @@ export const runLifecycleCli = async (
             `PRE_PUSH=${status.policyValidation.stages.PRE_PUSH.validationCode ?? 'n/a'} strict=${status.policyValidation.stages.PRE_PUSH.strict ? 'yes' : 'no'} ` +
             `CI=${status.policyValidation.stages.CI.validationCode ?? 'n/a'} strict=${status.policyValidation.stages.CI.strict ? 'yes' : 'no'}`
           );
+          writeInfo(
+            `[pumuki] notifications: enabled=${status.notifications.enabled ? 'yes' : 'no'} ` +
+            `deliverable=${status.notifications.deliverable ? 'yes' : 'no'} ` +
+            `channel=${status.notifications.channel} ` +
+            `blocked_dialog=${status.notifications.blockedDialogEnabled ? 'yes' : 'no'} ` +
+            `reason=${status.notifications.disabledReason ?? 'none'}`
+          );
+          if (status.notifications.remediation) {
+            writeInfo(`[pumuki] notifications remediation: ${status.notifications.remediation}`);
+          }
           writeInfo(
             `[pumuki] experimental: ANALYTICS=${status.experimentalFeatures.features.analytics.mode} source=${status.experimentalFeatures.features.analytics.source} layer=${status.experimentalFeatures.features.analytics.layer} blocking=${status.experimentalFeatures.features.analytics.blocking ? 'yes' : 'no'} env=${status.experimentalFeatures.features.analytics.activationVariable}`
           );

package/integrations/lifecycle/doctor.ts

@@ -21,6 +21,10 @@ import {
   type LifecycleDependencyInventory,
 } from './dependencyInventory';
 import { readPreWriteLeaseStatus } from './preWriteLease';
+import {
+  readLifecycleNotificationStatus,
+  type LifecycleNotificationStatus,
+} from './notificationStatus';
 
 export type DoctorIssueSeverity = 'warning' | 'error';
 
@@ -102,6 +106,7 @@ export type LifecycleDoctorReport = {
   hooksDirectory: string;
   hooksDirectoryResolution: 'git-rev-parse' | 'git-config' | 'default';
   policyValidation: LifecyclePolicyValidationSnapshot;
+  notifications: LifecycleNotificationStatus;
   policy_signature_remediation?: string;
   issues: ReadonlyArray<DoctorIssue>;
   deep?: DoctorDeepReport;
@@ -117,6 +122,9 @@ const buildDoctorIssues = (params: {
   lifecycleState: LifecycleState;
 }): ReadonlyArray<DoctorIssue> => {
   const issues: DoctorIssue[] = [];
+  const notificationStatus = readLifecycleNotificationStatus({
+    repoRoot: params.repoRoot,
+  });
   const evidenceResult = readEvidenceResult(params.repoRoot);
   const preWriteLeaseStatus = readPreWriteLeaseStatus({
     repoRoot: params.repoRoot,
@@ -132,6 +140,15 @@ const buildDoctorIssues = (params: {
     });
   }
 
+  if (!notificationStatus.deliverable) {
+    issues.push({
+      severity: 'warning',
+      message:
+        `System notifications are not deliverable (${notificationStatus.disabledReason ?? 'unknown'}). ` +
+        `${notificationStatus.remediation ?? 'Review notification configuration.'}`,
+    });
+  }
+
   if (params.trackedNodeModulesPaths.length > 0) {
     issues.push({
       severity: 'error',
@@ -900,6 +917,7 @@ export const runLifecycleDoctor = (params?: {
 
   const policyValidation = readLifecyclePolicyValidationSnapshot(repoRoot);
   const policySignatureRemediation = buildPolicySignatureRemediation(policyValidation);
+  const notifications = readLifecycleNotificationStatus({ repoRoot });
 
   return {
     repoRoot,
@@ -912,6 +930,7 @@ export const runLifecycleDoctor = (params?: {
     hooksDirectory: hooksDirectory.path,
     hooksDirectoryResolution: hooksDirectory.source,
     policyValidation,
+    notifications,
     ...(policySignatureRemediation
       ? { policy_signature_remediation: policySignatureRemediation }
       : {}),

package/integrations/lifecycle/install.ts

@@ -15,6 +15,11 @@ import { ensureRuntimeArtifactsIgnored } from './artifacts';
 import { runLifecycleAdapterInstall } from './adapter';
 import { runPolicyReconcile } from './policyReconcile';
 import { emitGateBlockedNotification } from '../notifications/emitAuditSummaryNotification';
+import { persistSystemNotificationsConfig } from '../../scripts/framework-menu-system-notifications-config';
+import {
+  readLifecycleNotificationStatus,
+  type LifecycleNotificationStatus,
+} from './notificationStatus';
 
 export type LifecycleInstallResult = {
   repoRoot: string;
@@ -22,6 +27,7 @@ export type LifecycleInstallResult = {
   changedHooks: ReadonlyArray<string>;
   openSpecBootstrap?: OpenSpecBootstrapResult;
   degradedDoctorBypass?: boolean;
+  notifications: LifecycleNotificationStatus;
 };
 
 const shouldBootstrapEvidence = (repoRoot: string): boolean =>
@@ -102,6 +108,11 @@ const materializeStrictPolicyAsCode = (repoRoot: string): void => {
 const isPreWriteEnforcementGapIssue = (message: string): boolean =>
   message.startsWith('ENFORCEMENT_GAP: PRE_WRITE hard-stop lease is not valid');
 
+const ensureInstallNotificationsEnabled = (repoRoot: string): LifecycleNotificationStatus => {
+  persistSystemNotificationsConfig(repoRoot, true);
+  return readLifecycleNotificationStatus({ repoRoot });
+};
+
 export const runLifecycleInstall = (params?: {
   cwd?: string;
   git?: ILifecycleGitService;
@@ -117,6 +128,7 @@ export const runLifecycleInstall = (params?: {
     cwd: params?.cwd,
     git,
   });
+  const notifications = ensureInstallNotificationsEnabled(report.repoRoot);
   const installBlockingIssues = report.issues.filter(
     (issue) => issue.severity === 'error' && !isPreWriteEnforcementGapIssue(issue.message)
   );
@@ -141,6 +153,7 @@ export const runLifecycleInstall = (params?: {
         changedHooks,
         openSpecBootstrap: undefined,
         degradedDoctorBypass: true,
+        notifications,
       };
     }
     const renderedIssues = installBlockingIssues.map((issue) => `- [${issue.severity}] ${issue.message}`).join('\n');
@@ -193,5 +206,6 @@ export const runLifecycleInstall = (params?: {
     version,
     changedHooks,
     openSpecBootstrap,
+    notifications,
   };
 };

package/integrations/lifecycle/notificationStatus.ts

@@ -0,0 +1,54 @@
+import { resolveEffectiveSystemNotificationsConfig } from '../../scripts/framework-menu-system-notifications-effective-config';
+import { resolveSystemNotificationGate } from '../../scripts/framework-menu-system-notifications-gate';
+
+export type LifecycleNotificationStatus = {
+  enabled: boolean;
+  blockedDialogEnabled: boolean;
+  channel: string;
+  muteUntil: string | null;
+  deliverable: boolean;
+  disabledReason: string | null;
+  remediation: string | null;
+};
+
+const remediationForReason = (reason: string | null): string | null => {
+  if (reason === null) {
+    return null;
+  }
+  if (reason === 'disabled') {
+    return 'Activa notificaciones con la configuracion repo-local de Pumuki y elimina env vars PUMUKI_*NOTIFICATIONS que las deshabiliten.';
+  }
+  if (reason === 'muted') {
+    return 'Quita el silencio temporal desde la notificacion o elimina muteUntil en .pumuki/system-notifications.json.';
+  }
+  if (reason === 'unsupported-platform') {
+    return 'Usa el fallback stderr o configura un canal compatible para este sistema.';
+  }
+  return 'Revisa la configuracion de notificaciones y reejecuta pumuki status/doctor.';
+};
+
+export const readLifecycleNotificationStatus = (params: {
+  repoRoot: string;
+  env?: NodeJS.ProcessEnv;
+  now?: () => number;
+}): LifecycleNotificationStatus => {
+  const env = params.env ?? process.env;
+  const config = resolveEffectiveSystemNotificationsConfig({
+    repoRoot: params.repoRoot,
+  });
+  const gate = resolveSystemNotificationGate({
+    config,
+    nowMs: (params.now ?? Date.now)(),
+    env,
+  });
+  const disabledReason = gate?.reason ?? null;
+  return {
+    enabled: config.enabled,
+    blockedDialogEnabled: config.blockedDialogEnabled === true,
+    channel: config.channel,
+    muteUntil: config.muteUntil ?? null,
+    deliverable: gate === null,
+    disabledReason,
+    remediation: remediationForReason(disabledReason),
+  };
+};

package/integrations/lifecycle/status.ts

@@ -18,6 +18,10 @@ import {
   type LifecycleDependencyInventory,
 } from './dependencyInventory';
 import { readPreWriteLeaseStatus } from './preWriteLease';
+import {
+  readLifecycleNotificationStatus,
+  type LifecycleNotificationStatus,
+} from './notificationStatus';
 
 export type LifecycleStatus = {
   repoRoot: string;
@@ -31,15 +35,27 @@ export type LifecycleStatus = {
   dependencyInventory: LifecycleDependencyInventory;
   policyValidation: LifecyclePolicyValidationSnapshot;
   experimentalFeatures: LifecycleExperimentalFeaturesSnapshot;
+  notifications: LifecycleNotificationStatus;
   issues: ReadonlyArray<DoctorIssue>;
 };
 
 const buildLifecycleIssues = (repoRoot: string): ReadonlyArray<DoctorIssue> => {
+  const notificationStatus = readLifecycleNotificationStatus({ repoRoot });
   const evidenceResult = readEvidenceResult(repoRoot);
   const preWriteLeaseStatus = readPreWriteLeaseStatus({
     repoRoot,
     git: new LifecycleGitService(),
   });
+  const notificationIssues: DoctorIssue[] = notificationStatus.deliverable
+    ? []
+    : [
+        {
+          severity: 'warning',
+          message:
+            `System notifications are not deliverable (${notificationStatus.disabledReason ?? 'unknown'}). ` +
+            `${notificationStatus.remediation ?? 'Review notification configuration.'}`,
+        },
+      ];
   const leaseIssues: DoctorIssue[] =
     !preWriteLeaseStatus.valid && preWriteLeaseStatus.changedCodePaths.length > 0
       ? [
@@ -52,7 +68,7 @@ const buildLifecycleIssues = (repoRoot: string): ReadonlyArray<DoctorIssue> => {
         ]
       : [];
   if (evidenceResult.kind !== 'valid') {
-    return leaseIssues;
+    return [...notificationIssues, ...leaseIssues];
   }
 
   const evidence = evidenceResult.evidence;
@@ -63,11 +79,12 @@ const buildLifecycleIssues = (repoRoot: string): ReadonlyArray<DoctorIssue> => {
 
   if (!blocked) {
     if (evidence.snapshot.outcome !== 'WARN') {
-      return leaseIssues;
+      return [...notificationIssues, ...leaseIssues];
     }
 
     const warnStage = evidence?.snapshot?.stage ?? 'PRE_WRITE';
     return [
+      ...notificationIssues,
       ...leaseIssues,
       {
         severity: 'warning',
@@ -85,6 +102,7 @@ const buildLifecycleIssues = (repoRoot: string): ReadonlyArray<DoctorIssue> => {
     message: `Governance is blocked (${blockedStage}).`,
   });
   return [
+    ...notificationIssues,
     ...leaseIssues,
     {
       severity: 'error',
@@ -110,6 +128,7 @@ export const readLifecycleStatus = (params?: {
   });
   const policyValidation = readLifecyclePolicyValidationSnapshot(repoRoot);
   const experimentalFeatures = readLifecycleExperimentalFeaturesSnapshot();
+  const notifications = readLifecycleNotificationStatus({ repoRoot });
   const issues = buildLifecycleIssues(repoRoot);
 
   return {
@@ -124,6 +143,7 @@ export const readLifecycleStatus = (params?: {
     dependencyInventory,
     policyValidation,
     experimentalFeatures,
+    notifications,
     issues,
   };
 };

package/integrations/lifecycle/watch.ts

@@ -155,7 +155,8 @@ const defaultDependencies: LifecycleWatchDependencies = {
   ensureRuntimeArtifactsIgnored: (repoRoot) => {
     try {
       ensureRuntimeArtifactsIgnored(repoRoot);
-    } catch {
+    } catch (error) {
+      void error;
     }
   },
   emitAuditSummaryNotificationFromEvidence,

package/integrations/mcp/evidenceStdioServer.cli.ts

@@ -108,8 +108,8 @@ const startOrReuseEvidenceHttp = async (): Promise<{
     if (health.status === 'ok') {
       return { host, port: requestedPort, route };
     }
-  } catch {
-    // ignored
+  } catch (error) {
+    void error;
   }
 
   const portInUse = await isPortInUse(host, requestedPort);

package/integrations/policy/skillsEnforcement.ts

@@ -1,4 +1,4 @@
-export type SkillsEnforcementMode = 'advisory' | 'strict';
+export type SkillsEnforcementMode = 'strict';
 
 export type SkillsEnforcementResolution = {
   mode: SkillsEnforcementMode;
@@ -24,17 +24,6 @@ const toSkillsEnforcementMode = (
   ) {
     return 'strict';
   }
-  if (
-    normalized === 'advisory'
-    || normalized === 'warn'
-    || normalized === 'warning'
-    || normalized === '0'
-    || normalized === 'false'
-    || normalized === 'no'
-    || normalized === 'off'
-  ) {
-    return 'advisory';
-  }
   return null;
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.268",
+  "version": "6.3.269",
   "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": {
@@ -109,6 +109,7 @@
     "validation:consumer-startup-unblock-status": "npx --yes tsx@4.21.0 scripts/build-consumer-startup-unblock-status.ts",
     "validation:consumer-startup-triage": "npx --yes tsx@4.21.0 scripts/build-consumer-startup-triage.ts",
     "validation:mock-consumer-ab-report": "npx --yes tsx@4.21.0 scripts/build-mock-consumer-ab-report.ts",
+    "skills:classify": "npx --yes tsx@4.21.0 scripts/classify-skills-rules.ts",
     "validation:adapter-readiness": "npx --yes tsx@4.21.0 scripts/build-adapter-readiness.ts",
     "validation:adapter-real-session-report": "npx --yes tsx@4.21.0 scripts/build-adapter-real-session-report.ts",
     "validation:adapter-session-status": "npx --yes tsx@4.21.0 scripts/build-adapter-session-status.ts",

package/scripts/classify-skills-rules.ts

@@ -0,0 +1,32 @@
+import { loadSkillsLock } from '../integrations/config/skillsLock';
+import { classifySkillsRules } from '../integrations/config/skillsRuleClassification';
+
+const repoRoot = process.argv[2] ?? process.cwd();
+const lock = loadSkillsLock(repoRoot);
+
+if (!lock) {
+  process.stderr.write(`skills.lock.json not found or invalid at ${repoRoot}\n`);
+  process.exit(1);
+}
+
+const summary = classifySkillsRules(lock);
+
+process.stdout.write(`${JSON.stringify({
+  total: summary.total,
+  byStatus: summary.byStatus,
+  byPlatform: summary.byPlatform,
+  samples: {
+    AST_IMPLEMENTED: summary.rules
+      .filter((rule) => rule.status === 'AST_IMPLEMENTED')
+      .slice(0, 12),
+    IMPLEMENTABLE_AHORA: summary.rules
+      .filter((rule) => rule.status === 'IMPLEMENTABLE_AHORA')
+      .slice(0, 12),
+    REQUIERE_ESTUDIO: summary.rules
+      .filter((rule) => rule.status === 'REQUIERE_ESTUDIO')
+      .slice(0, 12),
+    NO_ES_REGLA_DE_CODIGO: summary.rules
+      .filter((rule) => rule.status === 'NO_ES_REGLA_DE_CODIGO')
+      .slice(0, 12),
+  },
+}, null, 2)}\n`);

package/scripts/framework-menu-system-notifications-cause.ts

@@ -34,6 +34,10 @@ const BLOCKED_CAUSE_SUMMARY_BY_CODE: Readonly<Record<string, string>> = {
     'Falta enforcement crítico de skills para la plataforma detectada.',
   EVIDENCE_SKILLS_CONTRACT_INCOMPLETE:
     'El contrato de skills está incompleto para este stage.',
+  CONTEXT_NOT_APPLIED:
+    'Contexto local obligatorio no aplicado.',
+  CONTEXT_INVALID:
+    'Contexto local obligatorio inválido.',
 };
 
 const ENGLISH_CAUSE_HINTS = [
@@ -70,6 +74,9 @@ const resolvePriorityCauseFromMessage = (message?: string): string | null => {
   return PRIORITY_CODES_FROM_MESSAGE.find((code) => message.includes(code)) ?? null;
 };
 
+const isCauseCodePriorityOverTracking = (causeCode: string): boolean =>
+  causeCode === 'CONTEXT_NOT_APPLIED' || causeCode === 'CONTEXT_INVALID';
+
 const buildGenericSpanishBlockedCauseSummary = (
   event: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>,
   causeCode: string
@@ -118,10 +125,13 @@ export const resolveBlockedCauseSummary = (
   if (priorityCode) {
     return BLOCKED_CAUSE_SUMMARY_BY_CODE[priorityCode];
   }
+  const mapped = BLOCKED_CAUSE_SUMMARY_BY_CODE[causeCode];
+  if (mapped && isCauseCodePriorityOverTracking(causeCode)) {
+    return mapped;
+  }
   if (trackingContext) {
     return buildNotificationTrackingCauseSummary(trackingContext);
   }
-  const mapped = BLOCKED_CAUSE_SUMMARY_BY_CODE[causeCode];
   if (mapped) {
     return mapped;
   }

package/scripts/package-install-smoke-consumer-git-payload-lib.ts

@@ -15,7 +15,7 @@ export const commitBaseline = (
   runGitStep(workspace, ['add', '.'], 'git add baseline');
   runGitStep(
     workspace,
-    ['commit', '--no-verify', '-m', 'chore: baseline'],
+    ['commit', '-m', 'chore: baseline'],
     'git commit baseline'
   );
 };
@@ -32,7 +32,7 @@ export const writeAndCommitRangePayloadForBlockMode = (
   runGitStep(workspace, ['add', '.'], 'git add range payload');
   runGitStep(
     workspace,
-    ['commit', '--no-verify', '-m', 'test: range payload for package smoke'],
+    ['commit', '-m', 'test: range payload for package smoke'],
     'git commit range payload'
   );
 };

package/scripts/package-install-smoke-consumer-git-repo-lib.ts

@@ -39,7 +39,7 @@ export const configureRemoteAndFeatureBranch = (
     workspace.tmpRoot
   );
   runGitStep(workspace, ['remote', 'add', 'origin', workspace.bareRemote], 'git remote add origin');
-  runGitStep(workspace, ['push', '--no-verify', '-u', 'origin', 'main'], 'git push origin main');
+  runGitStep(workspace, ['push', '-u', 'origin', 'main'], 'git push origin main');
   runGitStep(workspace, ['checkout', '-b', 'feature/package-smoke'], 'git checkout feature branch');
   runGitStep(
     workspace,