pumuki 6.3.113 → 6.3.114

package/integrations/mcp/aiGateCheck.ts

@@ -1,20 +1,10 @@
 import { evaluateAiGate, type AiGateStage } from '../gate/evaluateAiGate';
 import { resolveRemediationHintForViolationCode } from '../gate/remediationCatalog';
-import { readLifecyclePolicyValidationSnapshot } from '../lifecycle/policyValidationSnapshot';
 import { resolveLearningContextExperimentalFeature } from '../policy/experimentalFeatures';
-import { resolvePreWriteEnforcement } from '../policy/preWriteEnforcement';
 import { readSddLearningContext, type SddLearningContext } from '../sdd/learningInsights';
-import { runMcpAlignedPlatformGate } from './alignedPlatformGate';
 
 const PROTECTED_BRANCHES = new Set(['main', 'master', 'develop', 'dev']);
 
-type PlatformGateAlignment = {
-  mode: 'full' | 'policy';
-  exit_code: number;
-  aligned: boolean;
-  skip_reason: string | null;
-};
-
 export type EnterpriseAiGateCheckResult = {
   tool: 'ai_gate_check';
   dryRun: true;
@@ -26,19 +16,6 @@ export type EnterpriseAiGateCheckResult = {
     timestamp: string | null;
     branch: string | null;
     message: string;
-    reason_code: string;
-    instruction: string;
-    prewrite_effective: {
-      mode: ReturnType<typeof resolvePreWriteEnforcement>['mode'];
-      source: ReturnType<typeof resolvePreWriteEnforcement>['source'];
-      blocking: boolean;
-      strict_policy: boolean;
-    };
-    next_action: {
-      kind: 'info';
-      reason: string;
-      message: string;
-    };
     stage: ReturnType<typeof evaluateAiGate>['stage'];
     policy: ReturnType<typeof evaluateAiGate>['policy'];
     violations: ReturnType<typeof evaluateAiGate>['violations'];
@@ -54,7 +31,6 @@ export type EnterpriseAiGateCheckResult = {
       reason_code: 'HOOK_RUNNER_CAN_REFRESH_EVIDENCE' | null;
       message: string;
     };
-    platform_gate_alignment?: PlatformGateAlignment;
   };
 };
 
@@ -65,18 +41,23 @@ const isHookRefreshableEvidenceCode = (code: string): boolean =>
 
 type AiGateCheckDependencies = {
   evaluateAiGate: typeof evaluateAiGate;
-  runMcpAlignedPlatformGate: typeof runMcpAlignedPlatformGate;
 };
 
 const defaultDependencies: AiGateCheckDependencies = {
   evaluateAiGate,
-  runMcpAlignedPlatformGate,
 };
 
 const buildConsistencyHint = (
-  evaluation: ReturnType<typeof evaluateAiGate>,
-  platform?: { exitCode: number; aligned: boolean; skipReason: string | null }
+  evaluation: ReturnType<typeof evaluateAiGate>
 ): EnterpriseAiGateCheckResult['result']['consistency_hint'] => {
+  if (!HOOK_STAGE_SET.has(evaluation.stage)) {
+    return {
+      comparable_with_hook_runner: true,
+      reason_code: null,
+      message: 'Stage is directly comparable with ai_gate_check semantics.',
+    };
+  }
+
   const hasRefreshableEvidenceViolation = evaluation.violations.some((violation) =>
     isHookRefreshableEvidenceCode(violation.code)
   );
@@ -91,24 +72,6 @@ const buildConsistencyHint = (
     };
   }
 
-  if (platform?.aligned) {
-    return {
-      comparable_with_hook_runner: true,
-      reason_code: null,
-      message:
-        `ai_gate_check ejecutó runPlatformGate después de leer la evidencia actual (exit_code=${platform.exitCode}); ` +
-        'alineación hook-like habilitada explícitamente para este stage.',
-    };
-  }
-
-  if (!HOOK_STAGE_SET.has(evaluation.stage)) {
-    return {
-      comparable_with_hook_runner: true,
-      reason_code: null,
-      message: 'Stage is directly comparable with ai_gate_check semantics.',
-    };
-  }
-
   return {
     comparable_with_hook_runner: true,
     reason_code: null,
@@ -155,31 +118,7 @@ const buildAutoFixes = (
   return fixes;
 };
 
-const buildReasonCode = (evaluation: ReturnType<typeof evaluateAiGate>): string =>
-  evaluation.violations[0]?.code ?? 'AI_GATE_ALLOWED';
-
-const buildInstruction = (evaluation: ReturnType<typeof evaluateAiGate>): string =>
-  evaluation.allowed
-    ? 'Continúa con el stage actual manteniendo el vocabulario canónico de governance.'
-    : 'Corrige el bloqueante primario y vuelve a ejecutar ai_gate_check en el mismo stage.';
-
-const buildNextAction = (
-  evaluation: ReturnType<typeof evaluateAiGate>,
-  autoFixes: ReadonlyArray<string>
-): EnterpriseAiGateCheckResult['result']['next_action'] => ({
-  kind: 'info',
-  reason: buildReasonCode(evaluation),
-  message: autoFixes[0] ?? buildInstruction(evaluation),
-});
-
-const buildMessage = (
-  evaluation: ReturnType<typeof evaluateAiGate>,
-  platform?: { exitCode: number; skipReason: string | null }
-): string => {
-  if (platform && platform.exitCode !== 0) {
-    const suffix = platform.skipReason ? ` (${platform.skipReason})` : '';
-    return `🔴 runPlatformGate exit_code=${platform.exitCode}${suffix}.`;
-  }
+const buildMessage = (evaluation: ReturnType<typeof evaluateAiGate>): string => {
   if (evaluation.allowed) {
     return `✅ Gate ${evaluation.stage} ALLOWED.`;
   }
@@ -190,26 +129,6 @@ const buildMessage = (
   return `🔴 ${firstViolation.code}: ${firstViolation.message}`;
 };
 
-const resolveAiGateCheckMode = (): PlatformGateAlignment['mode'] => {
-  const raw = process.env.PUMUKI_MCP_AI_GATE_CHECK_MODE?.trim().toLowerCase();
-  return raw === 'full' || raw === 'aligned' ? 'full' : 'policy';
-};
-
-const toPlatformGateAlignment = (
-  mode: PlatformGateAlignment['mode'],
-  platform?: { exitCode: number; aligned: boolean; skipReason: string | null }
-): PlatformGateAlignment | undefined => {
-  if (mode !== 'full' || !platform) {
-    return undefined;
-  }
-  return {
-    mode,
-    exit_code: platform.exitCode,
-    aligned: platform.aligned,
-    skip_reason: platform.skipReason,
-  };
-};
-
 export const runEnterpriseAiGateCheck = (params: {
   repoRoot: string;
   stage: AiGateStage;
@@ -232,8 +151,6 @@ export const runEnterpriseAiGateCheck = (params: {
     : readSddLearningContext({
       repoRoot: params.repoRoot,
     });
-  const preWriteEnforcement = resolvePreWriteEnforcement();
-  const policyValidation = readLifecyclePolicyValidationSnapshot(params.repoRoot);
   const warnings = buildWarnings(evaluation);
   const autoFixes = buildAutoFixes(evaluation, learningContext);
   const message = buildMessage(evaluation);
@@ -249,15 +166,6 @@ export const runEnterpriseAiGateCheck = (params: {
       timestamp,
       branch,
       message,
-      reason_code: buildReasonCode(evaluation),
-      instruction: buildInstruction(evaluation),
-      prewrite_effective: {
-        mode: preWriteEnforcement.mode,
-        source: preWriteEnforcement.source,
-        blocking: preWriteEnforcement.blocking,
-        strict_policy: policyValidation.stages.PRE_WRITE.strict,
-      },
-      next_action: buildNextAction(evaluation, autoFixes),
       stage: evaluation.stage,
       policy: evaluation.policy,
       violations: evaluation.violations,
@@ -272,95 +180,3 @@ export const runEnterpriseAiGateCheck = (params: {
     },
   };
 };
-
-export const runEnterpriseAiGateCheckAsync = async (params: {
-  repoRoot: string;
-  stage: AiGateStage;
-  requireMcpReceipt?: boolean;
-}, dependencies: Partial<AiGateCheckDependencies> = {}): Promise<EnterpriseAiGateCheckResult> => {
-  const mode = resolveAiGateCheckMode();
-  const activeDependencies: AiGateCheckDependencies = {
-    ...defaultDependencies,
-    ...dependencies,
-  };
-  const evaluation = activeDependencies.evaluateAiGate({
-    repoRoot: params.repoRoot,
-    stage: params.stage,
-    requireMcpReceipt: params.requireMcpReceipt ?? false,
-  });
-
-  let platform:
-    | { exitCode: number; aligned: boolean; skipReason: string | null }
-    | undefined;
-  if (mode === 'full') {
-    platform = await activeDependencies.runMcpAlignedPlatformGate({
-      repoRoot: params.repoRoot,
-      stage: params.stage,
-    });
-  }
-
-  const platformBlocks = Boolean(platform && platform.exitCode !== 0);
-  const allowed = evaluation.allowed && !platformBlocks;
-  const status: 'ALLOWED' | 'BLOCKED' = allowed ? 'ALLOWED' : 'BLOCKED';
-  const violations = platformBlocks && platform
-    ? [
-      ...evaluation.violations,
-      {
-        code: 'PLATFORM_GATE_EXIT_NON_ZERO',
-        message:
-          `runPlatformGate devolvió exit_code=${platform.exitCode}` +
-          (platform.skipReason ? ` (${platform.skipReason})` : ''),
-        severity: 'ERROR' as const,
-      },
-    ]
-    : evaluation.violations;
-  const branch = evaluation.repo_state.git.branch;
-  const timestamp = evaluation.evidence.source.generated_at;
-  const learningContextFeature = resolveLearningContextExperimentalFeature();
-  const learningContext = learningContextFeature.mode === 'off'
-    ? null
-    : readSddLearningContext({
-      repoRoot: params.repoRoot,
-    });
-  const evaluationForHints = { ...evaluation, allowed, status, violations };
-  const warnings = buildWarnings(evaluationForHints);
-  const autoFixes = buildAutoFixes(evaluationForHints, learningContext);
-  const message = buildMessage(evaluationForHints, platform);
-  const preWriteEnforcement = resolvePreWriteEnforcement();
-  const policyValidation = readLifecyclePolicyValidationSnapshot(params.repoRoot);
-
-  return {
-    tool: 'ai_gate_check',
-    dryRun: true,
-    executed: true,
-    success: allowed,
-    result: {
-      allowed,
-      status,
-      timestamp,
-      branch,
-      message,
-      reason_code: buildReasonCode(evaluationForHints),
-      instruction: buildInstruction(evaluationForHints),
-      prewrite_effective: {
-        mode: preWriteEnforcement.mode,
-        source: preWriteEnforcement.source,
-        blocking: preWriteEnforcement.blocking,
-        strict_policy: policyValidation.stages.PRE_WRITE.strict,
-      },
-      next_action: buildNextAction(evaluationForHints, autoFixes),
-      stage: evaluation.stage,
-      policy: evaluation.policy,
-      violations,
-      warnings,
-      auto_fixes: autoFixes,
-      learning_context: learningContext,
-      evidence: evaluation.evidence,
-      mcp_receipt: evaluation.mcp_receipt,
-      skills_contract: evaluation.skills_contract,
-      repo_state: evaluation.repo_state,
-      consistency_hint: buildConsistencyHint(evaluationForHints, platform),
-      platform_gate_alignment: toPlatformGateAlignment(mode, platform),
-    },
-  };
-};

package/integrations/mcp/autoExecuteAiStart.ts

@@ -1,9 +1,6 @@
-import {
-  buildGovernanceValidateCommand,
-  resolveGovernanceCatalogAction,
-} from '../gate/governanceActionCatalog';
 import { evaluateAiGate, type AiGateStage, type AiGateViolation } from '../gate/evaluateAiGate';
 import { collectWorktreeAtomicSlices } from '../git/worktreeAtomicSlices';
+import { getCurrentPumukiVersion } from '../lifecycle/packageInfo';
 import { resolveLearningContextExperimentalFeature } from '../policy/experimentalFeatures';
 import { readSddLearningContext, type SddLearningContext } from '../sdd/learningInsights';
 
@@ -54,98 +51,126 @@ const confidenceFromViolation = (violationCode: string | null): number => {
   if (isEvidenceCode(violationCode)) {
     return 65;
   }
-  if (
-    violationCode === 'GITFLOW_PROTECTED_BRANCH'
-    || violationCode === 'GITFLOW_BRANCH_NAMING_INVALID'
-  ) {
+  if (violationCode === 'GITFLOW_PROTECTED_BRANCH') {
     return 40;
   }
   return 50;
 };
 
-const normalizeGovernanceCatalogCode = (code: string): string => {
-  switch (code) {
-    case 'EVIDENCE_INVALID':
-    case 'EVIDENCE_CHAIN_INVALID':
-      return 'EVIDENCE_INVALID_OR_CHAIN';
-    case 'GITFLOW_PROTECTED_BRANCH':
-      return 'GITFLOW_PROTECTED_BRANCH_CONTEXT';
-    case 'GITFLOW_BRANCH_NAMING_INVALID':
-      return 'GITFLOW_BRANCH_NAMING_INVALID_CONTEXT';
-    default:
-      return code;
-  }
-};
-
-const resolveAutoExecuteRemediation = (params: {
-  violation: AiGateViolation | undefined;
+const buildPinnedPumukiNpxCommand = (params: {
   repoRoot: string;
-  stage: AiGateStage;
-  allowed: boolean;
-}): {
-  instruction: string;
-  nextAction: AutoExecuteNextAction;
-} => {
-  if (!params.violation) {
-    const readyAction = resolveGovernanceCatalogAction({
-      code: 'READY',
-      stage: params.stage,
-    });
+  executableAndArgs: string;
+}): string =>
+  `npx --yes --package pumuki@${getCurrentPumukiVersion({ repoRoot: params.repoRoot })} ${params.executableAndArgs}`;
+
+const nextActionFromViolation = (
+  violation: AiGateViolation | undefined,
+  repoRoot: string
+): AutoExecuteNextAction => {
+  if (!violation) {
     return {
-      instruction: readyAction.instruction,
-      nextAction: readyAction.next_action,
+      kind: 'info',
+      message: 'Gate listo. Puedes continuar con implementación.',
     };
   }
-
-  if (
-    params.violation.code === 'EVIDENCE_PREWRITE_WORKTREE_OVER_LIMIT'
-    || params.violation.code === 'EVIDENCE_PREWRITE_WORKTREE_WARN'
-  ) {
-    const validateCommand = buildGovernanceValidateCommand(params.stage);
-    const plan = collectWorktreeAtomicSlices({
-      repoRoot: params.repoRoot,
-      maxSlices: 3,
-      maxFilesPerSlice: 4,
-    });
-    if (plan.slices.length > 0) {
-      const firstSlice = plan.slices[0];
+  switch (violation.code) {
+    case 'EVIDENCE_MISSING':
+    case 'EVIDENCE_INVALID':
+    case 'EVIDENCE_CHAIN_INVALID':
+    case 'EVIDENCE_STALE':
       return {
-        instruction: 'Particiona el worktree en slices atómicos antes de continuar.',
-        nextAction: {
-          kind: params.allowed ? 'info' : 'run_command',
-          message:
-            `Particiona el worktree en slices atómicos por scope. Primer lote sugerido: ${firstSlice?.scope ?? 'scope-desconocido'}.`,
-          command: params.allowed
-            ? undefined
-            : `${firstSlice?.staged_command ?? 'git add -p'} && ${validateCommand}`,
-        },
+        kind: 'run_command',
+        message: 'Regenera o refresca evidencia y vuelve a evaluar PRE_WRITE.',
+        command: buildPinnedPumukiNpxCommand({
+          repoRoot,
+          executableAndArgs: 'pumuki sdd validate --stage=PRE_WRITE --json',
+        }),
       };
-    }
-    return {
-      instruction: 'Particiona el worktree en slices atómicos antes de continuar.',
-      nextAction: {
-        kind: params.allowed ? 'info' : 'run_command',
-        message: 'Particiona el worktree en slices atómicos y revalida PRE_WRITE para continuar sin fricción.',
-        command: params.allowed
-          ? undefined
-          : `git status --short && git add -p && ${validateCommand}`,
-      },
-    };
-  }
-
-  const governanceAction = resolveGovernanceCatalogAction({
-    code: normalizeGovernanceCatalogCode(params.violation.code),
-    stage: params.stage,
-  });
-  return {
-    instruction: governanceAction.instruction,
-    nextAction: params.allowed
-      ? {
-        kind: 'info',
-        message: governanceAction.next_action.message,
+    case 'EVIDENCE_ACTIVE_RULE_IDS_EMPTY_FOR_CODE_CHANGES':
+      return {
+        kind: 'run_command',
+        message:
+          'No hay active_rule_ids para plataforma de código detectada. Reconciliación strict de policy/skills y revalidación PRE_WRITE.',
+        command:
+          `${buildPinnedPumukiNpxCommand({
+            repoRoot,
+            executableAndArgs: 'pumuki policy reconcile --strict --json',
+          })} && ${buildPinnedPumukiNpxCommand({
+            repoRoot,
+            executableAndArgs: 'pumuki sdd validate --stage=PRE_WRITE --json',
+          })}`,
+      };
+    case 'EVIDENCE_PLATFORM_SKILLS_SCOPE_INCOMPLETE':
+    case 'EVIDENCE_PLATFORM_SKILLS_BUNDLES_MISSING':
+    case 'EVIDENCE_SKILLS_CONTRACT_INCOMPLETE':
+      return {
+        kind: 'run_command',
+        message:
+          'Completa cobertura de skills por plataforma (prefijos + bundles) y revalida PRE_WRITE.',
+        command: buildPinnedPumukiNpxCommand({
+          repoRoot,
+          executableAndArgs: 'pumuki sdd validate --stage=PRE_WRITE --json',
+        }),
+      };
+    case 'EVIDENCE_PLATFORM_CRITICAL_SKILLS_RULES_MISSING':
+    case 'EVIDENCE_CROSS_PLATFORM_CRITICAL_ENFORCEMENT_INCOMPLETE':
+      return {
+        kind: 'run_command',
+        message:
+          'Reconcilia policy/skills en modo estricto (incluida skills.ios.critical-test-quality cuando aplique) y revalida PRE_WRITE.',
+        command:
+          `${buildPinnedPumukiNpxCommand({
+            repoRoot,
+            executableAndArgs: 'pumuki policy reconcile --strict --json',
+          })} && ${buildPinnedPumukiNpxCommand({
+            repoRoot,
+            executableAndArgs: 'pumuki sdd validate --stage=PRE_WRITE --json',
+          })}`,
+      };
+    case 'EVIDENCE_PREWRITE_WORKTREE_OVER_LIMIT':
+    case 'EVIDENCE_PREWRITE_WORKTREE_WARN':
+      {
+        const plan = collectWorktreeAtomicSlices({
+          repoRoot,
+          maxSlices: 3,
+          maxFilesPerSlice: 4,
+        });
+        if (plan.slices.length > 0) {
+          const firstSlice = plan.slices[0];
+          return {
+            kind: 'run_command',
+            message:
+              `Particiona el worktree en slices atómicos por scope. Primer lote sugerido: ${firstSlice?.scope ?? 'scope-desconocido'}.`,
+            command:
+              `${firstSlice?.staged_command ?? 'git add -p'} && ${buildPinnedPumukiNpxCommand({
+                repoRoot,
+                executableAndArgs: 'pumuki sdd validate --stage=PRE_WRITE --json',
+              })}`,
+          };
+        }
       }
-      : governanceAction.next_action,
-  };
+      return {
+        kind: 'run_command',
+        message:
+          'Particiona el worktree en slices atómicos y revalida PRE_WRITE para continuar sin fricción.',
+        command:
+          `git status --short && git add -p && ${buildPinnedPumukiNpxCommand({
+            repoRoot,
+            executableAndArgs: 'pumuki sdd validate --stage=PRE_WRITE --json',
+          })}`,
+      };
+    case 'GITFLOW_PROTECTED_BRANCH':
+      return {
+        kind: 'run_command',
+        message: 'Cambia a una rama feature/* antes de continuar.',
+        command: 'git checkout -b feature/<descripcion-kebab-case>',
+      };
+    default:
+      return {
+        kind: 'info',
+        message: 'Corrige la violación bloqueante y vuelve a ejecutar auto_execute_ai_start.',
+      };
+  }
 };
 
 export type EnterpriseAutoExecuteAiStartResult = {
@@ -196,20 +221,19 @@ export const runEnterpriseAutoExecuteAiStart = (params: {
   const action: AutoExecuteAction = evaluation.allowed ? 'proceed' : 'ask';
   const phase = toAutoExecutePhase(action);
   const confidencePct = confidenceFromViolation(firstViolation?.code ?? null);
-  const remediation = resolveAutoExecuteRemediation({
-    violation: firstViolation,
-    repoRoot: params.repoRoot,
-    stage,
-    allowed: evaluation.allowed,
-  });
-  const nextAction = remediation.nextAction;
+  const nextAction = evaluation.allowed
+    ? {
+      kind: 'info' as const,
+      message: 'Gate en verde. Continúa con la implementación.',
+    }
+    : nextActionFromViolation(firstViolation, params.repoRoot);
 
   let message = toHumanMessage({
     action,
     confidencePct,
     reasonCode,
   });
-  let instruction = remediation.instruction;
+  let instruction = nextAction.message;
   if (learningContext?.recommended_actions[0]) {
     message = `${message} Learning: ${learningContext.recommended_actions[0]}`;
     instruction = `${instruction} Learning: ${learningContext.recommended_actions[0]}`;

package/integrations/mcp/enterpriseServer.ts

@@ -9,7 +9,7 @@ import { resolveMcpEnterpriseExperimentalFeature } from '../policy/experimentalF
 import { evaluateSddPolicy, readSddStatus } from '../sdd';
 import type { SddStage } from '../sdd';
 import { toStatusPayload } from './evidencePayloads';
-import { runEnterpriseAiGateCheckAsync } from './aiGateCheck';
+import { runEnterpriseAiGateCheck } from './aiGateCheck';
 import { runEnterprisePreFlightCheck } from './preFlightCheck';
 import { runEnterpriseAutoExecuteAiStart } from './autoExecuteAiStart';
 import { writeMcpAiGateReceipt } from './aiGateReceipt';
@@ -39,14 +39,6 @@ type EnterpriseStatusPayload = {
   evidence: ReturnType<typeof toStatusPayload>;
 };
 
-type EnterpriseHealthPayload = {
-  status: 'ok';
-  repoRoot: string;
-  experimentalFeatures: {
-    mcp_enterprise: ReturnType<typeof resolveMcpEnterpriseExperimentalFeature>;
-  };
-};
-
 const ENTERPRISE_RESOURCES = [
   'evidence://status',
   'gitflow://state',
@@ -390,16 +382,16 @@ const evaluateCriticalToolGuard = (
   }
 };
 
-const executeEnterpriseTool = async (
+const executeEnterpriseTool = (
   repoRoot: string,
   toolName: EnterpriseToolName,
   args: Record<string, string | number | boolean | bigint | symbol | null | Date | object>,
   dryRun: boolean
-): Promise<EnterpriseToolExecution> => {
+): EnterpriseToolExecution => {
   switch (toolName) {
     case 'ai_gate_check': {
       const stage = toSddStage(args.stage, 'PRE_COMMIT');
-      const execution = await runEnterpriseAiGateCheckAsync({
+      const execution = runEnterpriseAiGateCheck({
         repoRoot,
         stage,
       });
@@ -658,14 +650,6 @@ const buildStatusPayload = (repoRoot: string): EnterpriseStatusPayload => ({
   evidence: toStatusPayload(repoRoot),
 });
 
-const buildHealthPayload = (repoRoot: string): EnterpriseHealthPayload => ({
-  status: 'ok',
-  repoRoot,
-  experimentalFeatures: {
-    mcp_enterprise: readMcpEnterpriseExperimentalState(),
-  },
-});
-
 export const startEnterpriseMcpServer = (
   options: EnterpriseServerOptions = {}
 ): EnterpriseServerHandle => {
@@ -696,7 +680,7 @@ export const startEnterpriseMcpServer = (
         sendJson(res, 405, { error: 'Method not allowed' });
         return;
       }
-      sendJson(res, 200, buildHealthPayload(repoRoot));
+      sendJson(res, 200, { status: 'ok' });
       return;
     }
 
@@ -757,7 +741,7 @@ export const startEnterpriseMcpServer = (
         return;
       }
       void readJsonBody(req)
-        .then(async (body) => {
+        .then((body) => {
           if (typeof body !== 'object' || body === null) {
             sendJson(res, 400, {
               error: 'Invalid request body.',
@@ -830,7 +814,7 @@ export const startEnterpriseMcpServer = (
           }
           let result: EnterpriseToolExecution;
           try {
-            result = await executeEnterpriseTool(
+            result = executeEnterpriseTool(
               repoRoot,
               toolName,
               args,

package/integrations/mcp/enterpriseStdioServer.cli.ts

@@ -1,6 +1,5 @@
 import { Socket, createServer } from 'node:net';
 import { startEnterpriseMcpServer } from './enterpriseServer';
-import { resolveMcpEnterpriseExperimentalFeature } from '../policy/experimentalFeatures';
 
 type JsonRpcId = string | number | null;
 
@@ -99,32 +98,11 @@ const fetchJson = async (url: string, options?: RequestInit): Promise<unknown> =
   }
 };
 
-type EnterpriseHealthPayload = {
-  status?: string;
-  repoRoot?: string;
-  experimentalFeatures?: {
-    mcp_enterprise?: {
-      mode?: string;
-    };
-  };
-};
-
-const canReuseEnterpriseHttp = (
-  health: EnterpriseHealthPayload,
-  repoRoot: string,
-  expectedMcpMode: string
-): boolean =>
-  health.status === 'ok'
-  && health.repoRoot === repoRoot
-  && health.experimentalFeatures?.mcp_enterprise?.mode === expectedMcpMode;
-
 const startOrReuseEnterpriseHttp = async (): Promise<{
   host: string;
   port: number;
   startedByThisProcess: boolean;
 }> => {
-  const repoRoot = process.cwd();
-  const expectedMcpMode = resolveMcpEnterpriseExperimentalFeature().mode;
   const host = process.env.PUMUKI_ENTERPRISE_MCP_HOST ?? '127.0.0.1';
   const parsedPort = Number.parseInt(process.env.PUMUKI_ENTERPRISE_MCP_PORT ?? '', 10);
   const preferredPort = Number.isFinite(parsedPort) ? parsedPort : 7391;
@@ -132,8 +110,8 @@ const startOrReuseEnterpriseHttp = async (): Promise<{
 
   const healthUrl = `http://${host}:${requestedPort}/health`;
   try {
-    const health = (await fetchJson(healthUrl)) as EnterpriseHealthPayload;
-    if (canReuseEnterpriseHttp(health, repoRoot, expectedMcpMode)) {
+    const health = (await fetchJson(healthUrl)) as { status?: string };
+    if (health.status === 'ok') {
       return {
         host,
         port: requestedPort,
@@ -141,12 +119,7 @@ const startOrReuseEnterpriseHttp = async (): Promise<{
       };
     }
   } catch (error) {
-    if (process.env.PUMUKI_DEBUG_MCP === '1') {
-      const message = error instanceof Error ? error.message : String(error);
-      process.stderr.write(
-        `[pumuki-mcp-enterprise-stdio] health probe reuse skipped: ${message}\n`
-      );
-    }
+    void error;
   }
 
   const portInUse = await isPortInUse(host, requestedPort);
@@ -154,7 +127,7 @@ const startOrReuseEnterpriseHttp = async (): Promise<{
   startEnterpriseMcpServer({
     host,
     port: resolvedPort,
-    repoRoot,
+    repoRoot: process.cwd(),
   });
 
   return {