pumuki 6.3.97 → 6.3.98

package/integrations/mcp/aiGateCheck.ts

@@ -1,20 +1,10 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
 import { evaluateAiGate, type AiGateStage } from '../gate/evaluateAiGate';
 import { resolveRemediationHintForViolationCode } from '../gate/remediationCatalog';
 import { resolveLearningContextExperimentalFeature } from '../policy/experimentalFeatures';
 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;
@@ -41,7 +31,6 @@ export type EnterpriseAiGateCheckResult = {
       reason_code: 'HOOK_RUNNER_CAN_REFRESH_EVIDENCE' | null;
       message: string;
     };
-    platform_gate_alignment?: PlatformGateAlignment;
   };
 };
 
@@ -50,22 +39,25 @@ const HOOK_STAGE_SET = new Set<AiGateStage>(['PRE_COMMIT', 'PRE_PUSH', 'CI']);
 const isHookRefreshableEvidenceCode = (code: string): boolean =>
   code.startsWith('EVIDENCE_');
 
-const MCP_ENTERPRISE_ADAPTER_MISSING_CODE = 'MCP_ENTERPRISE_ADAPTER_MISSING';
-
 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)
   );
@@ -80,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,
@@ -124,9 +98,6 @@ const buildAutoFixes = (
   learningContext: SddLearningContext | null
 ): ReadonlyArray<string> => {
   const fixes: string[] = [];
-  if (evaluation.violations.some((violation) => violation.code === MCP_ENTERPRISE_ADAPTER_MISSING_CODE)) {
-    fixes.push('Regenera .pumuki/adapter.json con `pnpm exec pumuki install` antes de volver a validar el gate MCP.');
-  }
   const emittedCodes = new Set<string>();
   for (const violation of evaluation.violations) {
     if (emittedCodes.has(violation.code)) {
@@ -147,14 +118,7 @@ const buildAutoFixes = (
   return fixes;
 };
 
-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.`;
   }
@@ -165,59 +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 hasMcpAdapter = (repoRoot: string): boolean =>
-  existsSync(join(repoRoot, '.pumuki', 'adapter.json'));
-
-const withRequiredMcpAdapter = (
-  evaluation: ReturnType<typeof evaluateAiGate>,
-  repoRoot: string,
-  requireMcpReceipt: boolean
-): ReturnType<typeof evaluateAiGate> => {
-  if (!requireMcpReceipt || hasMcpAdapter(repoRoot)) {
-    return evaluation;
-  }
-  if (evaluation.violations.some((violation) => violation.code === MCP_ENTERPRISE_ADAPTER_MISSING_CODE)) {
-    return {
-      ...evaluation,
-      allowed: false,
-      status: 'BLOCKED',
-    };
-  }
-  return {
-    ...evaluation,
-    allowed: false,
-    status: 'BLOCKED',
-    violations: [
-      {
-        code: MCP_ENTERPRISE_ADAPTER_MISSING_CODE,
-        severity: 'ERROR',
-        message: 'Missing .pumuki/adapter.json. MCP-dependent validation cannot prove a real MCP invocation.',
-      },
-      ...evaluation.violations,
-    ],
-  };
-};
-
-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,131 +143,40 @@ export const runEnterpriseAiGateCheck = (params: {
     stage: params.stage,
     requireMcpReceipt: params.requireMcpReceipt ?? false,
   });
-  const normalizedEvaluation = withRequiredMcpAdapter(
-    evaluation,
-    params.repoRoot,
-    params.requireMcpReceipt ?? false
-  );
-  const branch = normalizedEvaluation.repo_state.git.branch;
-  const timestamp = normalizedEvaluation.evidence.source.generated_at;
-  const learningContextFeature = resolveLearningContextExperimentalFeature();
-  const learningContext = learningContextFeature.mode === 'off'
-    ? null
-    : readSddLearningContext({
-      repoRoot: params.repoRoot,
-    });
-  const warnings = buildWarnings(normalizedEvaluation);
-  const autoFixes = buildAutoFixes(normalizedEvaluation, learningContext);
-  const message = buildMessage(normalizedEvaluation);
-
-  return {
-    tool: 'ai_gate_check',
-    dryRun: true,
-    executed: true,
-    success: normalizedEvaluation.allowed,
-    result: {
-      allowed: normalizedEvaluation.allowed,
-      status: normalizedEvaluation.status,
-      timestamp,
-      branch,
-      message,
-      stage: normalizedEvaluation.stage,
-      policy: normalizedEvaluation.policy,
-      violations: normalizedEvaluation.violations,
-      warnings,
-      auto_fixes: autoFixes,
-      learning_context: learningContext,
-      evidence: normalizedEvaluation.evidence,
-      mcp_receipt: normalizedEvaluation.mcp_receipt,
-      skills_contract: normalizedEvaluation.skills_contract,
-      repo_state: normalizedEvaluation.repo_state,
-      consistency_hint: buildConsistencyHint(normalizedEvaluation),
-    },
-  };
-};
-
-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,
-  });
-  const normalizedEvaluation = withRequiredMcpAdapter(
-    evaluation,
-    params.repoRoot,
-    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 = normalizedEvaluation.allowed && !platformBlocks;
-  const status: 'ALLOWED' | 'BLOCKED' = allowed ? 'ALLOWED' : 'BLOCKED';
-  const violations = platformBlocks && platform
-    ? [
-      ...normalizedEvaluation.violations,
-      {
-        code: 'PLATFORM_GATE_EXIT_NON_ZERO',
-        message:
-          `runPlatformGate devolvió exit_code=${platform.exitCode}` +
-          (platform.skipReason ? ` (${platform.skipReason})` : ''),
-        severity: 'ERROR' as const,
-      },
-    ]
-    : normalizedEvaluation.violations;
-  const branch = normalizedEvaluation.repo_state.git.branch;
-  const timestamp = normalizedEvaluation.evidence.source.generated_at;
+  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 = { ...normalizedEvaluation, allowed, status, violations };
-  const warnings = buildWarnings(evaluationForHints);
-  const autoFixes = buildAutoFixes(evaluationForHints, learningContext);
-  const message = buildMessage(evaluationForHints, platform);
+  const warnings = buildWarnings(evaluation);
+  const autoFixes = buildAutoFixes(evaluation, learningContext);
+  const message = buildMessage(evaluation);
 
   return {
     tool: 'ai_gate_check',
     dryRun: true,
     executed: true,
-    success: allowed,
+    success: evaluation.allowed,
     result: {
-      allowed,
-      status,
+      allowed: evaluation.allowed,
+      status: evaluation.status,
       timestamp,
       branch,
       message,
-      stage: normalizedEvaluation.stage,
-      policy: normalizedEvaluation.policy,
-      violations,
+      stage: evaluation.stage,
+      policy: evaluation.policy,
+      violations: evaluation.violations,
       warnings,
       auto_fixes: autoFixes,
       learning_context: learningContext,
-      evidence: normalizedEvaluation.evidence,
-      mcp_receipt: normalizedEvaluation.mcp_receipt,
-      skills_contract: normalizedEvaluation.skills_contract,
-      repo_state: normalizedEvaluation.repo_state,
-      consistency_hint: buildConsistencyHint(evaluationForHints, platform),
-      platform_gate_alignment: toPlatformGateAlignment(mode, platform),
+      evidence: evaluation.evidence,
+      mcp_receipt: evaluation.mcp_receipt,
+      skills_contract: evaluation.skills_contract,
+      repo_state: evaluation.repo_state,
+      consistency_hint: buildConsistencyHint(evaluation),
     },
   };
 };

package/integrations/mcp/autoExecuteAiStart.ts

@@ -1,7 +1,3 @@
-import {
-  buildGovernanceValidateCommand,
-  resolveGovernanceCatalogAction,
-} from '../gate/governanceActionCatalog';
 import { evaluateAiGate, type AiGateStage, type AiGateViolation } from '../gate/evaluateAiGate';
 import { collectWorktreeAtomicSlices } from '../git/worktreeAtomicSlices';
 import { resolveLearningContextExperimentalFeature } from '../policy/experimentalFeatures';
@@ -54,98 +50,96 @@ 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) {
+const nextActionFromViolation = (
+  violation: AiGateViolation | undefined,
+  repoRoot: string
+): AutoExecuteNextAction => {
+  if (!violation) {
+    return {
+      kind: 'info',
+      message: 'Gate listo. Puedes continuar con implementación.',
+    };
+  }
+  switch (violation.code) {
+    case 'EVIDENCE_MISSING':
     case 'EVIDENCE_INVALID':
     case 'EVIDENCE_CHAIN_INVALID':
-      return 'EVIDENCE_INVALID_OR_CHAIN';
+    case 'EVIDENCE_STALE':
+      return {
+        kind: 'run_command',
+        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':
+      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:
+          'npx --yes --package pumuki@latest pumuki policy reconcile --strict --json && npx --yes --package pumuki@latest 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: 'npx --yes --package pumuki@latest 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:
+          'npx --yes --package pumuki@latest pumuki policy reconcile --strict --json && npx --yes --package pumuki@latest 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'} && npx --yes --package pumuki@latest pumuki sdd validate --stage=PRE_WRITE --json`,
+          };
+        }
+      }
+      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 && npx --yes --package pumuki@latest pumuki sdd validate --stage=PRE_WRITE --json',
+      };
     case 'GITFLOW_PROTECTED_BRANCH':
-      return 'GITFLOW_PROTECTED_BRANCH_CONTEXT';
-    case 'GITFLOW_BRANCH_NAMING_INVALID':
-      return 'GITFLOW_BRANCH_NAMING_INVALID_CONTEXT';
+      return {
+        kind: 'run_command',
+        message: 'Cambia a una rama feature/* antes de continuar.',
+        command: 'git checkout -b feature/<descripcion-kebab-case>',
+      };
     default:
-      return code;
-  }
-};
-
-const resolveAutoExecuteRemediation = (params: {
-  violation: AiGateViolation | undefined;
-  repoRoot: string;
-  stage: AiGateStage;
-  allowed: boolean;
-}): {
-  instruction: string;
-  nextAction: AutoExecuteNextAction;
-} => {
-  if (!params.violation) {
-    const readyAction = resolveGovernanceCatalogAction({
-      code: 'READY',
-      stage: params.stage,
-    });
-    return {
-      instruction: readyAction.instruction,
-      nextAction: readyAction.next_action,
-    };
-  }
-
-  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];
       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: 'info',
+        message: 'Corrige la violación bloqueante y vuelve a ejecutar auto_execute_ai_start.',
       };
-    }
-    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,
-      }
-      : governanceAction.next_action,
-  };
 };
 
 export type EnterpriseAutoExecuteAiStartResult = {
@@ -196,20 +190,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 {