@vibecodetown/mcp-server 1.4.0 → 1.5.0

package/build/mcp/profile-config.d.ts

@@ -1,7 +1,7 @@
 export declare const TOOL_GROUPS: {
     readonly mvp: readonly ["vibe_pm.briefing", "vibe_pm.get_decision", "vibe_pm.submit_decision", "vibe_pm.create_work_order", "vibe_pm.inspect_code", "vibe_pm.status", "vibe_pm.doctor", "vibe_pm.ingress"];
-    readonly core: readonly ["vibe_pm.briefing", "vibe_pm.get_decision", "vibe_pm.submit_decision", "vibe_pm.create_work_order", "vibe_pm.inspect_code", "vibe_pm.status", "vibe_pm.doctor", "vibe_pm.ingress"];
-    readonly ops: readonly ["vibe_pm.init_docs", "vibe_pm.ui_manifest", "vibe_pm.ui_resource", "vibe_pm.scaffold", "vibe_pm.workspace_recipe", "vibe_pm.setup", "vibe_pm.block_search"];
+    readonly core: readonly ["vibe_pm.briefing", "vibe_pm.get_decision", "vibe_pm.submit_decision", "vibe_pm.create_work_order", "vibe_pm.inspect_code", "vibe_pm.status", "vibe_pm.doctor", "vibe_pm.ingress", "vibe_pm.finalize_work", "vibe_pm.undo_last_task"];
+    readonly ops: readonly ["vibe_pm.init_docs", "vibe_pm.ui_manifest", "vibe_pm.ui_resource", "vibe_pm.scaffold", "vibe_pm.workspace_recipe", "vibe_pm.setup", "vibe_pm.block_search", "vibe_pm.skills", "vibe_pm.suggest_roots", "vibe_pm.check_resources", "vibe_pm.check_dormant", "vibe_pm.repair_plan", "vibe_pm.branch_pivot"];
     readonly bridge: readonly [];
     readonly memory: readonly ["vibe_pm.memory", "vibe_pm.memory_status", "vibe_pm.memory_sync", "vibe_pm.memory_retrieve"];
     readonly research: readonly [];

package/build/mcp/profile-config.js

@@ -26,8 +26,10 @@ export const TOOL_GROUPS = {
         'vibe_pm.status',
         'vibe_pm.doctor',
         'vibe_pm.ingress',
+        'vibe_pm.finalize_work', // 작업 마무리 + 커밋
+        'vibe_pm.undo_last_task', // 마지막 작업 되돌리기
     ],
-    // Ops: 설치/운영 + UI 도구 + 블록 검색 (AS-BUILT: init_docs + ui_manifest/ui_resource + scaffold + setup + block_search)
+    // Ops: 설치/운영 + UI 도구 + 블록 검색 + 진단/관리 도구
     ops: [
         'vibe_pm.init_docs',
         'vibe_pm.ui_manifest',
@@ -36,6 +38,12 @@ export const TOOL_GROUPS = {
         'vibe_pm.workspace_recipe',
         'vibe_pm.setup',
         'vibe_pm.block_search', // P38: DB FTS 블록 검색
+        'vibe_pm.skills', // 스킬팩 조회
+        'vibe_pm.suggest_roots', // 프로젝트 루트 탐색
+        'vibe_pm.check_resources', // 시스템 리소스 점검
+        'vibe_pm.check_dormant', // 프로젝트 비활성 감지
+        'vibe_pm.repair_plan', // 복구 계획 생성
+        'vibe_pm.branch_pivot', // 브랜치 전환 + 스냅샷
     ],
     // Bridge: 예약(AS-BUILT 미등록)
     bridge: [],

package/build/mcp/tool-registry.js

@@ -199,6 +199,25 @@ export async function registerAllTools(server, opts = {}) {
     if (registerIfEnabled(server, 'vibe_pm.block_snapshot', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.block_snapshot'], pm.blockSnapshotInputSchema.shape, async (input) => pm.vibePmBlockSnapshot(pm.blockSnapshotInputSchema.parse(input))))
         registeredCount++;
     // ============================================================
+    // Sprint 048: Gap Closure tools (skills, suggest_roots, check_resources, check_dormant, repair_plan, finalize_work, undo_last_task, branch_pivot)
+    // ============================================================
+    if (registerIfEnabled(server, 'vibe_pm.skills', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.skills'], pm.skillsInputSchema.shape, async (input) => pm.vibePmSkills(pm.skillsInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.suggest_roots', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.suggest_roots'], pm.suggestRootsInputSchema.shape, async (input) => pm.vibePmSuggestRoots(pm.suggestRootsInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.check_resources', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.check_resources'], pm.checkResourcesInputSchema.shape, async (input) => pm.vibePmCheckResources(pm.checkResourcesInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.check_dormant', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.check_dormant'], pm.checkDormantInputSchema.shape, async (input) => pm.vibePmCheckDormant(pm.checkDormantInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.repair_plan', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.repair_plan'], pm.repairPlanInputSchema.shape, async (input) => pm.vibePmRepairPlan(pm.repairPlanInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.finalize_work', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.finalize_work'], pm.finalizeWorkInputSchema.shape, async (input) => pm.vibePmFinalizeWork(pm.finalizeWorkInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.undo_last_task', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.undo_last_task'], pm.undoLastTaskInputSchema.shape, async (input) => pm.vibePmUndoLastTask(pm.undoLastTaskInputSchema.parse(input))))
+        registeredCount++;
+    if (registerIfEnabled(server, 'vibe_pm.branch_pivot', VIBE_PM_TOOL_DESCRIPTIONS['vibe_pm.branch_pivot'], pm.branchPivotInputSchema.shape, async (input) => pm.vibePmBranchPivot(pm.branchPivotInputSchema.parse(input))))
+        registeredCount++;
+    // ============================================================
     // Human Surface meta-tools (gated by VIBE_PROFILE=human)
     // ============================================================
     let humanCount = 0;

package/build/mcp/tools/vibe_pm/branch_pivot.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const branchPivotInputSchema: z.ZodObject<{
+    target_branch: z.ZodString;
+    save_snapshot: z.ZodDefault<z.ZodBoolean>;
+    restore_snapshot: z.ZodDefault<z.ZodBoolean>;
+    workspace_root: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    target_branch: string;
+    save_snapshot: boolean;
+    restore_snapshot: boolean;
+    workspace_root?: string | undefined;
+}, {
+    target_branch: string;
+    workspace_root?: string | undefined;
+    save_snapshot?: boolean | undefined;
+    restore_snapshot?: boolean | undefined;
+}>;
+export type BranchPivotInput = z.infer<typeof branchPivotInputSchema>;
+export declare function branchPivot(input: BranchPivotInput): Promise<unknown>;

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

@@ -0,0 +1,85 @@
+// vibe_pm.branch_pivot — Switch branches with optional .vibe/ snapshot save/restore
+import { z } from 'zod';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+export const branchPivotInputSchema = z.object({
+    target_branch: z.string(),
+    save_snapshot: z.boolean().default(false),
+    restore_snapshot: z.boolean().default(false),
+    workspace_root: z.string().optional(),
+});
+export async function branchPivot(input) {
+    const workspaceRoot = input.workspace_root ?? process.cwd();
+    const vibePath = path.join(workspaceRoot, '.vibe');
+    const snapshotDir = path.join(vibePath, 'snapshots');
+    // Get current branch
+    let currentBranch = '';
+    try {
+        currentBranch = execSync('git branch --show-current', { cwd: workspaceRoot, timeout: 5000, encoding: 'utf8' }).trim();
+    }
+    catch {
+        return { error: 'git 브랜치를 확인할 수 없습니다.' };
+    }
+    // Save .vibe/ snapshot before switching
+    if (input.save_snapshot) {
+        try {
+            const snapshotPath = path.join(snapshotDir, `branch_${currentBranch}`);
+            fs.mkdirSync(snapshotPath, { recursive: true });
+            // Copy key state files
+            const stateFiles = ['decision_log.v1.jsonl', 'fsm_state.json', 'config.json', 'dev_log.jsonl'];
+            for (const file of stateFiles) {
+                const src = path.join(vibePath, file);
+                if (fs.existsSync(src)) {
+                    fs.copyFileSync(src, path.join(snapshotPath, file));
+                }
+            }
+            // Save metadata
+            fs.writeFileSync(path.join(snapshotPath, '_meta.json'), JSON.stringify({ branch: currentBranch, saved_at: new Date().toISOString() }));
+        }
+        catch (err) {
+            return { error: `스냅샷 저장 실패: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+    // Switch branch
+    try {
+        execSync(`git checkout ${input.target_branch}`, { cwd: workspaceRoot, timeout: 10000 });
+    }
+    catch (err) {
+        return { error: `브랜치 전환 실패: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    // Restore .vibe/ snapshot for target branch
+    if (input.restore_snapshot) {
+        const snapshotPath = path.join(snapshotDir, `branch_${input.target_branch}`);
+        if (fs.existsSync(snapshotPath)) {
+            try {
+                const files = fs.readdirSync(snapshotPath).filter(f => !f.startsWith('_'));
+                for (const file of files) {
+                    fs.copyFileSync(path.join(snapshotPath, file), path.join(vibePath, file));
+                }
+            }
+            catch {
+                // fail-safe: continue without restore
+            }
+            return {
+                status: 'switched_and_restored',
+                from_branch: currentBranch,
+                to_branch: input.target_branch,
+                snapshot_restored: true,
+            };
+        }
+        return {
+            status: 'switched',
+            from_branch: currentBranch,
+            to_branch: input.target_branch,
+            snapshot_restored: false,
+            warning: `브랜치 '${input.target_branch}'에 대한 스냅샷이 없습니다.`,
+        };
+    }
+    return {
+        status: 'switched',
+        from_branch: currentBranch,
+        to_branch: input.target_branch,
+        snapshot_saved: input.save_snapshot,
+    };
+}

package/build/mcp/tools/vibe_pm/check_dormant.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const checkDormantInputSchema: z.ZodObject<{
+    workspace_root: z.ZodOptional<z.ZodString>;
+    threshold_days: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    threshold_days: number;
+    workspace_root?: string | undefined;
+}, {
+    workspace_root?: string | undefined;
+    threshold_days?: number | undefined;
+}>;
+export type CheckDormantInput = z.infer<typeof checkDormantInputSchema>;
+export declare function checkDormant(input: CheckDormantInput): Promise<unknown>;

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

@@ -0,0 +1,67 @@
+// vibe_pm.check_dormant — Detect dormant/inactive projects
+import { z } from 'zod';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+export const checkDormantInputSchema = z.object({
+    workspace_root: z.string().optional(),
+    threshold_days: z.number().int().min(1).default(7),
+});
+export async function checkDormant(input) {
+    const workspaceRoot = input.workspace_root ?? process.cwd();
+    const thresholdDays = input.threshold_days ?? 7;
+    const now = Date.now();
+    const msPerDay = 86400000;
+    let latestMs = 0;
+    let latestSource = 'none';
+    // Check .vibe/ directory mtime
+    try {
+        const vibePath = path.join(workspaceRoot, '.vibe');
+        const stat = fs.statSync(vibePath);
+        if (stat.mtimeMs > latestMs) {
+            latestMs = stat.mtimeMs;
+            latestSource = '.vibe directory';
+        }
+    }
+    catch { /* no .vibe */ }
+    // Check decision_log.v1.jsonl last line timestamp
+    try {
+        const logPath = path.join(workspaceRoot, '.vibe', 'decision_log.v1.jsonl');
+        const content = fs.readFileSync(logPath, 'utf8');
+        const lines = content.trim().split('\n').filter(Boolean);
+        if (lines.length > 0) {
+            const last = JSON.parse(lines[lines.length - 1]);
+            const ts = new Date(last.timestamp ?? last.ts ?? 0).getTime();
+            if (ts > latestMs) {
+                latestMs = ts;
+                latestSource = 'decision_log';
+            }
+        }
+    }
+    catch { /* no log */ }
+    // Check git log
+    try {
+        const gitDate = execSync('git log -1 --format=%ci', { cwd: workspaceRoot, timeout: 5000, encoding: 'utf8' }).trim();
+        const gitMs = new Date(gitDate).getTime();
+        if (gitMs > latestMs) {
+            latestMs = gitMs;
+            latestSource = 'git commit';
+        }
+    }
+    catch { /* no git */ }
+    const daysInactive = latestMs > 0 ? Math.floor((now - latestMs) / msPerDay) : -1;
+    const isDormant = daysInactive < 0 || daysInactive >= thresholdDays;
+    let suggestedAction = '정상 활동 중';
+    if (isDormant) {
+        suggestedAction = daysInactive >= 30
+            ? '장기 미사용 프로젝트. 아카이브 또는 재활성화를 검토하세요.'
+            : `${daysInactive}일 비활성. vibe_pm.ingress로 컨텍스트를 재스캔하세요.`;
+    }
+    return {
+        is_dormant: isDormant,
+        days_inactive: daysInactive,
+        last_activity_source: latestSource,
+        suggested_action: suggestedAction,
+        threshold_days: thresholdDays,
+    };
+}

package/build/mcp/tools/vibe_pm/check_resources.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const checkResourcesInputSchema: z.ZodObject<{
+    workspace_root: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    workspace_root?: string | undefined;
+}, {
+    workspace_root?: string | undefined;
+}>;
+export type CheckResourcesInput = z.infer<typeof checkResourcesInputSchema>;
+export declare function checkResources(input: CheckResourcesInput): Promise<unknown>;

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

@@ -0,0 +1,30 @@
+// vibe_pm.check_resources — System resource check (CPU, memory, disk)
+import { z } from 'zod';
+import * as os from 'node:os';
+import * as fs from 'node:fs';
+export const checkResourcesInputSchema = z.object({
+    workspace_root: z.string().optional(),
+});
+export async function checkResources(input) {
+    const workspaceRoot = input.workspace_root ?? process.cwd();
+    const GB = 1024 * 1024 * 1024;
+    let diskTotal = 0;
+    let diskFree = 0;
+    try {
+        const stat = fs.statfsSync(workspaceRoot);
+        diskTotal = (stat.blocks * stat.bsize) / GB;
+        diskFree = (stat.bavail * stat.bsize) / GB;
+    }
+    catch {
+        // statfs not available on all platforms
+    }
+    return {
+        cpu_cores: os.cpus().length,
+        cpu_load_1m: os.loadavg()[0],
+        memory_total_gb: +(os.totalmem() / GB).toFixed(2),
+        memory_free_gb: +(os.freemem() / GB).toFixed(2),
+        disk_total_gb: +diskTotal.toFixed(2),
+        disk_free_gb: +diskFree.toFixed(2),
+        workspace_root: workspaceRoot,
+    };
+}

package/build/mcp/tools/vibe_pm/finalize_work.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const finalizeWorkInputSchema: z.ZodObject<{
+    summary: z.ZodOptional<z.ZodString>;
+    commit_type: z.ZodDefault<z.ZodEnum<["feat", "fix", "refactor", "chore", "docs", "test"]>>;
+    confirm: z.ZodDefault<z.ZodBoolean>;
+    workspace_root: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    commit_type: "fix" | "docs" | "test" | "feat" | "refactor" | "chore";
+    confirm: boolean;
+    workspace_root?: string | undefined;
+    summary?: string | undefined;
+}, {
+    workspace_root?: string | undefined;
+    summary?: string | undefined;
+    commit_type?: "fix" | "docs" | "test" | "feat" | "refactor" | "chore" | undefined;
+    confirm?: boolean | undefined;
+}>;
+export type FinalizeWorkInput = z.infer<typeof finalizeWorkInputSchema>;
+export declare function finalizeWork(input: FinalizeWorkInput): Promise<unknown>;

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

@@ -0,0 +1,78 @@
+// vibe_pm.finalize_work — Finalize work session with dev log + commit message
+import { z } from 'zod';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+export const finalizeWorkInputSchema = z.object({
+    summary: z.string().optional(),
+    commit_type: z.enum(['feat', 'fix', 'refactor', 'chore', 'docs', 'test']).default('feat'),
+    confirm: z.boolean().default(false),
+    workspace_root: z.string().optional(),
+});
+export async function finalizeWork(input) {
+    const workspaceRoot = input.workspace_root ?? process.cwd();
+    const commitType = input.commit_type ?? 'feat';
+    // Get changed files from git
+    let changedFiles = [];
+    let diffSummary = '';
+    try {
+        changedFiles = execSync('git diff --name-only HEAD', { cwd: workspaceRoot, timeout: 5000, encoding: 'utf8' })
+            .trim().split('\n').filter(Boolean);
+        const stagedFiles = execSync('git diff --cached --name-only', { cwd: workspaceRoot, timeout: 5000, encoding: 'utf8' })
+            .trim().split('\n').filter(Boolean);
+        changedFiles = [...new Set([...changedFiles, ...stagedFiles])];
+        diffSummary = execSync('git diff --stat HEAD', { cwd: workspaceRoot, timeout: 5000, encoding: 'utf8' }).trim();
+    }
+    catch {
+        // no git or no changes
+    }
+    if (changedFiles.length === 0) {
+        return { status: 'no_changes', message: '변경된 파일이 없습니다.' };
+    }
+    // Infer scope from changed files
+    const dirs = changedFiles.map(f => f.split('/')[0]);
+    const uniqueDirs = [...new Set(dirs)];
+    const scope = uniqueDirs.length === 1 ? uniqueDirs[0] : uniqueDirs.length <= 3 ? uniqueDirs.join(',') : 'multi';
+    const summary = input.summary ?? `${changedFiles.length}개 파일 변경`;
+    const commitMessage = `${commitType}(${scope}): ${summary}`;
+    // Append to dev_log
+    try {
+        const devLogPath = path.join(workspaceRoot, '.vibe', 'dev_log.jsonl');
+        const logEntry = {
+            timestamp: new Date().toISOString(),
+            action: 'finalize_work',
+            summary,
+            changed_files: changedFiles.length,
+            commit_type: commitType,
+            committed: input.confirm,
+        };
+        fs.mkdirSync(path.dirname(devLogPath), { recursive: true });
+        fs.appendFileSync(devLogPath, JSON.stringify(logEntry) + '\n');
+    }
+    catch {
+        // fail-safe
+    }
+    // Execute commit if confirmed
+    if (input.confirm) {
+        try {
+            execSync('git add -A', { cwd: workspaceRoot, timeout: 10000 });
+            execSync(`git commit -m "${commitMessage.replace(/"/g, '\\"')}"`, { cwd: workspaceRoot, timeout: 10000 });
+            return {
+                status: 'committed',
+                commit_message: commitMessage,
+                changed_files: changedFiles,
+                diff_summary: diffSummary,
+            };
+        }
+        catch (err) {
+            return { status: 'commit_failed', error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    return {
+        status: 'dry_run',
+        commit_message: commitMessage,
+        changed_files: changedFiles,
+        diff_summary: diffSummary,
+        hint: 'confirm: true를 전달하면 실제로 커밋합니다.',
+    };
+}

package/build/mcp/tools/vibe_pm/index.d.ts

@@ -603,6 +603,95 @@ export declare function defineVibePmTools(opts?: {
         until?: string | undefined;
         retention_days?: number | undefined;
     }>;
+    skillsInputSchema: import("zod").ZodObject<{
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<["list", "detail"]>>;
+        skill_id: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        mode: "list" | "detail";
+        skill_id?: string | undefined;
+    }, {
+        mode?: "list" | "detail" | undefined;
+        skill_id?: string | undefined;
+    }>;
+    suggestRootsInputSchema: import("zod").ZodObject<{
+        scan_path: import("zod").ZodOptional<import("zod").ZodString>;
+        max_depth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    }, "strip", import("zod").ZodTypeAny, {
+        max_depth: number;
+        scan_path?: string | undefined;
+    }, {
+        scan_path?: string | undefined;
+        max_depth?: number | undefined;
+    }>;
+    checkResourcesInputSchema: import("zod").ZodObject<{
+        workspace_root: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        workspace_root?: string | undefined;
+    }, {
+        workspace_root?: string | undefined;
+    }>;
+    checkDormantInputSchema: import("zod").ZodObject<{
+        workspace_root: import("zod").ZodOptional<import("zod").ZodString>;
+        threshold_days: import("zod").ZodDefault<import("zod").ZodNumber>;
+    }, "strip", import("zod").ZodTypeAny, {
+        threshold_days: number;
+        workspace_root?: string | undefined;
+    }, {
+        workspace_root?: string | undefined;
+        threshold_days?: number | undefined;
+    }>;
+    repairPlanInputSchema: import("zod").ZodObject<{
+        run_id: import("zod").ZodOptional<import("zod").ZodString>;
+        workspace_root: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        run_id?: string | undefined;
+        workspace_root?: string | undefined;
+    }, {
+        run_id?: string | undefined;
+        workspace_root?: string | undefined;
+    }>;
+    finalizeWorkInputSchema: import("zod").ZodObject<{
+        summary: import("zod").ZodOptional<import("zod").ZodString>;
+        commit_type: import("zod").ZodDefault<import("zod").ZodEnum<["feat", "fix", "refactor", "chore", "docs", "test"]>>;
+        confirm: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        workspace_root: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        commit_type: "fix" | "docs" | "test" | "feat" | "refactor" | "chore";
+        confirm: boolean;
+        workspace_root?: string | undefined;
+        summary?: string | undefined;
+    }, {
+        workspace_root?: string | undefined;
+        summary?: string | undefined;
+        commit_type?: "fix" | "docs" | "test" | "feat" | "refactor" | "chore" | undefined;
+        confirm?: boolean | undefined;
+    }>;
+    undoLastTaskInputSchema: import("zod").ZodObject<{
+        confirm: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        workspace_root: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        confirm: boolean;
+        workspace_root?: string | undefined;
+    }, {
+        workspace_root?: string | undefined;
+        confirm?: boolean | undefined;
+    }>;
+    branchPivotInputSchema: import("zod").ZodObject<{
+        target_branch: import("zod").ZodString;
+        save_snapshot: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        restore_snapshot: import("zod").ZodDefault<import("zod").ZodBoolean>;
+        workspace_root: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        target_branch: string;
+        save_snapshot: boolean;
+        restore_snapshot: boolean;
+        workspace_root?: string | undefined;
+    }, {
+        target_branch: string;
+        workspace_root?: string | undefined;
+        save_snapshot?: boolean | undefined;
+        restore_snapshot?: boolean | undefined;
+    }>;
     vibePmBriefing: (input: {
         mode: "mvp_fast" | "balanced" | "quality_first";
         project_brief: string;
@@ -813,6 +902,41 @@ export declare function defineVibePmTools(opts?: {
         until?: string | undefined;
         retention_days?: number | undefined;
     }, extra?: unknown) => Promise<import("./tool_handler_factory.js").CallToolResult>;
+    vibePmSkills: (input: {
+        mode: "list" | "detail";
+        skill_id?: string | undefined;
+    }, extra?: unknown) => Promise<import("./tool_handler_factory.js").CallToolResult>;
+    vibePmSuggestRoots: (input: {
+        max_depth: number;
+        scan_path?: string | undefined;
+    }, extra?: unknown) => Promise<import("./tool_handler_factory.js").CallToolResult>;
+    vibePmCheckResources: (input: {
+        workspace_root?: string | undefined;
+    }, extra?: unknown) => Promise<import("./tool_handler_factory.js").CallToolResult>;
+    vibePmCheckDormant: (input: {
+        threshold_days: number;
+        workspace_root?: string | undefined;
+    }, extra?: unknown) => Promise<import("./tool_handler_factory.js").CallToolResult>;
+    vibePmRepairPlan: (input: {
+        run_id?: string | undefined;
+        workspace_root?: string | undefined;
+    }, extra?: unknown) => Promise<import("./tool_handler_factory.js").CallToolResult>;
+    vibePmFinalizeWork: (input: {
+        commit_type: "fix" | "docs" | "test" | "feat" | "refactor" | "chore";
+        confirm: boolean;
+        workspace_root?: string | undefined;
+        summary?: string | undefined;
+    }, extra?: unknown) => Promise<import("./tool_handler_factory.js").CallToolResult>;
+    vibePmUndoLastTask: (input: {
+        confirm: boolean;
+        workspace_root?: string | undefined;
+    }, extra?: unknown) => Promise<import("./tool_handler_factory.js").CallToolResult>;
+    vibePmBranchPivot: (input: {
+        target_branch: string;
+        save_snapshot: boolean;
+        restore_snapshot: boolean;
+        workspace_root?: string | undefined;
+    }, extra?: unknown) => Promise<import("./tool_handler_factory.js").CallToolResult>;
     ensureDocsStructure: typeof ensureDocsStructure;
 };
 export { VIBE_PM_TOOL_DESCRIPTIONS } from './tool_descriptions.js';

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

@@ -39,6 +39,14 @@ import { dashboard, dashboardInputSchema, } from './dashboard.js';
 import { blockSearch, blockSearchInputSchema, } from './block_search.js';
 import { blockEvents, blockEventsInputSchema, } from './block_events.js';
 import { blockSnapshot, blockSnapshotInputSchema, } from './block_snapshot.js';
+import { skills, skillsInputSchema } from './skills_tool.js';
+import { suggestRoots, suggestRootsInputSchema } from './suggest_roots.js';
+import { checkResources, checkResourcesInputSchema } from './check_resources.js';
+import { checkDormant, checkDormantInputSchema } from './check_dormant.js';
+import { repairPlan, repairPlanInputSchema } from './repair_plan.js';
+import { finalizeWork, finalizeWorkInputSchema } from './finalize_work.js';
+import { undoLastTask, undoLastTaskInputSchema } from './undo_last_task.js';
+import { branchPivot, branchPivotInputSchema } from './branch_pivot.js';
 // Extracted modules
 import { createToolHandler, setKernelDepsForTools, resolveRunDir, toolResult, toStructuredContent, formatStatusSummary, readNestedString, getProjectOrRunId, fsmTransition, } from './tool_handler_factory.js';
 // ============================================================
@@ -375,6 +383,78 @@ const vibePmBlockSnapshot = createToolHandler({
     error: { code: 'block_snapshot_failed', recovery: 'mode 또는 snapshot_id를 확인하세요.' },
 });
 // ============================================================
+// Skills Tool
+// ============================================================
+const vibePmSkills = createToolHandler({
+    toolName: 'vibe_pm.skills',
+    inputSchema: skillsInputSchema,
+    handler: input => skills(input),
+    error: { code: 'skills_failed', recovery: 'mode를 확인하세요 (list/detail).' },
+});
+// ============================================================
+// Suggest Roots Tool
+// ============================================================
+const vibePmSuggestRoots = createToolHandler({
+    toolName: 'vibe_pm.suggest_roots',
+    inputSchema: suggestRootsInputSchema,
+    handler: input => suggestRoots(input),
+    error: { code: 'suggest_roots_failed', recovery: 'scan_path를 확인하세요.' },
+});
+// ============================================================
+// Check Resources Tool
+// ============================================================
+const vibePmCheckResources = createToolHandler({
+    toolName: 'vibe_pm.check_resources',
+    inputSchema: checkResourcesInputSchema,
+    handler: input => checkResources(input),
+    error: { code: 'check_resources_failed' },
+});
+// ============================================================
+// Check Dormant Tool
+// ============================================================
+const vibePmCheckDormant = createToolHandler({
+    toolName: 'vibe_pm.check_dormant',
+    inputSchema: checkDormantInputSchema,
+    handler: input => checkDormant(input),
+    error: { code: 'check_dormant_failed', recovery: 'workspace_root를 확인하세요.' },
+});
+// ============================================================
+// Repair Plan Tool
+// ============================================================
+const vibePmRepairPlan = createToolHandler({
+    toolName: 'vibe_pm.repair_plan',
+    inputSchema: repairPlanInputSchema,
+    handler: input => repairPlan(input),
+    error: { code: 'repair_plan_failed', recovery: 'inspect_code를 먼저 실행하세요.' },
+});
+// ============================================================
+// Finalize Work Tool
+// ============================================================
+const vibePmFinalizeWork = createToolHandler({
+    toolName: 'vibe_pm.finalize_work',
+    inputSchema: finalizeWorkInputSchema,
+    handler: input => finalizeWork(input),
+    error: { code: 'finalize_work_failed', recovery: 'workspace_root를 확인하세요.' },
+});
+// ============================================================
+// Undo Last Task Tool
+// ============================================================
+const vibePmUndoLastTask = createToolHandler({
+    toolName: 'vibe_pm.undo_last_task',
+    inputSchema: undoLastTaskInputSchema,
+    handler: input => undoLastTask(input),
+    error: { code: 'undo_last_task_failed', recovery: 'GO 판정 기록이 있는지 확인하세요.' },
+});
+// ============================================================
+// Branch Pivot Tool
+// ============================================================
+const vibePmBranchPivot = createToolHandler({
+    toolName: 'vibe_pm.branch_pivot',
+    inputSchema: branchPivotInputSchema,
+    handler: input => branchPivot(input),
+    error: { code: 'branch_pivot_failed', recovery: 'target_branch를 확인하세요.' },
+});
+// ============================================================
 // Export
 // ============================================================
 export function defineVibePmTools(opts) {
@@ -411,6 +491,14 @@ export function defineVibePmTools(opts) {
         blockEventsInputSchema,
         blockSnapshotInputSchema,
         decisionHistoryInputSchema: DecisionHistoryInputSchema,
+        skillsInputSchema,
+        suggestRootsInputSchema,
+        checkResourcesInputSchema,
+        checkDormantInputSchema,
+        repairPlanInputSchema,
+        finalizeWorkInputSchema,
+        undoLastTaskInputSchema,
+        branchPivotInputSchema,
         // Tool handlers
         vibePmBriefing,
         vibePmGetDecision,
@@ -440,6 +528,14 @@ export function defineVibePmTools(opts) {
         vibePmBlockEvents,
         vibePmBlockSnapshot,
         vibePmDecisionHistory,
+        vibePmSkills,
+        vibePmSuggestRoots,
+        vibePmCheckResources,
+        vibePmCheckDormant,
+        vibePmRepairPlan,
+        vibePmFinalizeWork,
+        vibePmUndoLastTask,
+        vibePmBranchPivot,
         // Docs structure helper
         ensureDocsStructure,
     };

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

@@ -16,7 +16,7 @@ import { appendDecisionLogEvent, readCurrentWorkOrderId, readCurrentDecisionId,
 import { readLastCheckSync } from '../bitnet-cache.js';
 import { computePhaseAndMissing } from '../phase.js';
 import { computeAndPersistStage } from '../stage-computer.js';
-import { attachNudge } from '../nudge.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';
@@ -288,7 +288,16 @@ export async function inspectCode(input, progress, log) {
     }
     // Determine review result from signal_level
     const signalLevel = oneLoopResult.signal_level ?? oneLoopResult.signal ?? 'LEVEL_2';
-    const { result: reviewResult, verdict } = signalToReview(signalLevel);
+    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, {

package/build/mcp/tools/vibe_pm/repair_plan.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const repairPlanInputSchema: z.ZodObject<{
+    run_id: z.ZodOptional<z.ZodString>;
+    workspace_root: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    run_id?: string | undefined;
+    workspace_root?: string | undefined;
+}, {
+    run_id?: string | undefined;
+    workspace_root?: string | undefined;
+}>;
+export type RepairPlanInput = z.infer<typeof repairPlanInputSchema>;
+export declare function repairPlan(input: RepairPlanInput): Promise<unknown>;

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

@@ -0,0 +1,67 @@
+// vibe_pm.repair_plan — Generate structured repair plan from last inspect_code result
+import { z } from 'zod';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { generateRepairPrompt, formatIssueType } from './pm_language.js';
+export const repairPlanInputSchema = z.object({
+    run_id: z.string().optional(),
+    workspace_root: z.string().optional(),
+});
+export async function repairPlan(input) {
+    const workspaceRoot = input.workspace_root ?? process.cwd();
+    // Find the most recent inspect result from decision_log
+    const logPath = path.join(workspaceRoot, '.vibe', 'decision_log.v1.jsonl');
+    let lastInspect = null;
+    try {
+        const content = fs.readFileSync(logPath, 'utf8');
+        const lines = content.trim().split('\n').filter(Boolean);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const entry = JSON.parse(lines[i]);
+            if (entry.event_type === 'inspect_verdict') {
+                if (!input.run_id || entry.run_id === input.run_id) {
+                    lastInspect = entry;
+                    break;
+                }
+            }
+        }
+    }
+    catch {
+        return { error: 'decision_log를 읽을 수 없습니다. inspect_code를 먼저 실행하세요.' };
+    }
+    if (!lastInspect) {
+        return { error: 'inspect_verdict 기록이 없습니다. inspect_code를 먼저 실행하세요.' };
+    }
+    const verdict = lastInspect.verdict;
+    if (verdict === 'GO') {
+        return { problem_summary: '이슈 없음', repair_steps: [], repair_prompt: null, next_tool: 'vibe_pm.status' };
+    }
+    const issuesSummary = lastInspect.issues_summary ?? '';
+    const bottleneck = lastInspect.bottleneck ?? 'unknown';
+    const runId = lastInspect.run_id ?? '';
+    // Parse issues from summary
+    const issueParts = issuesSummary.split(';').map(s => s.trim()).filter(Boolean);
+    const repairSteps = issueParts.map((part, i) => {
+        const [type, ...rest] = part.split(':');
+        return {
+            step: i + 1,
+            issue_type: type?.trim() ?? 'unknown',
+            description: rest.join(':').trim() || part,
+            action: `${formatIssueType((type?.trim() ?? 'unknown')).name} 수정`,
+        };
+    });
+    const repairData = {
+        projectName: runId,
+        mode: 'balanced',
+        problem: issuesSummary || `${bottleneck} 관련 문제`,
+        cause: `주요 병목: ${bottleneck}`,
+        fixDirection: repairSteps.map(s => s.action),
+        verifyCriteria: ['빌드 성공', '테스트 통과', '범위 내 변경'],
+    };
+    return {
+        problem_summary: `${verdict} — ${bottleneck} (${issueParts.length}건)`,
+        repair_steps: repairSteps,
+        repair_prompt: generateRepairPrompt(repairData),
+        next_tool: verdict === 'FIX' ? 'vibe_pm.inspect_code' : 'vibe_pm.get_decision',
+        run_id: runId,
+    };
+}

package/build/mcp/tools/vibe_pm/skills_tool.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const skillsInputSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<["list", "detail"]>>;
+    skill_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    mode: "list" | "detail";
+    skill_id?: string | undefined;
+}, {
+    mode?: "list" | "detail" | undefined;
+    skill_id?: string | undefined;
+}>;
+export type SkillsInput = z.infer<typeof skillsInputSchema>;
+export declare function skills(input: SkillsInput): Promise<unknown>;

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

@@ -0,0 +1,57 @@
+// vibe_pm.skills — Skill pack listing and detail
+import { z } from 'zod';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { listActivatedSkills } from '../../bootstrap/skills-installer.js';
+export const skillsInputSchema = z.object({
+    mode: z.enum(['list', 'detail']).default('list'),
+    skill_id: z.string().optional(),
+});
+export async function skills(input) {
+    const skillsDir = path.resolve(__dirname, '../../../../skills');
+    const skillpackPath = path.join(skillsDir, 'skillpack.json');
+    let entries = [];
+    try {
+        const raw = fs.readFileSync(skillpackPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        entries = Array.isArray(parsed.skills) ? parsed.skills : [];
+    }
+    catch {
+        return { skills: [], error: 'skillpack.json을 읽을 수 없습니다.' };
+    }
+    // Get activation state
+    let activated = [];
+    try {
+        activated = await listActivatedSkills();
+    }
+    catch {
+        // fail-safe
+    }
+    const activatedSet = new Set(activated);
+    if (input.mode === 'detail' && input.skill_id) {
+        const skill = entries.find(s => s.id === input.skill_id);
+        if (!skill) {
+            return { error: `스킬 '${input.skill_id}'을(를) 찾을 수 없습니다.` };
+        }
+        return {
+            skill: {
+                id: skill.id,
+                name: skill.name,
+                description: skill.description ?? '',
+                required_tools: skill.required_tools ?? [],
+                version: skill.version ?? '1.0.0',
+                activated: activatedSet.has(skill.id),
+            },
+        };
+    }
+    return {
+        skills: entries.map(s => ({
+            id: s.id,
+            name: s.name,
+            description: s.description ?? '',
+            activated: activatedSet.has(s.id),
+        })),
+        total: entries.length,
+        activated_count: entries.filter(s => activatedSet.has(s.id)).length,
+    };
+}

package/build/mcp/tools/vibe_pm/suggest_roots.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export declare const suggestRootsInputSchema: z.ZodObject<{
+    scan_path: z.ZodOptional<z.ZodString>;
+    max_depth: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    max_depth: number;
+    scan_path?: string | undefined;
+}, {
+    scan_path?: string | undefined;
+    max_depth?: number | undefined;
+}>;
+export type SuggestRootsInput = z.infer<typeof suggestRootsInputSchema>;
+interface Root {
+    path: string;
+    type: string;
+    confidence: number;
+}
+export declare function suggestRoots(input: SuggestRootsInput): Promise<{
+    roots: Root[];
+}>;
+export {};

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

@@ -0,0 +1,56 @@
+// vibe_pm.suggest_roots — Discover project roots by marker files
+import { z } from 'zod';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export const suggestRootsInputSchema = z.object({
+    scan_path: z.string().optional(),
+    max_depth: z.number().int().min(1).max(10).default(5),
+});
+const MARKERS = {
+    'package.json': 'node',
+    'Cargo.toml': 'rust',
+    'go.mod': 'go',
+    'pyproject.toml': 'python',
+    'pom.xml': 'java',
+    'build.gradle': 'java',
+    'CMakeLists.txt': 'cmake',
+};
+export async function suggestRoots(input) {
+    const scanPath = input.scan_path ?? process.cwd();
+    const maxDepth = input.max_depth ?? 5;
+    const roots = [];
+    function walk(dir, depth) {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const markerType = MARKERS[entry.name];
+            if (markerType) {
+                roots.push({
+                    path: dir,
+                    type: markerType,
+                    confidence: Math.max(0.1, 1 - depth * 0.15),
+                });
+                return; // don't recurse into found root's children for same marker
+            }
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'target')
+                continue;
+            walk(path.join(dir, entry.name), depth + 1);
+        }
+    }
+    walk(scanPath, 0);
+    roots.sort((a, b) => b.confidence - a.confidence);
+    return { roots };
+}

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

@@ -28,4 +28,12 @@ export const VIBE_PM_TOOL_DESCRIPTIONS = {
     'vibe_pm.block_search': '블록 검색(FTS). mode: search(전문 검색), chain(체인 내 블록), recent(최근 블록). block_types로 필터링 가능.',
     'vibe_pm.block_events': '블록 이벤트 조회/폴링. mode: recent(최근 이벤트), poll(cursor 기반 폴링). kinds로 이벤트 종류 필터링.',
     'vibe_pm.block_snapshot': '블록 스토어 스냅샷. mode: create(생성), restore(복원), list(목록), get(상세), delete(삭제).',
+    'vibe_pm.skills': '스킬팩 조회. mode: list(전체 목록), detail(특정 스킬 상세). 활성화 상태 포함.',
+    'vibe_pm.suggest_roots': '프로젝트 루트 자동 탐색. package.json/Cargo.toml 등 마커 파일 기반 추천.',
+    'vibe_pm.check_resources': '시스템 리소스 점검. CPU, 메모리, 디스크 사용량 확인.',
+    'vibe_pm.check_dormant': '프로젝트 비활성 감지. .vibe/git 활동 기반 휴면 상태 판단.',
+    'vibe_pm.repair_plan': '복구 계획 생성. 최근 inspect_code 결과에서 구조화된 수정 프롬프트 생성.',
+    'vibe_pm.finalize_work': '작업 마무리. dev_log 기록 + conventional commit 메시지 생성. confirm: true로 실제 커밋.',
+    'vibe_pm.undo_last_task': '마지막 작업 되돌리기. GO 판정 기록의 관련 커밋을 git revert. confirm: true로 실행.',
+    'vibe_pm.branch_pivot': '브랜치 전환. .vibe/ 상태 스냅샷 저장/복원 지원.',
 };

package/build/mcp/tools/vibe_pm/undo_last_task.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+export declare const undoLastTaskInputSchema: z.ZodObject<{
+    confirm: z.ZodDefault<z.ZodBoolean>;
+    workspace_root: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    confirm: boolean;
+    workspace_root?: string | undefined;
+}, {
+    workspace_root?: string | undefined;
+    confirm?: boolean | undefined;
+}>;
+export type UndoLastTaskInput = z.infer<typeof undoLastTaskInputSchema>;
+export declare function undoLastTask(input: UndoLastTaskInput): Promise<unknown>;

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

@@ -0,0 +1,87 @@
+// vibe_pm.undo_last_task — Revert the most recent task's git commits
+import { z } from 'zod';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+export const undoLastTaskInputSchema = z.object({
+    confirm: z.boolean().default(false),
+    workspace_root: z.string().optional(),
+});
+export async function undoLastTask(input) {
+    const workspaceRoot = input.workspace_root ?? process.cwd();
+    // Find last task from decision_log
+    const logPath = path.join(workspaceRoot, '.vibe', 'decision_log.v1.jsonl');
+    let lastTask = null;
+    try {
+        const content = fs.readFileSync(logPath, 'utf8');
+        const lines = content.trim().split('\n').filter(Boolean);
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const entry = JSON.parse(lines[i]);
+            if (entry.event_type === 'inspect_verdict' && entry.verdict === 'GO') {
+                lastTask = entry;
+                break;
+            }
+        }
+    }
+    catch {
+        return { error: 'decision_log를 읽을 수 없습니다.' };
+    }
+    if (!lastTask) {
+        return { error: 'GO 판정 기록이 없습니다. 되돌릴 작업이 없습니다.' };
+    }
+    // Find commits associated with this run_id (between this GO and previous verdict)
+    const runId = lastTask.run_id;
+    const timestamp = lastTask.timestamp;
+    let commitsToRevert = [];
+    try {
+        const since = new Date(timestamp);
+        since.setMinutes(since.getMinutes() - 30); // look back 30 mins before GO
+        const commits = execSync(`git log --since="${since.toISOString()}" --until="${timestamp}" --format=%H`, { cwd: workspaceRoot, timeout: 5000, encoding: 'utf8' }).trim().split('\n').filter(Boolean);
+        commitsToRevert = commits;
+    }
+    catch {
+        // fallback: revert HEAD
+        try {
+            const head = execSync('git rev-parse HEAD', { cwd: workspaceRoot, timeout: 5000, encoding: 'utf8' }).trim();
+            commitsToRevert = [head];
+        }
+        catch {
+            return { error: 'git 커밋을 찾을 수 없습니다.' };
+        }
+    }
+    if (commitsToRevert.length === 0) {
+        return { error: '되돌릴 커밋이 없습니다.', run_id: runId };
+    }
+    // Preview diff
+    let previewDiff = '';
+    try {
+        const oldest = commitsToRevert[commitsToRevert.length - 1];
+        previewDiff = execSync(`git diff ${oldest}^..HEAD --stat`, { cwd: workspaceRoot, timeout: 5000, encoding: 'utf8' }).trim();
+    }
+    catch {
+        previewDiff = '(diff 미리보기 실패)';
+    }
+    if (input.confirm) {
+        try {
+            for (const hash of commitsToRevert) {
+                execSync(`git revert --no-commit ${hash}`, { cwd: workspaceRoot, timeout: 10000 });
+            }
+            execSync(`git commit -m "revert: undo task ${runId}"`, { cwd: workspaceRoot, timeout: 10000 });
+            return {
+                status: 'reverted',
+                commits_reverted: commitsToRevert,
+                run_id: runId,
+            };
+        }
+        catch (err) {
+            return { status: 'revert_failed', error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    return {
+        status: 'dry_run',
+        commits_to_revert: commitsToRevert,
+        preview_diff: previewDiff,
+        run_id: runId,
+        hint: 'confirm: true를 전달하면 실제로 되돌립니다.',
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibecodetown/mcp-server",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Vibe PM - AI Project Manager MCP Server for non-technical founders",
   "type": "module",
   "main": "./build/mcp/index.js",