@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/skills/lazy.js

@@ -0,0 +1,48 @@
+import { activateSkills, listActivatedSkills } from '../bootstrap/skills-installer.js';
+import { getRequiredSkills } from './deps.js';
+import { logger } from '../../shared/logger.js';
+const ensuredByWorkspace = new Map();
+function isEnabled() {
+    return (process.env.VIBECODE_SKILLS_AUTO ?? '').trim() === '1';
+}
+function getWorkspaceCache(workspaceRoot) {
+    let set = ensuredByWorkspace.get(workspaceRoot);
+    if (!set) {
+        set = new Set();
+        ensuredByWorkspace.set(workspaceRoot, set);
+    }
+    return set;
+}
+/**
+ * Best-effort skill activation (fail-soft).
+ *
+ * - Only runs when `VIBECODE_SKILLS_AUTO=1`.
+ * - Activates only missing skills.
+ * - Never throws: tool execution should proceed even if skills are unavailable.
+ */
+export async function ensureSkillsForTool(params) {
+    if (!isEnabled())
+        return { activated: [], errors: [] };
+    const needed = getRequiredSkills(params.toolName);
+    if (needed.length === 0)
+        return { activated: [], errors: [] };
+    const workspaceCache = getWorkspaceCache(params.workspaceRoot);
+    const alreadyActivated = new Set(await listActivatedSkills(params.workspaceRoot));
+    const missing = needed.filter((id) => !alreadyActivated.has(id) && !workspaceCache.has(id));
+    if (missing.length === 0)
+        return { activated: [], errors: [] };
+    try {
+        const res = await activateSkills(params.workspaceRoot, missing);
+        for (const id of res.activated)
+            workspaceCache.add(id);
+        if (res.errors.length > 0) {
+            logger.error(`[SKILLS] Activation errors: ${res.errors.join(' | ')}`);
+        }
+        return res;
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        logger.error(`[SKILLS] Activation failed (ignored): ${msg}`);
+        return { activated: [], errors: [msg] };
+    }
+}

package/build/mcp/tool-handler-registry.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared Tool Handler Registry
+ *
+ * Stores tool handlers during MCP registration (tool-registry.ts) so that
+ * tool_executor.ts can resolve them without hardcoded switch statements.
+ *
+ * This module has NO imports from tool-registry.ts or agents/ — it's a
+ * dependency-free shared map that both sides import, avoiding circular deps.
+ */
+export type ToolHandler = (input: unknown, extra?: unknown) => Promise<unknown>;
+/**
+ * Register a tool handler. Called during MCP tool registration.
+ * Duplicate registrations overwrite silently (last writer wins).
+ */
+export declare function registerToolHandler(name: string, handler: ToolHandler): void;
+/**
+ * Look up a registered tool handler by name.
+ * Returns null if the tool was never registered (e.g. gated by env var).
+ */
+export declare function getToolHandler(name: string): ToolHandler | null;
+/**
+ * Get all registered tool names (for diagnostics / system.dispatch status).
+ */
+export declare function getRegisteredToolNames(): string[];
+/**
+ * Clear all handlers (for testing).
+ */
+export declare function clearToolHandlerRegistry(): void;

package/build/mcp/tool-handler-registry.js

@@ -0,0 +1,36 @@
+/**
+ * Shared Tool Handler Registry
+ *
+ * Stores tool handlers during MCP registration (tool-registry.ts) so that
+ * tool_executor.ts can resolve them without hardcoded switch statements.
+ *
+ * This module has NO imports from tool-registry.ts or agents/ — it's a
+ * dependency-free shared map that both sides import, avoiding circular deps.
+ */
+const handlers = new Map();
+/**
+ * Register a tool handler. Called during MCP tool registration.
+ * Duplicate registrations overwrite silently (last writer wins).
+ */
+export function registerToolHandler(name, handler) {
+    handlers.set(name, handler);
+}
+/**
+ * Look up a registered tool handler by name.
+ * Returns null if the tool was never registered (e.g. gated by env var).
+ */
+export function getToolHandler(name) {
+    return handlers.get(name) ?? null;
+}
+/**
+ * Get all registered tool names (for diagnostics / system.dispatch status).
+ */
+export function getRegisteredToolNames() {
+    return [...handlers.keys()];
+}
+/**
+ * Clear all handlers (for testing).
+ */
+export function clearToolHandlerRegistry() {
+    handlers.clear();
+}

package/build/mcp/tool-registry.d.ts

@@ -13,6 +13,7 @@
  * - Profile 기반으로 필요한 모듈만 dynamic import
  * - BitNet 도구가 비활성화된 profile에서는 해당 모듈 로드 스킵
  */
+import type { KernelDeps } from '../kernel/deps.js';
 export type ToolSchemaArg = unknown;
 export type ToolRegistration = {
     name: string;
@@ -22,5 +23,7 @@ export type ToolRegistration = {
 export type ToolRegistrySpy = {
     tool: (name: string, desc: string, schemaArg: ToolSchemaArg, handler: unknown) => void;
 };
-export declare function registerAllTools(server: ToolRegistrySpy): Promise<void>;
+export declare function registerAllTools(server: ToolRegistrySpy, opts?: {
+    kernelDeps?: KernelDeps;
+}): Promise<void>;
 export declare function captureRegistrySnapshot(): Promise<ToolRegistration[]>;

package/build/mcp/tool-registry.js

@@ -13,37 +13,120 @@
  * - Profile 기반으로 필요한 모듈만 dynamic import
  * - BitNet 도구가 비활성화된 profile에서는 해당 모듈 로드 스킵
  */
-import { LEGACY_ALIAS_MAPPING, getLegacyDescription } from "./legacy_alias.js";
-import { isToolEnabled, getCurrentProfile, getProfileStats } from "./profile-config.js";
+import { logger } from '../shared/logger.js';
+import { LEGACY_ALIAS_MAPPING, getLegacyDescription } from './legacy_alias.js';
+import { isToolEnabled, getCurrentProfile, getProfileStats, isHumanProfile } from './profile-config.js';
+import { getActiveToolNames } from './packs/index.js';
+import { acquireForTool } from './engine/lazy.js';
+import { preflightToolExecution } from './policy/unified.js';
+import { runWithPolicyContext } from './policy/context.js';
+import { ensureSkillsForTool } from './skills/lazy.js';
+import { getTracer, isOtelActive } from '../observability/otel.js';
+import { getOtelBridge } from './metrics/collector.js';
+import { registerToolHandler } from './tool-handler-registry.js';
+let activePackToolNames = new Set();
+let workspaceRootForTools = process.cwd();
+function wrapHandler(name, handler) {
+    const typedHandler = handler;
+    return async (input, extra) => {
+        // N-3: OTel span wrapping (no-op when OTel inactive — zero overhead)
+        const tracer = getTracer();
+        return tracer.startActiveSpan(`tool:${name}`, async (span) => {
+            const startMs = Date.now();
+            try {
+                // P3: best-effort skill activation (opt-in)
+                await ensureSkillsForTool({ toolName: name, workspaceRoot: workspaceRootForTools });
+                // P3: ensure tool dependencies (JIT acquisition)
+                await acquireForTool(name);
+                // P3: unified preflight (input + zone + sandbox)
+                const preflight = await preflightToolExecution({
+                    toolName: name,
+                    rawInput: input,
+                    workspaceRoot: workspaceRootForTools,
+                });
+                const result = await runWithPolicyContext({ toolName: name, sandbox: preflight.sandbox }, async () => await typedHandler(input, extra));
+                // Feed OTel metrics bridge if active
+                if (isOtelActive()) {
+                    const bridge = getOtelBridge();
+                    if (bridge) {
+                        const durationSec = (Date.now() - startMs) / 1000;
+                        bridge.toolCallsCounter.add(1, { tool_name: name });
+                        bridge.toolDurationHistogram.record(durationSec, { tool_name: name });
+                    }
+                }
+                return result;
+            }
+            catch (err) {
+                span.recordException(err);
+                span.setStatus({ code: 2, message: err instanceof Error ? err.message : 'unknown error' });
+                throw err;
+            }
+            finally {
+                span.end();
+            }
+        });
+    };
+}
 /**
  * Register tool only if enabled by current profile
  * @returns true if tool was registered, false if skipped
  */
 function registerIfEnabled(server, name, desc, schemaArg, handler) {
-    if (!isToolEnabled(name)) {
+    if (!isToolEnabled(name) && !activePackToolNames.has(name)) {
         return false;
     }
-    server.tool(name, desc, schemaArg, handler);
+    const wrapped = wrapHandler(name, handler);
+    server.tool(name, desc, schemaArg, wrapped);
+    // Also store in shared handler registry for tool_executor dynamic resolution
+    registerToolHandler(name, wrapped);
     return true;
 }
 /**
  * Check if any BitNet tool is enabled in current profile
  */
 function isBitNetEnabled() {
-    return (isToolEnabled("bitnet.check") ||
-        isToolEnabled("bitnet.trace") ||
-        isToolEnabled("bitnet.signal"));
+    return (isToolEnabled('bitnet.check') ||
+        isToolEnabled('bitnet.trace') ||
+        isToolEnabled('bitnet.signal') ||
+        isToolEnabled('bitnet.scout') ||
+        isToolEnabled('vibe_pm.scout'));
+}
+/**
+ * Check if Prime tools should be loaded (VIBE_PRIME=1)
+ */
+function isPrimeEnabled() {
+    return process.env.VIBE_PRIME === '1';
+}
+/**
+ * Check if Cockpit tools should be loaded (VIBE_COCKPIT=1)
+ */
+function isCockpitEnabled() {
+    return process.env.VIBE_COCKPIT === '1';
 }
-export async function registerAllTools(server) {
+/**
+ * Check if Musu Bridge tools should be loaded (MUSU_PRIME_URL set)
+ */
+function isMusuBridgeEnabled() {
+    return !!process.env.MUSU_PRIME_URL;
+}
+/**
+ * Check if Hive Bridge tools should be loaded (MUSU_PRIME_URL set — routes through gateway)
+ */
+function isHiveBridgeEnabled() {
+    return !!process.env.MUSU_PRIME_URL;
+}
+export async function registerAllTools(server, opts = {}) {
     const profile = getCurrentProfile();
+    activePackToolNames = getActiveToolNames();
+    workspaceRootForTools = opts.kernelDeps?.paths.workspaceRoot ?? process.cwd();
     // Lazy import: always load vibe_pm (core tools)
-    const { defineVibePmTools, VIBE_PM_TOOL_DESCRIPTIONS } = await import("./tools/vibe_pm/index.js");
-    const pm = defineVibePmTools();
+    const { defineVibePmTools, VIBE_PM_TOOL_DESCRIPTIONS } = (await import('./tools/vibe_pm/index.js'));
+    const pm = defineVibePmTools({ kernelDeps: opts.kernelDeps });
     // Lazy import: load BitNet only if any bitnet tool is enabled
     let bitnet = null;
     let BITNET_TOOL_DESCRIPTIONS = {};
     if (isBitNetEnabled()) {
-        const bitnetModule = await import("./tools/bitnet/index.js");
+        const bitnetModule = (await import('./tools/bitnet/index.js'));
         bitnet = bitnetModule.defineBitNetToolsV2();
         BITNET_TOOL_DESCRIPTIONS = bitnetModule.BITNET_TOOL_DESCRIPTIONS;
     }
@@ -51,78 +134,293 @@ export async function registerAllTools(server) {
     // ============================================================
     // vibe_pm tools (filtered by profile)
     // ============================================================
-    if (registerIfEnabled(server, "vibe_pm.status", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.status"], pm.statusInputSchema.shape, async (input) => pm.vibePmStatus(pm.statusInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.status', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.status'], pm.statusInputSchema.shape, async (input) => pm.vibePmStatus(pm.statusInputSchema.parse(input))))
         registeredCount++;
-    if (registerIfEnabled(server, "vibe_pm.briefing", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.briefing"], pm.briefingInputSchema.shape, async (input) => pm.vibePmBriefing(pm.briefingInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.briefing', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.briefing'], pm.briefingInputSchema.shape, async (input, extra) => pm.vibePmBriefing(pm.briefingInputSchema.parse(input), extra)))
         registeredCount++;
-    if (registerIfEnabled(server, "vibe_pm.get_decision", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.get_decision"], pm.getDecisionInputSchema.shape, async (input) => pm.vibePmGetDecision(pm.getDecisionInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.get_decision', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.get_decision'], pm.getDecisionInputSchema.shape, async (input) => pm.vibePmGetDecision(pm.getDecisionInputSchema.parse(input))))
         registeredCount++;
-    if (registerIfEnabled(server, "vibe_pm.submit_decision", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.submit_decision"], pm.submitDecisionInputSchema.shape, async (input) => pm.vibePmSubmitDecision(pm.submitDecisionInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.submit_decision', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.submit_decision'], pm.submitDecisionInputSchema.shape, async (input) => pm.vibePmSubmitDecision(pm.submitDecisionInputSchema.parse(input))))
         registeredCount++;
-    if (registerIfEnabled(server, "vibe_pm.create_work_order", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.create_work_order"], pm.createWorkOrderInputSchema.shape, async (input) => pm.vibePmCreateWorkOrder(pm.createWorkOrderInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.create_work_order', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.create_work_order'], pm.createWorkOrderInputSchema.shape, async (input) => pm.vibePmCreateWorkOrder(pm.createWorkOrderInputSchema.parse(input))))
         registeredCount++;
-    if (registerIfEnabled(server, "vibe_pm.inspect_code", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.inspect_code"], pm.inspectCodeInputSchema.shape, async (input) => pm.vibePmInspectCode(pm.inspectCodeInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.inspect_code', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.inspect_code'], pm.inspectCodeInputSchema.shape, async (input, extra) => pm.vibePmInspectCode(pm.inspectCodeInputSchema.parse(input), extra)))
         registeredCount++;
-    if (registerIfEnabled(server, "vibe_pm.doctor", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.doctor"], pm.doctorInputSchema.shape, async (input) => pm.vibePmDoctor(pm.doctorInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.doctor', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.doctor'], pm.doctorInputSchema.shape, async (input) => pm.vibePmDoctor(pm.doctorInputSchema.parse(input))))
         registeredCount++;
-    if (registerIfEnabled(server, "vibe_pm.ingress", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.ingress"], pm.ingressInputSchema.shape, async (input) => pm.vibePmIngress(pm.ingressInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.ingress', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.ingress'], pm.ingressInputSchema.shape, async (input) => pm.vibePmIngress(pm.ingressInputSchema.parse(input))))
         registeredCount++;
-    if (registerIfEnabled(server, "vibe_pm.memory_status", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.memory_status"], pm.memoryStatusInputSchema.shape, async (input) => pm.vibePmMemoryStatus(pm.memoryStatusInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.memory_status', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.memory_status'], pm.memoryStatusInputSchema.shape, async (input) => pm.vibePmMemoryStatus(pm.memoryStatusInputSchema.parse(input))))
         registeredCount++;
-    if (registerIfEnabled(server, "vibe_pm.memory_sync", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.memory_sync"], pm.memorySyncInputSchema.shape, async (input) => pm.vibePmMemorySync(pm.memorySyncInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.memory_sync', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.memory_sync'], pm.memorySyncInputSchema.shape, async (input) => pm.vibePmMemorySync(pm.memorySyncInputSchema.parse(input))))
         registeredCount++;
-    if (registerIfEnabled(server, "vibe_pm.memory_retrieve", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.memory_retrieve"], pm.memoryRetrieveInputSchema.shape, async (input) => pm.vibePmMemoryRetrieve(pm.memoryRetrieveInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.memory_retrieve', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.memory_retrieve'], pm.memoryRetrieveInputSchema.shape, async (input) => pm.vibePmMemoryRetrieve(pm.memoryRetrieveInputSchema.parse(input))))
         registeredCount++;
     // Consolidated memory tool (Tier 3 - preferred over individual memory_* tools)
-    if (registerIfEnabled(server, "vibe_pm.memory", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.memory"], pm.memoryInputSchema.shape, async (input) => pm.vibePmMemory(pm.memoryInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.memory', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.memory'], pm.memoryInputSchema.shape, async (input) => pm.vibePmMemory(pm.memoryInputSchema.parse(input))))
         registeredCount++;
-    if (registerIfEnabled(server, "vibe_pm.init_docs", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.init_docs"], pm.initDocsInputSchema.shape, async (input) => pm.vibePmInitDocs(pm.initDocsInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.init_docs', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.init_docs'], pm.initDocsInputSchema.shape, async (input) => pm.vibePmInitDocs(pm.initDocsInputSchema.parse(input))))
         registeredCount++;
     // XT Apps UI Tools (P2)
-    if (registerIfEnabled(server, "vibe_pm.ui_manifest", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.ui_manifest"], pm.uiManifestInputSchema.shape, async (input) => pm.vibePmUIManifest(pm.uiManifestInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.ui_manifest', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.ui_manifest'], pm.uiManifestInputSchema.shape, async (input) => pm.vibePmUIManifest(pm.uiManifestInputSchema.parse(input))))
         registeredCount++;
-    if (registerIfEnabled(server, "vibe_pm.ui_resource", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.ui_resource"], pm.uiResourceInputSchema.shape, async (input) => pm.vibePmUIResource(pm.uiResourceInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.ui_resource', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.ui_resource'], pm.uiResourceInputSchema.shape, async (input) => pm.vibePmUIResource(pm.uiResourceInputSchema.parse(input))))
         registeredCount++;
     // Scaffold tool
-    if (registerIfEnabled(server, "vibe_pm.scaffold", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.scaffold"], pm.scaffoldInputSchema.shape, async (input) => pm.vibePmScaffold(pm.scaffoldInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.scaffold', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.scaffold'], pm.scaffoldInputSchema.shape, async (input) => pm.vibePmScaffold(pm.scaffoldInputSchema.parse(input))))
+        registeredCount++;
+    // Agent lifecycle tool
+    if (registerIfEnabled(server, 'vibe_pm.agent', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.agent'], pm.agentInputSchema.shape, async (input) => pm.vibePmAgent(pm.agentInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.workspace_recipe', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.workspace_recipe'], pm.workspaceRecipeInputSchema.shape, async (input) => pm.vibePmWorkspaceRecipe(pm.workspaceRecipeInputSchema.parse(input))))
         registeredCount++;
     // Setup tool (one-click MCP configuration)
-    if (registerIfEnabled(server, "vibe_pm.setup", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.setup"], pm.setupInputSchema.shape, async (input) => pm.vibePmSetup(pm.setupInputSchema.parse(input))))
+    if (registerIfEnabled(server, 'vibe_pm.setup', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.setup'], pm.setupInputSchema.shape, async (input) => pm.vibePmSetup(pm.setupInputSchema.parse(input))))
+        registeredCount++;
+    // Worker pack tools (async queue/task lifecycle)
+    if (registerIfEnabled(server, 'vibe_pm.submit_task', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.submit_task'], pm.submitTaskInputSchema.shape, async (input) => pm.vibePmSubmitTask(pm.submitTaskInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.worker_status', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.worker_status'], pm.workerStatusInputSchema.shape, async (input) => pm.vibePmWorkerStatus(pm.workerStatusInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.get_result', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.get_result'], pm.getResultInputSchema.shape, async (input) => pm.vibePmGetResult(pm.getResultInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.dashboard', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.dashboard'], pm.dashboardInputSchema.shape, async (input) => pm.vibePmDashboard(pm.dashboardInputSchema.parse(input))))
+        registeredCount++;
+    // Scout tool (BitNet trigger dispatch — vibe_pm namespace, bitnet group)
+    if (registerIfEnabled(server, 'vibe_pm.scout', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.scout'], pm.scoutInputSchema.shape, async (input, extra) => pm.vibePmScout(pm.scoutInputSchema.parse(input), extra)))
+        registeredCount++;
+    // Block Search tool (P38 — DB FTS search via tsvector)
+    if (registerIfEnabled(server, 'vibe_pm.block_search', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.block_search'], pm.blockSearchInputSchema.shape, async (input) => pm.vibePmBlockSearch(pm.blockSearchInputSchema.parse(input))))
+        registeredCount++;
+    // Block Events tool (Sprint 1 — Signal polling)
+    if (registerIfEnabled(server, 'vibe_pm.block_events', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.block_events'], pm.blockEventsInputSchema.shape, async (input) => pm.vibePmBlockEvents(pm.blockEventsInputSchema.parse(input))))
+        registeredCount++;
+    // Block Snapshot tool (Sprint 4 — Snapshot/Restore)
+    if (registerIfEnabled(server, 'vibe_pm.block_snapshot', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.block_snapshot'], pm.blockSnapshotInputSchema.shape, async (input) => pm.vibePmBlockSnapshot(pm.blockSnapshotInputSchema.parse(input))))
         registeredCount++;
     // ============================================================
-    // Legacy Alias (하위 호환) - always loaded for backwards compat
+    // Sprint 048: Gap Closure tools (skills, suggest_roots, check_resources, check_dormant, repair_plan, finalize_work, undo_last_task, branch_pivot)
     // ============================================================
+    if (registerIfEnabled(server, 'vibe_pm.skills', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.skills'], pm.skillsInputSchema.shape, async (input) => pm.vibePmSkills(pm.skillsInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.suggest_roots', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.suggest_roots'], pm.suggestRootsInputSchema.shape, async (input) => pm.vibePmSuggestRoots(pm.suggestRootsInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.check_resources', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.check_resources'], pm.checkResourcesInputSchema.shape, async (input) => pm.vibePmCheckResources(pm.checkResourcesInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.check_dormant', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.check_dormant'], pm.checkDormantInputSchema.shape, async (input) => pm.vibePmCheckDormant(pm.checkDormantInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.repair_plan', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.repair_plan'], pm.repairPlanInputSchema.shape, async (input) => pm.vibePmRepairPlan(pm.repairPlanInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.finalize_work', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.finalize_work'], pm.finalizeWorkInputSchema.shape, async (input) => pm.vibePmFinalizeWork(pm.finalizeWorkInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.undo_last_task', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.undo_last_task'], pm.undoLastTaskInputSchema.shape, async (input) => pm.vibePmUndoLastTask(pm.undoLastTaskInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.branch_pivot', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.branch_pivot'], pm.branchPivotInputSchema.shape, async (input) => pm.vibePmBranchPivot(pm.branchPivotInputSchema.parse(input))))
+        registeredCount++;
+    // ============================================================
+    // Human Surface meta-tools (gated by VIBE_PROFILE=human)
+    // ============================================================
+    let humanCount = 0;
+    if (isHumanProfile(profile)) {
+        const humanModule = (await import('./tools/vibe_pm/human_tools.js'));
+        if (registerIfEnabled(server, 'vibe_pm.do', humanModule.HUMAN_TOOL_DESCRIPTIONS['vibe_pm.do'], humanModule.doInputSchema.shape, async (input, extra) => humanModule.handleDo(humanModule.doInputSchema.parse(input), extra)))
+            humanCount++;
+        if (registerIfEnabled(server, 'vibe_pm.ask', humanModule.HUMAN_TOOL_DESCRIPTIONS['vibe_pm.ask'], humanModule.askInputSchema.shape, async (input) => humanModule.handleAsk(humanModule.askInputSchema.parse(input))))
+            humanCount++;
+        if (registerIfEnabled(server, 'vibe_pm.check', humanModule.HUMAN_TOOL_DESCRIPTIONS['vibe_pm.check'], humanModule.checkInputSchema.shape, async (input) => humanModule.handleCheck(humanModule.checkInputSchema.parse(input))))
+            humanCount++;
+    }
+    // ============================================================
+    // Prime tools (lazy loaded, gated by VIBE_PRIME=1)
+    // ============================================================
+    let primeCount = 0;
+    let primePool = null;
+    if (isPrimeEnabled()) {
+        const primeModule = (await import('./tools/vibe_pm/prime_tools.js'));
+        const { getPool } = await import('../db_sync/pool.js');
+        // Best-effort pool acquisition — Prime tools won't register if DB is unavailable
+        try {
+            const pool = await getPool('mcp');
+            primePool = pool;
+            if (registerIfEnabled(server, 'vibe_pm.start_mission', primeModule.PRIME_TOOL_DESCRIPTIONS['vibe_pm.start_mission'], primeModule.startMissionInputSchema.shape, async (input) => primeModule.handleStartMission(primeModule.startMissionInputSchema.parse(input), pool)))
+                primeCount++;
+            if (registerIfEnabled(server, 'vibe_pm.mission_status', primeModule.PRIME_TOOL_DESCRIPTIONS['vibe_pm.mission_status'], primeModule.missionStatusInputSchema.shape, async (input) => primeModule.handleMissionStatus(primeModule.missionStatusInputSchema.parse(input), pool)))
+                primeCount++;
+            if (registerIfEnabled(server, 'vibe_pm.set_mode', primeModule.PRIME_TOOL_DESCRIPTIONS['vibe_pm.set_mode'], primeModule.setModeInputSchema.shape, async (input) => primeModule.handleSetMode(primeModule.setModeInputSchema.parse(input), pool)))
+                primeCount++;
+        }
+        catch {
+            // DB not available — DB-dependent Prime tools not registered
+            logger.warn('[tool-registry] Prime DB unavailable — skipping: start_mission, mission_status, set_mode');
+        }
+        // Holodeck virtual shell (no DB required)
+        if (registerIfEnabled(server, 'vibe_pm.virtual_shell', primeModule.PRIME_TOOL_DESCRIPTIONS['vibe_pm.virtual_shell'], primeModule.virtualShellInputSchema.shape, async (input) => primeModule.handleVirtualShell(primeModule.virtualShellInputSchema.parse(input))))
+            primeCount++;
+        // Hive Mind parallel thinking (no DB required)
+        if (registerIfEnabled(server, 'vibe_pm.hive_think', primeModule.PRIME_TOOL_DESCRIPTIONS['vibe_pm.hive_think'], primeModule.hiveThinkInputSchema.shape, async (input) => primeModule.handleHiveThink(primeModule.hiveThinkInputSchema.parse(input))))
+            primeCount++;
+        // Time Stone simulation (no DB required)
+        if (registerIfEnabled(server, 'vibe_pm.simulate', primeModule.PRIME_TOOL_DESCRIPTIONS['vibe_pm.simulate'], primeModule.simulateInputSchema.shape, async (input) => primeModule.handleSimulate(primeModule.simulateInputSchema.parse(input), primePool ?? undefined)))
+            primeCount++;
+        // Hybrid status check (no DB required)
+        if (registerIfEnabled(server, 'vibe_pm.hybrid_status', primeModule.PRIME_TOOL_DESCRIPTIONS['vibe_pm.hybrid_status'], primeModule.hybridStatusInputSchema.shape, async (input) => primeModule.handleHybridStatus(primeModule.hybridStatusInputSchema.parse(input))))
+            primeCount++;
+        // System Control — Iron Man (Rust Worker) + local File I/O (no DB required)
+        if (registerIfEnabled(server, 'vibe_pm.system_control', primeModule.PRIME_TOOL_DESCRIPTIONS['vibe_pm.system_control'], primeModule.systemControlInputSchema.shape, async (input) => primeModule.handleSystemControl(primeModule.systemControlInputSchema.parse(input))))
+            primeCount++;
+    }
+    // ============================================================
+    // Cockpit bridge tools (lazy loaded, gated by VIBE_COCKPIT=1)
+    // ============================================================
+    let cockpitCount = 0;
+    if (isCockpitEnabled()) {
+        const cockpitModule = (await import('./cockpit-bridge/tools/index.js'));
+        const cockpitTools = [
+            cockpitModule.cockpitStatusTool,
+            cockpitModule.cockpitRunTool,
+            cockpitModule.cockpitStopTool,
+            cockpitModule.cockpitPauseTool,
+            cockpitModule.cockpitResumeTool,
+            cockpitModule.cockpitResetTool,
+            cockpitModule.cockpitDecideTool,
+            cockpitModule.cockpitPromptTool,
+            cockpitModule.cockpitManualTool,
+        ];
+        for (const tool of cockpitTools) {
+            if (registerIfEnabled(server, tool.name, tool.description, tool.inputSchema, tool.handler)) {
+                cockpitCount++;
+            }
+        }
+    }
+    // ============================================================
+    // RAG / Knowledge tools (lazy loaded, gated by MUSU_RAG_ENABLED=1)
+    // ============================================================
+    let ragCount = 0;
+    if (process.env.MUSU_RAG_ENABLED === '1') {
+        const ragModule = await import('./tools/vibe_pm/knowledge_search.js');
+        if (registerIfEnabled(server, 'vibe_pm.knowledge_search', ragModule.KNOWLEDGE_SEARCH_DESCRIPTION, ragModule.knowledgeSearchInputSchema.shape, async (input) => ragModule.handleKnowledgeSearch(ragModule.knowledgeSearchInputSchema.parse(input))))
+            ragCount++;
+    }
+    // ============================================================
+    // Musu Bridge tools (lazy loaded, gated by MUSU_PRIME_URL)
+    // ============================================================
+    let musuBridgeCount = 0;
+    if (isMusuBridgeEnabled()) {
+        const musuModule = (await import('./musu-bridge/tools/index.js'));
+        const musuToolDefs = [
+            musuModule.musuStatusTool,
+            musuModule.musuFleetTool,
+            musuModule.musuGatewayTool,
+            musuModule.musuDispatchTool,
+            musuModule.musuKnowledgeTool,
+            musuModule.musuRunTool,
+        ];
+        for (const tool of musuToolDefs) {
+            if (registerIfEnabled(server, tool.name, tool.description, tool.inputSchema, tool.handler)) {
+                musuBridgeCount++;
+            }
+        }
+    }
+    // ============================================================
+    // Hive Bridge tools (lazy loaded, gated by MUSU_PRIME_URL)
+    // ============================================================
+    let hiveBridgeCount = 0;
+    if (isHiveBridgeEnabled()) {
+        const hiveModule = (await import('./hive-bridge/tools/index.js'));
+        const hiveToolDefs = [
+            hiveModule.hiveRunCommandTool,
+            hiveModule.hiveFileListTool,
+            hiveModule.hiveFileReadTool,
+            hiveModule.hiveSubmitJobTool,
+            hiveModule.hiveNodesTool,
+        ];
+        for (const tool of hiveToolDefs) {
+            if (registerIfEnabled(server, tool.name, tool.description, tool.inputSchema, tool.handler)) {
+                hiveBridgeCount++;
+            }
+        }
+    }
+    // ============================================================
+    // System tools (always loaded — discovery/health/agents/templates)
+    // ============================================================
+    let systemCount = 0;
+    {
+        const discoverModule = (await import('./ai-native/discover.js'));
+        const healthModule = (await import('./ai-native/health.js'));
+        const agentModule = (await import('./tools/agents.js'));
+        const templateModule = (await import('./tools/templates/index.js'));
+        const systemToolDefs = [
+            discoverModule.systemDiscoverTool,
+            healthModule.systemHealthTool,
+            agentModule.systemAgentsTool,
+            agentModule.systemWorkflowsTool,
+            agentModule.systemDispatchTool,
+            templateModule.systemTemplatesTool,
+            templateModule.systemTemplateDetailTool,
+            templateModule.systemTemplateApplyTool,
+            templateModule.systemTemplateValidateTool,
+            templateModule.systemTemplateRunStartTool,
+            templateModule.systemTemplateRunStatusTool,
+            templateModule.systemTemplateRunRecoverTool,
+            templateModule.systemTemplateRunMaintenanceTool,
+        ];
+        // System tools bypass profile/pack gating for AI profiles.
+        // For human profile, they're registered in handler registry only (available via vibe_pm.ask)
+        // but NOT exposed as direct MCP tools.
+        for (const tool of systemToolDefs) {
+            const wrapped = wrapHandler(tool.name, tool.handler);
+            // Always register in handler registry (meta-tools need access)
+            registerToolHandler(tool.name, wrapped);
+            if (!isHumanProfile(profile)) {
+                server.tool(tool.name, tool.description, tool.inputSchema, wrapped);
+                systemCount++;
+            }
+        }
+    }
+    // Handlers have typed inputs; widen to `unknown` for the legacy map contract.
+    const asLegacy = (h) => h;
     const LEGACY_HANDLER_MAP = {
-        "vibe_pm.inspect_code": { schema: pm.inspectCodeInputSchema, handler: pm.vibePmInspectCode },
-        "vibe_pm.get_decision": { schema: pm.getDecisionInputSchema, handler: pm.vibePmGetDecision },
-        "vibe_pm.submit_decision": { schema: pm.submitDecisionInputSchema, handler: pm.vibePmSubmitDecision },
-        "vibe_pm.status": { schema: pm.statusInputSchema, handler: pm.vibePmStatus },
-        "vibe_pm.create_work_order": { schema: pm.createWorkOrderInputSchema, handler: pm.vibePmCreateWorkOrder },
+        'vibe_pm.inspect_code': { schema: pm.inspectCodeInputSchema, handler: asLegacy(pm.vibePmInspectCode) },
+        'vibe_pm.get_decision': { schema: pm.getDecisionInputSchema, handler: asLegacy(pm.vibePmGetDecision) },
+        'vibe_pm.submit_decision': {
+            schema: pm.submitDecisionInputSchema,
+            handler: asLegacy(pm.vibePmSubmitDecision),
+        },
+        'vibe_pm.status': { schema: pm.statusInputSchema, handler: asLegacy(pm.vibePmStatus) },
+        'vibe_pm.create_work_order': {
+            schema: pm.createWorkOrderInputSchema,
+            handler: asLegacy(pm.vibePmCreateWorkOrder),
+        },
     };
     let legacyCount = 0;
-    for (const [legacyName, newName] of Object.entries(LEGACY_ALIAS_MAPPING)) {
-        const target = LEGACY_HANDLER_MAP[newName];
-        if (target) {
-            server.tool(legacyName, getLegacyDescription(legacyName, newName), target.schema.shape, async (input) => target.handler(target.schema.parse(input)));
-            legacyCount++;
+    if (!isHumanProfile(profile)) {
+        for (const [legacyName, newName] of Object.entries(LEGACY_ALIAS_MAPPING)) {
+            const target = LEGACY_HANDLER_MAP[newName];
+            if (target) {
+                server.tool(legacyName, getLegacyDescription(legacyName, newName), target.schema.shape, async (input) => target.handler(target.schema.parse(input)));
+                legacyCount++;
+            }
         }
-    }
+    } // end !isHumanProfile
     // ============================================================
     // BitNet tools (lazy loaded, filtered by profile)
     // ============================================================
     let bitnetCount = 0;
     // Only register BitNet tools if module was loaded
     if (bitnet) {
-        if (registerIfEnabled(server, "bitnet.check", BITNET_TOOL_DESCRIPTIONS["bitnet.check"], bitnet.bitnetCheckInputSchema.shape, async (input) => bitnet.bitnetCheckHandler(bitnet.bitnetCheckInputSchema.parse(input))))
+        if (registerIfEnabled(server, 'bitnet.check', BITNET_TOOL_DESCRIPTIONS['bitnet.check'], bitnet.bitnetCheckInputSchema.shape, async (input, extra) => bitnet.bitnetCheckHandler(bitnet.bitnetCheckInputSchema.parse(input), extra)))
+            bitnetCount++;
+        if (registerIfEnabled(server, 'bitnet.trace', BITNET_TOOL_DESCRIPTIONS['bitnet.trace'], bitnet.bitnetTraceInputSchema.shape, async (input) => bitnet.bitnetTraceHandler(bitnet.bitnetTraceInputSchema.parse(input))))
             bitnetCount++;
-        if (registerIfEnabled(server, "bitnet.trace", BITNET_TOOL_DESCRIPTIONS["bitnet.trace"], bitnet.bitnetTraceInputSchema.shape, async (input) => bitnet.bitnetTraceHandler(bitnet.bitnetTraceInputSchema.parse(input))))
+        if (registerIfEnabled(server, 'bitnet.signal', BITNET_TOOL_DESCRIPTIONS['bitnet.signal'], bitnet.bitnetSignalInputSchema.shape, async (input) => bitnet.bitnetSignalHandler(bitnet.bitnetSignalInputSchema.parse(input))))
             bitnetCount++;
-        if (registerIfEnabled(server, "bitnet.signal", BITNET_TOOL_DESCRIPTIONS["bitnet.signal"], bitnet.bitnetSignalInputSchema.shape, async (input) => bitnet.bitnetSignalHandler(bitnet.bitnetSignalInputSchema.parse(input))))
+        if (registerIfEnabled(server, 'bitnet.scout', BITNET_TOOL_DESCRIPTIONS['bitnet.scout'], bitnet.bitnetScoutInputSchema.shape, async (input) => bitnet.bitnetScoutHandler(bitnet.bitnetScoutInputSchema.parse(input))))
             bitnetCount++;
     }
     // Log profile info
     const stats = getProfileStats(profile);
-    console.error(`[vibe-pm] Profile: ${profile}, Tools: ${registeredCount} vibe_pm + ${legacyCount} legacy + ${bitnetCount} bitnet = ${registeredCount + legacyCount + bitnetCount} total`);
+    const total = registeredCount + humanCount + legacyCount + bitnetCount + primeCount + cockpitCount + ragCount + musuBridgeCount + hiveBridgeCount + systemCount;
+    logger.error(`[vibe-pm] Profile: ${profile}, Tools: ${registeredCount} vibe_pm + ${humanCount} human + ${legacyCount} legacy + ${bitnetCount} bitnet + ${primeCount} prime + ${cockpitCount} cockpit + ${ragCount} rag + ${musuBridgeCount} musu + ${hiveBridgeCount} hive + ${systemCount} system = ${total} total`);
 }
 export async function captureRegistrySnapshot() {
     const regs = [];