@vibecodetown/mcp-server 1.3.1 → 1.5.0

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

@@ -0,0 +1,621 @@
+/**
+ * Core inspectCode orchestration.
+ * Main export: inspectCode()
+ */
+import { attachBoundaryWarnings, } from '../../shared/boundary_errors.js';
+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 { computeAndPersistStage } from '../stage-computer.js';
+import { attachNudge, buildNudgeContext } from '../nudge.js';
+import { readScorecard } from '../scorecard/index.js';
+import { runPreprocess } from '../../../preprocess.js';
+import { isPolicyEnabled, loadPolicyConfig, analyzeForPolicy, } from '../policy/index.js';
+import { isObserverEnabled, invokeOnVerificationRequired } from '../../../a2a/observer/hooks.js';
+import { resolveTierSnapshot } from '../../shared/tier_facade.js';
+import { executeWithRetry } from '../../../../domains/ant/healing_loop.js';
+import { getWorkerManager } from '../../../../workers/index.js';
+import { logger } from '../../../../shared/logger.js';
+import { runGitDiff, appendScorecardSafe, appendSignalSafe, inferBottleneck, transformIssue, determineMessageTemplate, determineNextAction, } from './helpers.js';
+import { delegateToCockpitd } from './cockpit.js';
+import { runTierAnalysis, pollForBuildResult } from './tier.js';
+/**
+ * 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, progress, log) {
+    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 ===
+        progress?.report(4, 4, `Verdict: BLOCK (missing: ${missingList})`);
+        log?.log('warning', { tool: 'vibe_pm.inspect_code', run_id, reason: 'P0_GATE', missing: missingList }, 'inspect_code blocked');
+        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: '스펙/계획을 먼저 생성한 뒤 검수를 다시 진행합니다.',
+            },
+        };
+    }
+    // v1.7.0: 2-Stage Review — resolve review_stage from input
+    const reviewStage = input.review_stage ?? 'full';
+    const skipMapping = reviewStage === 'code_quality';
+    const skipOneLoop = reviewStage === 'spec_compliance';
+    // Cockpitd delegation: VIBE_COCKPIT=1 + cockpitd 가용 시 원격 위임
+    if (process.env.VIBE_COCKPIT === '1') {
+        progress?.report(1, 4, 'Cockpit: 원격 검수 위임 중');
+        const delegated = await delegateToCockpitd(input, reviewStage, project_id, run_id, progress, log);
+        if (delegated) {
+            const boundaryWarnings = [];
+            const dVerdict = delegated.review_summary.review_result;
+            await appendScorecardSafe(basePath, run_id, {
+                verdict: dVerdict,
+                bottleneck: delegated.issues_found.length > 0 ? 'UNKNOWN_ERROR' : undefined,
+                fix_count_increment: dVerdict === 'GO' ? 0 : 1,
+                details: { source: 'cockpitd' },
+            }, boundaryWarnings);
+            await appendSignalSafe(basePath, {
+                type: 'INSPECT_VERDICT',
+                severity: dVerdict === 'BLOCK' ? 'P0' : dVerdict === 'FIX' ? 'P1' : 'P2',
+                run_id,
+                data: { verdict: dVerdict, source: 'cockpitd' },
+            }, boundaryWarnings);
+            attachBoundaryWarnings(delegated, boundaryWarnings);
+            return delegated;
+        }
+        // cockpitd 불가 → 로컬 흐름으로 폴백
+        log?.log('warning', { tool: 'vibe_pm.inspect_code', run_id }, 'cockpitd unavailable, falling back to local');
+    }
+    // Mapping Guard: Check change_map violations BEFORE oneLoopSelection
+    let mappingViolationIssues = [];
+    let mappingResult = null;
+    try {
+        if (hasSpecMap(basePath) && !skipMapping) {
+            progress?.report(1, 4, 'Mapping: 변경 파일 분석 중');
+            log?.log('info', { tool: 'vibe_pm.inspect_code', run_id, stage: 'mapping' }, 'mapping guard start');
+            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 ===
+                    progress?.report(4, 4, 'Verdict: BLOCK (mapping violation)');
+                    log?.log('warning', { tool: 'vibe_pm.inspect_code', run_id, reason: 'MAPPING_BLOCK', violations: mappingResult.changeMap.violations.length }, 'mapping block');
+                    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)
+        logger.error(`[vibe_pm.inspect_code] Mapping Guard failed: ${err}`);
+    }
+    // v1.7.0: spec_compliance stage — skip oneLoop, use mapping result only
+    let oneLoopResult = { status: 'UNKNOWN' };
+    if (skipOneLoop) {
+        // Stage 1 only: verdict from mapping violations
+        const hasMappingIssues = mappingViolationIssues.length > 0;
+        oneLoopResult = {
+            status: hasMappingIssues ? 'FIX' : 'GO',
+            signal_level: hasMappingIssues ? 'LEVEL_2' : 'LEVEL_1',
+            issues: [],
+        };
+        progress?.report(2, 4, 'Spec compliance: 매핑 검사 완료');
+    }
+    else {
+        // Build command arguments
+        progress?.report(2, 4, 'Diagram: 구조 검증 중');
+        log?.log('info', { tool: 'vibe_pm.inspect_code', run_id, stage: 'one_loop' }, 'one-loop start');
+        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
+        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';
+    let { result: reviewResult, verdict } = signalToReview(signalLevel);
+    // 3-Strike auto-BLOCK: escalate FIX → BLOCK after 3 consecutive FIX verdicts
+    {
+        const nudgeCtx = buildNudgeContext(basePath);
+        if (nudgeCtx.consecutive_fix_count >= 3 && reviewResult === 'FIX') {
+            reviewResult = 'BLOCK';
+            verdict = '동일 문제 3회 반복 — 접근 방식 재검토 필요';
+            logger.warn({ consecutive_fix: nudgeCtx.consecutive_fix_count }, '3-strike auto-BLOCK');
+        }
+    }
+    // === 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 ===
+    // v1.7.0: Fire verification hook (FAIL-SAFE, observer-gated)
+    if (isObserverEnabled()) {
+        try {
+            invokeOnVerificationRequired({
+                run_id,
+                verdict: reviewResult,
+                review_stage: reviewStage,
+                evidence_paths: oneLoopResult.modified_files ?? [],
+                build_passed: null, // will be updated after BuildWorker phase
+                test_passed: null,
+            });
+        }
+        catch {
+            // FAIL-SAFE: verification hook failure never blocks inspect_code
+        }
+    }
+    // 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;
+        // Compute bottleneck and issues summary for failure observability
+        const allIssues = oneLoopResult.issues ?? [];
+        const issuesSummary = allIssues.length > 0
+            ? allIssues.slice(0, 5).map((i) => `${i.type ?? 'unknown'}: ${i.message ?? ''}`).join('; ')
+            : null;
+        // Bottleneck: most frequent issue type
+        const typeCounts = new Map();
+        for (const i of allIssues) {
+            const t = i.type ?? 'unknown';
+            typeCounts.set(t, (typeCounts.get(t) ?? 0) + 1);
+        }
+        let bottleneck = null;
+        if (typeCounts.size > 0) {
+            bottleneck = [...typeCounts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+        }
+        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(),
+                bottleneck,
+                issues_summary: issuesSummary,
+            },
+        });
+    }
+    catch (e) {
+        logger.error({ err: e }, '[decision_log] failed to append inspect_verdict');
+    }
+    // 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)
+    const fixedIssues = [];
+    const autoFixEnabled = input.auto_fix !== false; // default true
+    // Check tier for extended auto-fix (Pro only)
+    const isPro = resolveTierSnapshot().isPro;
+    if (autoFixEnabled && reviewResult !== 'GO') {
+        try {
+            progress?.report(3, 4, 'Policy: 자동 수정 적용 중');
+            // 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) {
+                logger.error(`[vibe_pm.inspect_code] Auto-fixed ${fixedIssues.length} issue(s)`);
+            }
+        }
+        catch (err) {
+            // Auto-fix failed, continue without it
+            logger.error(`[vibe_pm.inspect_code] Auto-fix failed: ${err}`);
+        }
+    }
+    // === P9: Self-Healing (PRO, FAIL-SAFE) ===
+    let selfHealingResult = null;
+    if (isPro && fixedIssues.length > 0 && reviewResult === 'FIX') {
+        try {
+            const modifiedFiles = fixedIssues.map(f => f.file).filter((f) => !!f);
+            if (modifiedFiles.length > 0) {
+                const loopResult = await executeWithRetry({
+                    basePath,
+                    modifiedFiles,
+                    verdict: reviewResult,
+                    reason: `Auto-fix: ${fixedIssues.length} issues`,
+                });
+                selfHealingResult = loopResult.result;
+            }
+        }
+        catch {
+            // FAIL-SAFE: self-healing failure never blocks inspect_code
+        }
+    }
+    // === 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) {
+            logger.error({ err }, '[vibe_pm.inspect_code] BuildWorker failed');
+            // 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
+        logger.error('[policy] check failed: %s', 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
+    progress?.report(4, 4, 'Verdict: 최종 판정 중');
+    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,
+    };
+    // v1.7.0: Add review stage and verification gap info
+    output.review_stage_completed = reviewStage;
+    if (reviewResult === 'GO' && !buildResult && input.run_build !== true) {
+        output.verification_gap = '빌드/테스트 미실행. run_build: true로 재검수하면 완전한 검증이 가능합니다.';
+    }
+    // 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,
+        };
+    }
+    // P9: Self-healing diagnostic (bracket notation — .strict() schema bypass)
+    if (selfHealingResult?.attempted) {
+        output['_self_healing'] = {
+            action: selfHealingResult.action,
+            consensus_verdict: selfHealingResult.consensusVerdict,
+            risk_score: selfHealingResult.riskScore,
+            task_id: selfHealingResult.taskId,
+        };
+    }
+    try {
+        await computeAndPersistStage(basePath);
+    }
+    catch { /* fail-safe */ }
+    return attachNudge(output, basePath);
+}

package/build/mcp/tools/vibe_pm/inspect_code/helpers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Helper functions for inspect_code.
+ * Extracted: git diff, safe wrappers, issue transform, message helpers.
+ */
+import { type BoundaryWarning } from '../../shared/boundary_errors.js';
+import type { Issue, IssueType, ReviewResult, MessageTemplateId, NextAction } from '../types.js';
+import { type BottleneckCode, type ScorecardEntryInput } from '../scorecard/index.js';
+import { type SignalEventInput } from '../signals/index.js';
+import type { OneLoopResult } from './types.js';
+export declare function runGitDiff(params: {
+    cwd: string;
+    files: string[];
+    base?: string;
+    head?: string;
+    useStaged?: boolean;
+}): Promise<string>;
+export declare function appendScorecardSafe(basePath: string, runId: string, entry: ScorecardEntryInput, warnings?: BoundaryWarning[]): Promise<void>;
+export declare function appendSignalSafe(basePath: string, event: SignalEventInput, warnings?: BoundaryWarning[]): Promise<void>;
+export declare function inferBottleneck(issues: OneLoopResult['issues']): BottleneckCode | undefined;
+export declare function transformIssue(rawIssue: NonNullable<OneLoopResult['issues']>[number]): Issue;
+export declare function mapIssueType(rawType: string): IssueType;
+export declare function determineMessageTemplate(reviewResult: ReviewResult, issues: Issue[]): MessageTemplateId;
+export declare function determineNextAction(reviewResult: ReviewResult, promptBlock?: string): NextAction;