@vibecodetown/mcp-server 1.3.1 → 1.5.0

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

@@ -1,729 +0,0 @@
-// 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
-}