pumuki 6.3.113 → 6.3.115

package/integrations/config/skillsMarkdownRules.ts

@@ -440,63 +440,6 @@ const normalizeKnownRuleTarget = (
 
   if (platform === 'backend' || platform === 'frontend') {
     const prefix = platform === 'backend' ? 'skills.backend' : 'skills.frontend';
-    if (
-      platform === 'backend' &&
-      (includes('try-catch silenciosos') ||
-        includes('try catch silenciosos') ||
-        includes('silenciosos siempre loggear o propagar') ||
-        includes('siempre loggear o propagar'))
-    ) {
-      return 'skills.backend.guideline.backend.try-catch-silenciosos-siempre-loggear-o-propagar';
-    }
-    if (
-      platform === 'backend' &&
-      (includes('hardcoded values') ||
-        includes('config en variables de entorno') ||
-        includes('hardcoded values - config en variables de entorno'))
-    ) {
-      return 'skills.backend.guideline.backend.hardcoded-values-config-en-variables-de-entorno';
-    }
-    if (
-      platform === 'backend' &&
-      (includes('magic numbers') ||
-        includes('usar constantes con nombres descriptivos') ||
-        includes('magic numbers - usar constantes con nombres descriptivos'))
-    ) {
-      return 'skills.backend.guideline.backend.magic-numbers-usar-constantes-con-nombres-descriptivos';
-    }
-    if (
-      platform === 'backend' &&
-      (includes('mocks en producción') ||
-        includes('mocks en produccion') ||
-        includes('usar fakes/spies de test') ||
-        includes('runtime productivo') ||
-        includes('solo adaptadores y datos reales'))
-    ) {
-      return 'skills.backend.guideline.backend.mocks-en-produccion-usar-fakes-spies-de-test';
-    }
-    if (
-      platform === 'backend' &&
-      (includes('anemic domain models') ||
-        includes('entidades con comportamiento') ||
-        includes('no solo getters/setters'))
-    ) {
-      return 'skills.backend.guideline.backend.anemic-domain-models-entidades-con-comportamiento';
-    }
-    if (
-      platform === 'backend' &&
-      (includes('lógica en controllers') ||
-        includes('logica en controllers') ||
-        includes('lo gica en controllers') ||
-        includes('mover lógica de negocio a casos de uso/servicios') ||
-        includes('mover logica de negocio a casos de uso/servicios') ||
-        includes('mover lo gica de negocio a casos de uso/servicios') ||
-        (includes('controllers') &&
-          includes('casos de uso') &&
-          includes('servicios')))
-    ) {
-      return 'skills.backend.guideline.backend.logica-en-controllers-mover-logica-de-negocio-a-casos-de-uso-servicios';
-    }
     if (includes('solid') || includes('single responsibility') || includes('srp')) {
       return `${prefix}.no-solid-violations`;
     }

package/integrations/evidence/buildEvidence.ts

@@ -687,16 +687,6 @@ const normalizeRepoState = (repoState?: RepoState): RepoState | undefined => {
   if (!repoState) {
     return undefined;
   }
-  const tracking = repoState.lifecycle.tracking ?? {
-    enforced: false,
-    canonical_path: null,
-    canonical_present: false,
-    source_file: null,
-    in_progress_count: null,
-    single_in_progress_valid: null,
-    conflict: false,
-    declarations: [],
-  };
   return {
     repo_root: repoState.repo_root,
     git: {
@@ -726,20 +716,6 @@ const normalizeRepoState = (repoState?: RepoState): RepoState | undefined => {
           config_path: repoState.lifecycle.hard_mode.config_path,
         }
         : undefined,
-      tracking: {
-        enforced: tracking.enforced,
-        canonical_path: tracking.canonical_path,
-        canonical_present: tracking.canonical_present,
-        source_file: tracking.source_file,
-        in_progress_count: tracking.in_progress_count,
-        single_in_progress_valid: tracking.single_in_progress_valid,
-        conflict: tracking.conflict,
-        declarations: tracking.declarations.map((entry) => ({
-          source_file: entry.source_file,
-          declared_path: entry.declared_path,
-          resolved_path: entry.resolved_path,
-        })),
-      },
     },
   };
 };

package/integrations/evidence/repoState.ts

@@ -1,11 +1,12 @@
 import { execFileSync as runBinarySync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { readLifecycleStatus } from '../lifecycle/status';
+import { LifecycleGitService } from '../lifecycle/gitService';
+import { getPumukiHooksStatus } from '../lifecycle/hookManager';
 import { resolvePumukiVersionMetadata } from '../lifecycle/packageInfo';
+import { readLifecycleState } from '../lifecycle/state';
 import { readPersistedHardModeConfig } from '../policy/policyProfiles';
 import type { RepoHardModeState, RepoHookState, RepoState } from './schema';
-import { readRepoTrackingState } from './trackingContract';
 
 type HookStateShape = { exists: boolean; managedBlockPresent: boolean };
 
@@ -74,10 +75,13 @@ const toAheadBehind = (
 };
 
 const readLifecycleStatusSafe = (repoRoot: string): LifecycleStatusShape => {
+  const git = new LifecycleGitService();
   try {
-    return readLifecycleStatus({
-      cwd: repoRoot,
-    });
+    return {
+      lifecycleState: readLifecycleState(git, repoRoot),
+      packageVersion: resolvePumukiVersionMetadata({ repoRoot }).resolvedVersion,
+      hookStatus: getPumukiHooksStatus(repoRoot),
+    };
   } catch {
     return {
       lifecycleState: {},
@@ -124,7 +128,6 @@ export const captureRepoState = (repoRoot: string): RepoState => {
   const consumerFacingVersion = versionMetadata.resolvedVersion;
   const installedVersion = versionMetadata.consumerInstalledVersion;
   const hardModeState = readHardModeState(repoRoot);
-  const trackingState = readRepoTrackingState(repoRoot);
 
   return {
     repo_root: repoRoot,
@@ -152,7 +155,6 @@ export const captureRepoState = (repoRoot: string): RepoState => {
         pre_push: toHookState(lifecycle.hookStatus['pre-push']),
       },
       hard_mode: hardModeState,
-      tracking: trackingState,
     },
   };
 };

package/integrations/evidence/schema.ts

@@ -171,23 +171,6 @@ export type RepoHardModeState = {
   config_path: string;
 };
 
-export type RepoTrackingDeclaration = {
-  source_file: string;
-  declared_path: string;
-  resolved_path: string;
-};
-
-export type RepoTrackingState = {
-  enforced: boolean;
-  canonical_path: string | null;
-  canonical_present: boolean;
-  source_file: string | null;
-  in_progress_count: number | null;
-  single_in_progress_valid: boolean | null;
-  conflict: boolean;
-  declarations: ReadonlyArray<RepoTrackingDeclaration>;
-};
-
 export type RepoState = {
   repo_root: string;
   git: {
@@ -213,7 +196,6 @@ export type RepoState = {
       pre_push: RepoHookState;
     };
     hard_mode?: RepoHardModeState;
-    tracking: RepoTrackingState;
   };
 };
 

package/integrations/evidence/writeEvidence.ts

@@ -188,16 +188,6 @@ const normalizeRepoState = (
   if (!repoState) {
     return undefined;
   }
-  const tracking = repoState.lifecycle.tracking ?? {
-    enforced: false,
-    canonical_path: null,
-    canonical_present: false,
-    source_file: null,
-    in_progress_count: null,
-    single_in_progress_valid: null,
-    conflict: false,
-    declarations: [],
-  };
   return {
     repo_root: toRelativeRepoPath(repoRoot, repoState.repo_root),
     git: {
@@ -227,20 +217,6 @@ const normalizeRepoState = (
           config_path: toRelativeRepoPath(repoRoot, repoState.lifecycle.hard_mode.config_path),
         }
         : undefined,
-      tracking: {
-        enforced: tracking.enforced,
-        canonical_path: tracking.canonical_path,
-        canonical_present: tracking.canonical_present,
-        source_file: tracking.source_file,
-        in_progress_count: tracking.in_progress_count,
-        single_in_progress_valid: tracking.single_in_progress_valid,
-        conflict: tracking.conflict,
-        declarations: tracking.declarations.map((entry) => ({
-          source_file: entry.source_file,
-          declared_path: entry.declared_path,
-          resolved_path: entry.resolved_path,
-        })),
-      },
     },
   };
 };

package/integrations/gate/evaluateAiGate.ts

@@ -1,12 +1,11 @@
 import type { EvidenceReadResult } from '../evidence/readEvidence';
 import { readEvidenceResult } from '../evidence/readEvidence';
 import { captureRepoState } from '../evidence/repoState';
-import type { RepoState, RepoTrackingState } from '../evidence/schema';
+import type { RepoState } from '../evidence/schema';
 import { resolvePolicyForStage } from './stagePolicies';
 import { execFileSync } from 'node:child_process';
 import { existsSync, realpathSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { isSeverityAtLeast } from '../../core/rules/Severity';
 import type { SkillsLockV1, SkillsStage } from '../config/skillsLock';
 import {
   loadEffectiveSkillsLock,
@@ -133,10 +132,6 @@ const PREWRITE_WORKTREE_HYGIENE_WARN_THRESHOLD_ENV = 'PUMUKI_PREWRITE_WORKTREE_W
 const PREWRITE_WORKTREE_HYGIENE_BLOCK_THRESHOLD_ENV = 'PUMUKI_PREWRITE_WORKTREE_BLOCK_THRESHOLD';
 
 const DEFAULT_PROTECTED_BRANCHES = new Set(['main', 'master', 'develop', 'dev']);
-const DEFAULT_GITFLOW_BRANCH_PATTERNS = [
-  /^(?:feature|bugfix|hotfix|chore|refactor|docs)\/[a-z0-9]+(?:-[a-z0-9]+)*$/,
-  /^release\/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/,
-] as const;
 const PREWRITE_SKILLS_PLATFORMS = ['ios', 'android', 'backend', 'frontend'] as const;
 type PreWriteSkillsPlatform = (typeof PREWRITE_SKILLS_PLATFORMS)[number];
 const PLATFORM_SKILLS_RULE_PREFIXES: Readonly<Record<PreWriteSkillsPlatform, string>> = {
@@ -403,45 +398,6 @@ const collectWorktreeChangedPaths = (repoRoot: string): ReadonlyArray<string> =>
   }
 };
 
-const collectGitChangedPaths = (
-  repoRoot: string,
-  args: ReadonlyArray<string>
-): ReadonlyArray<string> => {
-  try {
-    const output = execFileSync(
-      'git',
-      [...args],
-      {
-        cwd: repoRoot,
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'ignore'],
-      }
-    );
-    const files = output
-      .split('\n')
-      .map((line) => parseChangedPath(line))
-      .filter((line): line is string => typeof line === 'string' && line.length > 0);
-    return [...new Set(files)];
-  } catch {
-    return [];
-  }
-};
-
-const collectStagedChangedPaths = (repoRoot: string): ReadonlyArray<string> =>
-  collectGitChangedPaths(repoRoot, ['diff', '--cached', '--name-status', '--find-renames']);
-
-const collectRangeChangedPaths = (params: {
-  repoRoot: string;
-  fromRef: string;
-  toRef: string;
-}): ReadonlyArray<string> =>
-  collectGitChangedPaths(params.repoRoot, [
-    'diff',
-    '--name-status',
-    '--find-renames',
-    `${params.fromRef}...${params.toRef}`,
-  ]);
-
 const isPlatformPath = (platform: PreWriteSkillsPlatform, filePath: string): boolean => {
   const normalized = normalizeChangedPath(filePath).toLowerCase();
   if (platform === 'ios') {
@@ -488,47 +444,6 @@ const isPlatformPath = (platform: PreWriteSkillsPlatform, filePath: string): boo
     || /(^|\/)(frontend|web|client)(\/|$)/.test(normalized);
 };
 
-const toDetectedPlatformsFromPaths = (params: {
-  changedPaths: ReadonlyArray<string>;
-  requiredPlatforms: ReadonlyArray<PreWriteSkillsPlatform>;
-}): ReadonlyArray<PreWriteSkillsPlatform> => {
-  if (params.changedPaths.length === 0) {
-    return [];
-  }
-
-  const detected = new Set<PreWriteSkillsPlatform>();
-  for (const filePath of params.changedPaths) {
-    for (const platform of params.requiredPlatforms) {
-      if (isPlatformPath(platform, filePath)) {
-        detected.add(platform);
-      }
-    }
-  }
-
-  return PREWRITE_SKILLS_PLATFORMS.filter((platform) => detected.has(platform));
-};
-
-const collectStageScopedChangedPaths = (params: {
-  stage: AiGateStage;
-  repoRoot: string;
-  upstream: string | null;
-}): ReadonlyArray<string> => {
-  if (params.stage === 'PRE_WRITE') {
-    return collectWorktreeChangedPaths(params.repoRoot);
-  }
-  if (params.stage === 'PRE_COMMIT') {
-    return collectStagedChangedPaths(params.repoRoot);
-  }
-  if (params.stage === 'PRE_PUSH' && typeof params.upstream === 'string' && params.upstream.length > 0) {
-    return collectRangeChangedPaths({
-      repoRoot: params.repoRoot,
-      fromRef: params.upstream,
-      toRef: 'HEAD',
-    });
-  }
-  return [];
-};
-
 const hasWorktreeCodePlatforms = (params: {
   repoRoot: string;
   requiredPlatforms: ReadonlyArray<PreWriteSkillsPlatform>;
@@ -542,22 +457,6 @@ const hasWorktreeCodePlatforms = (params: {
   );
 };
 
-const toStageScopedDetectedPlatforms = (params: {
-  stage: AiGateStage;
-  repoRoot: string;
-  upstream: string | null;
-  requiredPlatforms: ReadonlyArray<PreWriteSkillsPlatform>;
-}): ReadonlyArray<PreWriteSkillsPlatform> => {
-  return toDetectedPlatformsFromPaths({
-    changedPaths: collectStageScopedChangedPaths({
-      stage: params.stage,
-      repoRoot: params.repoRoot,
-      upstream: params.upstream,
-    }),
-    requiredPlatforms: params.requiredPlatforms,
-  });
-};
-
 const toLockRequiredPlatforms = (
   requiredLock: SkillsLockV1 | undefined
 ): ReadonlyArray<PreWriteSkillsPlatform> => {
@@ -849,18 +748,8 @@ const toSkillsContractAssessment = (params: {
   const coverage = params.evidenceResult.evidence.snapshot.rules_coverage;
   const explicitlyDetectedPlatforms = toDetectedSkillsPlatforms(params.evidenceResult.evidence.platforms);
   const inferredPlatforms = toCoverageInferredPlatforms(coverage);
-  const stageScopedDetectedPlatforms =
-    params.stage !== 'CI' && requiredPlatforms.length > 0
-      ? toStageScopedDetectedPlatforms({
-          stage: params.stage,
-          repoRoot: params.repoRoot,
-          upstream: params.repoState.git.upstream,
-          requiredPlatforms,
-        })
-      : [];
-  const worktreeDetectedPlatforms = stageScopedDetectedPlatforms;
   const repoTreeDetectedPlatforms =
-    params.stage === 'CI' && requiredPlatforms.length > 0
+    params.stage !== 'PRE_WRITE' && requiredPlatforms.length > 0
       ? toRepoTreeDetectedPlatforms({
           repoRoot: params.repoRoot,
           platforms: requiredPlatforms,
@@ -870,24 +759,20 @@ const toSkillsContractAssessment = (params: {
     explicitlyDetectedPlatforms.length > 0
       ? toEffectiveSkillsPlatforms({
           platforms: params.evidenceResult.evidence.platforms,
-        coverage,
-      })
+          coverage,
+        })
       : [];
   const detectedPlatforms =
-    stageScopedDetectedPlatforms.length > 0
-      ? stageScopedDetectedPlatforms
-      : explicitlyDetectedEffectivePlatforms.length > 0
+    explicitlyDetectedEffectivePlatforms.length > 0
       ? explicitlyDetectedEffectivePlatforms
       : inferredPlatforms.length > 0
         ? inferredPlatforms
-        : worktreeDetectedPlatforms.length > 0
-          ? worktreeDetectedPlatforms
         : repoTreeDetectedPlatforms;
   const pendingChanges = resolvePendingChanges(params.repoState);
   const detectedPlatformSet = new Set(detectedPlatforms);
   const assessmentPlatforms =
     requiredPlatforms.length > 0
-      ? params.stage !== 'CI' && detectedPlatforms.length > 0
+      ? params.stage === 'PRE_WRITE' && detectedPlatforms.length > 0
         ? requiredPlatforms.filter((platform) => detectedPlatformSet.has(platform))
         : requiredPlatforms
       : detectedPlatforms;
@@ -1279,63 +1164,6 @@ const collectEvidenceViolations = (
   return { violations, ageSeconds };
 };
 
-const severityOrder: ReadonlyArray<'CRITICAL' | 'ERROR' | 'WARN' | 'INFO'> = [
-  'CRITICAL',
-  'ERROR',
-  'WARN',
-  'INFO',
-];
-
-const toHighestTriggeredSeverity = (
-  severityCounts: Readonly<Record<'INFO' | 'WARN' | 'ERROR' | 'CRITICAL', number>>,
-  threshold: 'INFO' | 'WARN' | 'ERROR' | 'CRITICAL'
-): 'INFO' | 'WARN' | 'ERROR' | 'CRITICAL' | null => {
-  for (const severity of severityOrder) {
-    if (severityCounts[severity] > 0 && isSeverityAtLeast(severity, threshold)) {
-      return severity;
-    }
-  }
-  return null;
-};
-
-const collectEvidencePolicyThresholdViolations = (params: {
-  evidenceResult: EvidenceReadResult;
-  policy: ReturnType<typeof resolvePolicyForStage>['policy'];
-}): AiGateViolation[] => {
-  if (params.evidenceResult.kind !== 'valid') {
-    return [];
-  }
-
-  const severityCounts = params.evidenceResult.evidence.severity_metrics.by_severity;
-  const blockSeverity = toHighestTriggeredSeverity(
-    severityCounts,
-    params.policy.blockOnOrAbove
-  );
-  if (blockSeverity && params.evidenceResult.evidence.ai_gate.status !== 'BLOCKED') {
-    return [
-      toErrorViolation(
-        'EVIDENCE_POLICY_THRESHOLD_BLOCK',
-        `Evidence severities exceed block_on_or_above=${params.policy.blockOnOrAbove} (highest=${blockSeverity}).`
-      ),
-    ];
-  }
-
-  const warnSeverity = toHighestTriggeredSeverity(
-    severityCounts,
-    params.policy.warnOnOrAbove
-  );
-  if (warnSeverity && params.evidenceResult.evidence.ai_gate.status === 'ALLOWED') {
-    return [
-      toWarnViolation(
-        'EVIDENCE_POLICY_THRESHOLD_WARN',
-        `Evidence severities exceed warn_on_or_above=${params.policy.warnOnOrAbove} (highest=${warnSeverity}).`
-      ),
-    ];
-  }
-
-  return [];
-};
-
 const toEvidenceSourceDescriptor = (
   result: EvidenceReadResult,
   repoRoot: string
@@ -1365,81 +1193,17 @@ const collectGitflowViolations = (
   if (!repoState.git.available) {
     return violations;
   }
-  const branch = repoState.git.branch?.trim() ?? null;
-  const normalizedBranch = branch?.toLowerCase() ?? null;
-  if (branch && normalizedBranch && protectedBranches.has(normalizedBranch)) {
+  if (repoState.git.branch && protectedBranches.has(repoState.git.branch)) {
     violations.push(
       toErrorViolation(
         'GITFLOW_PROTECTED_BRANCH',
-        `Direct work on protected branch "${branch}" is not allowed.`
-      )
-    );
-    return violations;
-  }
-  if (
-    branch
-    && !DEFAULT_GITFLOW_BRANCH_PATTERNS.some((pattern) => pattern.test(branch))
-  ) {
-    violations.push(
-      toErrorViolation(
-        'GITFLOW_BRANCH_NAMING_INVALID',
-        `Branch "${branch}" does not comply with GitFlow naming. Use feature/*, bugfix/*, hotfix/*, release/*, chore/*, refactor/* or docs/*.`
+        `Direct work on protected branch "${repoState.git.branch}" is not allowed.`
       )
     );
   }
   return violations;
 };
 
-const DEFAULT_TRACKING_STATE: RepoTrackingState = {
-  enforced: false,
-  canonical_path: null,
-  canonical_present: false,
-  source_file: null,
-  in_progress_count: null,
-  single_in_progress_valid: null,
-  conflict: false,
-  declarations: [],
-};
-
-const collectTrackingViolations = (repoState: RepoState): AiGateViolation[] => {
-  const tracking = repoState.lifecycle.tracking ?? DEFAULT_TRACKING_STATE;
-  if (!tracking.enforced) {
-    return [];
-  }
-
-  if (tracking.conflict) {
-    const declaredPaths = tracking.declarations
-      .map((entry) => `${entry.source_file}:${entry.resolved_path}`)
-      .join(', ');
-    return [
-      toErrorViolation(
-        'TRACKING_CANONICAL_SOURCE_CONFLICT',
-        `Tracking canonical source conflict detected (${declaredPaths}).`
-      ),
-    ];
-  }
-
-  if (!tracking.canonical_path || !tracking.canonical_present) {
-    return [
-      toErrorViolation(
-        'TRACKING_CANONICAL_FILE_MISSING',
-        `Tracking canonical file is missing (${tracking.canonical_path ?? 'undeclared'}).`
-      ),
-    ];
-  }
-
-  if (tracking.single_in_progress_valid === false) {
-    return [
-      toErrorViolation(
-        'TRACKING_CANONICAL_IN_PROGRESS_INVALID',
-        `Tracking canonical file must contain exactly one in-progress task (count=${tracking.in_progress_count ?? 'n/a'}).`
-      ),
-    ];
-  }
-
-  return [];
-};
-
 const resolvePendingChanges = (repoState: RepoState): number | null => {
   if (!repoState.git.available) {
     return null;
@@ -1658,7 +1422,6 @@ export const evaluateAiGate = (
     readMcpAiGateReceipt: activeDependencies.readMcpAiGateReceipt,
   });
   const gitflowViolations = collectGitflowViolations(repoState, protectedBranches);
-  const trackingViolations = collectTrackingViolations(repoState);
   const skillsContract = toSkillsContractAssessment({
     stage: params.stage,
     repoRoot: params.repoRoot,
@@ -1682,16 +1445,10 @@ export const evaluateAiGate = (
             `Skills contract incomplete for ${params.stage}: ${skillsContract.violations.map((violation) => violation.code).join(', ')}.`
           ),
         ];
-  const policyThresholdViolations = collectEvidencePolicyThresholdViolations({
-    evidenceResult,
-    policy: resolvedPolicy.policy,
-  });
   const violations = [
     ...evidenceAssessment.violations,
-    ...policyThresholdViolations,
     ...stageSkillsContractViolations,
     ...gitflowViolations,
-    ...trackingViolations,
     ...mcpReceiptAssessment.violations,
   ];
   const blocked = violations.some((violation) => violation.severity === 'ERROR');

package/integrations/gate/remediationCatalog.ts

@@ -17,14 +17,6 @@ export const REMEDIATION_HINT_BY_CODE: Readonly<Record<string, string>> = {
   EVIDENCE_ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES:
     'Reconcilia policy/skills y revalida PRE_WRITE: npx --yes --package pumuki@latest pumuki policy reconcile --strict --json && npx --yes --package pumuki@latest pumuki sdd validate --stage=PRE_WRITE --json',
   GITFLOW_PROTECTED_BRANCH: 'Trabaja en feature/* y evita ramas protegidas.',
-  GITFLOW_BRANCH_NAMING_INVALID:
-    'Renombra o recrea la rama con un prefijo GitFlow válido (feature/*, bugfix/*, hotfix/*, release/*, chore/*, refactor/* o docs/*).',
-  TRACKING_CANONICAL_SOURCE_CONFLICT:
-    'Alinea AGENTS.md y los README canónicos para que todos apunten al mismo MD de seguimiento.',
-  TRACKING_CANONICAL_FILE_MISSING:
-    'Crea o restaura el archivo canónico de tracking declarado por el repo.',
-  TRACKING_CANONICAL_IN_PROGRESS_INVALID:
-    'Deja exactamente una tarea o fase `🚧` en el MD canónico de seguimiento antes de continuar.',
   EVIDENCE_PREWRITE_WORKTREE_OVER_LIMIT:
     'Reduce archivos staged/unstaged por debajo del umbral (o ajusta PUMUKI_PREWRITE_WORKTREE_*); divide el trabajo en commits más pequeños.',
   EVIDENCE_PREWRITE_WORKTREE_WARN:

package/integrations/git/GitService.ts

@@ -9,12 +9,19 @@ export { parseNameStatus } from './gitDiffUtils';
 export interface IGitService {
   runGit(args: ReadonlyArray<string>, cwd?: string): string;
   getStagedFacts(extensions: ReadonlyArray<string>): ReadonlyArray<Fact>;
+  getUnstagedFacts(
+    extensions: ReadonlyArray<string>,
+    includeUntracked?: boolean
+  ): ReadonlyArray<Fact>;
   getRepoFacts(extensions: ReadonlyArray<string>): ReadonlyArray<Fact>;
   getRepoAndStagedFacts(extensions: ReadonlyArray<string>): ReadonlyArray<Fact>;
   getStagedAndUnstagedFacts(extensions: ReadonlyArray<string>): ReadonlyArray<Fact>;
   resolveRepoRoot(): string;
 }
 
+const shouldIncludeUntrackedFacts = (env = process.env) =>
+  env.PUMUKI_INCLUDE_UNTRACKED_WORKTREE === '1';
+
 const assertSafeGitArgs = (args: ReadonlyArray<string>): void => {
   for (const arg of args) {
     if (arg.includes('\u0000') || arg.includes('\n') || arg.includes('\r')) {
@@ -44,6 +51,35 @@ export class GitService implements IGitService {
     );
   }
 
+  getUnstagedFacts(
+    extensions: ReadonlyArray<string>,
+    includeUntracked = shouldIncludeUntrackedFacts()
+  ): ReadonlyArray<Fact> {
+    const nameStatus = this.runGit(['diff', '--name-status']);
+    const changes = parseNameStatus(nameStatus).filter((change) =>
+      hasAllowedExtension(change.path, extensions)
+    );
+    const untrackedPaths = includeUntracked
+      ? this.runGit(['ls-files', '--others', '--exclude-standard'])
+          .split('\n')
+          .map((line) => line.trim())
+          .filter((line) => line.length > 0)
+          .filter((path) => hasAllowedExtension(path, extensions))
+      : [];
+    const unstagedPaths = new Set(changes.map((change) => change.path));
+    const untrackedChanges = untrackedPaths
+      .filter((path) => !unstagedPaths.has(path))
+      .map((path) => ({
+        path,
+        changeType: 'added' as const,
+      }));
+    const mergedChanges = [...changes, ...untrackedChanges];
+    const repoRoot = this.resolveRepoRoot();
+    return buildFactsFromChanges(mergedChanges, 'git:unstaged', (filePath) =>
+      this.readWorkingTreeFile(repoRoot, filePath)
+    );
+  }
+
   getRepoFacts(extensions: ReadonlyArray<string>): ReadonlyArray<Fact> {
     const trackedFiles = this.runGit(['ls-files'])
       .split('\n')
@@ -83,6 +119,7 @@ export class GitService implements IGitService {
 
   getStagedAndUnstagedFacts(extensions: ReadonlyArray<string>): ReadonlyArray<Fact> {
     const hasHeadCommit = this.hasHeadCommit();
+    const includeUntracked = shouldIncludeUntrackedFacts();
     const trackedNameStatus = hasHeadCommit
       ? this.runGit(['diff', '--name-status', 'HEAD'])
       : [
@@ -93,11 +130,13 @@ export class GitService implements IGitService {
         .join('\n');
     const trackedChanges = this.deduplicateChangesByPath(parseNameStatus(trackedNameStatus))
       .filter((change) => hasAllowedExtension(change.path, extensions));
-    const untrackedPaths = this.runGit(['ls-files', '--others', '--exclude-standard'])
-      .split('\n')
-      .map((line) => line.trim())
-      .filter((line) => line.length > 0)
-      .filter((path) => hasAllowedExtension(path, extensions));
+    const untrackedPaths = includeUntracked
+      ? this.runGit(['ls-files', '--others', '--exclude-standard'])
+          .split('\n')
+          .map((line) => line.trim())
+          .filter((line) => line.length > 0)
+          .filter((path) => hasAllowedExtension(path, extensions))
+      : [];
     const existingTracked = new Set(trackedChanges.map((change) => change.path));
     const repoRoot = this.resolveRepoRoot();