@vibecodetown/mcp-server 2.2.0 → 2.2.1

package/build/tools/vibe_pm/spec_rag.js

@@ -0,0 +1,185 @@
+// adapters/mcp-ts/src/tools/vibe_pm/spec_rag.ts
+// Spec RAG: Auto-inject SSOT context into work orders
+// Reference: docs/DEV_SPEC/0124/SPEC_RAG_WORK_PROTOCOL
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { runKceRetrieve, runKceStatus } from "./kce/preflight.js";
+/**
+ * Priority-ordered list of SSOT documents to inject
+ */
+const SPEC_DOCS = [
+    "docs/ssot/DECISION_SSOT.md",
+    "docs/ssot/QUALITY_SSOT.md",
+    "docs/ssot/MCP_SSOT.md",
+    "docs/SSOT.md"
+];
+/**
+ * Get spec context for injection into work orders.
+ *
+ * Strategy:
+ * 1. Try KCE retrieval (if status=READY)
+ * 2. Fallback to direct file reading
+ * 3. Return empty if both fail
+ */
+export async function getSpecContext(opts) {
+    const maxChars = opts.maxChars ?? 2500;
+    const maxItems = opts.maxItems ?? 4;
+    const basePath = opts.basePath ?? process.cwd();
+    // Strategy 1: Try KCE retrieval
+    try {
+        const status = await runKceStatus();
+        if (status.readiness_state === "READY") {
+            const result = await runKceRetrieve({
+                query: opts.query,
+                maxItems,
+                limit: 10,
+                maxTotalChars: maxChars,
+                maxChunkChars: Math.min(800, Math.floor(maxChars / maxItems)),
+                pathPrefix: "docs/ssot"
+            });
+            if (result.context_block.trim()) {
+                const referencedDocs = (result.hits ?? [])
+                    .map((h) => h.path)
+                    .filter((p) => p.endsWith(".md"));
+                return {
+                    context_block: buildSpecBlock(result.context_block, referencedDocs),
+                    source: "kce",
+                    referenced_docs: referencedDocs
+                };
+            }
+        }
+    }
+    catch {
+        // KCE unavailable, fall through to fallback
+    }
+    // Strategy 2: Fallback to direct file reading
+    try {
+        const { content, docs } = readSpecDocsFallback(basePath, maxChars);
+        if (content.trim()) {
+            return {
+                context_block: buildSpecBlock(content, docs),
+                source: "fallback",
+                referenced_docs: docs
+            };
+        }
+    }
+    catch {
+        // Fallback also failed
+    }
+    // Strategy 3: Return empty
+    return {
+        context_block: "",
+        source: "empty",
+        referenced_docs: []
+    };
+}
+/**
+ * Build the [SPEC_CONTEXT] block for injection
+ */
+export function buildSpecBlock(content, docs) {
+    if (!content.trim())
+        return "";
+    const lines = [];
+    lines.push("[SPEC_CONTEXT]");
+    lines.push(content.trim());
+    if (docs.length > 0) {
+        lines.push("");
+        lines.push("[참조 문서]");
+        for (const doc of docs.slice(0, 6)) {
+            const basename = path.basename(doc);
+            lines.push(`- ${basename}`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Fallback: Read spec docs directly from filesystem
+ */
+function readSpecDocsFallback(basePath, maxChars) {
+    const chunks = [];
+    const docs = [];
+    let totalChars = 0;
+    const perDocLimit = Math.floor(maxChars / SPEC_DOCS.length);
+    for (const docPath of SPEC_DOCS) {
+        if (totalChars >= maxChars)
+            break;
+        const fullPath = path.join(basePath, docPath);
+        if (!fs.existsSync(fullPath))
+            continue;
+        try {
+            const content = fs.readFileSync(fullPath, "utf-8");
+            const extracted = extractRelevantSections(content, perDocLimit);
+            if (extracted.trim()) {
+                const basename = path.basename(docPath);
+                chunks.push(`### ${basename}\n${extracted.trim()}`);
+                docs.push(docPath);
+                totalChars += extracted.length;
+            }
+        }
+        catch {
+            // Skip unreadable files
+        }
+    }
+    return {
+        content: chunks.join("\n\n"),
+        docs
+    };
+}
+/**
+ * Extract relevant sections from a markdown document
+ * Focus on rules, constraints, and key definitions
+ */
+function extractRelevantSections(content, maxChars) {
+    // Priority headers to extract
+    const priorityPatterns = [
+        /^#+\s*(?:규칙|Rules|제약|Constraints|필수|Required|금지|Prohibited)/im,
+        /^#+\s*(?:개요|Overview|핵심|Core|원칙|Principles)/im,
+        /^#+\s*(?:정의|Definitions|용어|Terms)/im
+    ];
+    const lines = content.split("\n");
+    const sections = [];
+    let currentSection = [];
+    let inPrioritySection = false;
+    let sectionHeader = "";
+    for (const line of lines) {
+        // Check if this is a header
+        const isHeader = /^#+\s+/.test(line);
+        if (isHeader) {
+            // Save previous section if it was a priority section
+            if (inPrioritySection && currentSection.length > 0) {
+                sections.push([sectionHeader, ...currentSection].join("\n"));
+            }
+            // Check if this header is a priority section
+            inPrioritySection = priorityPatterns.some((p) => p.test(line));
+            sectionHeader = line;
+            currentSection = [];
+        }
+        else if (inPrioritySection) {
+            currentSection.push(line);
+        }
+    }
+    // Don't forget the last section
+    if (inPrioritySection && currentSection.length > 0) {
+        sections.push([sectionHeader, ...currentSection].join("\n"));
+    }
+    // If no priority sections found, extract the first N characters as overview
+    if (sections.length === 0) {
+        const overview = content.slice(0, Math.min(maxChars, 500)).trim();
+        if (overview) {
+            // Try to end at a sentence boundary
+            const lastPeriod = overview.lastIndexOf(".");
+            const lastNewline = overview.lastIndexOf("\n");
+            const cutoff = Math.max(lastPeriod, lastNewline);
+            return cutoff > 100 ? overview.slice(0, cutoff + 1) : overview;
+        }
+        return "";
+    }
+    // Combine sections up to maxChars
+    let result = "";
+    for (const section of sections) {
+        if (result.length + section.length > maxChars)
+            break;
+        result += (result ? "\n\n" : "") + section;
+    }
+    return result;
+}

package/build/tools/vibe_pm/status.js

@@ -1,11 +1,14 @@
 // adapters/mcp-ts/src/tools/vibe_pm/status.ts
 // vibe_pm.status - Project status query
+import * as fs from "node:fs";
+import * as path from "node:path";
 import { runEngineWithCache } from "../../engine.js";
 import { safeJsonParse } from "../../cli.js";
 import { resolveRunId, resolveProjectId, getRunContext, readRunState } from "./context.js";
 import { formatMode, formatPhase, signalToReview } from "./pm_language.js";
 import { validateToolInput } from "../../security/input-validator.js";
 import { SpecHighValidateOutputSchema } from "../../generated/spec_high_validate_output.js";
+import { IngressSummaryFileSchema } from "../../generated/ingress_summary_file.js";
 /**
  * vibe_pm.status - Query current project status
  *
@@ -13,8 +16,7 @@ import { SpecHighValidateOutputSchema } from "../../generated/spec_high_validate
  *   → spec-high validate <run_id>
  *   → status summary generation
  */
-export async function status(input) {
-    const basePath = process.cwd();
+export async function status(input, basePath = process.cwd()) {
     validateToolInput({ project_id: input.project_id });
     // Resolve run_id
     const { run_id, is_new } = resolveRunId(input.project_id, basePath);
@@ -77,7 +79,17 @@ export async function status(input) {
     // Collect risks
     const risks = validateResult?.risks ?? [];
     // Determine next action based on state
-    const nextAction = determineNextAction(phase, decisionsPending, lastReviewStatus);
+    let nextAction = determineNextAction(phase, decisionsPending, lastReviewStatus);
+    // P27: deterministic auto-routing for "pre-work clarification" (based on ingress signals)
+    const routed = maybeAutoRouteForClarification({
+        runDirAbs: context.runs_path,
+        phase,
+        decisionsPending
+    });
+    if (routed) {
+        risks.push(routed.risk_note);
+        nextAction = routed.next_action;
+    }
     return {
         project_id,
         project: {
@@ -95,6 +107,41 @@ export async function status(input) {
         next_action: nextAction
     };
 }
+function maybeAutoRouteForClarification(args) {
+    // Never override when user still has pending approvals.
+    if (args.decisionsPending > 0)
+        return null;
+    // Only relevant before work order is issued.
+    if (!(args.phase === "decision" || args.phase === "briefing" || args.phase === "init"))
+        return null;
+    const summaryAbs = path.join(args.runDirAbs, "ingress", "ingress_summary.json");
+    if (!fs.existsSync(summaryAbs))
+        return null;
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(summaryAbs, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    const parsed = IngressSummaryFileSchema.safeParse(raw);
+    if (!parsed.success)
+        return null;
+    const recommended = parsed.data.high_level.clarification_recommended === true;
+    if (!recommended)
+        return null;
+    // Treat as completed if seed exists (protocol done).
+    const seedAbs = path.join(args.runDirAbs, "bridge", "work_order_seed.json");
+    if (fs.existsSync(seedAbs))
+        return null;
+    return {
+        next_action: {
+            tool: "vibe_pm.bridge_generate_references",
+            label: "다음 할 일: 예시를 고르고 작업 방향을 고정하기"
+        },
+        risk_note: "작업 방향이 아직 충분히 고정되지 않았습니다. 예시를 한 번 선택하면 다음 단계가 빨라집니다."
+    };
+}
 function determineNextAction(phase, decisionsPending, lastReviewStatus) {
     // If there are pending decisions
     if (decisionsPending > 0) {

package/build/tools/vibe_pm/submit_decision.js

@@ -20,8 +20,8 @@ export async function submitDecision(input) {
     const project_id = resolveProjectId(run_id, basePath);
     // Format answer text (combine choice with note if provided)
     const answerText = input.note ? `${input.choice}: ${input.note}` : input.choice;
-    // Step 1: Submit answer
-    const answerResult = await runEngine("vibecoding-helper", ["answer", run_id, "--text", answerText], { timeoutMs: 120_000 });
+    // Step 1: Submit answer via spec-high
+    const answerResult = await runEngine("spec-high", ["--root", "engines/spec_high", "answer", run_id, "--text", answerText], { timeoutMs: 120_000 });
     if (answerResult.code !== 0) {
         throw new Error(`결재 제출 실패: ${answerResult.stderr || "알 수 없는 오류"}`);
     }

package/build/tools/vibe_pm/types.js

@@ -183,6 +183,14 @@ import { SearchOssInputSchema } from "../../generated/search_oss_input.js";
 import { SearchOssOutputSchema } from "../../generated/search_oss_output.js";
 import { ZoektEvidenceInputSchema } from "../../generated/zoekt_evidence_input.js";
 import { ZoektEvidenceOutputSchema } from "../../generated/zoekt_evidence_output.js";
+import { IngressInputSchema } from "../../generated/ingress_input.js";
+import { IngressOutputSchema } from "../../generated/ingress_output.js";
+import { BridgeGenerateReferencesInputSchema } from "../../generated/bridge_generate_references_input.js";
+import { BridgeGenerateReferencesOutputSchema } from "../../generated/bridge_generate_references_output.js";
+import { BridgeConfirmReferenceInputSchema } from "../../generated/bridge_confirm_reference_input.js";
+import { BridgeConfirmReferenceOutputSchema } from "../../generated/bridge_confirm_reference_output.js";
+import { BridgeBuildSeedInputSchema } from "../../generated/bridge_build_seed_input.js";
+import { BridgeBuildSeedOutputSchema } from "../../generated/bridge_build_seed_output.js";
 export const finalizeWorkInputSchema = FinalizeWorkInputSchema;
 // Output schema is generated from JSON Schema SSOT.
 export const finalizeWorkOutputSchema = FinalizeWorkOutputSchema;
@@ -222,6 +230,26 @@ export const zoektEvidenceInputSchema = ZoektEvidenceInputSchema;
 // Output schema is generated from JSON Schema SSOT.
 export const zoektEvidenceOutputSchema = ZoektEvidenceOutputSchema;
 // ============================================================
+// vibe_pm.ingress
+// ============================================================
+export const ingressInputSchema = IngressInputSchema;
+export const ingressOutputSchema = IngressOutputSchema;
+// ============================================================
+// vibe_pm.bridge_generate_references
+// ============================================================
+export const bridgeGenerateReferencesInputSchema = BridgeGenerateReferencesInputSchema;
+export const bridgeGenerateReferencesOutputSchema = BridgeGenerateReferencesOutputSchema;
+// ============================================================
+// vibe_pm.bridge_confirm_reference
+// ============================================================
+export const bridgeConfirmReferenceInputSchema = BridgeConfirmReferenceInputSchema;
+export const bridgeConfirmReferenceOutputSchema = BridgeConfirmReferenceOutputSchema;
+// ============================================================
+// vibe_pm.bridge_build_seed
+// ============================================================
+export const bridgeBuildSeedInputSchema = BridgeBuildSeedInputSchema;
+export const bridgeBuildSeedOutputSchema = BridgeBuildSeedOutputSchema;
+// ============================================================
 // vibe_pm.doctor / vibe_pm.update (Output SSOT only)
 // ============================================================
 export const doctorOutputSchema = DoctorOutputSchema;

package/build/tools/vibe_pm/undo_last_task.js

@@ -5,6 +5,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { invokeGit } from "../../runtime/cli_invoker.js";
+import { isGitConflictError } from "../../errors.js";
 /**
  * vibe_pm.undo_last_task - Rollback recent commits via git revert
  *
@@ -55,8 +56,14 @@ export async function undoLastTask(input) {
             const errMsg = result.stderr || result.stdout;
             revertErrors.push(`${commit.shortHash}: ${errMsg}`);
             // If revert fails due to conflicts, abort and stop
-            if (errMsg.includes("conflict") || errMsg.includes("CONFLICT")) {
-                await invokeGit(["revert", "--abort"], basePath);
+            // Check for conflict indicators (exit code 1 with conflict message)
+            // P1-4: Use centralized error pattern
+            if (isGitConflictError(errMsg) || result.exitCode === 1) {
+                const abortResult = await invokeGit(["revert", "--abort"], basePath);
+                if (abortResult.exitCode !== 0) {
+                    // Abort failed - critical state inconsistency
+                    revertErrors.push(`[CRITICAL] git revert --abort 실패. 수동 복구 필요: git status 확인 후 git revert --abort 또는 git revert --continue 실행`);
+                }
                 break;
             }
         }

package/build/tools/vibe_pm/waiter_mapping.js

@@ -0,0 +1,155 @@
+// adapters/mcp-ts/src/tools/vibe_pm/waiter_mapping.ts
+// Waiter(Front) rendering: message_template_id mapping + term dictionary (data-driven)
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { MessageTemplateIdMappingFileSchema } from "../../generated/message_template_id_mapping_file.js";
+let cache = null;
+function packageRoot() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    // src/tools/vibe_pm → package root
+    return path.resolve(here, "..", "..", "..");
+}
+function repoRoot(pkgRoot) {
+    // adapters/mcp-ts → repo root
+    return path.resolve(pkgRoot, "..", "..");
+}
+function existsFile(p) {
+    try {
+        return fs.existsSync(p) && fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function readJsonFile(p) {
+    const raw = fs.readFileSync(p, "utf-8");
+    return JSON.parse(raw);
+}
+function safeLocaleList(mapping) {
+    const locales = mapping?.supported_locales;
+    return Array.isArray(locales) ? locales.map((x) => String(x).trim()).filter(Boolean) : [];
+}
+function safeDefaultLocale(mapping) {
+    const d = mapping?.default_locale;
+    return typeof d === "string" && d.trim() ? d.trim() : "ko";
+}
+function safeFallbackLocale(mapping) {
+    const f = mapping?.human_language_policy?.fallback_locale;
+    const s = typeof f === "string" && f.trim() ? f.trim() : "";
+    return s || safeDefaultLocale(mapping);
+}
+export function resetWaiterMappingCacheForTest() {
+    cache = null;
+}
+export function getWaiterMapping() {
+    const pkgRoot = packageRoot();
+    const candidates = [
+        path.join(pkgRoot, "assets", "message_template_id_mapping.v1.json"),
+        path.join(repoRoot(pkgRoot), "schemas", "message_template_id_mapping.v1.json")
+    ];
+    for (const p of candidates) {
+        if (!existsFile(p))
+            continue;
+        const mtimeMs = fs.statSync(p).mtimeMs;
+        if (cache && cache.mappingPath === p && cache.mtimeMs === mtimeMs) {
+            return cache.mapping;
+        }
+        const raw = readJsonFile(p);
+        const parsed = MessageTemplateIdMappingFileSchema.parse(raw);
+        cache = { mappingPath: p, mtimeMs, mapping: parsed };
+        return parsed;
+    }
+    // Fail-closed is too harsh for user-facing rendering; fall back to a minimal internal default.
+    const fallback = MessageTemplateIdMappingFileSchema.parse({
+        version: "message_template_id_mapping.v1",
+        default_locale: "ko",
+        supported_locales: ["ko", "en"],
+        templates: {
+            "GO-01": { category: "GO", verdict: { ko: "진행 가능", en: "OK to proceed" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "GO-02": { category: "GO", verdict: { ko: "진행 가능", en: "OK to proceed" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "FIX-01": { category: "FIX", verdict: { ko: "보완 필요", en: "Needs changes" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "FIX-02": { category: "FIX", verdict: { ko: "보완 필요", en: "Needs changes" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "BLOCK-01": { category: "BLOCK", verdict: { ko: "반려", en: "Blocked" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "BLOCK-02": { category: "BLOCK", verdict: { ko: "반려", en: "Blocked" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "TRIAGE-SKIP-01": { category: "TRIAGE", verdict: { ko: "사전 점검 생략", en: "Pre-check skipped" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "TRIAGE-RUN-01": { category: "TRIAGE", verdict: { ko: "사전 점검 실행", en: "Pre-check running" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "TRIAGE-RUN-02": { category: "TRIAGE", verdict: { ko: "사전 점검 실행", en: "Pre-check running" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "ADV-01": { category: "ADVICE", verdict: { ko: "참고", en: "Advice" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "ADV-02": { category: "ADVICE", verdict: { ko: "참고", en: "Advice" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "WARN-01": { category: "WARN", verdict: { ko: "주의", en: "Warning" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "WARN-02": { category: "WARN", verdict: { ko: "주의", en: "Warning" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } },
+            "SOFTBLOCK-01": { category: "SOFTBLOCK", verdict: { ko: "잠깐 멈춤", en: "Pause" }, next_action_prefix: { ko: "다음 단계:", en: "Next:" } }
+        },
+        term_dictionary: { entries: [{ id: "ENGINE_RUN_ID", aliases: ["run_id"], replacement: { ko: "프로젝트", en: "project" }, category: "engine_term" }] }
+    });
+    cache = { mappingPath: "<fallback>", mtimeMs: 0, mapping: fallback };
+    return fallback;
+}
+export function resolveLocaleFromText(text, mapping = getWaiterMapping()) {
+    const env = (process.env.VIBECODE_LOCALE ?? "").trim();
+    const supported = safeLocaleList(mapping);
+    if (env && supported.includes(env))
+        return env;
+    const hasKo = /[가-힣]/.test(text);
+    if (hasKo && supported.includes("ko"))
+        return "ko";
+    if (!hasKo && supported.includes("en"))
+        return "en";
+    return safeFallbackLocale(mapping);
+}
+export function resolveLocaleFromData(data, mapping = getWaiterMapping()) {
+    const env = (process.env.VIBECODE_LOCALE ?? "").trim();
+    const supported = safeLocaleList(mapping);
+    if (env && supported.includes(env))
+        return env;
+    if (data && typeof data === "object") {
+        const obj = data;
+        const oneLine = obj.review_summary?.one_line_verdict;
+        const msg = typeof oneLine === "string" ? oneLine : typeof obj.message === "string" ? obj.message : "";
+        if (msg)
+            return resolveLocaleFromText(msg, mapping);
+    }
+    return safeFallbackLocale(mapping);
+}
+export function renderVerdictFromTemplateId(templateId, locale, mapping = getWaiterMapping()) {
+    const templates = mapping?.templates ?? {};
+    const t = templates[templateId];
+    if (!t || typeof t !== "object")
+        return null;
+    const verdict = t?.verdict;
+    if (!verdict || typeof verdict !== "object")
+        return null;
+    const v = verdict[locale];
+    if (typeof v === "string" && v.trim())
+        return v.trim();
+    const fallback = safeFallbackLocale(mapping);
+    const vf = verdict[fallback];
+    if (typeof vf === "string" && vf.trim())
+        return vf.trim();
+    return null;
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function applyTermDictionary(text, locale, mapping = getWaiterMapping()) {
+    let out = text;
+    const entries = mapping?.term_dictionary?.entries;
+    if (!Array.isArray(entries) || entries.length === 0)
+        return out;
+    for (const e of entries) {
+        const obj = e;
+        const aliases = Array.isArray(obj?.aliases) ? obj.aliases.map((a) => String(a)).filter(Boolean) : [];
+        const rep = obj?.replacement;
+        const replacement = typeof rep === "object" && rep !== null ? String(rep[locale] ?? "").trim() : "";
+        if (!replacement || aliases.length === 0)
+            continue;
+        for (const a of aliases) {
+            const alias = String(a).trim();
+            if (!alias)
+                continue;
+            out = out.replace(new RegExp(escapeRegex(alias), "gi"), replacement);
+        }
+    }
+    return out;
+}

package/build/tools/vibe_pm/zoekt_evidence.js

@@ -1,10 +1,11 @@
 // adapters/mcp-ts/src/tools/vibe_pm/zoekt_evidence.ts
 // vibe_pm.zoekt_evidence - Collect pattern evidence across local roots (zoekt/rg/python_scan)
 import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
-import { runEngine } from "../../engine.js";
+import { runPythonCli } from "../../engine.js";
 import { safeJsonParse } from "../../cli.js";
 import { validateToolInput } from "../../security/input-validator.js";
 import { resolveProjectId, resolveRunId } from "./context.js";
+import { classifyPythonError } from "./python_error.js";
 function toCsv(values) {
     return values
         .map((v) => (typeof v === "string" ? v.trim() : ""))
@@ -43,9 +44,10 @@ export async function zoektEvidence(input) {
     const writeEvidence = input?.write_evidence !== false;
     if (!writeEvidence)
         cmd.push("--no-write-evidence");
-    const res = await runEngine("vibecoding-helper", cmd, { timeoutMs: 300_000 });
+    const res = await runPythonCli(cmd, { timeoutMs: 300_000 });
     if (res.code !== 0) {
-        throw new Error(`zoekt-evidence failed: ${res.stderr || res.stdout || `exit_code=${res.code}`}`);
+        const classified = classifyPythonError(res.stderr ?? "", res.code, "패턴 증거 수집");
+        throw new Error(`${classified.issueCode}: ${classified.summary}`);
     }
     const parsed = safeJsonParse(res.stdout);
     if (!parsed.ok) {

package/build/tools.js

@@ -3,7 +3,7 @@
 import { z } from "zod";
 import { safeJsonParse } from "./cli.js";
 import { parseSelectionValidationResult } from "./contracts.js";
-import { runEngine } from "./engine.js";
+import { runEngine, runPythonCli } from "./engine.js";
 import { doctor as doctorImpl } from "./bootstrap/doctor.js";
 import { ToolErrorOutputSchema } from "./generated/tool_error_output.js";
 function toolText(obj) {
@@ -45,7 +45,9 @@ export function defineTools() {
     });
     async function vibecodeOneLoop(input) {
         try {
-            const { code, stdout, stderr } = await runEngine("vibecoding-helper", ["one-loop", input.run_id, "--output", input.output], { timeoutMs: input.timeout_ms ?? 120_000 });
+            // [DEPRECATED] Use vibe_pm.inspect_code instead
+            // Changed from runEngine("vibecoding-helper") to runPythonCli for correct routing
+            const { code, stdout, stderr } = await runPythonCli(["one-loop", input.run_id, "--output", input.output], { timeoutMs: input.timeout_ms ?? 120_000 });
             const parsed = safeJsonParse(stdout);
             if (!parsed.ok) {
                 return err("invalid_json", {
@@ -148,7 +150,9 @@ export function defineTools() {
     });
     async function vibecodeShowAskQueue(input) {
         try {
-            const { code, stdout, stderr } = await runEngine("vibecoding-helper", ["show-ask-queue", input.run_id], { timeoutMs: input.timeout_ms ?? 60_000 });
+            // [DEPRECATED] Use vibe_pm.get_decision instead
+            // Changed from runEngine("vibecoding-helper") to runPythonCli for correct routing
+            const { code, stdout, stderr } = await runPythonCli(["show-ask-queue", input.run_id], { timeoutMs: input.timeout_ms ?? 60_000 });
             return toolText({
                 status: code === 0 ? "OK" : "FAIL",
                 exit_code: code,
@@ -168,7 +172,9 @@ export function defineTools() {
     });
     async function vibecodeShowDecisions(input) {
         try {
-            const { code, stdout, stderr } = await runEngine("vibecoding-helper", ["show-decisions", input.run_id], { timeoutMs: input.timeout_ms ?? 60_000 });
+            // [DEPRECATED] Use vibe_pm.status instead
+            // Changed from runEngine("vibecoding-helper") to runPythonCli for correct routing
+            const { code, stdout, stderr } = await runPythonCli(["show-decisions", input.run_id], { timeoutMs: input.timeout_ms ?? 60_000 });
             return toolText({
                 status: code === 0 ? "OK" : "FAIL",
                 exit_code: code,
@@ -189,7 +195,9 @@ export function defineTools() {
     });
     async function vibecodeAnswer(input) {
         try {
-            const { code, stdout, stderr } = await runEngine("vibecoding-helper", ["answer", input.run_id, "--text", input.text], { timeoutMs: input.timeout_ms ?? 120_000 });
+            // [DEPRECATED] Use vibe_pm.submit_decision instead
+            // Changed from runEngine("vibecoding-helper") to runPythonCli for correct routing
+            const { code, stdout, stderr } = await runPythonCli(["answer", input.run_id, "--text", input.text], { timeoutMs: input.timeout_ms ?? 120_000 });
             return toolText({
                 status: code === 0 ? "OK" : "FAIL",
                 exit_code: code,