@vibecodetown/mcp-server 1.3.1

package/build/mcp/tools/vibe_pm/inspect_code.js

@@ -0,0 +1,729 @@
+// MVP Core - vibe_pm.inspect_code
+// Code review and validation (simplified MVP version)
+import { invalidateEngineCache } from "../../engine.js";
+import { resolveRunId, resolveProjectId, resolveBridgePath, readRunState, invalidateStateCache } from "./context.js";
+import { signalToReview, formatIssueType, generateRepairPrompt, getStatusMessage } from "./pm_language.js";
+import { VibecodingHelperOneLoopSelectionOutputSchema } from "../../generated/vibecoding_helper_one_loop_selection_output.js";
+import { autoFixDependencies, hasFixableIssues } from "./modules/fix_dependencies.js";
+import { fixMissingImports, hasFixableImportIssues } from "./modules/fix_imports.js";
+import { fixLintViolations, hasFixableLintIssues } from "./modules/fix_lint.js";
+import { oneLoopSelection } from "./modules/one_loop.js";
+import { runMappingPipelineSmart, hasSpecMap, } from "./mapping/index.js";
+import { appendDecisionLogEvent, readCurrentWorkOrderId, readCurrentDecisionId } from "./decision-log.js";
+import { readLastCheckSync } from "./bitnet-cache.js";
+import { computePhaseAndMissing } from "./phase.js";
+import { appendScorecard, readScorecard } from "./scorecard/index.js";
+import { appendSignal } from "./signals/index.js";
+import { runPreprocess } from "../../preprocess.js";
+import { spawn } from "node:child_process";
+import { isPolicyEnabled, loadPolicyConfig, analyzeForPolicy, } from "./policy/index.js";
+import { getWorkerManager } from "../../../workers/index.js";
+import { LicenseManager } from "../../../license-manager.js";
+import { Scorecard as TierScorecard, PolicyAnalyzer, } from "../../../tier/index.js";
+async function runGitDiff(params) {
+    if (!params.files.length)
+        return "";
+    const maxFiles = 50;
+    const files = params.files.slice(0, maxFiles);
+    const args = ["diff", "--no-color", "--unified=3"];
+    if (params.useStaged || params.base === "staged" || params.head === "working") {
+        args.push("--cached");
+    }
+    else if (params.base && params.head) {
+        args.push(`${params.base}..${params.head}`);
+    }
+    args.push("--", ...files);
+    return new Promise((resolve) => {
+        const proc = spawn("git", args, { cwd: params.cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        proc.stdout?.on("data", (d) => {
+            stdout += d.toString();
+        });
+        proc.on("close", () => resolve(stdout));
+        proc.on("error", () => resolve(""));
+    });
+}
+// === SCORECARD/SIGNALS FAIL-SAFE WRAPPERS ===
+/**
+ * FAIL-SAFE wrapper for scorecard append
+ * Never throws - logs error and continues
+ */
+async function appendScorecardSafe(basePath, runId, entry) {
+    try {
+        await appendScorecard(basePath, runId, entry);
+    }
+    catch (e) {
+        console.error("[scorecard] append failed:", e instanceof Error ? e.message : e);
+    }
+}
+/**
+ * FAIL-SAFE wrapper for signals append
+ * Never throws - logs error and continues
+ */
+async function appendSignalSafe(basePath, event) {
+    try {
+        await appendSignal(basePath, event);
+    }
+    catch (e) {
+        console.error("[signals] append failed:", e instanceof Error ? e.message : e);
+    }
+}
+/**
+ * Infer bottleneck code from issues array
+ * Priority: TEST_FAILURE > LINT_VIOLATION > TYPE_ERROR > MAPPING_VIOLATION > LOGIC_FLAW
+ */
+function inferBottleneck(issues) {
+    if (!issues || issues.length === 0)
+        return "UNKNOWN_ERROR";
+    const typeSet = new Set(issues.map((i) => (i.type ?? i.issue_type ?? "").toUpperCase()));
+    if (typeSet.has("TEST_FAIL") || typeSet.has("VERIFY_FAIL"))
+        return "TEST_FAILURE";
+    if (typeSet.has("RULE_VIOLATION"))
+        return "LINT_VIOLATION";
+    if (typeSet.has("TYPE_ERROR"))
+        return "TYPE_ERROR";
+    if (typeSet.has("SCOPE_MISMATCH"))
+        return "MAPPING_VIOLATION";
+    if (typeSet.has("RISK_SPIKE"))
+        return "LOGIC_FLAW";
+    return "UNKNOWN_ERROR";
+}
+/**
+ * vibe_pm.inspect_code - Code review and validation (MVP)
+ *
+ * Internal mapping:
+ *   → vibecoding-helper one-loop <run_id> --output selection
+ *   → issue classification
+ *   → prompt_block generation (if FIX/BLOCK)
+ */
+export async function inspectCode(input) {
+    const basePath = process.cwd();
+    // Resolve run_id and bridge path
+    const { run_id } = resolveRunId(input.project_id, basePath);
+    const project_id = resolveProjectId(run_id, basePath);
+    const runState = readRunState(run_id, basePath);
+    const bridgePath = resolveBridgePath(input.bridge_path, run_id, basePath);
+    // Get mode for context
+    const mode = runState?.mode ?? "balanced";
+    // Best-effort preprocess (airlock/router/chunking)
+    try {
+        const rawText = JSON.stringify({
+            target_paths: input.target_paths ?? [],
+            mode: input.mode ?? "thorough",
+            auto_fix: input.auto_fix ?? true,
+            run_build: input.run_build ?? false,
+        });
+        await runPreprocess({
+            workspaceRoot: basePath,
+            runId: run_id,
+            rawText,
+            filePath: input.target_paths?.[0] ?? "inspect_code.txt",
+            taskType: "inspect_code",
+        });
+    }
+    catch {
+        // ignore (best-effort)
+    }
+    // P0 Gate: No Spec + No Plan → No Work (mutation tool hard gate)
+    // - Inspect can trigger writes (auto_fix). Block before one-loop unless spec/plan exist.
+    const phase = computePhaseAndMissing(run_id, basePath);
+    const mutationMissing = phase.missing.filter((m) => m.required_for.includes("MUTATION"));
+    if (mutationMissing.length > 0) {
+        const missingList = mutationMissing.map((m) => m.id).join(", ");
+        // === INJECTION POINT A: P0 Gate (spec/plan missing) ===
+        await appendScorecardSafe(basePath, run_id, {
+            verdict: "BLOCK",
+            bottleneck: mutationMissing[0]?.id === "SPEC_MISSING" ? "SPEC_MISSING" : "PLAN_MISSING",
+            fix_count_increment: 0,
+            evidence_refs: mutationMissing.map((m) => m.evidence?.[0] ?? ""),
+        });
+        await appendSignalSafe(basePath, {
+            type: "INSPECT_VERDICT",
+            severity: "P0",
+            run_id,
+            data: { verdict: "BLOCK", reason: "P0_GATE", missing: mutationMissing.map((m) => m.id) },
+        });
+        // === END INJECTION POINT A ===
+        return {
+            project_id,
+            message_template_id: "BLOCK-01",
+            review_summary: {
+                decision_context: `프로젝트 ${project_id} 검수 준비 필요`,
+                review_result: "BLOCK",
+                one_line_verdict: `❌ 반려 - 필수 문서가 없습니다 (${missingList})`,
+            },
+            issues_found: mutationMissing.map((m) => ({
+                type: "VERIFY_FAIL",
+                business_risk: `필수 문서 누락: ${m.id}`,
+                plain_explanation: "검수 전에 스펙(spec)과 계획(plan)을 먼저 고정해야 합니다.",
+                technical_detail: {
+                    file_path: (m.evidence?.[0] ?? "runs/<run_id>/..."),
+                },
+            })),
+            next_action: {
+                action_type: "CONTINUE",
+                tool: "vibe_pm.create_work_order",
+                reason: "스펙/계획을 먼저 생성한 뒤 검수를 다시 진행합니다.",
+            },
+        };
+    }
+    // Mapping Guard: Check change_map violations BEFORE oneLoopSelection
+    let mappingViolationIssues = [];
+    let mappingResult = null;
+    try {
+        if (hasSpecMap(basePath)) {
+            mappingResult = await runMappingPipelineSmart({
+                workspaceRoot: basePath,
+                run_id,
+            });
+            // Best-effort preprocess with mapping output (diff-based context)
+            try {
+                const diffText = await runGitDiff({
+                    cwd: basePath,
+                    files: [
+                        ...mappingResult.changeMap.mapped.map((m) => m.file),
+                        ...mappingResult.changeMap.unmapped.map((u) => u.file),
+                    ],
+                    base: mappingResult.changeMap.base,
+                    head: mappingResult.changeMap.head,
+                    useStaged: mappingResult.changeMap.base === "staged",
+                });
+                const MAX_DIFF_CHARS = 50000;
+                const diffExcerpt = diffText.length > MAX_DIFF_CHARS ? diffText.slice(0, MAX_DIFF_CHARS) : diffText;
+                const preprocessText = JSON.stringify({
+                    change_map_summary: mappingResult.changeMap.summary,
+                    mapped_files: mappingResult.changeMap.mapped.map((m) => m.file),
+                    unmapped_files: mappingResult.changeMap.unmapped.map((u) => u.file),
+                    violations: mappingResult.changeMap.violations,
+                    decision: mappingResult.decision,
+                    change_map_path: mappingResult.changeMapPath,
+                    diff_base: mappingResult.changeMap.base,
+                    diff_head: mappingResult.changeMap.head,
+                    diff_excerpt: diffExcerpt,
+                    diff_truncated: diffText.length > MAX_DIFF_CHARS,
+                });
+                await runPreprocess({
+                    workspaceRoot: basePath,
+                    runId: run_id,
+                    rawText: preprocessText,
+                    filePath: mappingResult.changeMapPath,
+                    taskType: "mapping",
+                });
+            }
+            catch {
+                // ignore (best-effort)
+            }
+            // Convert mapping violations to issues
+            if (mappingResult.decision.verdict !== "GO") {
+                mappingViolationIssues = mappingResult.changeMap.violations.map((v) => ({
+                    type: (v.severity === "BLOCK" ? "SCOPE_MISMATCH" : "RULE_VIOLATION"),
+                    business_risk: v.detail,
+                    plain_explanation: mappingResult.decision.navigation?.[0] ?? "spec_map.v1.json 또는 코드 소속을 확인하세요.",
+                    technical_detail: v.file ? {
+                        file_path: v.file,
+                    } : undefined,
+                }));
+                // If BLOCK-level violations exist, return early without oneLoopSelection
+                if (mappingResult.decision.verdict === "BLOCK") {
+                    // === INJECTION POINT B: Mapping Guard (mapping blocks) ===
+                    await appendScorecardSafe(basePath, run_id, {
+                        verdict: "BLOCK",
+                        bottleneck: "MAPPING_VIOLATION",
+                        fix_count_increment: 0,
+                        details: { violations: mappingResult.changeMap.violations.length },
+                    });
+                    await appendSignalSafe(basePath, {
+                        type: "MAPPING_BLOCK",
+                        severity: "P0",
+                        run_id,
+                        data: { verdict: "BLOCK", violations_count: mappingResult.changeMap.violations.length },
+                    });
+                    // === END INJECTION POINT B ===
+                    const statusMessage = getStatusMessage("BLOCK");
+                    return {
+                        project_id,
+                        message_template_id: "BLOCK-02",
+                        review_summary: {
+                            decision_context: `프로젝트 ${project_id} 검수 결과`,
+                            review_result: "BLOCK",
+                            one_line_verdict: `${statusMessage} - 경계 위반 감지`
+                        },
+                        issues_found: mappingViolationIssues,
+                        next_action: {
+                            action_type: "ASK_DECISION",
+                            tool: "vibe_pm.get_decision",
+                            reason: "소속 경계 위반이 발생했습니다. 결재 단계로 돌아가 다시 결정해야 합니다."
+                        }
+                    };
+                }
+            }
+        }
+    }
+    catch (err) {
+        // Mapping Guard 실패는 무시 (FAIL-SAFE)
+        console.error(`[vibe_pm.inspect_code] Mapping Guard failed: ${err}`);
+    }
+    // Build command arguments
+    const oneLoopResultRaw = await oneLoopSelection({
+        run_id,
+        base_path: basePath,
+        bridge_path: bridgePath,
+        target_paths: input.target_paths ?? []
+    });
+    // Invalidate caches after inspection
+    invalidateEngineCache(new RegExp(run_id));
+    invalidateStateCache(run_id, basePath);
+    // Parse result
+    let oneLoopResult = { status: "UNKNOWN" };
+    const validated = VibecodingHelperOneLoopSelectionOutputSchema.safeParse(oneLoopResultRaw);
+    if (validated.success) {
+        oneLoopResult = validated.data;
+    }
+    else {
+        // Keep behavior deterministic for MCP clients: treat as verification failure.
+        oneLoopResult = {
+            status: "ERROR",
+            signal_level: "LEVEL_2",
+            issues: [{
+                    type: "VERIFY_FAIL",
+                    message: "검수 실행에 실패했습니다.",
+                    description: "내부 검수 결과 포맷이 올바르지 않습니다."
+                }]
+        };
+    }
+    // Determine review result from signal_level
+    const signalLevel = oneLoopResult.signal_level ?? oneLoopResult.signal ?? "LEVEL_2";
+    const { result: reviewResult, verdict } = signalToReview(signalLevel);
+    // === INJECTION POINT C: Final Verdict ===
+    const finalBottleneck = reviewResult !== "GO"
+        ? inferBottleneck(oneLoopResult.issues)
+        : undefined;
+    await appendScorecardSafe(basePath, run_id, {
+        verdict: reviewResult,
+        bottleneck: finalBottleneck,
+        fix_count_increment: reviewResult === "GO" ? 0 : 1,
+        evidence_refs: oneLoopResult.modified_files,
+    });
+    await appendSignalSafe(basePath, {
+        type: "INSPECT_VERDICT",
+        severity: reviewResult === "BLOCK" ? "P0" : reviewResult === "FIX" ? "P1" : "P2",
+        run_id,
+        data: {
+            verdict: reviewResult,
+            issues_count: oneLoopResult.issues?.length ?? 0,
+            bottleneck: finalBottleneck,
+        },
+    });
+    // === END INJECTION POINT C ===
+    // PR-H: Append inspect_verdict to decision_log (FAIL-SAFE)
+    try {
+        const work_order_id = await readCurrentWorkOrderId({ workspaceRoot: basePath });
+        const decision_id = await readCurrentDecisionId({ workspaceRoot: basePath });
+        // BitNet trace_id 읽기 (있으면)
+        let bitnet_trace_id = null;
+        try {
+            const bitnetCache = readLastCheckSync(basePath);
+            bitnet_trace_id = bitnetCache.data?.trace_id ?? null;
+        }
+        catch {
+            // BitNet not available
+        }
+        const changed_files_count = oneLoopResult.modified_files?.length ?? null;
+        await appendDecisionLogEvent({
+            workspaceRoot: basePath,
+            event: {
+                event_type: "inspect_verdict",
+                run_id,
+                verdict: reviewResult,
+                bitnet_trace_id,
+                bitnet_result_path: bitnet_trace_id ? ".vibe/cache/bitnet/last_check.json" : null,
+                decision_id,
+                work_order_id,
+                changed_files_count,
+                timestamp: new Date().toISOString(),
+            },
+        });
+    }
+    catch (e) {
+        console.error("[decision_log] failed to append inspect_verdict:", e);
+    }
+    // Transform issues to PM language
+    let issues = (oneLoopResult.issues ?? []).map(transformIssue);
+    // Merge FIX-level mapping violations (if any)
+    if (mappingViolationIssues.length > 0) {
+        issues = [...mappingViolationIssues, ...issues];
+    }
+    // v2.0: Auto-fix recoverable issues if enabled (default: true)
+    let fixedIssues = [];
+    const autoFixEnabled = input.auto_fix !== false; // default true
+    // Check tier for extended auto-fix (Pro only)
+    const isPro = (() => {
+        try {
+            const licenseManager = new LicenseManager();
+            return licenseManager.loadEntitlements().planEffective === "PRO";
+        }
+        catch {
+            return false;
+        }
+    })();
+    if (autoFixEnabled && reviewResult !== "GO") {
+        try {
+            // 1. Dependencies auto-fix (FREE tier)
+            if (hasFixableIssues(issues)) {
+                const depFixes = await autoFixDependencies(issues, basePath);
+                fixedIssues.push(...depFixes);
+            }
+            // 2. Import auto-fix (PRO tier only)
+            if (isPro && hasFixableImportIssues(issues)) {
+                const importFixes = await fixMissingImports(issues, basePath);
+                fixedIssues.push(...importFixes);
+            }
+            // 3. Lint auto-fix (PRO tier only)
+            if (isPro && hasFixableLintIssues(issues)) {
+                const lintFixes = await fixLintViolations(issues, basePath);
+                fixedIssues.push(...lintFixes);
+            }
+            // If we fixed issues, log for debugging
+            if (fixedIssues.length > 0) {
+                console.error(`[vibe_pm.inspect_code] Auto-fixed ${fixedIssues.length} issue(s)`);
+            }
+        }
+        catch (err) {
+            // Auto-fix failed, continue without it
+            console.error(`[vibe_pm.inspect_code] Auto-fix failed: ${err}`);
+        }
+    }
+    // === PHASE 14: BuildWorker Integration ===
+    let buildResult = null;
+    if (input.run_build === true) {
+        try {
+            const manager = getWorkerManager();
+            const buildSteps = input.build_steps ?? [
+                { name: 'lint', cmd: 'npm run lint --if-present', continueOnFailure: true },
+                { name: 'test', cmd: 'npm test --if-present', continueOnFailure: false },
+            ];
+            const submitResult = await manager.submitTask({
+                project_id: run_id,
+                worker_type: 'build',
+                inputs: {
+                    workspace_root: basePath,
+                    steps: buildSteps,
+                    capture: { stdout: true, stderr: true },
+                },
+                limits: { timeout_ms: 120000 },
+            });
+            // Poll for completion (max 60 seconds)
+            buildResult = await pollForBuildResult(manager, submitResult.task_id, run_id, 60000);
+            // Convert build failures to issues
+            if (buildResult && buildResult.summary.failed > 0) {
+                const buildIssues = buildResult.steps
+                    .filter(s => !s.success)
+                    .map(s => ({
+                    type: 'VERIFY_FAIL',
+                    business_risk: `${s.name} 실패 (exit code: ${s.exitCode})`,
+                    plain_explanation: s.stderr?.slice(0, 200) || 'Unknown error',
+                    technical_detail: {
+                        file_path: s.name,
+                        rule_violated: s.command,
+                    },
+                }));
+                issues = [...issues, ...buildIssues];
+            }
+        }
+        catch (err) {
+            console.error('[vibe_pm.inspect_code] BuildWorker failed:', err);
+            // FAIL-SAFE: continue without build results
+        }
+    }
+    // === END PHASE 14: BuildWorker Integration ===
+    // === POLICY LOOP (Phase IV - opt-in) ===
+    let policyAdjustment = null;
+    try {
+        if (isPolicyEnabled()) {
+            const policyConfig = loadPolicyConfig();
+            const scorecard = await readScorecard(basePath, run_id);
+            // Get BitNet result (may be null)
+            let bitnetResult = null;
+            try {
+                const bitnetCache = readLastCheckSync(basePath);
+                if (bitnetCache.data) {
+                    bitnetResult = {
+                        verdict: bitnetCache.data.verdict ?? "GO",
+                        risk_tags: bitnetCache.data.risk_tags,
+                    };
+                }
+            }
+            catch {
+                // BitNet not available - continue without it
+            }
+            policyAdjustment = analyzeForPolicy(scorecard, bitnetResult, policyConfig);
+            // Log policy signal if triggered
+            if (policyAdjustment) {
+                await appendSignalSafe(basePath, {
+                    type: "POLICY_RECOMMENDED",
+                    severity: "P1",
+                    run_id,
+                    evidence: [policyAdjustment.policy_id],
+                    data: {
+                        policy_id: policyAdjustment.policy_id,
+                        trigger: policyAdjustment.trigger,
+                        gate_mode_suggested: policyAdjustment.gate_mode_suggested,
+                        reason: policyAdjustment.reason,
+                    },
+                });
+            }
+        }
+    }
+    catch (e) {
+        // FAIL-SAFE: policy errors don't block main flow
+        console.error("[policy] check failed:", e instanceof Error ? e.message : e);
+    }
+    // === END POLICY LOOP ===
+    // Generate status message
+    const statusMessage = getStatusMessage(reviewResult);
+    // Determine message template (consider auto-fixed issues)
+    const messageTemplateId = fixedIssues.length > 0
+        ? "DEPS-02" // Auto-fix completed
+        : determineMessageTemplate(reviewResult, issues);
+    // Generate repair prompt if needed
+    let promptBlock;
+    if (reviewResult !== "GO" && issues.length > 0) {
+        const repairData = {
+            projectName: project_id,
+            mode,
+            problem: issues.map(i => i.business_risk).join("; "),
+            cause: issues.map(i => i.plain_explanation).join("; "),
+            fixDirection: issues.map(i => `${formatIssueType(i.type).name}: ${i.plain_explanation}`),
+            verifyCriteria: ["빌드 성공", "테스트 통과", "범위 내 변경"]
+        };
+        promptBlock = generateRepairPrompt(repairData);
+    }
+    // Determine next action
+    const nextAction = determineNextAction(reviewResult, promptBlock);
+    // Get tier info and run Pro analysis if available
+    const tierAnalysis = await runTierAnalysis(basePath);
+    // Build output
+    const output = {
+        project_id,
+        message_template_id: messageTemplateId,
+        review_summary: {
+            decision_context: `프로젝트 ${project_id} 검수 결과`,
+            review_result: reviewResult,
+            one_line_verdict: `${statusMessage} - ${verdict}`
+        },
+        issues_found: issues,
+        next_action: nextAction
+    };
+    // Add fixed_issues if any were fixed
+    if (fixedIssues.length > 0) {
+        output.fixed_issues = fixedIssues;
+    }
+    // Add policy_adjustment if policy triggered (Phase IV)
+    if (policyAdjustment) {
+        output.policy_adjustment = {
+            policy_id: policyAdjustment.policy_id,
+            trigger: policyAdjustment.trigger,
+            gate_mode_suggested: policyAdjustment.gate_mode_suggested,
+            reason: policyAdjustment.reason,
+        };
+    }
+    // Add tier analysis results (v1.6.0)
+    if (tierAnalysis) {
+        output.tier_info = tierAnalysis.tier_info;
+        if (tierAnalysis.scorecard) {
+            output.scorecard = tierAnalysis.scorecard;
+        }
+        if (tierAnalysis.policy) {
+            output.policy = tierAnalysis.policy;
+        }
+    }
+    // Add build_result (Phase 14)
+    if (buildResult) {
+        output.build_result = {
+            total_duration_ms: buildResult.totalDuration,
+            steps_passed: buildResult.summary.passed,
+            steps_failed: buildResult.summary.failed,
+            artifacts: buildResult.artifacts ? {
+                junit: buildResult.artifacts.junit,
+                coverage: buildResult.artifacts.coverage,
+            } : undefined,
+        };
+    }
+    return output;
+}
+function transformIssue(rawIssue) {
+    const issueType = mapIssueType(rawIssue.type ?? rawIssue.issue_type ?? "unknown");
+    const typeInfo = formatIssueType(issueType);
+    const issue = {
+        type: issueType,
+        business_risk: rawIssue.business_risk ?? rawIssue.message ?? "알 수 없는 문제",
+        plain_explanation: rawIssue.description ?? typeInfo.description
+    };
+    // Only add technical_detail if file_path exists
+    if (rawIssue.file_path) {
+        issue.technical_detail = {
+            file_path: rawIssue.file_path,
+            line_range: rawIssue.line_range,
+            rule_violated: rawIssue.rule_violated
+        };
+    }
+    return issue;
+}
+function mapIssueType(rawType) {
+    const normalized = rawType.toUpperCase().replace(/[\s-]/g, "_");
+    // Map various raw types to the 4 valid IssueTypes
+    const mapping = {
+        // Direct mappings
+        RULE_VIOLATION: "RULE_VIOLATION",
+        VERIFY_FAIL: "VERIFY_FAIL",
+        SCOPE_MISMATCH: "SCOPE_MISMATCH",
+        RISK_SPIKE: "RISK_SPIKE",
+        // Alias mappings
+        BUILD_FAIL: "VERIFY_FAIL",
+        TEST_FAIL: "VERIFY_FAIL",
+        SPEC_DRIFT: "SCOPE_MISMATCH",
+        SCOPE_VIOLATION: "SCOPE_MISMATCH",
+        PATH_ZONE_VIOLATION: "SCOPE_MISMATCH",
+        LOOP_LIMIT: "RISK_SPIKE"
+    };
+    return mapping[normalized] ?? "RULE_VIOLATION";
+}
+function determineMessageTemplate(reviewResult, issues) {
+    if (reviewResult === "GO") {
+        return "GO-01";
+    }
+    if (reviewResult === "BLOCK") {
+        const hasScopeMismatch = issues.some(i => i.type === "SCOPE_MISMATCH");
+        return hasScopeMismatch ? "BLOCK-02" : "BLOCK-01";
+    }
+    // FIX
+    const hasVerifyFail = issues.some(i => i.type === "VERIFY_FAIL");
+    return hasVerifyFail ? "FIX-02" : "FIX-01";
+}
+function determineNextAction(reviewResult, promptBlock) {
+    if (reviewResult === "GO") {
+        return {
+            action_type: "CONTINUE",
+            tool: "vibe_pm.create_work_order",
+            reason: "검수 통과. 다음 작업 지시서를 받거나 작업을 완료합니다."
+        };
+    }
+    if (reviewResult === "BLOCK") {
+        return {
+            action_type: "ASK_DECISION",
+            tool: "vibe_pm.get_decision",
+            reason: "결재 단계로 돌아가 다시 결정해야 합니다."
+        };
+    }
+    // FIX - use COPY_PASTE_TO_AGENT if we have a prompt block
+    if (promptBlock) {
+        return {
+            action_type: "COPY_PASTE_TO_AGENT",
+            label: "수정 프롬프트",
+            prompt_block: promptBlock
+        };
+    }
+    // FIX without prompt block - suggest doctor
+    return {
+        action_type: "CONTINUE",
+        tool: "vibe_pm.doctor",
+        reason: "문제를 수정한 후 다시 검수해주세요."
+    };
+}
+/**
+ * Run tier analysis (Scorecard, Policy) for Pro users
+ * FAIL-SAFE: Returns tier_info only on error or Free tier
+ */
+async function runTierAnalysis(basePath) {
+    try {
+        const manager = new LicenseManager();
+        const entitlements = manager.loadEntitlements();
+        const isPro = entitlements.planEffective === "PRO";
+        const featuresUsed = [];
+        // Base tier info (always returned)
+        const tierInfo = {
+            plan: entitlements.planEffective,
+            features_used: featuresUsed,
+        };
+        // If not Pro, return basic tier info only
+        if (!isPro) {
+            return { tier_info: tierInfo };
+        }
+        // Run Pro-only analysis
+        let scorecardResult = null;
+        let policyResult = null;
+        // Try Scorecard
+        try {
+            const scorecard = new TierScorecard({ workspace: basePath });
+            scorecardResult = await scorecard.generate();
+            featuresUsed.push("scorecard");
+        }
+        catch {
+            // Scorecard failed - continue without it
+        }
+        // Try Policy Analysis
+        try {
+            const analyzer = new PolicyAnalyzer(basePath);
+            policyResult = await analyzer.analyze();
+            featuresUsed.push("policy_analysis");
+        }
+        catch {
+            // Policy failed - continue without it
+        }
+        // Build result
+        const result = {
+            tier_info: tierInfo,
+        };
+        if (scorecardResult) {
+            result.scorecard = {
+                overall_score: scorecardResult.overallScore,
+                grade: scorecardResult.grade,
+                metrics: scorecardResult.metrics.map((m) => ({
+                    name: m.name,
+                    score: m.score,
+                })),
+                suggestions: scorecardResult.suggestions,
+            };
+        }
+        if (policyResult) {
+            const criticalViolations = policyResult.violations
+                .filter((v) => v.severity === "error")
+                .slice(0, 5)
+                .map((v) => ({
+                rule_id: v.ruleId,
+                message: v.message,
+            }));
+            result.policy = {
+                passed: policyResult.passed,
+                violations_count: policyResult.summary.total,
+                critical_violations: criticalViolations,
+            };
+        }
+        return result;
+    }
+    catch {
+        // FAIL-SAFE: Return null on error (tier info won't be added to output)
+        return null;
+    }
+}
+/**
+ * Poll for build result with timeout
+ * @param manager WorkerManager instance
+ * @param taskId Task ID to poll
+ * @param runId Run ID for project context
+ * @param timeoutMs Maximum wait time in milliseconds
+ */
+async function pollForBuildResult(manager, taskId, runId, timeoutMs) {
+    const start = Date.now();
+    const pollInterval = 500;
+    while (Date.now() - start < timeoutMs) {
+        const status = await manager.getStatus({ task_id: taskId, project_id: runId });
+        const task = status.tasks[0];
+        if (task?.status === 'done' || task?.status === 'failed') {
+            const result = await manager.getResult({ task_id: taskId, project_id: runId });
+            return result.result?.output ?? null;
+        }
+        await new Promise(r => setTimeout(r, pollInterval));
+    }
+    return null; // Timeout
+}