@vibecodetown/mcp-server 1.3.1 → 1.5.0

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

@@ -1,24 +1,24 @@
 // MVP Core - vibe_pm.status
 // Project status query (simplified MVP version)
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { runEngineWithCache } from "../../engine.js";
-import { safeJsonParse } from "../../cli.js";
-import { resolveRunId, resolveProjectId, getRunContext, readRunState } from "./context.js";
-import { resolvePmRunDirForRead } from "../../paths.js";
-import { formatMode, formatPhase, signalToReview } from "./pm_language.js";
-import { computePhaseAndMissing, buildRewindDirective } from "./phase.js";
-import { SpecHighValidateOutputSchema } from "../../generated/spec_high_validate_output.js";
-import { getIngressState, checkIngressArtifacts } from "./ingress.js";
-import { getFeatureFlags, isIngressRequired, isObserverEnabled, getObserverMode, } from "./feature-flags.js";
-import { getObserverStatus as getObserverStatusFromModule, isBitNetEnabled } from "./observer.js";
-import { readLastCheck } from "./bitnet-cache.js";
-import { readScorecard } from "./scorecard/index.js";
-import { collectFacts } from "./facts/index.js";
-import { resolveNextActions } from "./navigation/index.js";
-import { LicenseManager } from "../../../license-manager.js";
-import { calcSlotLimits } from "../../../bitnet-worker/hw_slots.js";
-import { collectTriggerFacts, createTriggerEvaluator, } from "../../../tier/index.js";
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { runEngineWithCache } from '../../engine.js';
+import { safeJsonParse } from '../../cli.js';
+import { resolveRunId, resolveProjectId, readRunState } from './context.js';
+import { getPackSummary } from '../../packs/index.js';
+import { resolvePmRunDirForRead } from '../../../kernel/paths.js';
+import { formatMode, formatPhase, signalToReview } from './pm_language.js';
+import { computePhaseAndMissing, buildRewindDirective } from './phase.js';
+import { SpecHighValidateOutputSchema, } from '../../generated/spec_high_validate_output.js';
+import { collectTriggerFacts as _collectTriggerFacts } from '../../../domains/bee/trigger_facts_collector.js';
+import { createTriggerEvaluator as _createTriggerEvaluator } from '../../../domains/bee/trigger_evaluator.js';
+import { resolveTierSnapshot as _resolveTierSnapshot } from '../shared/tier_facade.js';
+import { getIngressState, checkIngressArtifacts } from './ingress.js';
+import { getFeatureFlags, isIngressRequired, isObserverEnabled, getObserverMode, } from './feature-flags.js';
+import { computeObserverRuntime, determineNextAction } from './status_logic.js';
+import { computeProjectStage } from './stage-computer.js';
+import { getObserverStatus, getBitNetStatus, getScorecardHints, getFactsSummary, getNextActions, getPreprocessSummary, getTriggerStatus, getTierStatus, getAntLaneStatus, getTensorRiskStatus, getAutopilotDashboard, } from './status_readers.js';
+void [_collectTriggerFacts, _createTriggerEvaluator, _resolveTierSnapshot];
 /**
  * vibe_pm.status - Query current project status (MVP)
  *
@@ -27,6 +27,7 @@ import { collectTriggerFacts, createTriggerEvaluator, } from "../../../tier/inde
  *   → status summary generation
  */
 export async function status(input, basePath = process.cwd()) {
+    const packs = getPackSummary();
     // Resolve run_id
     const { run_id, is_new } = resolveRunId(input.project_id, basePath);
     const project_id = resolveProjectId(run_id, basePath);
@@ -42,49 +43,52 @@ export async function status(input, basePath = process.cwd()) {
             project_id,
             project: {
                 name: project_id,
-                mode: "미설정",
-                started_at: "없음"
+                mode: '미설정',
+                started_at: '없음',
             },
+            packs,
             current_state: {
-                phase: "프로젝트가 없습니다",
+                phase: '프로젝트가 없습니다',
                 decisions_made: 0,
-                decisions_pending: 0
+                decisions_pending: 0,
             },
             risks: [],
             next_action: {
-                tool: "vibe_pm.ingress",
-                label: "새 프로젝트입니다. 무엇을 만들까요?"
+                tool: 'vibe_pm.ingress',
+                label: '새 프로젝트입니다. 무엇을 만들까요?',
             },
             // v1.1.0 fields
             ingress: {
-                state: "missing",
+                state: 'missing',
                 required: ingressRequired,
                 artifacts: {
-                    ingress_summary: { exists: false, path: "" },
+                    ingress_summary: { exists: false, path: '' },
                 },
                 dirty: {
                     is_dirty: false,
                     reasons: [],
                 },
-                next_action: ingressRequired ? {
-                    tool: "vibe_pm.ingress",
-                    input: { force: true },
-                } : undefined,
+                next_action: ingressRequired
+                    ? {
+                        tool: 'vibe_pm.ingress',
+                        input: { force: true },
+                    }
+                    : undefined,
             },
             observer: {
                 enabled: observerEnabled,
                 mode: observerMode,
-                health: observerEnabled ? "stopped" : "ok",
+                health: observerEnabled ? 'stopped' : 'ok',
                 state: observerRuntime.state,
                 heartbeat_is_alive: observerRuntime.heartbeat_is_alive,
                 heartbeat_age_ms: observerRuntime.heartbeat_age_ms,
                 heartbeat_reason: observerRuntime.heartbeat_reason,
-                is_attached: observerRuntime.state === "RUNNING",
+                is_attached: observerRuntime.state === 'RUNNING',
             },
             bitnet: await getBitNetStatus(basePath),
             dirty: {
                 is_dirty: false,
-                confidence: "low",
+                confidence: 'low',
                 reasons: [],
                 computed_at: new Date().toISOString(),
             },
@@ -98,6 +102,10 @@ export async function status(input, basePath = process.cwd()) {
             tier: getTierStatus(),
             // v1.6.0: Trigger status
             trigger: await getTriggerStatus(basePath, getTierStatus().plan),
+            // v1.8.0: Ant Lane queue status
+            ant_lane: getAntLaneStatus(basePath),
+            // P14v2: Tensor risk score
+            tensor_risk: getTensorRiskStatus(basePath),
         };
     }
     // ============================================================
@@ -110,18 +118,17 @@ export async function status(input, basePath = process.cwd()) {
     const phaseResult = computePhaseAndMissing(run_id, basePath);
     // Rewind Directive: SPEC/PLAN missing → auto-recovery
     // Only trigger when run folder exists (hasRunContext) but files are missing
-    const hasRunContext = !phaseResult.missing.some(m => m.id === "RUN_CONTEXT");
-    if (hasRunContext && phaseResult.phase === "INTAKE" && phaseResult.missing.length > 0) {
-        return buildRewindDirective("vibe_pm.status", phaseResult.missing);
+    const hasRunContext = !phaseResult.missing.some(m => m.id === 'RUN_CONTEXT');
+    if (hasRunContext && phaseResult.phase === 'INTAKE' && phaseResult.missing.length > 0) {
+        return buildRewindDirective('vibe_pm.status', phaseResult.missing);
     }
-    // Get run context and state
-    const context = getRunContext(run_id, basePath);
+    // Get run state
     const runState = readRunState(run_id, basePath);
     // Run spec-high validate to get current status (with caching)
     let validateResult = null;
     try {
-        const { code, stdout } = await runEngineWithCache("spec-high", ["--root", "engines/spec_high", "validate", run_id], {
-            timeoutMs: 60_000
+        const { code, stdout } = await runEngineWithCache('spec-high', ['--root', 'engines/spec_high', 'validate', run_id], {
+            timeoutMs: 60_000,
         });
         if (code === 0 && stdout) {
             const parsed = safeJsonParse(stdout);
@@ -141,11 +148,11 @@ export async function status(input, basePath = process.cwd()) {
         if (p)
             return p;
         const runDir = resolvePmRunDirForRead(basePath, run_id);
-        const ingressDir = path.join(runDir, "ingress");
-        const hasIngress = fs.existsSync(path.join(ingressDir, "ingress_summary.json"));
-        return hasIngress ? "status_unavailable" : "ingress_required";
+        const ingressDir = path.join(runDir, 'ingress');
+        const hasIngress = fs.existsSync(path.join(ingressDir, 'ingress_summary.json'));
+        return hasIngress ? 'status_unavailable' : 'ingress_required';
     })();
-    const mode = runState?.mode ?? "balanced";
+    const mode = runState?.mode ?? 'balanced';
     const decisionsMade = validateResult?.decisions_made ?? runState?.decisions_made ?? 0;
     const decisionsPending = validateResult?.decisions_pending ?? runState?.decisions_pending ?? 0;
     // Get last review status
@@ -171,13 +178,14 @@ export async function status(input, basePath = process.cwd()) {
         project: {
             name: project_id,
             mode: formatMode(mode),
-            started_at: runState?.created_at ?? "알 수 없음"
+            started_at: runState?.created_at ?? '알 수 없음',
         },
+        packs,
         current_state: {
             phase: formatPhase(phase),
             decisions_made: decisionsMade,
             decisions_pending: decisionsPending,
-            last_review_status: lastReviewStatus
+            last_review_status: lastReviewStatus,
         },
         risks,
         next_action: nextAction,
@@ -188,25 +196,33 @@ export async function status(input, basePath = process.cwd()) {
             artifacts: {
                 ingress_summary: {
                     exists: ingressArtifacts.artifacts.ingress_summary?.exists ?? false,
-                    path: ingressArtifacts.artifacts.ingress_summary?.path ?? "",
+                    path: ingressArtifacts.artifacts.ingress_summary?.path ?? '',
                 },
-                ingress_resolution: ingressArtifacts.artifacts.ingress_resolution ? {
-                    exists: ingressArtifacts.artifacts.ingress_resolution.exists,
-                    path: ingressArtifacts.artifacts.ingress_resolution.path,
-                } : undefined,
-                project_fingerprint: ingressArtifacts.artifacts.project_fingerprint ? {
-                    exists: ingressArtifacts.artifacts.project_fingerprint.exists,
-                    path: ingressArtifacts.artifacts.project_fingerprint.path,
-                } : undefined,
+                ingress_resolution: ingressArtifacts.artifacts.ingress_resolution
+                    ? {
+                        exists: ingressArtifacts.artifacts.ingress_resolution.exists,
+                        path: ingressArtifacts.artifacts.ingress_resolution.path,
+                    }
+                    : undefined,
+                project_fingerprint: ingressArtifacts.artifacts.project_fingerprint
+                    ? {
+                        exists: ingressArtifacts.artifacts.project_fingerprint.exists,
+                        path: ingressArtifacts.artifacts.project_fingerprint.path,
+                    }
+                    : undefined,
             },
             dirty: {
-                is_dirty: ingressState === "stale",
-                reasons: ingressState === "stale" ? [{ code: "mtime_changed", detail: "Ingress artifacts are outdated" }] : [],
+                is_dirty: ingressState === 'stale',
+                reasons: ingressState === 'stale'
+                    ? [{ code: 'mtime_changed', detail: 'Ingress artifacts are outdated' }]
+                    : [],
             },
-            next_action: ingressState !== "ready" && ingressRequired ? {
-                tool: "vibe_pm.ingress",
-                input: { run_id, force: true },
-            } : undefined,
+            next_action: ingressState !== 'ready' && ingressRequired
+                ? {
+                    tool: 'vibe_pm.ingress',
+                    input: { run_id, force: true },
+                }
+                : undefined,
         },
         observer: {
             enabled: observerEnabled,
@@ -223,12 +239,19 @@ export async function status(input, basePath = process.cwd()) {
             heartbeat_is_alive: observerRuntime.heartbeat_is_alive,
             heartbeat_age_ms: observerRuntime.heartbeat_age_ms,
             heartbeat_reason: observerRuntime.heartbeat_reason,
-            is_attached: observerRuntime.state === "RUNNING",
+            is_attached: observerRuntime.state === 'RUNNING',
         },
         dirty: {
-            is_dirty: ingressState === "stale",
-            confidence: "medium",
-            reasons: ingressState === "stale" ? [{ code: "mtime_changed", detail: "Files may have changed since last ingress" }] : [],
+            is_dirty: ingressState === 'stale',
+            confidence: 'medium',
+            reasons: ingressState === 'stale'
+                ? [
+                    {
+                        code: 'mtime_changed',
+                        detail: 'Files may have changed since last ingress',
+                    },
+                ]
+                : [],
             computed_at: new Date().toISOString(),
         },
         feature_flags: {
@@ -251,454 +274,22 @@ export async function status(input, basePath = process.cwd()) {
         trigger: await getTriggerStatus(basePath, getTierStatus().plan),
         // v1.7.0: Preprocess (airlock/router/chunking) summary
         preprocess: await getPreprocessSummary(basePath, run_id),
-    };
-}
-/**
- * Get observer status (wrapper for local use)
- */
-async function getObserverStatus(basePath) {
-    const status = await getObserverStatusFromModule(basePath);
-    return {
-        health: status.health,
-        started_at: status.heartbeat?.started_at,
-        last_heartbeat_at: status.heartbeat?.timestamp,
-        heartbeat_period_ms: status.heartbeat?.interval_ms,
-        last_scan_at: status.heartbeat?.last_scan_at,
-        last_scan_duration_ms: status.heartbeat?.last_scan_duration_ms,
-        last_error: status.last_error,
-    };
-}
-function computeObserverRuntime(enabled, status) {
-    if (!enabled) {
-        return { state: "STOPPED", heartbeat_is_alive: false, heartbeat_reason: "disabled" };
-    }
-    const ts = status?.last_heartbeat_at;
-    if (!ts) {
-        return { state: "STOPPED", heartbeat_is_alive: false, heartbeat_reason: "no_heartbeat" };
-    }
-    const t = new Date(ts).getTime();
-    if (!Number.isFinite(t)) {
-        return { state: "STOPPED", heartbeat_is_alive: false, heartbeat_reason: "invalid_timestamp" };
-    }
-    const ageMs = Date.now() - t;
-    const intervalMs = status?.heartbeat_period_ms ?? 5000;
-    const aliveThresholdMs = Math.max(30_000, intervalMs * 6);
-    const stoppedThresholdMs = Math.max(aliveThresholdMs * 10, 5 * 60_000);
-    if (ageMs <= aliveThresholdMs) {
-        return { state: "RUNNING", heartbeat_is_alive: true, heartbeat_age_ms: ageMs, heartbeat_reason: "fresh" };
-    }
-    if (ageMs <= stoppedThresholdMs) {
-        return { state: "STALE", heartbeat_is_alive: false, heartbeat_age_ms: ageMs, heartbeat_reason: "stale" };
-    }
-    return { state: "STOPPED", heartbeat_is_alive: false, heartbeat_age_ms: ageMs, heartbeat_reason: "too_old" };
-}
-function determineNextAction(phase, decisionsPending, lastReviewStatus) {
-    // If there are pending decisions
-    if (decisionsPending > 0) {
-        return {
-            tool: "vibe_pm.get_decision",
-            label: `다음 할 일: 결재 ${decisionsPending}건 처리가 필요합니다`
-        };
-    }
-    // Based on phase
-    switch (phase) {
-        case "init":
-        case "briefing":
-            return {
-                tool: "vibe_pm.get_decision",
-                label: "다음 할 일: 결재 요청을 확인해주세요"
-            };
-        case "decision":
-            return {
-                tool: "vibe_pm.create_work_order",
-                label: "다음 할 일: 작업 지시서를 발행합니다"
-            };
-        case "work_order":
-        case "implementation":
-            return {
-                tool: "vibe_pm.inspect_code",
-                label: "다음 할 일: 구현 후 검수를 요청해주세요"
-            };
-        case "review":
-            if (lastReviewStatus === "GO") {
-                return {
-                    tool: "vibe_pm.create_work_order",
-                    label: "다음 할 일: 다음 작업 지시서를 받습니다"
-                };
+        // v1.8.0: Ant Lane queue status
+        ant_lane: getAntLaneStatus(basePath),
+        // P14v2: Tensor risk score
+        tensor_risk: getTensorRiskStatus(basePath),
+        // v1.9.0: Autopilot dashboard (Lifecycle Hardening)
+        autopilot: await getAutopilotDashboard(basePath),
+        // v2.0.0: Project stage (Gravity Model)
+        project_stage: (() => {
+            try {
+                const { stage, confidence, reason_codes } = computeProjectStage(basePath);
+                return { stage, confidence, reason_codes };
             }
-            else if (lastReviewStatus === "FIX" || lastReviewStatus === "BLOCK") {
-                return {
-                    tool: "vibe_pm.get_decision",
-                    label: "다음 할 일: 수정 후 다시 결재를 진행합니다"
-                };
+            catch {
+                return undefined;
             }
-            return {
-                tool: "vibe_pm.inspect_code",
-                label: "다음 할 일: 검수를 다시 시도합니다"
-            };
-        case "completed":
-            return {
-                tool: "vibe_pm.briefing",
-                label: "다음 할 일: 새 프로젝트를 시작합니다"
-            };
-        default:
-            return {
-                tool: "vibe_pm.status",
-                label: "다음 할 일: 상태를 확인합니다"
-            };
-    }
-}
-/**
- * Get BitNet cache status (v1.2.0)
- *
- * Returns the cached BitNet result from .vibe/cache/bitnet/last_check.json (legacy: .vibe/bitnet/last_check.json)
- * Consumers can use this to display the last audit result without triggering a new check.
- */
-async function getBitNetStatus(basePath) {
-    const enabled = isBitNetEnabled();
-    // 5분 stale threshold
-    const STALE_THRESHOLD_MS = 5 * 60 * 1000;
-    try {
-        const result = await readLastCheck(basePath, STALE_THRESHOLD_MS);
-        if (!result.success) {
-            // 캐시 없음
-            return {
-                enabled,
-                cache_exists: false,
-                stale: false,
-                warning: enabled ? "Observer가 아직 BitNet 검사를 실행하지 않았습니다" : undefined,
-            };
-        }
-        // 캐시 있음
-        const data = result.data;
-        return {
-            enabled,
-            cache_exists: true,
-            stale: result.stale ?? false,
-            last_check: {
-                checked_at: data.checked_at,
-                verdict: data.verdict,
-                evidence_level: data.evidence_level,
-                risk_tags: data.risk_tags,
-                reason: data.reason,
-            },
-            warning: result.stale ? "캐시가 오래되었습니다. Observer가 실행 중인지 확인하세요." : undefined,
-        };
-    }
-    catch {
-        // 캐시 읽기 실패
-        return {
-            enabled,
-            cache_exists: false,
-            stale: false,
-            warning: "BitNet 캐시를 읽는 중 오류가 발생했습니다",
-        };
-    }
-}
-/**
- * Get scorecard hints for the current run (v1.3.0)
- *
- * Reads the run-local scorecard and generates hints from bottleneck analysis.
- * Returns undefined if no scorecard exists.
- */
-async function getScorecardHints(basePath, runId) {
-    try {
-        const scorecard = await readScorecard(basePath, runId);
-        if (!scorecard) {
-            return undefined;
-        }
-        // Generate hints from top bottlenecks
-        const hints = [];
-        // Add hints for repeated bottlenecks (count >= 2)
-        for (const { code, count } of scorecard.summary.top_bottlenecks.slice(0, 3)) {
-            if (count >= 2) {
-                const message = getBottleneckMessage(code, count);
-                hints.push({
-                    id: `HINT-${code}`,
-                    signal: "BOTTLENECK_QUEUE",
-                    message,
-                    confidence: Math.min(0.3 + count * 0.1, 0.9),
-                });
-            }
-        }
-        // Add hint for high fix rate
-        const fixRate = scorecard.summary.total_verdicts > 0
-            ? (scorecard.summary.fix_count + scorecard.summary.block_count) / scorecard.summary.total_verdicts
-            : 0;
-        if (fixRate > 0.5 && scorecard.summary.total_verdicts >= 3) {
-            hints.push({
-                id: "HINT-HIGH_FIX_RATE",
-                signal: "BOTTLENECK_QUEUE",
-                message: `반복 수정 비율이 높습니다 (${Math.round(fixRate * 100)}%). 스펙이나 계획을 점검하세요.`,
-                confidence: Math.min(0.4 + fixRate * 0.3, 0.8),
-            });
-        }
-        return {
-            exists: true,
-            summary: {
-                total_verdicts: scorecard.summary.total_verdicts,
-                go_count: scorecard.summary.go_count,
-                fix_count: scorecard.summary.fix_count,
-                block_count: scorecard.summary.block_count,
-                error_count: scorecard.summary.error_count,
-            },
-            hints,
-            top_bottlenecks: scorecard.summary.top_bottlenecks,
-            updated_at: scorecard.updated_at,
-        };
-    }
-    catch {
-        // FAIL-SAFE: Return undefined on error
-        return undefined;
-    }
-}
-/**
- * Get facts summary for the current run (v1.4.0)
- *
- * Collects facts from SSOT files without calling other MCP tools.
- */
-async function getFactsSummary(basePath, runId) {
-    try {
-        const facts = await collectFacts(basePath, runId);
-        // Filter out UNKNOWN from last_verdict for StatusOutput compatibility
-        const lastVerdict = facts.last_verdict === "UNKNOWN" ? undefined : facts.last_verdict;
-        return {
-            ask_queue_count: facts.ask_queue_count,
-            has_pending_decisions: facts.has_pending_decisions,
-            mapping_verdict: facts.mapping_verdict,
-            last_verdict: lastVerdict,
-            top_bottleneck: facts.top_bottleneck,
-            total_verdicts: facts.total_verdicts,
-            fix_count: facts.fix_count,
-            sources: facts.sources,
-        };
-    }
-    catch {
-        // FAIL-SAFE: Return undefined on error
-        return undefined;
-    }
-}
-/**
- * Get navigation actions (v1.5.0)
- *
- * Resolves deterministic next actions based on facts, scorecard, and phase.
- * FAIL-SAFE: Returns undefined on error (doesn't crash status).
- */
-async function getNextActions(basePath, runId, phase) {
-    try {
-        // Collect facts and scorecard in parallel
-        const [facts, scorecard] = await Promise.all([
-            collectFacts(basePath, runId),
-            readScorecard(basePath, runId),
-        ]);
-        // Resolve actions using navigation rules
-        return resolveNextActions(facts, scorecard, phase);
-    }
-    catch {
-        // FAIL-SAFE: Return undefined on error
-        return undefined;
-    }
-}
-function readJsonFile(absPath) {
-    try {
-        if (!fs.existsSync(absPath))
-            return undefined;
-        const raw = fs.readFileSync(absPath, "utf8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-}
-async function getPreprocessSummary(basePath, runId) {
-    try {
-        const runDir = resolvePmRunDirForRead(basePath, runId);
-        if (!fs.existsSync(runDir))
-            return undefined;
-        const airlockDir = path.join(runDir, "airlock");
-        const chunksDir = path.join(runDir, "chunks");
-        const reportPath = path.join(airlockDir, "redaction_report.json");
-        const safeContextPath = path.join(airlockDir, "safe_context.txt");
-        const fingerprintPath = path.join(airlockDir, "input_fingerprint.json");
-        const report = readJsonFile(reportPath);
-        const decisionPath = path.join(airlockDir, "router_decision.json");
-        const decision = readJsonFile(decisionPath);
-        const manifestPath = path.join(chunksDir, "chunk_manifest.v1.json");
-        const manifest = readJsonFile(manifestPath);
-        const airlock = report || fs.existsSync(safeContextPath) || fs.existsSync(fingerprintPath)
-            ? {
-                report_path: fs.existsSync(reportPath) ? reportPath : undefined,
-                safe_context_path: fs.existsSync(safeContextPath) ? safeContextPath : undefined,
-                fingerprint_path: fs.existsSync(fingerprintPath) ? fingerprintPath : undefined,
-                redacted_count: report?.redacted_count,
-                rules_applied: report?.rules_applied,
-                policy_name: report?.policy_name,
-                created_at: report?.created_at,
-            }
-            : undefined;
-        const router = decision
-            ? {
-                decision_path: fs.existsSync(decisionPath) ? decisionPath : undefined,
-                route: decision.route,
-                reason: decision.reason,
-                policy_id: decision.policy_id,
-                created_at: decision.created_at,
-            }
-            : undefined;
-        const profiles = manifest
-            ? manifest.chunks.reduce((acc, chunk) => {
-                acc[chunk.profile] = (acc[chunk.profile] ?? 0) + 1;
-                return acc;
-            }, {})
-            : undefined;
-        const chunking = manifest
-            ? {
-                manifest_path: fs.existsSync(manifestPath) ? manifestPath : undefined,
-                chunk_count: manifest.chunks.length,
-                profiles,
-                created_at: manifest.created_at,
-            }
-            : undefined;
-        if (!airlock && !router && !chunking)
-            return undefined;
-        const summaryParts = [];
-        if (airlock?.redacted_count && airlock.redacted_count > 0) {
-            summaryParts.push(`마스킹 ${airlock.redacted_count}건`);
-        }
-        if (router?.route) {
-            const routeLabel = router.route === "local_only"
-                ? "로컬"
-                : router.route === "local_then_cloud"
-                    ? "로컬→클라우드"
-                    : "클라우드";
-            summaryParts.push(`라우팅 ${routeLabel}`);
-        }
-        if (typeof chunking?.chunk_count === "number") {
-            summaryParts.push(`청크 ${chunking.chunk_count}개`);
-        }
-        const summary = summaryParts.length > 0 ? summaryParts.join(" · ") : undefined;
-        return {
-            summary,
-            airlock,
-            router,
-            chunking,
-        };
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Get human-readable message for a bottleneck code
- */
-function getBottleneckMessage(code, count) {
-    const messages = {
-        // Work failures
-        SPEC_MISSING: "스펙 문서가 없어 작업이 차단되고 있습니다",
-        PLAN_MISSING: "계획 문서가 없어 작업이 차단되고 있습니다",
-        CONTEXT_LOST: "컨텍스트가 유실되어 작업이 중단되고 있습니다",
-        LINT_VIOLATION: "린트 규칙 위반이 반복되고 있습니다",
-        TEST_FAILURE: "테스트 실패가 반복되고 있습니다",
-        TYPE_ERROR: "타입 오류가 반복되고 있습니다",
-        MAPPING_VIOLATION: "소속 경계 위반이 반복되고 있습니다",
-        LOGIC_FLAW: "로직 결함이 반복 감지되고 있습니다",
-        PERMISSION_DENIED: "권한이 없어 파일에 접근할 수 없습니다",
-        FORBIDDEN_PATH: "수정 금지된 경로에 접근을 시도했습니다",
-        // Platform failures
-        TIMEOUT: "타임아웃이 반복되고 있습니다",
-        TOOL_CRASH: "도구 충돌이 반복되고 있습니다",
-        UNKNOWN_ERROR: "알 수 없는 오류가 반복되고 있습니다",
-        USER_ABORT: "사용자 중단이 반복되고 있습니다",
-        PROCESS_CRASH: "프로세스가 비정상 종료되고 있습니다",
-        OOM_KILLED: "메모리 부족으로 프로세스가 종료되고 있습니다",
-        PORT_CONFLICT: "포트가 이미 사용 중입니다",
-        NETWORK_ERROR: "네트워크 연결에 문제가 있습니다",
-        DISK_FULL: "디스크 공간이 부족합니다",
-        ENGINE_UNAVAILABLE: "필요한 엔진을 사용할 수 없습니다",
+        })(),
     };
-    const base = messages[code] ?? `${code} 문제가 반복되고 있습니다`;
-    return `${base} (${count}회)`;
-}
-/**
- * Get trigger status (v1.6.0)
- *
- * Returns T1-T9 trigger evaluation results.
- * FAIL-SAFE: Returns empty status on error.
- */
-async function getTriggerStatus(basePath, tier) {
-    try {
-        const evaluator = createTriggerEvaluator(basePath, tier);
-        const facts = await collectTriggerFacts(basePath);
-        const result = await evaluator.evaluate(facts);
-        return {
-            active_triggers: result.triggered.map((t) => t.id),
-            highest_priority: result.highest_priority?.id ?? null,
-            cooldown_blocks: result.cooldown_blocks,
-            engine_backlog: result.should_skip_all,
-            last_evaluation: result.evaluated_at,
-        };
-    }
-    catch {
-        // FAIL-SAFE: Return empty status on error
-        return {
-            active_triggers: [],
-            highest_priority: null,
-            cooldown_blocks: [],
-            engine_backlog: false,
-            last_evaluation: null,
-        };
-    }
-}
-/**
- * Get tier status (v1.6.0)
- *
- * Returns license status and feature availability.
- * FAIL-SAFE: Returns FREE tier on any error.
- */
-function getTierStatus() {
-    try {
-        const manager = new LicenseManager();
-        const entitlements = manager.loadEntitlements();
-        const slots = calcSlotLimits();
-        const isPro = entitlements.planEffective === "PRO";
-        return {
-            plan: entitlements.planEffective,
-            status: entitlements.status,
-            days_left: entitlements.daysLeft,
-            concurrent_slots: {
-                free: slots.free,
-                paid: slots.paid,
-            },
-            features: {
-                scorecard: isPro,
-                policy_analysis: isPro,
-                auto_fix: isPro && entitlements.switches.autoFix,
-                bitnet_trace: isPro,
-            },
-            upgrade_hint: !isPro
-                ? "Upgrade to PRO for advanced analysis features (Scorecard, Policy Analysis, Auto-Fix)"
-                : entitlements.refreshRecommended
-                    ? `License expires in ${entitlements.daysLeft} days. Consider renewal.`
-                    : undefined,
-        };
-    }
-    catch {
-        // FAIL-SAFE: Return FREE tier on error
-        const slots = calcSlotLimits();
-        return {
-            plan: "FREE",
-            status: "MISSING",
-            concurrent_slots: {
-                free: slots.free,
-                paid: slots.paid,
-            },
-            features: {
-                scorecard: false,
-                policy_analysis: false,
-                auto_fix: false,
-                bitnet_trace: false,
-            },
-            upgrade_hint: "Upgrade to PRO for advanced analysis features",
-        };
-    }
 }
+// Helper functions extracted to status_readers.ts and status_logic.ts