@vibecodetown/mcp-server 1.3.1

package/build/mcp/tools/vibe_pm/facts/collector.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Facts Collector
+ *
+ * Collect facts from SSOT files without tool re-calls.
+ */
+import type { FactsV1, FactsCollectOptions, ScoutFacts } from "./types.js";
+/**
+ * Collect facts from SSOT files
+ *
+ * @param basePath - Workspace root path
+ * @param runId - Run ID to collect facts for
+ * @param options - Collection options
+ * @returns Collected facts
+ */
+export declare function collectFacts(basePath: string, runId: string, options?: FactsCollectOptions): Promise<FactsV1>;
+/**
+ * Collect facts synchronously (uses sync file reads where possible)
+ */
+export declare function collectFactsSync(basePath: string, runId: string, options?: FactsCollectOptions): FactsV1;
+/**
+ * Get a summary string for facts
+ */
+export declare function getFactsSummary(facts: FactsV1): string;
+/**
+ * Check if facts indicate any blocking issues
+ */
+export declare function hasBlockingIssues(facts: FactsV1): boolean;
+/**
+ * Check if facts indicate pending work
+ */
+export declare function hasPendingWork(facts: FactsV1): boolean;
+/**
+ * Collect scout facts from musu cache files
+ */
+export declare function collectScoutFacts(basePath: string): ScoutFacts | undefined;

package/build/mcp/tools/vibe_pm/facts/collector.js

@@ -0,0 +1,285 @@
+/**
+ * Facts Collector
+ *
+ * Collect facts from SSOT files without tool re-calls.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { loadAskQueueItems } from "../ask-queue/index.js";
+import { readVerdict } from "../verdict/index.js";
+import { readScorecard } from "../scorecard/index.js";
+import { isMusuAvailable } from "../../../runtime/index.js";
+import { resolvePmRunDirForRead } from "../../../paths.js";
+import { createEmptyFacts } from "./types.js";
+/**
+ * Collect facts from SSOT files
+ *
+ * @param basePath - Workspace root path
+ * @param runId - Run ID to collect facts for
+ * @param options - Collection options
+ * @returns Collected facts
+ */
+export async function collectFacts(basePath, runId, options = {}) {
+    const facts = createEmptyFacts();
+    const sources = [];
+    // 1. Ask Queue (no tool re-call)
+    if (!options.skipAskQueue) {
+        const askQueue = loadAskQueueItems(basePath, runId);
+        if (askQueue) {
+            facts.ask_queue_count = askQueue.length;
+            facts.has_pending_decisions = askQueue.length > 0;
+            sources.push("ask_queue");
+        }
+    }
+    // 2. Verdict file
+    if (!options.skipVerdict) {
+        const verdict = await readVerdict(basePath, runId);
+        if (verdict) {
+            facts.mapping_verdict = verdict.mapping.verdict;
+            facts.spec_map_present = verdict.mapping.spec_map_present;
+            facts.change_map_present = verdict.mapping.change_map_present;
+            facts.engine_last_error = verdict.engine?.last_error;
+            // If inspection verdict exists, use it
+            if (verdict.inspection) {
+                facts.last_verdict = verdict.inspection.verdict;
+            }
+            sources.push("verdict");
+        }
+    }
+    // 3. Scorecard
+    if (!options.skipScorecard) {
+        const scorecard = await readScorecard(basePath, runId);
+        if (scorecard) {
+            // Get latest entry
+            const lastEntry = scorecard.entries.at(-1);
+            if (lastEntry && !facts.last_verdict) {
+                facts.last_verdict = lastEntry.verdict;
+            }
+            // Get top bottleneck
+            if (scorecard.summary.top_bottlenecks.length > 0) {
+                facts.top_bottleneck = scorecard.summary.top_bottlenecks[0].code;
+            }
+            // Get summary counts
+            facts.total_verdicts = scorecard.summary.total_verdicts;
+            facts.fix_count = scorecard.summary.fix_count;
+            sources.push("scorecard");
+        }
+    }
+    // 4. Scout facts (musu analysis) - only add if there's meaningful data
+    if (!options.skipScout) {
+        const scoutFacts = collectScoutFacts(basePath);
+        // Only add scout to sources if there's actual cached data (not just availability check)
+        if (scoutFacts && (scoutFacts.sanity || scoutFacts.deps || scoutFacts.last_run_at)) {
+            facts.scout = scoutFacts;
+            sources.push("scout");
+        }
+    }
+    // 5. Preprocess facts (airlock/router/chunking)
+    try {
+        const runDir = resolvePmRunDirForRead(basePath, runId);
+        const airlockDir = path.join(runDir, "airlock");
+        const chunksDir = path.join(runDir, "chunks");
+        const reportPath = path.join(airlockDir, "redaction_report.json");
+        const routerDecisionPath = path.join(airlockDir, "router_decision.json");
+        const chunkManifestPath = path.join(chunksDir, "chunk_manifest.v1.json");
+        const report = readJsonFile(reportPath);
+        if (report && typeof report.redacted_count === "number") {
+            facts.preprocess_redaction_detected = report.redacted_count > 0;
+        }
+        const decision = readJsonFile(routerDecisionPath);
+        if (decision?.route) {
+            facts.preprocess_router_route = decision.route;
+        }
+        const manifest = readJsonFile(chunkManifestPath);
+        if (manifest?.chunks && Array.isArray(manifest.chunks)) {
+            facts.preprocess_chunk_count = manifest.chunks.length;
+        }
+        if (facts.preprocess_redaction_detected ||
+            facts.preprocess_router_route !== undefined ||
+            facts.preprocess_chunk_count !== undefined) {
+            sources.push("preprocess");
+        }
+    }
+    catch {
+        // best-effort
+    }
+    facts.sources = sources;
+    return facts;
+}
+/**
+ * Collect facts synchronously (uses sync file reads where possible)
+ */
+export function collectFactsSync(basePath, runId, options = {}) {
+    const facts = createEmptyFacts();
+    const sources = [];
+    // 1. Ask Queue (sync)
+    if (!options.skipAskQueue) {
+        const askQueue = loadAskQueueItems(basePath, runId);
+        if (askQueue) {
+            facts.ask_queue_count = askQueue.length;
+            facts.has_pending_decisions = askQueue.length > 0;
+            sources.push("ask_queue");
+        }
+    }
+    // Note: verdict and scorecard use async fs, so can't be fully sync
+    // This function is mainly for ask_queue which uses sync fs
+    facts.sources = sources;
+    return facts;
+}
+/**
+ * Get a summary string for facts
+ */
+export function getFactsSummary(facts) {
+    const parts = [];
+    if (facts.has_pending_decisions) {
+        parts.push(`${facts.ask_queue_count}건 결재 대기`);
+    }
+    if (facts.mapping_verdict !== "UNKNOWN") {
+        parts.push(`매핑: ${facts.mapping_verdict}`);
+    }
+    if (facts.last_verdict) {
+        parts.push(`최근 판정: ${facts.last_verdict}`);
+    }
+    if (facts.top_bottleneck) {
+        parts.push(`주요 병목: ${facts.top_bottleneck}`);
+    }
+    if (facts.preprocess_redaction_detected) {
+        parts.push("민감정보 마스킹 감지");
+    }
+    if (facts.preprocess_router_route) {
+        const label = facts.preprocess_router_route === "local_only"
+            ? "로컬"
+            : facts.preprocess_router_route === "local_then_cloud"
+                ? "로컬→클라우드"
+                : "클라우드";
+        parts.push(`라우팅: ${label}`);
+    }
+    if (typeof facts.preprocess_chunk_count === "number") {
+        parts.push(`청크: ${facts.preprocess_chunk_count}개`);
+    }
+    return parts.length > 0 ? parts.join(", ") : "데이터 없음";
+}
+/**
+ * Check if facts indicate any blocking issues
+ */
+export function hasBlockingIssues(facts) {
+    return (facts.mapping_verdict === "BLOCK" ||
+        facts.last_verdict === "BLOCK" ||
+        facts.last_verdict === "ERROR");
+}
+/**
+ * Check if facts indicate pending work
+ */
+export function hasPendingWork(facts) {
+    return (facts.has_pending_decisions ||
+        facts.mapping_verdict === "INFERRED" ||
+        facts.last_verdict === "FIX");
+}
+// ============================================================
+// Scout Facts Collection
+// ============================================================
+/**
+ * Collect scout facts from musu cache files
+ */
+export function collectScoutFacts(basePath) {
+    const cachePath = path.join(basePath, ".vibe", "cache", "bitnet");
+    // Check musu availability
+    const available = isMusuAvailable();
+    // Load sanity check cache
+    const sanityPath = path.join(cachePath, "sanity_warnings.v1.jsonl");
+    let sanity;
+    if (fs.existsSync(sanityPath)) {
+        try {
+            const content = fs.readFileSync(sanityPath, "utf-8").trim();
+            if (content) {
+                const lines = content.split("\n");
+                const lastLine = lines[lines.length - 1];
+                const data = JSON.parse(lastLine);
+                sanity = {
+                    pass: data.pass ?? true,
+                    errors: data.errors ?? 0,
+                    warnings: data.warnings ?? 0,
+                };
+            }
+        }
+        catch {
+            // Invalid cache
+        }
+    }
+    // Load dependency scan cache
+    const depsPath = path.join(cachePath, "dependency_impact.v1.json");
+    let deps;
+    if (fs.existsSync(depsPath)) {
+        try {
+            const data = JSON.parse(fs.readFileSync(depsPath, "utf-8"));
+            deps = {
+                blast_radius: data.overall_risk?.level ?? null,
+                affected_modules: data.affected_modules ?? [],
+            };
+        }
+        catch {
+            // Invalid cache
+        }
+    }
+    // Calculate risk level
+    const risk = calculateScoutRiskLevel(sanity, deps);
+    // Get last run timestamp
+    const runsPath = path.join(cachePath, "scout_runs.v1.jsonl");
+    let last_run_at = null;
+    if (fs.existsSync(runsPath)) {
+        try {
+            const content = fs.readFileSync(runsPath, "utf-8").trim();
+            if (content) {
+                const lines = content.split("\n");
+                const lastLine = lines[lines.length - 1];
+                last_run_at = JSON.parse(lastLine).timestamp ?? null;
+            }
+        }
+        catch {
+            // Invalid
+        }
+    }
+    return {
+        available,
+        last_run_at,
+        cooldown_until: null, // TODO: implement cooldown tracking
+        sanity,
+        deps,
+        risk,
+    };
+}
+function readJsonFile(absPath) {
+    try {
+        if (!fs.existsSync(absPath))
+            return undefined;
+        const raw = fs.readFileSync(absPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Calculate risk level from scout results
+ */
+function calculateScoutRiskLevel(sanity, deps) {
+    const tags = [];
+    let level = "none";
+    if (sanity?.errors && sanity.errors > 0) {
+        tags.push("sanity_errors");
+        level = "high";
+    }
+    else if (sanity?.warnings && sanity.warnings > 3) {
+        tags.push("sanity_warnings");
+        level = level === "none" ? "medium" : level;
+    }
+    if (deps?.blast_radius === "high") {
+        tags.push("high_blast_radius");
+        level = "high";
+    }
+    else if (deps?.blast_radius === "medium") {
+        tags.push("medium_blast_radius");
+        level = level === "none" ? "medium" : level;
+    }
+    return { level, tags };
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Facts Module
+ *
+ * Collect facts from SSOT files for status and navigation.
+ */
+export type { FactVerdict, FactMappingVerdict, FactSource, FactsV1, PartialFacts, FactsCollectOptions, ScoutFacts, } from "./types.js";
+export { createEmptyFacts, mergeFacts, isFactsV1, } from "./types.js";
+export { collectFacts, collectFactsSync, getFactsSummary, hasBlockingIssues, hasPendingWork, collectScoutFacts, } from "./collector.js";

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

@@ -0,0 +1,8 @@
+/**
+ * Facts Module
+ *
+ * Collect facts from SSOT files for status and navigation.
+ */
+export { createEmptyFacts, mergeFacts, isFactsV1, } from "./types.js";
+// Collector
+export { collectFacts, collectFactsSync, getFactsSummary, hasBlockingIssues, hasPendingWork, collectScoutFacts, } from "./collector.js";

package/build/mcp/tools/vibe_pm/facts/types.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Facts Types
+ *
+ * Types for facts collection from SSOT files.
+ */
+import type { NormalizedEngineError } from "../engine-errors/types.js";
+/**
+ * Verdict type for facts
+ */
+export type FactVerdict = "GO" | "FIX" | "BLOCK" | "ERROR" | "UNKNOWN";
+/**
+ * Mapping verdict for facts
+ */
+export type FactMappingVerdict = "GO" | "BLOCK" | "INFERRED" | "UNKNOWN";
+/**
+ * Source of fact data
+ */
+export type FactSource = "ask_queue" | "verdict" | "scorecard" | "state" | "scout" | "preprocess";
+/**
+ * Scout facts from musu analysis
+ */
+export interface ScoutFacts {
+    /** Scout/musu engine available */
+    available: boolean;
+    /** Last run timestamp */
+    last_run_at: string | null;
+    /** Cooldown end timestamp */
+    cooldown_until: string | null;
+    /** Sanity check results */
+    sanity?: {
+        pass: boolean;
+        errors: number;
+        warnings: number;
+    };
+    /** Dependency scan results */
+    deps?: {
+        blast_radius: "low" | "medium" | "high" | null;
+        affected_modules: string[];
+    };
+    /** Risk summary */
+    risk?: {
+        level: "none" | "low" | "medium" | "high" | "critical";
+        tags: string[];
+    };
+}
+/**
+ * Facts v1 - collected from SSOT files
+ */
+export interface FactsV1 {
+    ask_queue_count: number;
+    has_pending_decisions: boolean;
+    mapping_verdict: FactMappingVerdict;
+    spec_map_present: boolean;
+    change_map_present: boolean;
+    engine_last_error?: NormalizedEngineError;
+    last_verdict?: FactVerdict;
+    top_bottleneck?: string;
+    total_verdicts?: number;
+    fix_count?: number;
+    scout?: ScoutFacts;
+    preprocess_redaction_detected: boolean;
+    preprocess_router_route?: "local_only" | "local_then_cloud" | "cloud_direct";
+    preprocess_chunk_count?: number;
+    sources: FactSource[];
+}
+/**
+ * Partial facts (for incremental collection)
+ */
+export type PartialFacts = Partial<FactsV1>;
+/**
+ * Facts collection options
+ */
+export interface FactsCollectOptions {
+    /** Skip ask queue loading */
+    skipAskQueue?: boolean;
+    /** Skip verdict loading */
+    skipVerdict?: boolean;
+    /** Skip scorecard loading */
+    skipScorecard?: boolean;
+    /** Skip scout/musu facts loading */
+    skipScout?: boolean;
+}
+/**
+ * Create empty facts
+ */
+export declare function createEmptyFacts(): FactsV1;
+/**
+ * Merge partial facts into existing facts
+ */
+export declare function mergeFacts(base: FactsV1, partial: PartialFacts): FactsV1;
+/**
+ * Type guard for FactsV1
+ */
+export declare function isFactsV1(value: unknown): value is FactsV1;

package/build/mcp/tools/vibe_pm/facts/types.js

@@ -0,0 +1,44 @@
+/**
+ * Facts Types
+ *
+ * Types for facts collection from SSOT files.
+ */
+/**
+ * Create empty facts
+ */
+export function createEmptyFacts() {
+    return {
+        ask_queue_count: 0,
+        has_pending_decisions: false,
+        mapping_verdict: "UNKNOWN",
+        spec_map_present: false,
+        change_map_present: false,
+        preprocess_redaction_detected: false,
+        sources: [],
+    };
+}
+/**
+ * Merge partial facts into existing facts
+ */
+export function mergeFacts(base, partial) {
+    return {
+        ...base,
+        ...partial,
+        sources: [...new Set([...base.sources, ...(partial.sources ?? [])])],
+    };
+}
+/**
+ * Type guard for FactsV1
+ */
+export function isFactsV1(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const obj = value;
+    return (typeof obj.ask_queue_count === "number" &&
+        typeof obj.has_pending_decisions === "boolean" &&
+        typeof obj.mapping_verdict === "string" &&
+        typeof obj.spec_map_present === "boolean" &&
+        typeof obj.change_map_present === "boolean" &&
+        typeof obj.preprocess_redaction_detected === "boolean" &&
+        Array.isArray(obj.sources));
+}

package/build/mcp/tools/vibe_pm/failure/classifier.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Failure Classifier
+ * Classifies errors into Work vs Platform categories
+ * ADR-0004: Work vs Platform Failure + Ralph Loop
+ */
+import type { WorkFailureCode, PlatformFailureCode, FailureCategory } from "./types.js";
+import type { BottleneckCode } from "../scorecard/types.js";
+/**
+ * Check if a code is a Work failure
+ */
+export declare function isWorkFailure(code: string): code is WorkFailureCode;
+/**
+ * Check if a code is a Platform failure
+ */
+export declare function isPlatformFailure(code: string): code is PlatformFailureCode;
+/**
+ * Classify a failure code into Work or Platform category
+ * Defaults to WORK for unknown codes (safer default)
+ */
+export declare function classifyFailure(code: BottleneckCode | string): FailureCategory;
+/**
+ * Classify an error from its message (not stack trace)
+ * Returns both category and specific code
+ */
+export declare function classifyFromError(error: unknown): {
+    category: FailureCategory;
+    code: BottleneckCode;
+};
+/**
+ * Get all valid failure codes for a category
+ */
+export declare function getFailureCodesForCategory(category: FailureCategory): readonly string[];
+/**
+ * Check if a failure code should trigger user approval requirement
+ * Platform failures always require approval
+ */
+export declare function requiresUserApproval(code: string): boolean;

package/build/mcp/tools/vibe_pm/failure/classifier.js

@@ -0,0 +1,134 @@
+/**
+ * Failure Classifier
+ * Classifies errors into Work vs Platform categories
+ * ADR-0004: Work vs Platform Failure + Ralph Loop
+ */
+/**
+ * List of Work failure codes
+ * These require code/spec fixes, not infrastructure changes
+ */
+const WORK_FAILURE_CODES = [
+    "SPEC_MISSING",
+    "PLAN_MISSING",
+    "CONTEXT_LOST",
+    "LINT_VIOLATION",
+    "TEST_FAILURE",
+    "TYPE_ERROR",
+    "MAPPING_VIOLATION",
+    "LOGIC_FLAW",
+    "USER_ABORT",
+    "PERMISSION_DENIED",
+    "FORBIDDEN_PATH",
+];
+/**
+ * List of Platform failure codes
+ * These require infrastructure/environment fixes
+ */
+const PLATFORM_FAILURE_CODES = [
+    "PROCESS_CRASH",
+    "OOM_KILLED",
+    "PORT_CONFLICT",
+    "NETWORK_ERROR",
+    "DISK_FULL",
+    "TIMEOUT",
+    "ENGINE_UNAVAILABLE",
+];
+/**
+ * Check if a code is a Work failure
+ */
+export function isWorkFailure(code) {
+    return WORK_FAILURE_CODES.includes(code);
+}
+/**
+ * Check if a code is a Platform failure
+ */
+export function isPlatformFailure(code) {
+    return PLATFORM_FAILURE_CODES.includes(code);
+}
+/**
+ * Classify a failure code into Work or Platform category
+ * Defaults to WORK for unknown codes (safer default)
+ */
+export function classifyFailure(code) {
+    if (isWorkFailure(code))
+        return "WORK";
+    if (isPlatformFailure(code))
+        return "PLATFORM";
+    // Default to WORK for unknown codes (safer - requires human review)
+    return "WORK";
+}
+/**
+ * Error message pattern matching for Platform failures
+ */
+const PLATFORM_ERROR_PATTERNS = [
+    { pattern: /eaddrinuse/i, code: "PORT_CONFLICT" },
+    { pattern: /econnrefused/i, code: "NETWORK_ERROR" },
+    { pattern: /econnreset/i, code: "NETWORK_ERROR" },
+    { pattern: /etimedout/i, code: "NETWORK_ERROR" },
+    { pattern: /enomem/i, code: "OOM_KILLED" },
+    { pattern: /out of memory/i, code: "OOM_KILLED" },
+    { pattern: /enospc/i, code: "DISK_FULL" },
+    { pattern: /no space left/i, code: "DISK_FULL" },
+    { pattern: /timeout/i, code: "TIMEOUT" },
+    { pattern: /timed out/i, code: "TIMEOUT" },
+    { pattern: /killed/i, code: "PROCESS_CRASH" },
+    { pattern: /segmentation fault/i, code: "PROCESS_CRASH" },
+    { pattern: /sigsegv/i, code: "PROCESS_CRASH" },
+    { pattern: /sigkill/i, code: "OOM_KILLED" },
+    { pattern: /sigterm/i, code: "PROCESS_CRASH" },
+];
+/**
+ * Work error message patterns
+ */
+const WORK_ERROR_PATTERNS = [
+    { pattern: /lint/i, code: "LINT_VIOLATION" },
+    { pattern: /eslint/i, code: "LINT_VIOLATION" },
+    { pattern: /prettier/i, code: "LINT_VIOLATION" },
+    { pattern: /test fail/i, code: "TEST_FAILURE" },
+    { pattern: /assertion/i, code: "TEST_FAILURE" },
+    { pattern: /expect.*to/i, code: "TEST_FAILURE" },
+    { pattern: /type.*error/i, code: "TYPE_ERROR" },
+    { pattern: /typescript.*error/i, code: "TYPE_ERROR" },
+    { pattern: /cannot find.*module/i, code: "TYPE_ERROR" },
+    { pattern: /permission denied/i, code: "PERMISSION_DENIED" },
+    { pattern: /eacces/i, code: "PERMISSION_DENIED" },
+    { pattern: /eperm/i, code: "PERMISSION_DENIED" },
+];
+/**
+ * Classify an error from its message (not stack trace)
+ * Returns both category and specific code
+ */
+export function classifyFromError(error) {
+    // Use only error message, not stack trace, to avoid false matches
+    // (stack traces may contain words like "timeout" in file paths)
+    const errorMessage = error instanceof Error
+        ? error.message
+        : String(error);
+    // Check Work patterns first (more specific, code/spec related)
+    for (const { pattern, code } of WORK_ERROR_PATTERNS) {
+        if (pattern.test(errorMessage)) {
+            return { category: "WORK", code };
+        }
+    }
+    // Then check Platform patterns (infrastructure issues)
+    for (const { pattern, code } of PLATFORM_ERROR_PATTERNS) {
+        if (pattern.test(errorMessage)) {
+            return { category: "PLATFORM", code };
+        }
+    }
+    // Default to UNKNOWN_ERROR (Work category)
+    return { category: "WORK", code: "UNKNOWN_ERROR" };
+}
+/**
+ * Get all valid failure codes for a category
+ */
+export function getFailureCodesForCategory(category) {
+    return category === "WORK" ? WORK_FAILURE_CODES : PLATFORM_FAILURE_CODES;
+}
+/**
+ * Check if a failure code should trigger user approval requirement
+ * Platform failures always require approval
+ */
+export function requiresUserApproval(code) {
+    return isPlatformFailure(code);
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Failure Handling Module
+ * Work vs Platform failure separation + LOOP_OR_DIAGNOSE UI
+ * ADR-0004: Work vs Platform Failure + Ralph Loop
+ */
+export type { WorkFailureCode, PlatformFailureCode, FailureCategory, FailureContext, LoopOrDiagnoseItem, LoopResult, DiagnoseReport, } from "./types.js";
+export { FAILURE_CONSTANTS } from "./types.js";
+export { isWorkFailure, isPlatformFailure, classifyFailure, classifyFromError, getFailureCodesForCategory, requiresUserApproval, } from "./classifier.js";
+export type { FailureFingerprint } from "./tracker.js";
+export { recordFailure, getSameFailureCount, shouldTriggerLoopOrDiagnose, getRecentFailures, getFailureStats, clearFailureHistory, clearAllFailureHistory, hasRecentFailures, } from "./tracker.js";
+export { createLoopOrDiagnoseItem, isLoopOrDiagnoseItem, transformLoopOrDiagnoseForDecision, generateDiagnoseReport, } from "./loop_diagnose.js";

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

@@ -0,0 +1,11 @@
+/**
+ * Failure Handling Module
+ * Work vs Platform failure separation + LOOP_OR_DIAGNOSE UI
+ * ADR-0004: Work vs Platform Failure + Ralph Loop
+ */
+export { FAILURE_CONSTANTS } from "./types.js";
+// Classifier
+export { isWorkFailure, isPlatformFailure, classifyFailure, classifyFromError, getFailureCodesForCategory, requiresUserApproval, } from "./classifier.js";
+export { recordFailure, getSameFailureCount, shouldTriggerLoopOrDiagnose, getRecentFailures, getFailureStats, clearFailureHistory, clearAllFailureHistory, hasRecentFailures, } from "./tracker.js";
+// LOOP_OR_DIAGNOSE
+export { createLoopOrDiagnoseItem, isLoopOrDiagnoseItem, transformLoopOrDiagnoseForDecision, generateDiagnoseReport, } from "./loop_diagnose.js";