@vibecodetown/mcp-server 2.2.0 → 2.2.1

package/build/generated/bridge_build_seed_output.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const BridgeBuildSeedOutputSchema = z.object({ "success": z.boolean(), "project_id": z.string().min(1), "run_id": z.string().min(1), "seed_path": z.string().min(1), "next_action": z.object({ "tool": z.literal("vibe_pm.create_work_order"), "reason": z.string().min(1) }).strict() }).strict().describe("SSOT schema for vibe_pm.bridge_build_seed MCP tool output");

package/build/generated/bridge_confirm_reference_input.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const BridgeConfirmReferenceInputSchema = z.object({ "project_id": z.string().min(1), "run_id": z.string().min(1).optional(), "selected_key": z.enum(["A", "B", "C"]), "raw_answer": z.string().min(1).max(1000), "notes": z.string().max(2000).optional(), "must_have_overrides": z.array(z.string().min(1).max(120)).max(12).optional(), "must_not_overrides": z.array(z.string().min(1).max(120)).max(12).optional(), "write_files": z.boolean().default(true) }).strict().describe("SSOT schema for vibe_pm.bridge_confirm_reference MCP tool input");

package/build/generated/bridge_confirm_reference_output.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const BridgeConfirmReferenceOutputSchema = z.object({ "success": z.boolean(), "project_id": z.string().min(1), "run_id": z.string().min(1), "confirmed_reference_path": z.string().min(1), "selected": z.object({ "key": z.enum(["A", "B", "C"]), "title": z.string().min(1).max(120), "primary_link": z.string().min(4).max(2000) }).strict(), "next_action": z.object({ "tool": z.literal("vibe_pm.bridge_build_seed"), "reason": z.string().min(1) }).strict() }).strict().describe("SSOT schema for vibe_pm.bridge_confirm_reference MCP tool output");

package/build/generated/bridge_confirmed_reference_file.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const BridgeConfirmedReferenceFileSchema = z.object({ "schema_version": z.literal("bridge.confirmed_reference.v1"), "run_id": z.string().min(6).max(128), "project_id": z.string().min(1).max(128).optional(), "created_at": z.string().datetime({ offset: true }), "selected": z.object({ "key": z.enum(["A", "B", "C"]), "title": z.string().min(1).max(120), "kind": z.enum(["oss_repo", "library", "product", "pattern", "doc"]), "primary_link": z.string().min(4).max(2000) }).strict(), "user_confirmation": z.object({ "raw_answer": z.string().min(1).max(1000), "notes": z.string().max(2000).optional(), "must_have_overrides": z.array(z.string().min(1).max(120)).max(12).optional(), "must_not_overrides": z.array(z.string().min(1).max(120)).max(12).optional() }).strict() }).strict();

package/build/generated/bridge_generate_references_input.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const BridgeGenerateReferencesInputSchema = z.object({ "project_id": z.string().min(1), "run_id": z.string().min(1).optional(), "raw_user_intent": z.string().min(1).max(4000), "keywords": z.array(z.string().min(1).max(80)).min(0).max(12).describe("선택. 비어 있으면 context_scan 산출물 기반으로 자동 보강합니다.").optional(), "constraints": z.array(z.string().min(1).max(120)).max(12).optional(), "must_have": z.array(z.string().min(1).max(120)).max(12).optional(), "must_not": z.array(z.string().min(1).max(120)).max(12).optional(), "candidates_seed": z.array(z.object({ "title": z.string().min(1).max(120), "kind": z.enum(["oss_repo", "library", "product", "pattern", "doc"]), "primary_link": z.string().min(4).max(2000), "why_similar": z.string().max(1200).optional(), "fit_summary": z.string().max(1200).optional() }).strict()).max(10).describe("Optional. If provided, the tool will use these candidates as the primary source instead of running external search.").optional(), "max_candidates": z.number().int().gte(2).lte(3).default(3), "write_files": z.boolean().default(true) }).strict().describe("SSOT schema for vibe_pm.bridge_generate_references MCP tool input");

package/build/generated/bridge_generate_references_output.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const BridgeGenerateReferencesOutputSchema = z.object({ "success": z.boolean(), "project_id": z.string().min(1), "run_id": z.string().min(1), "references_path": z.string().min(1), "candidates": z.array(z.object({ "key": z.enum(["A", "B", "C"]), "title": z.string().min(1).max(120), "primary_link": z.string().min(4).max(2000) }).strict()).min(2).max(3), "warnings": z.array(z.string()), "next_action": z.object({ "tool": z.literal("vibe_pm.bridge_confirm_reference"), "reason": z.string().min(1) }).strict() }).strict().describe("SSOT schema for vibe_pm.bridge_generate_references MCP tool output");

package/build/generated/bridge_references_file.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const BridgeReferencesFileSchema = z.object({ "schema_version": z.literal("bridge.references.v1"), "run_id": z.string().min(6).max(128), "project_id": z.string().min(1).max(128).optional(), "created_at": z.string().datetime({ offset: true }), "query": z.object({ "raw_user_intent": z.string().min(1).max(4000), "keywords": z.array(z.string().min(1).max(80)).min(1).max(12), "constraints": z.array(z.string().min(1).max(120)).max(12).optional(), "must_have": z.array(z.string().min(1).max(120)).max(12).optional(), "must_not": z.array(z.string().min(1).max(120)).max(12).optional() }).strict(), "candidates": z.array(z.object({ "key": z.enum(["A", "B", "C"]), "title": z.string().min(1).max(120), "kind": z.enum(["oss_repo", "library", "product", "pattern", "doc"]), "why_similar": z.string().min(1).max(1200), "fit_summary": z.string().max(1200).optional(), "confidence": z.number().int().gte(1).lte(5), "links": z.object({ "primary": z.string().min(4).max(2000), "secondary": z.array(z.string().min(4).max(2000)).max(5).optional() }).strict(), "evidence": z.object({ "source": z.enum(["github", "local_zoekt", "manual"]).optional(), "highlights": z.array(z.string().min(1).max(300)).max(8).optional() }).strict().optional() }).strict()).min(2).max(3) }).strict();

package/build/generated/bridge_work_order_seed_file.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const BridgeWorkOrderSeedFileSchema = z.object({ "schema_version": z.literal("bridge.work_order_seed.v1"), "run_id": z.string().min(6).max(128), "project_id": z.string().min(1).max(128).optional(), "created_at": z.string().datetime({ offset: true }), "intent": z.object({ "goal": z.string().min(1).max(2000), "user_story": z.string().min(1).max(2000), "acceptance": z.array(z.string().min(1).max(300)).min(3).max(12), "constraints": z.array(z.string().min(1).max(200)).max(12).optional(), "non_goals": z.array(z.string().min(1).max(200)).max(8).optional() }).strict(), "scope_seed": z.object({ "include": z.array(z.string().min(1).max(300)).min(1).max(20), "exclude": z.array(z.string().min(1).max(300)).max(20), "do_not_touch": z.array(z.string().min(1).max(300)).max(20).optional() }).strict(), "reference": z.object({ "key": z.enum(["A", "B", "C"]), "title": z.string().min(1).max(120), "primary_link": z.string().min(4).max(2000), "takeaways": z.array(z.string().min(1).max(200)).max(10).optional() }).strict(), "handoff": z.object({ "preferred_stack_hint": z.string().max(200).optional(), "risk_notes": z.array(z.string().min(1).max(200)).max(8).optional() }).strict().optional() }).strict();

package/build/generated/contracts_bundle_info.js

@@ -1,5 +1,5 @@
 // Auto-generated from schemas/contracts.version.json + schemas/contracts.lock.json
 // DO NOT EDIT MANUALLY - run scripts/generate-contracts.sh
-export const CONTRACTS_VERSION = "1.8.1";
-export const CONTRACTS_BUNDLE_SHA256 = "c3fa79c3342e45c7f4e17af6ecb852350d84a684c2078c756ae24d6b05643b89";
-export const CONTRACTS_SCHEMA_COUNT = 87;
+export const CONTRACTS_VERSION = "1.8.6";
+export const CONTRACTS_BUNDLE_SHA256 = "117ae96448d5d0bd988281ae7170facabc90c20da074d1d3e845c63cc734ba06";
+export const CONTRACTS_SCHEMA_COUNT = 103;

package/build/generated/index.js

@@ -3,6 +3,7 @@
 export * from "./selection_validation_result.js";
 export * from "./finalize_work_input.js";
 export * from "./briefing_input.js";
+export * from "./ingress_input.js";
 export * from "./get_decision_input.js";
 export * from "./submit_decision_input.js";
 export * from "./create_work_order_input.js";
@@ -18,6 +19,9 @@ export * from "./run_app_input.js";
 export * from "./export_output_input.js";
 export * from "./search_oss_input.js";
 export * from "./zoekt_evidence_input.js";
+export * from "./bridge_generate_references_input.js";
+export * from "./bridge_confirm_reference_input.js";
+export * from "./bridge_build_seed_input.js";
 export * from "./doctor_input.js";
 export * from "./update_input.js";
 export * from "./activate_input.js";
@@ -31,6 +35,7 @@ export * from "./vibe_pm_verdict.js";
 export * from "./create_work_order_output.js";
 export * from "./repair_plan_output.js";
 export * from "./briefing_output.js";
+export * from "./ingress_output.js";
 export * from "./get_decision_output.js";
 export * from "./submit_decision_output.js";
 export * from "./status_output.js";
@@ -40,6 +45,12 @@ export * from "./memory_retrieve_output.js";
 export * from "./memory_state_file.js";
 export * from "./vibe_repo_config.js";
 export * from "./current_work_order_file.js";
+export * from "./ingress_resolution_file.js";
+export * from "./ingress_summary_file.js";
+export * from "./bridge_references_file.js";
+export * from "./bridge_confirmed_reference_file.js";
+export * from "./bridge_work_order_seed_file.js";
+export * from "./message_template_id_mapping_file.js";
 export * from "./advisory_review_output.js";
 export * from "./scaffold_output.js";
 export * from "./finalize_work_output.js";
@@ -48,6 +59,9 @@ export * from "./run_app_output.js";
 export * from "./export_output_output.js";
 export * from "./search_oss_output.js";
 export * from "./zoekt_evidence_output.js";
+export * from "./bridge_generate_references_output.js";
+export * from "./bridge_confirm_reference_output.js";
+export * from "./bridge_build_seed_output.js";
 export * from "./doctor_output.js";
 export * from "./update_output.js";
 export * from "./activate_output.js";

package/build/generated/ingress_input.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const IngressInputSchema = z.object({ "project_id": z.string().min(1).describe("프로젝트 ID 또는 run_id (생략 시 최근 프로젝트 자동)").optional(), "run_id": z.string().min(1).describe("명시 run_id (project_id보다 우선)").optional(), "workspace_path": z.string().min(1).describe("업무 폴더(생략 시 현재 작업 폴더)").optional(), "resolution": z.enum(["INGRESS_RESOLVED_RESUME", "INGRESS_RESOLVED_NEW_TASK", "INGRESS_RESOLVED_ADOPT", "INGRESS_ABORTED"]).describe("Ingress 종료 상태"), "context_scan": z.boolean().describe("Context Scan 수행 여부(권장: true)").default(true), "write_files": z.boolean().describe("runs/<run_id>/ingress 산출물 파일 생성 여부(테스트용)").default(true) }).strict().describe("SSOT schema for vibe_pm.ingress MCP tool input");

package/build/generated/ingress_output.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const IngressOutputSchema = z.object({ "success": z.boolean(), "project_id": z.string().min(1), "run_id": z.string().min(1), "workspace_path": z.string().min(1), "has_vibe_state": z.boolean(), "resolution": z.enum(["INGRESS_RESOLVED_RESUME", "INGRESS_RESOLVED_NEW_TASK", "INGRESS_RESOLVED_ADOPT", "INGRESS_ABORTED"]), "context_scan_required": z.boolean(), "context_scan_completed": z.boolean(), "ingress_resolution_path": z.string().min(1), "artifacts": z.object({ "project_fingerprint": z.string().min(1).optional(), "repo_map": z.string().min(1).optional(), "entrypoints": z.string().min(1).optional(), "docs_index": z.string().min(1).optional(), "risk_flags": z.string().min(1).optional(), "ingress_summary": z.string().min(1).optional() }).strict().optional(), "warnings": z.array(z.string().min(1)).describe("Best-effort 경고 목록").optional(), "message": z.string().min(1), "next_action": z.union([z.object({ "tool": z.enum(["vibe_pm.get_decision", "vibe_pm.briefing", "vibe_pm.ingress"]), "reason": z.string().min(1) }).strict(), z.null()]) }).strict().describe("SSOT schema for vibe_pm.ingress MCP tool output");

package/build/generated/ingress_resolution_file.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const IngressResolutionFileSchema = z.object({ "schema_version": z.literal("ingress.resolution.v2"), "run_id": z.string().min(3).max(128), "project_id": z.string().min(1).max(128).optional(), "workspace_path": z.string().min(1).max(4096), "resolution": z.enum(["INGRESS_RESOLVED_RESUME", "INGRESS_RESOLVED_NEW_TASK", "INGRESS_RESOLVED_ADOPT", "INGRESS_ABORTED"]), "has_vibe_state": z.boolean(), "context_scan_required": z.boolean(), "context_scan_completed": z.boolean(), "created_at": z.string().datetime({ offset: true }) }).strict();

package/build/generated/ingress_summary_file.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const IngressSummaryFileSchema = z.object({ "format_version": z.literal("ingress.summary.v1"), "run_id": z.string().min(3).max(128), "project_id": z.string().min(1).max(128).optional(), "created_at": z.string().datetime({ offset: true }), "producer": z.object({ "name": z.string().min(1).max(120), "version": z.string().min(1).max(64), "build": z.string().min(1).max(128).optional() }).strict(), "pointers": z.object({ "project_fingerprint": z.string().min(1).max(512), "repo_map": z.string().min(1).max(512), "entrypoints": z.string().min(1).max(512), "docs_index": z.string().min(1).max(512), "risk_flags": z.string().min(1).max(512) }).strict(), "high_level": z.object({ "repo_kind_hint": z.string().max(200).optional(), "entrypoint_status": z.enum(["OK", "AMBIGUOUS", "NONE"]), "clarification_recommended": z.boolean(), "clarification_reasons": z.array(z.string().min(1).max(120)).max(12).optional(), "docs_index_count": z.number().int().gte(0) }).strict(), "consumption_policy": z.object({ "front_reads": z.array(z.string().min(1).max(120)).min(1).max(20), "bridge_reads": z.array(z.string().min(1).max(120)).min(1).max(20), "back_reads": z.array(z.string().min(1).max(120)).min(1).max(20) }).strict() }).strict();

package/build/generated/message_template_id_mapping_file.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const MessageTemplateIdMappingFileSchema = z.object({ "version": z.literal("message_template_id_mapping.v1"), "description": z.string().min(0).max(2000).optional(), "default_locale": z.any(), "supported_locales": z.array(z.any()).min(1).refine((xs) => new Set(xs).size === xs.length, { message: "items must be unique" }), "human_language_policy": z.object({ "response_language_strategy": z.enum(["user_last_input", "fixed", "ask_once_on_conflict"]), "fallback_locale": z.any(), "max_confirmations_per_project": z.number().int().gte(0).lte(3) }).strict().optional(), "templates": z.object({ "GO-01": z.any(), "GO-02": z.any(), "FIX-01": z.any(), "FIX-02": z.any(), "BLOCK-01": z.any(), "BLOCK-02": z.any(), "TRIAGE-SKIP-01": z.any(), "TRIAGE-RUN-01": z.any(), "TRIAGE-RUN-02": z.any(), "ADV-01": z.any(), "ADV-02": z.any(), "WARN-01": z.any(), "WARN-02": z.any(), "SOFTBLOCK-01": z.any() }).strict(), "term_dictionary": z.object({ "entries": z.array(z.any()).min(1).max(200) }).strict() }).strict();

package/build/generated/run_app_input.js

@@ -1,2 +1,2 @@
 import { z } from "zod";
-export const RunAppInputSchema = z.object({ "mode": z.enum(["dev", "prod", "test"]).describe("실행 모드").default("dev"), "port": z.number().int().gte(1).lte(65535).describe("포트 번호 (선택사항)").optional(), "container": z.enum(["none", "podman"]).describe("실행 런타임 선택. 기본값은 기존 호스트 실행을 유지합니다.").default("none"), "container_image": z.string().regex(new RegExp("^[a-z0-9][a-z0-9./:_-]{0,199}$")).min(1).max(200).describe("컨테이너 이미지. 재현성을 위해 ':latest' 사용은 경고/차단 대상입니다(정책은 코드에서 강제).").optional(), "container_ports": z.array(z.number().int().gte(1).lte(65535)).max(32).refine((xs) => new Set(xs).size === xs.length, { message: "items must be unique" }).describe("컨테이너 포트 목록(선택). 생략 시 port(또는 프로젝트 디폴트 포트) 기반으로 자동 선택합니다.").optional(), "container_env": z.record(z.string().max(4096)).describe("컨테이너 환경변수(선택). allowlist 정책은 코드에서 강제합니다.").optional(), "container_mounts": z.array(z.object({ "host": z.string().min(1).max(512).describe("호스트 경로(상대/절대). repoRoot 밖 경로는 코드에서 차단합니다."), "container": z.string().regex(new RegExp("^/.*")).min(1).max(256).describe("컨테이너 내부 경로(절대 경로)"), "mode": z.enum(["ro", "rw"]).describe("마운트 모드") }).strict()).max(16).describe("컨테이너 마운트 목록(선택). 생략 시 repoRoot -> /work:rw 를 기본으로 사용합니다.").optional() }).strict().describe("SSOT schema for vibe_pm.run_app MCP tool input");
+export const RunAppInputSchema = z.object({ "mode": z.enum(["dev", "prod", "test"]).describe("실행 모드").default("dev"), "port": z.number().int().gte(1).lte(65535).describe("포트 번호 (선택사항)").optional(), "container": z.enum(["none", "podman"]).describe("실행 런타임 선택. 기본값은 기존 호스트 실행을 유지합니다.").default("none"), "container_image": z.string().regex(new RegExp("^[a-z0-9][a-z0-9./:_-]{0,199}$")).min(1).max(200).describe("컨테이너 이미지. 재현성을 위해 ':latest' 사용은 경고/차단 대상입니다(정책은 코드에서 강제).").optional(), "container_ports": z.array(z.number().int().gte(1).lte(65535)).max(32).refine((xs) => new Set(xs).size === xs.length, { message: "items must be unique" }).describe("컨테이너 포트 목록(선택). 생략 시 port(또는 프로젝트 디폴트 포트) 기반으로 자동 선택합니다.").optional(), "container_env": z.record(z.string().max(4096)).describe("컨테이너 환경변수(선택). allowlist 정책은 코드에서 강제합니다.").optional(), "container_mounts": z.array(z.object({ "host": z.string().min(1).max(512).describe("호스트 경로(상대/절대). repoRoot 밖 경로는 코드에서 차단합니다."), "container": z.string().regex(new RegExp("^/.*")).min(1).max(256).describe("컨테이너 내부 경로(절대 경로)"), "mode": z.enum(["ro", "rw"]).describe("마운트 모드") }).strict()).max(16).describe("컨테이너 마운트 목록(선택). 생략 시 repoRoot -> /work:rw 를 기본으로 사용합니다.").optional(), "option_key": z.enum(["A", "B", "C"]).describe("실행 후보가 여러 개일 때 선택 키(A/B/C). 후보가 1개면 생략 가능합니다.").optional() }).strict().describe("SSOT schema for vibe_pm.run_app MCP tool input");

package/build/index.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 // adapters/mcp-ts/src/index.ts
 // VibeCoding MCP Server (One-click Bootstrap)
 import * as fs from "node:fs";
@@ -51,6 +50,7 @@ const rp = defineReactPerfTools();
 // NEW: vibe_pm.* Tools (Recommended)
 // ============================================================
 server.tool("vibe_pm.briefing", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.briefing"], pm.briefingInputSchema.shape, async (input) => pm.vibePmBriefing(pm.briefingInputSchema.parse(input)));
+server.tool("vibe_pm.ingress", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.ingress"], pm.ingressInputSchema.shape, async (input) => pm.vibePmIngress(pm.ingressInputSchema.parse(input)));
 server.tool("vibe_pm.get_decision", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.get_decision"], pm.getDecisionInputSchema.shape, async (input) => pm.vibePmGetDecision(pm.getDecisionInputSchema.parse(input)));
 server.tool("vibe_pm.submit_decision", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.submit_decision"], pm.submitDecisionInputSchema.shape, async (input) => pm.vibePmSubmitDecision(pm.submitDecisionInputSchema.parse(input)));
 server.tool("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)));
@@ -70,9 +70,10 @@ server.tool("vibe_pm.run_app", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.run_app"], pm.
 server.tool("vibe_pm.export_output", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.export_output"], pm.exportOutputInputSchema.shape, async (input) => pm.vibePmExportOutput(pm.exportOutputInputSchema.parse(input)));
 server.tool("vibe_pm.search_oss", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.search_oss"], pm.searchOssInputSchema.shape, async (input) => pm.vibePmSearchOss(pm.searchOssInputSchema.parse(input)));
 server.tool("vibe_pm.zoekt_evidence", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.zoekt_evidence"], pm.zoektEvidenceInputSchema.shape, async (input) => pm.vibePmZoektEvidence(pm.zoektEvidenceInputSchema.parse(input)));
+server.tool("vibe_pm.bridge_generate_references", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.bridge_generate_references"], pm.bridgeGenerateReferencesInputSchema.shape, async (input) => pm.vibePmBridgeGenerateReferences(pm.bridgeGenerateReferencesInputSchema.parse(input)));
+server.tool("vibe_pm.bridge_confirm_reference", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.bridge_confirm_reference"], pm.bridgeConfirmReferenceInputSchema.shape, async (input) => pm.vibePmBridgeConfirmReference(pm.bridgeConfirmReferenceInputSchema.parse(input)));
+server.tool("vibe_pm.bridge_build_seed", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.bridge_build_seed"], pm.bridgeBuildSeedInputSchema.shape, async (input) => pm.vibePmBridgeBuildSeed(pm.bridgeBuildSeedInputSchema.parse(input)));
 server.tool("vibe_pm.gate", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.gate"], pm.gateInputSchema.shape, async (input) => pm.vibePmGate(pm.gateInputSchema.parse(input)));
-server.tool("vibe_pm.save_rule", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.save_rule"], pm.saveRuleInputSchema.shape, async (input) => pm.vibePmSaveRule(pm.saveRuleInputSchema.parse(input)));
-server.tool("vibe_pm.list_rules", VIBE_PM_TOOL_DESCRIPTIONS["vibe_pm.list_rules"], pm.listRulesInputSchema.shape, async (input) => pm.vibePmListRules(pm.listRulesInputSchema.parse(input)));
 // ============================================================
 // OPTIONAL: react_perf.* Tools (Performance Analysis)
 // ============================================================

package/build/local-mode/paths.js

@@ -15,6 +15,7 @@ export function getVibeRepoPaths(repoRoot) {
         archiveDir: path.join(vibeDir, "archive"),
         hooksDir,
         libDir,
+        skillsDir: path.join(vibeDir, "skills"),
         validateScript: path.join(libDir, "validate.sh"),
         prePushHook: path.join(hooksDir, "pre-push"),
         ciWorkflowFile,

package/build/local-mode/setup.js

@@ -4,6 +4,7 @@ import { initLocalModeRepo } from "./init.js";
 import { writeVersionLock } from "./version-lock.js";
 import { ensureEngines } from "../bootstrap/installer.js";
 import { healthCheck } from "../bootstrap/doctor.js";
+import { activateSkills, getSkillsHealth } from "../bootstrap/skills-installer.js";
 /**
  * Run unified setup process
  */
@@ -42,5 +43,24 @@ export async function runSetup(repoRoot, cliVersion, opts) {
     catch (e) {
         warnings.push(`버전 잠금 파일 생성 실패: ${e instanceof Error ? e.message : String(e)}`);
     }
-    return { local, engines, versionLock, warnings };
+    // Step 4: Skills activation
+    let skills = { activated: [], errors: [] };
+    if (!opts.skipSkills) {
+        try {
+            const skillsHealth = getSkillsHealth();
+            if (skillsHealth.installed && skillsHealth.skills.length > 0) {
+                // Activate all available skills by default
+                skills = await activateSkills(repoRoot);
+                if (skills.errors.length > 0) {
+                    for (const err of skills.errors) {
+                        warnings.push(`스킬 활성화 오류: ${err}`);
+                    }
+                }
+            }
+        }
+        catch (e) {
+            warnings.push(`스킬 활성화 실패: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    return { local, engines, skills, versionLock, warnings };
 }

package/build/path-utils.js

@@ -0,0 +1,68 @@
+// adapters/mcp-ts/src/path-utils.ts
+// P1-5: Centralized path normalization utilities (DRY)
+import * as path from "node:path";
+/**
+ * Convert Windows backslashes to POSIX forward slashes.
+ * This is the most basic normalization used across the codebase.
+ */
+export function toPosixPath(value) {
+    return value.replace(/\\/g, "/");
+}
+/**
+ * Normalize a relative path for POSIX style:
+ * - Convert backslashes to forward slashes
+ * - Trim whitespace
+ * - Remove leading slashes (makes it relative)
+ */
+export function normalizeRelativePosix(value) {
+    return (value ?? "").trim().replace(/\\/g, "/").replace(/^\/+/, "");
+}
+/**
+ * Normalize a path for comparison/matching:
+ * - Convert backslashes to forward slashes
+ * - Trim whitespace
+ * - Remove leading "./" prefix
+ */
+export function normalizeForMatch(value) {
+    let v = (value ?? "").trim().replace(/\\/g, "/");
+    if (v.startsWith("./"))
+        v = v.slice(2);
+    return v;
+}
+/**
+ * Resolve a path relative to a base path and normalize to POSIX.
+ * Returns empty string for empty input, "." for base path itself.
+ */
+export function resolveRelativePosix(basePath, value) {
+    const trimmed = (value ?? "").trim();
+    if (!trimmed)
+        return "";
+    const absolute = path.isAbsolute(trimmed) ? trimmed : path.resolve(basePath, trimmed);
+    const relative = path.relative(basePath, absolute);
+    if (!relative)
+        return ".";
+    return toPosixPath(relative);
+}
+/**
+ * Process and deduplicate an array of paths, normalizing each to POSIX relative format.
+ * Empty and duplicate paths are filtered out.
+ */
+export function normalizePathArray(basePath, values) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of values) {
+        const normalized = resolveRelativePosix(basePath, raw);
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+/**
+ * Deduplicate and normalize an array of strings for set operations.
+ * Uses basic POSIX normalization (backslash to forward slash).
+ */
+export function uniquePosixPaths(items) {
+    return Array.from(new Set(items.map((p) => normalizeRelativePosix(p)).filter(Boolean))).sort();
+}

package/build/runtime/cli_invoker.js

@@ -66,7 +66,7 @@ const SYSTEM_BINS = new Set([
 ]);
 /** Engine binary names (for type checking) */
 const ENGINE_BINS = new Set([
-    "spec-high", "vibecoding-helper", "clinic", "execution-engine",
+    "spec-high", "vibe-execution-engine", "clinic",
 ]);
 /**
  * Resolve binary path for a given CLI bin

package/build/tools/vibe_pm/advisory_review.js

@@ -1,10 +1,11 @@
 // adapters/mcp-ts/src/tools/vibe_pm/advisory_review.ts
 // vibe_pm.advisory_review - Advisory review (triage/quick/thorough) with routing + cache
-import { runEngine } from "../../engine.js";
+import { runPythonCli } from "../../engine.js";
 import { safeJsonParse } from "../../cli.js";
 import { validateToolInput } from "../../security/input-validator.js";
 import { resolveProjectId } from "./context.js";
 import { AdvisoryReviewOutputSchema } from "../../generated/advisory_review_output.js";
+import { classifyPythonError } from "./python_error.js";
 function clipArg(value, maxChars) {
     const v = value.trim();
     if (v.length <= maxChars)
@@ -65,9 +66,10 @@ export async function advisoryReview(input) {
         args.push("--product-intent-refs", input.product_intent_refs.join(","));
     }
     const timeoutMs = mode === "triage" ? 30_000 : 180_000;
-    const { code, stdout, stderr } = await runEngine("vibecoding-helper", args, { timeoutMs });
+    const { code, stdout, stderr } = await runPythonCli(args, { timeoutMs });
     if (code !== 0) {
-        throw new Error(stderr?.trim() ? `advisory_review_engine_error: ${stderr.trim()}` : `advisory_review_exit_code: ${code}`);
+        const classified = classifyPythonError(stderr ?? "", code, "Advisory Review");
+        throw new Error(`${classified.issueCode}: ${classified.summary}`);
     }
     const parsed = safeJsonParse(stdout);
     if (!parsed.ok) {

package/build/tools/vibe_pm/bridge_build_seed.js

@@ -0,0 +1,164 @@
+// adapters/mcp-ts/src/tools/vibe_pm/bridge_build_seed.ts
+// vibe_pm.bridge_build_seed - Create runs/<run_id>/bridge/work_order_seed.json
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { validateToolInput } from "../../security/input-validator.js";
+import { resolveProjectId, resolveRunId, getRunContext } from "./context.js";
+import { BridgeConfirmedReferenceFileSchema } from "../../generated/bridge_confirmed_reference_file.js";
+import { BridgeReferencesFileSchema } from "../../generated/bridge_references_file.js";
+import { BridgeWorkOrderSeedFileSchema } from "../../generated/bridge_work_order_seed_file.js";
+function sanitizeStrings(values, maxItems) {
+    if (!Array.isArray(values))
+        return [];
+    return values
+        .map((v) => (typeof v === "string" ? v.trim() : ""))
+        .filter(Boolean)
+        .slice(0, maxItems);
+}
+function toRelPath(basePath, absPath) {
+    const rel = path.relative(basePath, absPath);
+    return rel.replace(/\\\\/g, "/");
+}
+function looksKorean(text) {
+    return /[가-힣]/.test(text);
+}
+export async function bridgeBuildSeed(input, basePath = process.cwd()) {
+    validateToolInput({ project_id: input.project_id, run_id: input.run_id });
+    const resolvedRun = resolveRunId(input.run_id ?? input.project_id, basePath);
+    const run_id = resolvedRun.run_id;
+    const project_id = resolveProjectId(run_id, basePath);
+    const context = getRunContext(run_id, basePath);
+    const bridgeDir = path.join(context.runs_path, "bridge");
+    const confirmedPathAbs = path.join(bridgeDir, "confirmed_reference.json");
+    const referencesPathAbs = path.join(bridgeDir, "references.json");
+    const seedPathAbs = path.join(bridgeDir, "work_order_seed.json");
+    // Rule C: confirmed_reference 없이는 seed 생성 불가
+    let confirmedRaw;
+    try {
+        confirmedRaw = JSON.parse(await fs.readFile(confirmedPathAbs, "utf-8"));
+    }
+    catch {
+        throw new Error("confirmed_reference.json이 없어 seed를 만들 수 없습니다. 먼저 레퍼런스를 확정하세요.");
+    }
+    const confirmed = BridgeConfirmedReferenceFileSchema.parse(confirmedRaw);
+    const overwrite = input?.overwrite !== false;
+    if (!overwrite) {
+        try {
+            await fs.access(seedPathAbs);
+            throw new Error("work_order_seed.json이 이미 존재합니다. overwrite=true로 다시 시도하세요.");
+        }
+        catch {
+            // ok (does not exist)
+        }
+    }
+    let rawIntent = typeof input?.raw_user_intent === "string" ? input.raw_user_intent.trim() : "";
+    if (!rawIntent) {
+        try {
+            const refsRaw = JSON.parse(await fs.readFile(referencesPathAbs, "utf-8"));
+            const refs = BridgeReferencesFileSchema.parse(refsRaw);
+            rawIntent = typeof refs.query?.raw_user_intent === "string" ? refs.query.raw_user_intent.trim() : "";
+        }
+        catch {
+            // ignore
+        }
+    }
+    if (!rawIntent)
+        rawIntent = "Clarify requirements using the selected reference.";
+    const isKo = looksKorean(rawIntent);
+    const goal = typeof input?.goal === "string" && input.goal.trim()
+        ? input.goal.trim()
+        : isKo
+            ? `레퍼런스(${confirmed.selected.title}) 기준으로 요구사항을 정규화한다: ${rawIntent}`
+            : `Normalize requirements using reference (${confirmed.selected.title}): ${rawIntent}`;
+    const userStory = typeof input?.user_story === "string" && input.user_story.trim()
+        ? input.user_story.trim()
+        : isKo
+            ? `사용자로서, 나는 ${rawIntent}을(를) 원한다. 그래서 원하는 결과를 빠르게 얻을 수 있다.`
+            : `As a user, I want ${rawIntent} so I can get the intended result quickly.`;
+    const acceptance = sanitizeStrings(input?.acceptance, 12);
+    const acceptanceFinal = acceptance.length >= 3
+        ? acceptance
+        : isKo
+            ? [
+                "레퍼런스 확정(confirmed_reference.json)이 기록된다",
+                "seed(work_order_seed.json)이 생성된다",
+                "create_work_order가 seed를 소비한다"
+            ]
+            : [
+                "Confirmed reference is written (confirmed_reference.json)",
+                "Seed is written (work_order_seed.json)",
+                "create_work_order consumes the seed when it exists"
+            ];
+    const constraints = mergeOverrides(sanitizeStrings(input?.constraints, 12), sanitizeStrings(confirmed?.user_confirmation?.must_have_overrides, 12), 12);
+    const nonGoals = mergeOverrides(sanitizeStrings(input?.non_goals, 8), sanitizeStrings(confirmed?.user_confirmation?.must_not_overrides, 8), 8);
+    const scopeSeedRaw = input?.scope_seed;
+    const scope_seed = scopeSeedRaw && typeof scopeSeedRaw === "object"
+        ? {
+            include: sanitizeStrings(scopeSeedRaw?.include, 20),
+            exclude: sanitizeStrings(scopeSeedRaw?.exclude, 20),
+            do_not_touch: sanitizeStrings(scopeSeedRaw?.do_not_touch, 20)
+        }
+        : {
+            include: ["src/**", "tests/**"],
+            exclude: ["**/.vibe/**", "config/**"],
+            do_not_touch: ["config/**", ".env*", "*.pem", "*.key", ".vibe/**"]
+        };
+    if (scope_seed.include.length === 0)
+        scope_seed.include = ["src/**"];
+    const preferredStackHint = typeof input?.preferred_stack_hint === "string" ? input.preferred_stack_hint : "";
+    const riskNotes = sanitizeStrings(input?.risk_notes, 8);
+    const nowIso = new Date().toISOString();
+    const seedDoc = BridgeWorkOrderSeedFileSchema.parse({
+        schema_version: "bridge.work_order_seed.v1",
+        run_id,
+        project_id,
+        created_at: nowIso,
+        intent: {
+            goal,
+            user_story: userStory,
+            acceptance: acceptanceFinal,
+            constraints,
+            non_goals: nonGoals
+        },
+        scope_seed,
+        reference: {
+            key: confirmed.selected.key,
+            title: confirmed.selected.title,
+            primary_link: confirmed.selected.primary_link,
+            takeaways: []
+        },
+        handoff: {
+            preferred_stack_hint: preferredStackHint,
+            risk_notes: riskNotes
+        }
+    });
+    if (input?.write_files !== false) {
+        await fs.mkdir(bridgeDir, { recursive: true });
+        await fs.writeFile(seedPathAbs, JSON.stringify(seedDoc, null, 2) + "\n", "utf-8");
+    }
+    const out = {
+        success: true,
+        project_id,
+        run_id,
+        seed_path: toRelPath(basePath, seedPathAbs),
+        next_action: {
+            tool: "vibe_pm.create_work_order",
+            reason: "seed를 기반으로 작업 지시서를 발행하세요."
+        }
+    };
+    return out;
+}
+function mergeOverrides(base, overrides, maxItems) {
+    const seen = new Set();
+    const out = [];
+    for (const x of [...base, ...overrides]) {
+        const v = typeof x === "string" ? x.trim() : "";
+        if (!v || seen.has(v))
+            continue;
+        seen.add(v);
+        out.push(v);
+        if (out.length >= maxItems)
+            break;
+    }
+    return out;
+}

package/build/tools/vibe_pm/bridge_confirm_reference.js

@@ -0,0 +1,91 @@
+// adapters/mcp-ts/src/tools/vibe_pm/bridge_confirm_reference.ts
+// vibe_pm.bridge_confirm_reference - Create runs/<run_id>/bridge/confirmed_reference.json
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { validateToolInput } from "../../security/input-validator.js";
+import { resolveProjectId, resolveRunId, getRunContext } from "./context.js";
+import { BridgeReferencesFileSchema } from "../../generated/bridge_references_file.js";
+import { BridgeConfirmedReferenceFileSchema } from "../../generated/bridge_confirmed_reference_file.js";
+function sanitizeStrings(values, maxItems) {
+    if (!Array.isArray(values))
+        return [];
+    return values
+        .map((v) => (typeof v === "string" ? v.trim() : ""))
+        .filter(Boolean)
+        .slice(0, maxItems);
+}
+function toRelPath(basePath, absPath) {
+    const rel = path.relative(basePath, absPath);
+    return rel.replace(/\\\\/g, "/");
+}
+export async function bridgeConfirmReference(input, basePath = process.cwd()) {
+    validateToolInput({ project_id: input.project_id, run_id: input.run_id });
+    const resolvedRun = resolveRunId(input.run_id ?? input.project_id, basePath);
+    const run_id = resolvedRun.run_id;
+    const project_id = resolveProjectId(run_id, basePath);
+    const context = getRunContext(run_id, basePath);
+    const bridgeDir = path.join(context.runs_path, "bridge");
+    const referencesPathAbs = path.join(bridgeDir, "references.json");
+    const confirmedPathAbs = path.join(bridgeDir, "confirmed_reference.json");
+    let referencesRaw;
+    try {
+        referencesRaw = JSON.parse(await fs.readFile(referencesPathAbs, "utf-8"));
+    }
+    catch {
+        throw new Error("references.json이 없어 레퍼런스를 확정할 수 없습니다. 먼저 레퍼런스 후보를 생성하세요.");
+    }
+    const references = BridgeReferencesFileSchema.parse(referencesRaw);
+    const selectedKey = String(input?.selected_key ?? "").trim();
+    if (!["A", "B", "C"].includes(selectedKey)) {
+        throw new Error("selected_key는 A/B/C 중 하나여야 합니다.");
+    }
+    const selected = (references.candidates ?? []).find((c) => c?.key === selectedKey);
+    if (!selected) {
+        throw new Error("선택한 레퍼런스를 찾을 수 없습니다. A/B/C 중 다시 선택해주세요.");
+    }
+    const rawAnswer = String(input?.raw_answer ?? "").trim();
+    if (!rawAnswer)
+        throw new Error("raw_answer is required");
+    const notes = typeof input?.notes === "string" ? input.notes : "";
+    const mustHave = sanitizeStrings(input?.must_have_overrides, 12);
+    const mustNot = sanitizeStrings(input?.must_not_overrides, 12);
+    const nowIso = new Date().toISOString();
+    const confirmedDoc = BridgeConfirmedReferenceFileSchema.parse({
+        schema_version: "bridge.confirmed_reference.v1",
+        run_id,
+        project_id,
+        created_at: nowIso,
+        selected: {
+            key: selectedKey,
+            title: selected.title,
+            kind: selected.kind,
+            primary_link: selected.links.primary
+        },
+        user_confirmation: {
+            raw_answer: rawAnswer,
+            notes,
+            must_have_overrides: mustHave,
+            must_not_overrides: mustNot
+        }
+    });
+    if (input?.write_files !== false) {
+        await fs.mkdir(bridgeDir, { recursive: true });
+        await fs.writeFile(confirmedPathAbs, JSON.stringify(confirmedDoc, null, 2) + "\n", "utf-8");
+    }
+    const out = {
+        success: true,
+        project_id,
+        run_id,
+        confirmed_reference_path: toRelPath(basePath, confirmedPathAbs),
+        selected: {
+            key: confirmedDoc.selected.key,
+            title: confirmedDoc.selected.title,
+            primary_link: confirmedDoc.selected.primary_link
+        },
+        next_action: {
+            tool: "vibe_pm.bridge_build_seed",
+            reason: "확정된 레퍼런스를 기반으로 seed를 생성하세요."
+        }
+    };
+    return out;
+}