pumuki 6.3.51 → 6.3.53

package/README.md

@@ -34,6 +34,7 @@ Install and bootstrap:
 npm install --save-exact pumuki
 npx --yes pumuki bootstrap --enterprise --agent=codex
 npx --yes pumuki status
+npx --yes pumuki doctor --json
 ```
 
 Fallback (equivalent in pasos separados):
@@ -80,6 +81,16 @@ Expected behavior:
 - `PRE_PUSH`: blocks if branch has no upstream tracking reference.
 - `CI`: requires a valid diff range context (not `HEAD..HEAD` with ambiguous range).
 
+Version drift quick check:
+
+- `status --json` and `doctor --json` expose `version.effective`, `version.runtime`, `version.consumerInstalled`, `version.lifecycleInstalled`, `version.driftWarning`, and `version.alignmentCommand`.
+- If `driftWarning` is not `null`, align the consumer with:
+
+```bash
+npm install --save-exact pumuki@6.3.52
+npx --yes pumuki update --latest
+```
+
 ## Why Pumuki
 
 Modern teams need fast feedback with strict governance. Pumuki combines:

package/integrations/config/skillsCustomRules.ts

@@ -173,6 +173,10 @@ const computeBundleHash = (rules: ReadonlyArray<SkillsCompiledRule>): string =>
       confidence: rule.confidence ?? null,
       locked: rule.locked ?? false,
       evaluationMode: rule.evaluationMode ?? null,
+      ast_node_ids:
+        rule.astNodeIds && rule.astNodeIds.length > 0
+          ? [...new Set(rule.astNodeIds)].sort()
+          : null,
       origin: rule.origin ?? null,
       sourceSkill: rule.sourceSkill,
       sourcePath: rule.sourcePath,

package/integrations/evidence/repoState.ts

@@ -128,6 +128,7 @@ export const captureRepoState = (repoRoot: string): RepoState => {
   const statusLines = toStatusLines(safeRunGit(repoRoot, ['status', '--short']) ?? '');
   const staged = statusLines.filter((line) => line[0] && line[0] !== '?' && line[0] !== ' ').length;
   const unstaged = statusLines.filter((line) => line[1] && line[1] !== ' ').length;
+  const pendingChanges = statusLines.length;
   const { ahead, behind } = toAheadBehind(repoRoot, upstream);
   const lifecycle = readLifecycleStatusSafe(repoRoot);
   const versionMetadata = resolvePumukiVersionMetadata({ repoRoot });
@@ -146,6 +147,7 @@ export const captureRepoState = (repoRoot: string): RepoState => {
       dirty: statusLines.length > 0,
       staged: toCount(staged),
       unstaged: toCount(unstaged),
+      pending_changes: toCount(pendingChanges),
     },
     lifecycle: {
       installed: lifecycle.lifecycleState.installed === 'true',

package/integrations/evidence/schema.ts

@@ -164,6 +164,7 @@ export type RepoState = {
     dirty: boolean;
     staged: number;
     unstaged: number;
+    pending_changes?: number;
   };
   lifecycle: {
     installed: boolean;

package/integrations/gate/evaluateAiGate.ts

@@ -770,7 +770,9 @@ const collectPreWriteCoherenceViolations = (params: {
   }
 
   if (params.preWriteWorktreeHygiene.enabled && params.repoState.git.available) {
-    const pendingChanges = params.repoState.git.staged + params.repoState.git.unstaged;
+    const pendingChanges =
+      params.repoState.git.pending_changes
+      ?? (params.repoState.git.staged + params.repoState.git.unstaged);
     if (pendingChanges >= params.preWriteWorktreeHygiene.blockThreshold) {
       violations.push(
         toErrorViolation(

package/integrations/lifecycle/cli.ts

@@ -1482,7 +1482,20 @@ const printDoctorReport = (
   remoteCiDiagnostics?: RemoteCiDiagnostics
 ): void => {
   writeInfo(`[pumuki] repo: ${report.repoRoot}`);
-  writeInfo(`[pumuki] package version: ${report.packageVersion}`);
+  writeInfo(`[pumuki] effective version: ${report.version.effective}`);
+  writeInfo(`[pumuki] runtime version: ${report.version.runtime}`);
+  writeInfo(
+    `[pumuki] consumer installed version: ${report.version.consumerInstalled ?? 'unknown'}`
+  );
+  writeInfo(
+    `[pumuki] lifecycle installed version: ${report.version.lifecycleInstalled ?? 'unknown'}`
+  );
+  if (report.version.driftWarning) {
+    writeInfo(`[pumuki] version drift: ${report.version.driftWarning}`);
+    if (report.version.alignmentCommand) {
+      writeInfo(`[pumuki] version remediation: ${report.version.alignmentCommand}`);
+    }
+  }
   writeInfo(
     `[pumuki] hooks path: ${report.hooksDirectory} (${report.hooksDirectoryResolution})`
   );
@@ -2099,9 +2112,21 @@ export const runLifecycleCli = async (
           );
         } else {
           writeInfo(`[pumuki] repo: ${status.repoRoot}`);
-          writeInfo(`[pumuki] package version: ${status.packageVersion}`);
+          writeInfo(`[pumuki] effective version: ${status.version.effective}`);
+          writeInfo(`[pumuki] runtime version: ${status.version.runtime}`);
+          writeInfo(
+            `[pumuki] consumer installed version: ${status.version.consumerInstalled ?? 'unknown'}`
+          );
+          writeInfo(
+            `[pumuki] lifecycle installed version: ${status.version.lifecycleInstalled ?? 'unknown'}`
+          );
+          if (status.version.driftWarning) {
+            writeInfo(`[pumuki] version drift: ${status.version.driftWarning}`);
+            if (status.version.alignmentCommand) {
+              writeInfo(`[pumuki] version remediation: ${status.version.alignmentCommand}`);
+            }
+          }
           writeInfo(`[pumuki] lifecycle installed: ${status.lifecycleState.installed ?? 'false'}`);
-          writeInfo(`[pumuki] lifecycle version: ${status.lifecycleState.version ?? 'unknown'}`);
           writeInfo(
             `[pumuki] hooks path: ${status.hooksDirectory} (${status.hooksDirectoryResolution})`
           );

package/integrations/lifecycle/doctor.ts

@@ -4,7 +4,7 @@ import { readEvidenceResult } from '../evidence/readEvidence';
 import { resolvePolicyForStage } from '../gate/stagePolicies';
 import { getPumukiHooksStatus, resolvePumukiHooksDirectory } from './hookManager';
 import { LifecycleGitService, type ILifecycleGitService } from './gitService';
-import { getCurrentPumukiVersion } from './packageInfo';
+import { buildLifecycleVersionReport, getCurrentPumukiVersion } from './packageInfo';
 import {
   readLifecyclePolicyValidationSnapshot,
   type LifecyclePolicyValidationSnapshot,
@@ -72,6 +72,7 @@ export type DoctorCompatibilityContract = {
 export type LifecycleDoctorReport = {
   repoRoot: string;
   packageVersion: string;
+  version: ReturnType<typeof buildLifecycleVersionReport>;
   lifecycleState: LifecycleState;
   trackedNodeModulesPaths: ReadonlyArray<string>;
   hookStatus: ReturnType<typeof getPumukiHooksStatus>;
@@ -724,10 +725,15 @@ export const runLifecycleDoctor = (params?: {
       hookStatus,
     })
     : undefined;
+  const version = buildLifecycleVersionReport({
+    repoRoot,
+    lifecycleVersion: lifecycleState.version,
+  });
 
   return {
     repoRoot,
-    packageVersion: getCurrentPumukiVersion({ repoRoot }),
+    packageVersion: version.effective,
+    version,
     lifecycleState,
     trackedNodeModulesPaths,
     hookStatus,

package/integrations/lifecycle/packageInfo.ts

@@ -24,6 +24,21 @@ export type PumukiVersionMetadata = {
   source: 'consumer-node-modules' | 'runtime-package';
 };
 
+export type LifecycleVersionReport = {
+  effective: string;
+  runtime: string;
+  consumerInstalled: string | null;
+  lifecycleInstalled: string | null;
+  source: PumukiVersionMetadata['source'];
+  driftFromRuntime: boolean;
+  driftFromLifecycleInstalled: boolean;
+  driftWarning: string | null;
+  alignmentCommand: string | null;
+};
+
+export const buildLifecycleAlignmentCommand = (runtimeVersion: string): string =>
+  `npm install --save-exact pumuki@${runtimeVersion} && npx --yes --package pumuki@${runtimeVersion} pumuki install`;
+
 export const resolvePumukiVersionMetadata = (params?: { repoRoot?: string }): PumukiVersionMetadata => {
   const runtimeVersion = packageJson.version;
   const repoRoot = params?.repoRoot;
@@ -51,3 +66,37 @@ export const getCurrentPumukiVersion = (params?: { repoRoot?: string }): string
 };
 
 export const getCurrentPumukiPackageName = (): string => packageJson.name;
+
+export const buildLifecycleVersionReport = (params?: {
+  repoRoot?: string;
+  lifecycleVersion?: string | null | undefined;
+}): LifecycleVersionReport => {
+  const metadata = resolvePumukiVersionMetadata({ repoRoot: params?.repoRoot });
+  const lifecycleInstalled =
+    typeof params?.lifecycleVersion === 'string' && params.lifecycleVersion.trim().length > 0
+      ? params.lifecycleVersion.trim()
+      : null;
+  const driftFromRuntime = metadata.resolvedVersion !== metadata.runtimeVersion;
+  const driftFromLifecycleInstalled =
+    lifecycleInstalled !== null && metadata.resolvedVersion !== lifecycleInstalled;
+  const driftTargets = [
+    driftFromRuntime ? `runtime=${metadata.runtimeVersion}` : null,
+    driftFromLifecycleInstalled ? `lifecycle=${lifecycleInstalled}` : null,
+  ].filter((value): value is string => value !== null);
+
+  return {
+    effective: metadata.resolvedVersion,
+    runtime: metadata.runtimeVersion,
+    consumerInstalled: metadata.consumerInstalledVersion,
+    lifecycleInstalled,
+    source: metadata.source,
+    driftFromRuntime,
+    driftFromLifecycleInstalled,
+    driftWarning:
+      driftTargets.length > 0
+        ? `Version drift detectado: effective=${metadata.resolvedVersion} ${driftTargets.join(' ')}.`
+        : null,
+    alignmentCommand:
+      driftTargets.length > 0 ? buildLifecycleAlignmentCommand(metadata.runtimeVersion) : null,
+  };
+};

package/integrations/lifecycle/status.ts

@@ -1,6 +1,6 @@
 import { getPumukiHooksStatus, resolvePumukiHooksDirectory } from './hookManager';
 import { LifecycleGitService, type ILifecycleGitService } from './gitService';
-import { getCurrentPumukiVersion } from './packageInfo';
+import { buildLifecycleVersionReport } from './packageInfo';
 import {
   readLifecyclePolicyValidationSnapshot,
   type LifecyclePolicyValidationSnapshot,
@@ -10,6 +10,7 @@ import { readLifecycleState, type LifecycleState } from './state';
 export type LifecycleStatus = {
   repoRoot: string;
   packageVersion: string;
+  version: ReturnType<typeof buildLifecycleVersionReport>;
   lifecycleState: LifecycleState;
   hookStatus: ReturnType<typeof getPumukiHooksStatus>;
   hooksDirectory: string;
@@ -27,11 +28,17 @@ export const readLifecycleStatus = (params?: {
   const repoRoot = git.resolveRepoRoot(cwd);
   const hooksDirectory = resolvePumukiHooksDirectory(repoRoot);
   const trackedNodeModulesCount = git.trackedNodeModulesPaths(repoRoot).length;
+  const lifecycleState = readLifecycleState(git, repoRoot);
+  const version = buildLifecycleVersionReport({
+    repoRoot,
+    lifecycleVersion: lifecycleState.version,
+  });
 
   return {
     repoRoot,
-    packageVersion: getCurrentPumukiVersion({ repoRoot }),
-    lifecycleState: readLifecycleState(git, repoRoot),
+    packageVersion: version.effective,
+    version,
+    lifecycleState,
     hookStatus: getPumukiHooksStatus(repoRoot),
     hooksDirectory: hooksDirectory.path,
     hooksDirectoryResolution: hooksDirectory.source,

package/integrations/lifecycle/watch.ts

@@ -9,7 +9,7 @@ import { resolveFactsForGateScope } from '../git/runPlatformGateFacts';
 import { resolvePolicyForStage, type ResolvedStagePolicy } from '../gate/stagePolicies';
 import { readEvidence } from '../evidence/readEvidence';
 import type { AiEvidenceV2_1, SnapshotFinding } from '../evidence/schema';
-import { GitService } from '../git/GitService';
+import { GitService, type IGitService } from '../git/GitService';
 import type { Fact } from '../../core/facts/Fact';
 import { ensureRuntimeArtifactsIgnored } from './artifacts';
 import {
@@ -17,7 +17,11 @@ import {
   emitGateBlockedNotification,
 } from '../notifications/emitAuditSummaryNotification';
 import { runPolicyReconcile } from './policyReconcile';
-import { resolvePumukiVersionMetadata, type PumukiVersionMetadata } from './packageInfo';
+import {
+  buildLifecycleAlignmentCommand,
+  resolvePumukiVersionMetadata,
+  type PumukiVersionMetadata,
+} from './packageInfo';
 
 export type LifecycleWatchStage = 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
 export type LifecycleWatchScope = 'workingTree' | 'staged' | 'repoAndStaged' | 'repo';
@@ -59,6 +63,7 @@ export type LifecycleWatchResult = {
     source: PumukiVersionMetadata['source'];
     driftFromRuntime: boolean;
     driftWarning: string | null;
+    alignmentCommand: string | null;
   };
   stage: LifecycleWatchStage;
   scope: LifecycleWatchScope;
@@ -91,6 +96,20 @@ type LifecycleWatchDependencies = {
 
 const defaultGitService = new GitService();
 
+class RepoScopedGitService extends GitService implements IGitService {
+  constructor(private readonly repoRoot: string) {
+    super();
+  }
+
+  override runGit(args: ReadonlyArray<string>, cwd?: string): string {
+    return super.runGit(args, cwd ?? this.repoRoot);
+  }
+
+  override resolveRepoRoot(): string {
+    return this.repoRoot;
+  }
+}
+
 const defaultDependencies: LifecycleWatchDependencies = {
   resolveRepoRoot: () => defaultGitService.resolveRepoRoot(),
   readChangeToken: (repoRoot) =>
@@ -301,6 +320,7 @@ export const runLifecycleWatch = async (
     ...dependencies,
   };
   const repoRoot = params?.repoRoot ?? activeDependencies.resolveRepoRoot();
+  const repoGitService = new RepoScopedGitService(repoRoot);
   const versionMetadata = activeDependencies.resolvePumukiVersionMetadata({ repoRoot });
   const driftFromRuntime = versionMetadata.resolvedVersion !== versionMetadata.runtimeVersion;
   const driftWarning = driftFromRuntime
@@ -368,7 +388,7 @@ export const runLifecycleWatch = async (
       const gateScope = toGateScope(scope);
       const facts = await activeDependencies.resolveFactsForGateScope({
         scope: gateScope,
-        git: defaultGitService,
+        git: repoGitService,
       });
       const changedFiles = collectChangedFilesFromFacts(facts);
       const evaluatedFiles = collectEvaluatedFilesFromFacts(facts);
@@ -389,6 +409,9 @@ export const runLifecycleWatch = async (
           policyTrace: resolvedPolicy.trace,
           scope: gateScope,
           silent: true,
+          services: {
+            git: repoGitService,
+          },
         });
         const evidence = activeDependencies.readEvidence(repoRoot);
         const allFindingsBase = evidence?.snapshot.findings ?? [];
@@ -566,6 +589,9 @@ export const runLifecycleWatch = async (
           source: versionMetadata.source,
           driftFromRuntime,
           driftWarning,
+          alignmentCommand: driftFromRuntime
+            ? buildLifecycleAlignmentCommand(versionMetadata.runtimeVersion)
+            : null,
         },
         stage,
         scope,

package/integrations/mcp/autoExecuteAiStart.ts

@@ -31,6 +31,7 @@ const toHumanMessage = (params: {
 const isEvidenceCode = (code: string): boolean =>
   code === 'EVIDENCE_MISSING'
   || code === 'EVIDENCE_INVALID'
+  || code === 'EVIDENCE_CHAIN_INVALID'
   || code === 'EVIDENCE_STALE'
   || code === 'EVIDENCE_ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES'
   || code === 'EVIDENCE_SKILLS_CONTRACT_INCOMPLETE'
@@ -67,10 +68,11 @@ const nextActionFromViolation = (
   switch (violation.code) {
     case 'EVIDENCE_MISSING':
     case 'EVIDENCE_INVALID':
+    case 'EVIDENCE_CHAIN_INVALID':
     case 'EVIDENCE_STALE':
       return {
         kind: 'run_command',
-        message: 'Refresca evidencia y vuelve a evaluar PRE_WRITE.',
+        message: 'Regenera o refresca evidencia y vuelve a evaluar PRE_WRITE.',
         command: 'npx --yes --package pumuki@latest pumuki sdd validate --stage=PRE_WRITE --json',
       };
     case 'EVIDENCE_ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.51",
+  "version": "6.3.53",
   "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": {