@vibecodetown/mcp-server 2.2.0 → 2.2.1

package/build/tools/vibe_pm/ingress_gate.js

@@ -0,0 +1,116 @@
+// adapters/mcp-ts/src/tools/vibe_pm/ingress_gate.ts
+// Internal: Ingress v2 runtime gate (ingress_resolution.json)
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as path from "node:path";
+import { resolveProjectId, getRunContext, resolveRunDir } from "./context.js";
+import { IngressResolutionFileSchema } from "../../generated/ingress_resolution_file.js";
+function toRelPath(basePath, absPath) {
+    const rel = path.relative(basePath, absPath);
+    return rel.replace(/\\\\/g, "/");
+}
+async function writeJsonAtomic(absPath, doc) {
+    await fsPromises.mkdir(path.dirname(absPath), { recursive: true });
+    const tmp = `${absPath}.tmp`;
+    await fsPromises.writeFile(tmp, JSON.stringify(doc, null, 2) + "\n", "utf-8");
+    await fsPromises.rename(tmp, absPath);
+}
+function ingressDir(runDir) {
+    return path.join(runDir, "ingress");
+}
+export function ingressResolutionPathAbs(runDir) {
+    return path.join(ingressDir(runDir), "ingress_resolution.json");
+}
+export function isStrictIngressEnabled() {
+    const raw = (process.env.VIBECODE_STRICT_INGRESS ?? "").trim().toLowerCase();
+    if (!raw)
+        return false;
+    return !(raw === "0" || raw === "false" || raw === "no" || raw === "off");
+}
+export function isIngressGateRequiredForTool(toolName) {
+    // Keep the gate minimal and focused on "Back 단계" tools that can cause drift/confusion.
+    return (toolName === "vibe_pm.get_decision" ||
+        toolName === "vibe_pm.submit_decision" ||
+        toolName === "vibe_pm.create_work_order" ||
+        toolName === "vibe_pm.inspect_code" ||
+        toolName === "vibe_pm.run_app" ||
+        toolName === "vibe_pm.finalize_work" ||
+        toolName === "vibe_pm.undo_last_task");
+}
+export async function checkIngressGate(args) {
+    const allowLegacyAuto = args.allowLegacyAuto !== false;
+    // If the run directory doesn't exist at all, do not block.
+    const resolved = resolveRunDir(args.run_id, args.basePath);
+    const maybeLegacyRunDir = path.join(args.basePath, "runs", args.run_id);
+    if (!resolved && !fs.existsSync(maybeLegacyRunDir)) {
+        return { status: "SKIP_NO_RUN", reason: "run_dir_not_found" };
+    }
+    const context = getRunContext(args.run_id, args.basePath);
+    const absPath = ingressResolutionPathAbs(context.runs_path);
+    const relPath = toRelPath(args.basePath, absPath);
+    let legacyWritten = false;
+    if (!fs.existsSync(absPath)) {
+        if (isStrictIngressEnabled() || !allowLegacyAuto) {
+            return {
+                status: "BLOCK",
+                message: "프로젝트 시작 상태가 확정되지 않았습니다. 먼저 시작(ingress) 단계를 완료해주세요.",
+                recovery: "vibe_pm.ingress를 먼저 호출해 프로젝트 이어가기/새 작업을 확정하세요.",
+                details: { run_id: args.run_id, ingress_resolution_path: relPath }
+            };
+        }
+        const project_id = resolveProjectId(args.run_id, args.basePath);
+        const hasVibeState = fs.existsSync(path.join(args.basePath, ".vibe"));
+        const doc = IngressResolutionFileSchema.parse({
+            schema_version: "ingress.resolution.v2",
+            run_id: args.run_id,
+            project_id,
+            workspace_path: path.resolve(args.basePath),
+            resolution: "INGRESS_RESOLVED_NEW_TASK",
+            has_vibe_state: hasVibeState,
+            context_scan_required: false,
+            context_scan_completed: false,
+            created_at: new Date().toISOString()
+        });
+        await writeJsonAtomic(absPath, doc);
+        legacyWritten = true;
+    }
+    let raw;
+    try {
+        raw = JSON.parse(await fsPromises.readFile(absPath, "utf-8"));
+    }
+    catch {
+        return {
+            status: "BLOCK",
+            message: "프로젝트 시작 상태 파일을 읽을 수 없습니다.",
+            recovery: "vibe_pm.ingress를 다시 실행해 시작 상태를 다시 기록해주세요.",
+            details: { run_id: args.run_id, ingress_resolution_path: relPath }
+        };
+    }
+    const parsed = IngressResolutionFileSchema.safeParse(raw);
+    if (!parsed.success) {
+        return {
+            status: "BLOCK",
+            message: "프로젝트 시작 상태 파일 형식이 예상과 다릅니다.",
+            recovery: "도구 업데이트 후, vibe_pm.ingress로 시작 상태를 다시 생성해주세요.",
+            details: { run_id: args.run_id, ingress_resolution_path: relPath }
+        };
+    }
+    const doc = parsed.data;
+    if (doc.resolution === "INGRESS_ABORTED") {
+        return {
+            status: "BLOCK",
+            message: "프로젝트가 시작되지 않았습니다(중단됨).",
+            recovery: "vibe_pm.ingress에서 다시 시작 상태를 확정한 뒤 진행하세요.",
+            details: { run_id: args.run_id, ingress_resolution_path: relPath }
+        };
+    }
+    if (doc.context_scan_required && doc.context_scan_completed !== true) {
+        return {
+            status: "BLOCK",
+            message: "기존 프로젝트 이어가기를 위한 사전 점검(컨텍스트 스캔)이 완료되지 않았습니다.",
+            recovery: "vibe_pm.ingress를 context_scan=true로 다시 실행해 스캔을 완료하세요.",
+            details: { run_id: args.run_id, ingress_resolution_path: relPath }
+        };
+    }
+    return { status: "OK", doc, resolution_path: relPath, legacy_written: legacyWritten };
+}

package/build/tools/vibe_pm/inspect_code.js

@@ -3,7 +3,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { parse as parseYaml } from "yaml";
-import { runEngine, invalidateEngineCache } from "../../engine.js";
+import { runPythonCli, invalidateEngineCache } from "../../engine.js";
 import { safeJsonParse } from "../../cli.js";
 import { resolveRunId, resolveProjectId, resolveBridgePath, readRunState, getRunsDir, resolveRunDir, invalidateStateCache } from "./context.js";
 import { validateInspectCodeInput } from "../../security/input-validator.js";
@@ -21,6 +21,8 @@ import { kcePreflight } from "./kce/preflight.js";
 import { loadRulebook } from "./system_design/rulebook.js";
 import { runSemgrepDesignEnforcement } from "./system_design/semgrep.js";
 import { semgrepFindingsToIssues } from "./system_design/issue_mapping.js";
+import { isOpaEvalFailedError } from "../../errors.js";
+import { normalizeForMatch } from "../../path-utils.js";
 /**
  * vibe_pm.inspect_code - Code review and validation
  *
@@ -251,7 +253,7 @@ export async function inspectCode(input) {
         args.push("--quick");
     }
     // Run one-loop validation
-    const { code, stdout, stderr } = await runEngine("vibecoding-helper", args, {
+    const { code, stdout, stderr } = await runPythonCli(args, {
         timeoutMs: 180_000
     });
     // Parse result
@@ -278,7 +280,7 @@ export async function inspectCode(input) {
         !issues.some((i) => i.type === "RULE_VIOLATION" || i.type === "RISK_SPIKE")) {
         const recheckArgs = input.mode === "quick" ? args.filter((a) => a !== "--quick") : args;
         try {
-            const recheck = await runEngine("vibecoding-helper", recheckArgs, { timeoutMs: 180_000 });
+            const recheck = await runPythonCli(recheckArgs, { timeoutMs: 180_000 });
             const reParsed = safeJsonParse(recheck.stdout);
             if (reParsed.ok) {
                 const reValidated = VibecodingHelperOneLoopSelectionOutputSchema.safeParse(reParsed.value);
@@ -350,6 +352,17 @@ export async function inspectCode(input) {
     catch {
         // ignore (best-effort)
     }
+    // SRWP: Check for SPEC_UPDATE_MISSING condition
+    // Code changed but no spec updated → FIX issue
+    const specMissingIssue = checkSpecUpdateMissing(modifiedFiles);
+    if (specMissingIssue) {
+        issues.push(specMissingIssue);
+        // Downgrade GO → FIX when spec update is missing
+        if (reviewResult === "GO") {
+            reviewResult = "FIX";
+            verdict = "스펙 업데이트가 필요합니다";
+        }
+    }
     // Run Intent-based verification (if intent document exists)
     let intentCheck;
     try {
@@ -491,14 +504,11 @@ function readOpaPolicyResult(basePath, run_id) {
     }
 }
 function classifyOpaPolicyResult(result) {
-    const reasons = (result.reasons ?? []).join(" ").toLowerCase();
-    const matched = (result.matched_rules ?? []).join(" ").toLowerCase();
+    const reasons = (result.reasons ?? []).join(" ");
+    const matched = (result.matched_rules ?? []).join(" ");
     const corpus = `${reasons} ${matched}`.trim();
-    if (corpus.includes("eval_failed") ||
-        corpus.includes("opa_eval_failed") ||
-        corpus.includes("opa exception") ||
-        corpus.includes("opa_exception") ||
-        corpus.includes("eval failed")) {
+    // P1-4: Use centralized error pattern for OPA eval failures
+    if (isOpaEvalFailedError(corpus)) {
         return {
             rule_violated: "OPA_POLICY_EVAL_FAILED",
             one_line_verdict: "OPA 평가에 실패하여 안전을 위해 차단했습니다(기본 차단).",
@@ -707,7 +717,7 @@ function extractAllowPathsFromBridge(bridgeDoc) {
     if (Array.isArray(dg?.allow_paths)) {
         return dg.allow_paths
             .filter((item) => typeof item === "string")
-            .map((s) => normalizeAllowPath(s));
+            .map((s) => normalizeForMatch(s));
     }
     const scope = data?.scope;
     if (scope && typeof scope === "object") {
@@ -715,29 +725,24 @@ function extractAllowPathsFromBridge(bridgeDoc) {
         if (Array.isArray(include)) {
             return include
                 .filter((item) => typeof item === "string")
-                .map((s) => normalizeAllowPath(s));
+                .map((s) => normalizeForMatch(s));
         }
     }
     return [];
 }
-function normalizeAllowPath(value) {
-    let v = (value ?? "").trim().replace(/\\/g, "/");
-    if (v.startsWith("./"))
-        v = v.slice(2);
-    return v;
-}
+// P1-5: normalizeForMatch -> normalizeForMatch (centralized)
 function findInvalidAllowPaths(allowPaths) {
     if (!Array.isArray(allowPaths) || allowPaths.length === 0)
         return [];
     const allowedPrefixes = new Set(PATH_ZONES.GREEN.map((p) => {
-        const norm = normalizeAllowPath(p);
+        const norm = normalizeForMatch(p);
         const idx = norm.indexOf("**");
         const base = idx >= 0 ? norm.slice(0, idx) : norm;
         return base.endsWith("/") ? base : base + "/";
     }));
     const out = [];
     for (const raw of allowPaths) {
-        const p = normalizeAllowPath(raw);
+        const p = normalizeForMatch(raw);
         if (!p)
             continue;
         // Minimal path traversal / absolute-path guard
@@ -791,6 +796,71 @@ function collectModifiedFiles(result) {
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+// ============================================================
+// SRWP: Spec-Driven Loop Detection
+// ============================================================
+/**
+ * Detect if any files are code changes (not docs/config)
+ */
+function hasCodeChanges(files) {
+    const codePatterns = [
+        /^src\//,
+        /^lib\//,
+        /^tests?\//,
+        /^scripts\//,
+        /^adapters\//,
+        /^engines\//,
+        /^vibecoding_helper\//,
+        /\.ts$/,
+        /\.tsx$/,
+        /\.js$/,
+        /\.jsx$/,
+        /\.py$/,
+        /\.rs$/,
+        /\.go$/
+    ];
+    return files.some((f) => {
+        const normalized = f.replace(/\\/g, "/");
+        return codePatterns.some((p) => p.test(normalized));
+    });
+}
+/**
+ * Detect if any files are spec/documentation changes
+ */
+function hasSpecChanges(files) {
+    return files.some((f) => {
+        const normalized = f.replace(/\\/g, "/");
+        return (normalized === "docs/SSOT.md" ||
+            normalized === "docs/CURRENT_SPEC.md" ||
+            normalized.startsWith("docs/ssot/") ||
+            normalized.startsWith("docs/specs/") ||
+            normalized.startsWith("docs/dev_logs/") ||
+            normalized.startsWith("docs/planning/"));
+    });
+}
+/**
+ * Check for SPEC_UPDATE_MISSING condition
+ * Returns an Issue if code changed but no spec updated
+ */
+function checkSpecUpdateMissing(modifiedFiles) {
+    const codeChanged = hasCodeChanges(modifiedFiles);
+    const specChanged = hasSpecChanges(modifiedFiles);
+    if (codeChanged && !specChanged) {
+        const codeFileCount = modifiedFiles.filter((f) => hasCodeChanges([f])).length;
+        return {
+            type: "RULE_VIOLATION",
+            business_risk: "코드는 바뀌었는데 스펙 문서가 업데이트되지 않았습니다. " +
+                "이 상태로 배포하면 문서와 코드가 어긋나 유지보수가 어려워집니다.",
+            plain_explanation: `${codeFileCount}개 코드 파일이 변경되었지만 스펙 문서(docs/SSOT.md, docs/ssot/*, docs/dev_logs/*) 업데이트가 없습니다. ` +
+                "이번 작업의 변경사항을 문서에 반영하세요. (3회 반복 시 BLOCK)",
+            technical_detail: {
+                file_path: "docs/SSOT.md",
+                rule_violated: "SPEC_UPDATE_MISSING"
+            }
+        };
+    }
+    return null;
+}
 /**
  * Create error output for parsing/execution failures
  */

package/build/tools/vibe_pm/kce/doc_usage.js

@@ -3,9 +3,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { resolveRunDir } from "../context.js";
-function normalizeRelPosix(p) {
-    return (p ?? "").trim().replace(/\\\\/g, "/");
-}
+import { uniquePosixPaths } from "../../../path-utils.js";
 function tryReadJson(p) {
     try {
         if (!fs.existsSync(p))
@@ -16,9 +14,6 @@ function tryReadJson(p) {
         return null;
     }
 }
-function uniqSorted(items) {
-    return Array.from(new Set(items.map(normalizeRelPosix).filter(Boolean))).sort();
-}
 export function kceDocUsagePath(run_id, basePath) {
     const resolved = resolveRunDir(run_id, basePath);
     if (!resolved)
@@ -30,9 +25,9 @@ export function updateKceDocUsage(args) {
     if (!p)
         return;
     const existing = tryReadJson(p);
-    const touched = uniqSorted([...(existing?.touched_docs ?? []), ...(args.touched_docs ?? [])]);
-    const injected = uniqSorted([...(existing?.injected_docs ?? []), ...(args.injected_docs ?? [])]);
-    const entities = uniqSorted([...(existing?.referenced_entities ?? []), ...(args.referenced_entities ?? [])]);
+    const touched = uniquePosixPaths([...(existing?.touched_docs ?? []), ...(args.touched_docs ?? [])]);
+    const injected = uniquePosixPaths([...(existing?.injected_docs ?? []), ...(args.injected_docs ?? [])]);
+    const entities = uniquePosixPaths([...(existing?.referenced_entities ?? []), ...(args.referenced_entities ?? [])]);
     const out = {
         version: "kce_doc_usage.v1",
         created_at: new Date().toISOString(),

package/build/tools/vibe_pm/kce/on_finalize.js

@@ -1,9 +1,9 @@
 // adapters/mcp-ts/src/tools/vibe_pm/kce/on_finalize.ts
 // Internal: best-effort KCE sync after finalize_work (keeps KCE warm).
-import { runEngine } from "../../../engine.js";
+import { runPythonCli } from "../../../engine.js";
 export async function kickoffKceSyncBestEffort() {
     try {
-        await runEngine("vibecoding-helper", ["kce-sync", "--prune", "--skip-missing-roots"], { timeoutMs: 300_000 });
+        await runPythonCli(["kce-sync", "--prune", "--skip-missing-roots"], { timeoutMs: 300_000 });
     }
     catch {
         // ignore

package/build/tools/vibe_pm/kce/preflight.js

@@ -3,9 +3,10 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { z } from "zod";
-import { runEngine } from "../../../engine.js";
+import { runPythonCli } from "../../../engine.js";
 import { safeJsonParse } from "../../../cli.js";
 import { resolveRunDir } from "../context.js";
+import { classifyPythonError } from "../python_error.js";
 const KceStatusSchema = z.object({
     version: z.literal("kce_status.v1"),
     readiness_state: z.enum(["READY", "HEALING", "FAILED"]),
@@ -89,9 +90,10 @@ function kceEventsPath(run_id, basePath) {
     return path.join(dir, "kce_events.jsonl");
 }
 export async function runKceStatus() {
-    const { code, stdout, stderr } = await runEngine("vibecoding-helper", ["kce-status"], { timeoutMs: 60_000 });
+    const { code, stdout, stderr } = await runPythonCli(["kce-status"], { timeoutMs: 60_000 });
     if (code !== 0) {
-        throw new Error(`kce-status failed: ${stderr || `exit_code=${code}`}`);
+        const classified = classifyPythonError(stderr ?? "", code, "KCE 상태 확인");
+        throw new Error(`${classified.issueCode}: ${classified.summary}`);
     }
     const parsed = safeJsonParse(stdout);
     if (!parsed.ok)
@@ -109,11 +111,12 @@ export async function runKceSync(args) {
         cmd.push("--skip-missing-roots");
     if (args.forceFull)
         cmd.push("--force-full");
-    const { code, stdout, stderr } = await runEngine("vibecoding-helper", cmd, {
+    const { code, stdout, stderr } = await runPythonCli(cmd, {
         timeoutMs: Math.max(60_000, args.timeoutMs ?? 300_000)
     });
     if (code !== 0) {
-        throw new Error(`kce-sync failed: ${stderr || `exit_code=${code}`}`);
+        const classified = classifyPythonError(stderr ?? "", code, "KCE 동기화");
+        throw new Error(`${classified.issueCode}: ${classified.summary}`);
     }
     const parsed = safeJsonParse(stdout);
     if (!parsed.ok)
@@ -139,9 +142,10 @@ export async function runKceRetrieve(args) {
     ];
     if (args.pathPrefix)
         cmd.push("--path-prefix", args.pathPrefix);
-    const { code, stdout, stderr } = await runEngine("vibecoding-helper", cmd, { timeoutMs: 60_000 });
+    const { code, stdout, stderr } = await runPythonCli(cmd, { timeoutMs: 60_000 });
     if (code !== 0) {
-        throw new Error(`kce-retrieve failed: ${stderr || `exit_code=${code}`}`);
+        const classified = classifyPythonError(stderr ?? "", code, "KCE 검색");
+        throw new Error(`${classified.issueCode}: ${classified.summary}`);
     }
     const parsed = safeJsonParse(stdout);
     if (!parsed.ok)

package/build/tools/vibe_pm/memory_status.js

@@ -1,10 +1,11 @@
 // adapters/mcp-ts/src/tools/vibe_pm/memory_status.ts
 // vibe_pm.memory_status - Local Memory status (ChromaDB index readiness)
-import { runEngine } from "../../engine.js";
+import { runPythonCliWithCache } from "../../engine.js";
 import { safeJsonParse } from "../../cli.js";
 import { validateToolInput } from "../../security/input-validator.js";
 import { resolveProjectId } from "./context.js";
 import { MemoryStatusOutputSchema } from "../../generated/memory_status_output.js";
+import { classifyPythonError } from "./python_error.js";
 function isOfflineMode() {
     const v = (process.env.VIBECODE_OFFLINE ?? "").trim().toLowerCase();
     return v === "1" || v === "true" || v === "yes" || v === "on";
@@ -29,20 +30,21 @@ export async function memoryStatus(input) {
     const persistDir = (input.persist_dir ?? defaultPersistDir()).trim();
     try {
         const args = ["memory-status", "--project-id", project_id, "--docs-root", docsRoot, "--persist-dir", persistDir];
-        const { code, stdout, stderr } = await runEngine("vibecoding-helper", args, { timeoutMs: 60_000 });
+        const { code, stdout, stderr } = await runPythonCliWithCache(args, { timeoutMs: 60_000 });
         if (code !== 0) {
+            const classified = classifyPythonError(stderr ?? "", code, "Local Memory 상태 확인");
             return MemoryStatusOutputSchema.parse({
                 project_id,
                 status: "ERROR",
-                summary: "Local Memory 상태 확인에 실패했습니다.",
+                summary: classified.summary,
                 docs_root: docsRoot,
                 persist_dir: persistDir,
                 collection: "vibe_docs",
                 stats: { document_count: 0, chunk_count: 0, last_sync_at: null },
                 embedding: { backend: "unknown", model: null, ready: false },
                 offline_mode: isOfflineMode(),
-                issues: [stderr?.trim() ? `engine_error: ${stderr.trim()}` : `engine_exit_code: ${code}`],
-                next_action: { tool: "vibe_pm.doctor", reason: "설치/환경 상태를 점검하겠습니다." }
+                issues: [`${classified.issueCode}: ${stderr?.trim() || `exit_code=${code}`}`],
+                next_action: classified.nextAction
             });
         }
         const parsed = safeJsonParse(stdout);
@@ -65,18 +67,19 @@ export async function memoryStatus(input) {
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
+        const classified = classifyPythonError(msg, 1, "Local Memory 상태 확인");
         return MemoryStatusOutputSchema.parse({
             project_id,
             status: "ERROR",
-            summary: "Local Memory 상태 확인 중 오류가 발생했습니다.",
+            summary: classified.summary,
             docs_root: docsRoot,
             persist_dir: persistDir,
             collection: "vibe_docs",
             stats: { document_count: 0, chunk_count: 0, last_sync_at: null },
             embedding: { backend: "unknown", model: null, ready: false },
             offline_mode: isOfflineMode(),
-            issues: [msg],
-            next_action: { tool: "vibe_pm.doctor", reason: "설치/환경 상태를 점검하겠습니다." }
+            issues: [`${classified.issueCode}: ${msg}`],
+            next_action: classified.nextAction
         });
     }
 }

package/build/tools/vibe_pm/memory_sync.js

@@ -1,10 +1,11 @@
 // adapters/mcp-ts/src/tools/vibe_pm/memory_sync.ts
 // vibe_pm.memory_sync - Local Memory sync (incremental index update)
-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 { MemorySyncOutputSchema } from "../../generated/memory_sync_output.js";
+import { classifyPythonError } from "./python_error.js";
 const inFlight = new Map();
 function isOfflineMode() {
     const v = (process.env.VIBECODE_OFFLINE ?? "").trim().toLowerCase();
@@ -59,13 +60,14 @@ export async function memorySync(input) {
             if (forceFull)
                 args.push("--force-full");
             const startedAt = Date.now();
-            const { code, stdout, stderr } = await runEngine("vibecoding-helper", args, { timeoutMs: 300_000 });
+            const { code, stdout, stderr } = await runPythonCli(args, { timeoutMs: 300_000 });
             const durationMs = Date.now() - startedAt;
             if (code !== 0) {
+                const classified = classifyPythonError(stderr ?? "", code, "Local Memory 동기화");
                 return MemorySyncOutputSchema.parse({
                     project_id,
                     status: "ERROR",
-                    summary: "Local Memory 동기화에 실패했습니다.",
+                    summary: classified.summary,
                     docs_root: docsRoot,
                     persist_dir: persistDir,
                     collection: "vibe_docs",
@@ -77,8 +79,8 @@ export async function memorySync(input) {
                         duration_ms: durationMs
                     },
                     offline_mode: isOfflineMode(),
-                    issues: [stderr?.trim() ? `engine_error: ${stderr.trim()}` : `engine_exit_code: ${code}`],
-                    next_action: { tool: "vibe_pm.doctor", reason: "설치/환경 상태를 점검하겠습니다." }
+                    issues: [`${classified.issueCode}: ${stderr?.trim() || `exit_code=${code}`}`],
+                    next_action: classified.nextAction
                 });
             }
             const parsed = safeJsonParse(stdout);
@@ -106,10 +108,11 @@ export async function memorySync(input) {
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
+            const classified = classifyPythonError(msg, 1, "Local Memory 동기화");
             return MemorySyncOutputSchema.parse({
                 project_id,
                 status: "ERROR",
-                summary: "Local Memory 동기화 중 오류가 발생했습니다.",
+                summary: classified.summary,
                 docs_root: docsRoot,
                 persist_dir: persistDir,
                 collection: "vibe_docs",
@@ -121,8 +124,8 @@ export async function memorySync(input) {
                     duration_ms: 0
                 },
                 offline_mode: isOfflineMode(),
-                issues: [msg],
-                next_action: { tool: "vibe_pm.doctor", reason: "설치/환경 상태를 점검하겠습니다." }
+                issues: [`${classified.issueCode}: ${msg}`],
+                next_action: classified.nextAction
             });
         }
     })();

package/build/tools/vibe_pm/pm_language.js

@@ -1,6 +1,7 @@
 // adapters/mcp-ts/src/tools/vibe_pm/pm_language.ts
 // PM Language transformation utilities
 // Reference: docs/DEV_SPEC/MCP_TOOL_SCHEMA_SPEC.md Section: Status Mapping
+import { applyTermDictionary, resolveLocaleFromText } from "./waiter_mapping.js";
 // ============================================================
 // Signal Level Mapping (Internal → User-facing)
 // ============================================================
@@ -202,21 +203,21 @@ ${verifyList}
  * This is a simplified version - full implementation would parse and restructure
  */
 export function transformAskQueueText(rawText) {
-    let transformed = rawText;
-    // Replace common technical terms with PM-friendly alternatives
-    const replacements = [
-        [/run_id/gi, "프로젝트"],
-        [/bridge/gi, "작업 지시서"],
-        [/schema/gi, "구조"],
-        [/gate/gi, "검토"],
-        [/signal/gi, "상태"],
-        [/FSM/gi, "워크플로우"],
-        [/spec_drift/gi, "범위 변경"],
-        [/decision_card/gi, "결재 안건"],
-        [/clinic_bridge/gi, "검수 기준"]
-    ];
-    for (const [pattern, replacement] of replacements) {
-        transformed = transformed.replace(pattern, replacement);
+    try {
+        const locale = resolveLocaleFromText(rawText);
+        return applyTermDictionary(rawText, locale);
+    }
+    catch {
+        // Best-effort fallback: preserve previous behavior when mapping is unavailable.
+        return rawText
+            .replace(/run_id/gi, "프로젝트")
+            .replace(/bridge/gi, "작업 지시서")
+            .replace(/schema/gi, "구조")
+            .replace(/gate/gi, "검토")
+            .replace(/signal/gi, "상태")
+            .replace(/FSM/gi, "워크플로우")
+            .replace(/spec_drift/gi, "범위 변경")
+            .replace(/decision_card/gi, "결재 안건")
+            .replace(/clinic_bridge/gi, "검수 기준");
     }
-    return transformed;
 }