@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/agents/dispatcher.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Agent Automation Dispatcher
+ *
+ * Matches BitNet signals to workflows using priority-based dispatch rules.
+ * Follows the same pattern as router/decide.ts (priority sort → first match).
+ *
+ * Signal → DispatchRule match → mode downgrade by AutopilotLevel → DispatchDecision
+ */
+import type { BitNetSignal, AutopilotLevel, DispatchRule, DispatchDecision, SignalCondition } from "./types.js";
+/**
+ * Match a BitNet signal to a workflow via dispatch rules.
+ *
+ * @param signal - BitNet signal from the sensor layer
+ * @param rules - Dispatch rules (pre-sorted by priority, or will be sorted)
+ * @param autopilotLevel - Current VIBE_AUTOPILOT level (0-3)
+ * @returns DispatchDecision indicating what to do
+ */
+export declare function matchSignalToWorkflow(signal: BitNetSignal, rules: DispatchRule[], autopilotLevel: AutopilotLevel): DispatchDecision;
+/**
+ * Convenience: load rules from catalog and dispatch.
+ *
+ * @param basePath - Optional workspace root for rate limit enforcement.
+ *                   When provided, execute decisions are checked against rate limits
+ *                   and downgraded to propose if exceeded.
+ */
+export declare function dispatch(signal: BitNetSignal, autopilotLevel: AutopilotLevel, basePath?: string): Promise<DispatchDecision>;
+/** Check if a signal matches all conditions in a rule's `when` clause (AND logic). */
+export declare function matchesCondition(signal: BitNetSignal, condition: SignalCondition): boolean;
+/**
+ * Check if a specific tool can run in auto mode.
+ * Used by workflow engine to guard individual step execution.
+ */
+export declare function canToolRunAuto(toolName: string): boolean;

package/build/mcp/agents/dispatcher.js

@@ -0,0 +1,168 @@
+/**
+ * Agent Automation Dispatcher
+ *
+ * Matches BitNet signals to workflows using priority-based dispatch rules.
+ * Follows the same pattern as router/decide.ts (priority sort → first match).
+ *
+ * Signal → DispatchRule match → mode downgrade by AutopilotLevel → DispatchDecision
+ */
+import { loadDispatchRules } from "./catalog_loader.js";
+import { checkRateLimit, loadRateLimitConfig } from "./feedback_loop.js";
+// Workflows allowed at each autopilot level for AUTO mode
+const LEVEL_AUTO_WORKFLOWS = {
+    0: new Set(), // Level 0: OBSERVE ONLY — nothing auto
+    1: new Set(["code-review-gate", "auto-fix-loop"]), // Level 1: safe review + auto-fix
+    2: new Set(["code-review-gate", "auto-fix-loop", "build-and-test", "system-diagnosis"]), // Level 2: + build/test/diagnosis
+    3: "all", // Level 3: everything (except submit_decision check below)
+};
+// Tools that NEVER run in auto mode, even at Level 3
+const NEVER_AUTO_TOOLS = new Set([
+    "vibe_pm.submit_decision",
+    "cockpit.decide",
+]);
+/**
+ * Match a BitNet signal to a workflow via dispatch rules.
+ *
+ * @param signal - BitNet signal from the sensor layer
+ * @param rules - Dispatch rules (pre-sorted by priority, or will be sorted)
+ * @param autopilotLevel - Current VIBE_AUTOPILOT level (0-3)
+ * @returns DispatchDecision indicating what to do
+ */
+export function matchSignalToWorkflow(signal, rules, autopilotLevel) {
+    // Sort by priority ascending (lower = higher priority)
+    const sorted = [...rules].sort((a, b) => a.priority - b.priority);
+    for (const rule of sorted) {
+        if (!matchesCondition(signal, rule.when))
+            continue;
+        // Rule matched — determine effective mode
+        const effectiveMode = resolveEffectiveMode(rule.mode, rule.workflow_id, autopilotLevel);
+        if (effectiveMode === "block") {
+            return {
+                action: "block",
+                reason: rule.description,
+                risk_tags: signal.risk_signals.tags,
+            };
+        }
+        if (!rule.workflow_id) {
+            return { action: "skip", reason: `Rule ${rule.id}: no workflow target` };
+        }
+        const plan = {
+            workflow_id: rule.workflow_id,
+            step_id: "", // filled by workflow engine at execution time
+            agent_id: "", // filled by workflow engine
+            tool: "", // filled by workflow engine
+            input: {},
+            mode: effectiveMode,
+            trace_id: signal.trace_id,
+        };
+        if (effectiveMode === "auto") {
+            return { action: "execute", plan };
+        }
+        return {
+            action: "propose",
+            plan,
+            message: rule.description,
+        };
+    }
+    // No rule matched
+    return { action: "skip", reason: "No dispatch rule matched this signal" };
+}
+/**
+ * Convenience: load rules from catalog and dispatch.
+ *
+ * @param basePath - Optional workspace root for rate limit enforcement.
+ *                   When provided, execute decisions are checked against rate limits
+ *                   and downgraded to propose if exceeded.
+ */
+export async function dispatch(signal, autopilotLevel, basePath) {
+    const rules = await loadDispatchRules();
+    const decision = matchSignalToWorkflow(signal, rules, autopilotLevel);
+    // Rate limit guard: downgrade execute → propose when limit exceeded
+    if (decision.action === "execute" && basePath && decision.plan) {
+        const config = loadRateLimitConfig(basePath);
+        const withinLimit = await checkRateLimit(basePath, undefined, {
+            autopilotLevel,
+            workflowId: decision.plan.workflow_id,
+            config,
+        });
+        if (!withinLimit) {
+            return {
+                action: "propose",
+                plan: decision.plan,
+                message: `Rate limit exceeded — downgraded to propose`,
+            };
+        }
+    }
+    return decision;
+}
+// ── Internal ─────────────────────────────────────────────────────────────────
+/** Check if a signal matches all conditions in a rule's `when` clause (AND logic). */
+export function matchesCondition(signal, condition) {
+    // Phase check
+    if (condition.phases && condition.phases.length > 0) {
+        if (!condition.phases.includes(signal.state_guess.phase))
+            return false;
+    }
+    // Risk level check
+    if (condition.risk_levels && condition.risk_levels.length > 0) {
+        if (!condition.risk_levels.includes(signal.risk_signals.level))
+            return false;
+    }
+    // Risk tags ANY check (signal must have at least one of these tags)
+    if (condition.risk_tags_any && condition.risk_tags_any.length > 0) {
+        const signalTags = new Set(signal.risk_signals.tags);
+        const hasAny = condition.risk_tags_any.some((t) => signalTags.has(t));
+        if (!hasAny)
+            return false;
+    }
+    // Risk tags NONE check (signal must NOT have any of these tags)
+    if (condition.risk_tags_none && condition.risk_tags_none.length > 0) {
+        const signalTags = new Set(signal.risk_signals.tags);
+        const hasNone = condition.risk_tags_none.some((t) => signalTags.has(t));
+        if (hasNone)
+            return false;
+    }
+    // Autopilot eligibility check
+    if (condition.autopilot_eligible !== undefined) {
+        // Check the first next_action's autopilot_eligible flag
+        const topAction = signal.next_actions[0];
+        const isEligible = topAction?.autopilot_eligible ?? false;
+        if (condition.autopilot_eligible !== isEligible)
+            return false;
+    }
+    return true;
+}
+/**
+ * Downgrade mode based on autopilot level.
+ *
+ * - Level 0: all auto → propose
+ * - Level 1: only code-review-gate auto
+ * - Level 2: code-review-gate + build-and-test auto
+ * - Level 3: all auto (except NEVER_AUTO_TOOLS)
+ * - block always stays block
+ */
+function resolveEffectiveMode(ruleMode, workflowId, level) {
+    // Block always stays block
+    if (ruleMode === "block")
+        return "block";
+    // Propose stays propose (no upgrade)
+    if (ruleMode === "propose")
+        return "propose";
+    // Auto mode — check level permissions
+    const allowed = LEVEL_AUTO_WORKFLOWS[level];
+    if (allowed === "all") {
+        return "auto"; // Level 3 allows everything
+    }
+    if (allowed.has(workflowId)) {
+        return "auto"; // Workflow is in the allowlist for this level
+    }
+    // Downgrade auto → propose
+    return "propose";
+}
+/**
+ * Check if a specific tool can run in auto mode.
+ * Used by workflow engine to guard individual step execution.
+ */
+export function canToolRunAuto(toolName) {
+    return !NEVER_AUTO_TOOLS.has(toolName);
+}

package/build/mcp/agents/feedback_loop.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Feedback Loop — Re-evaluation after workflow execution
+ *
+ * After a workflow completes, feeds the result back to BitNet for re-evaluation.
+ * Implements safety rules:
+ * - 3 consecutive FIX → BLOCK escalation
+ * - Rate limit: max 10 auto-executions per hour (Level 3)
+ * - Logs all feedback to .vibe/observer/feedback.jsonl
+ */
+import type { WorkflowResult, BitNetSignal, AutopilotLevel } from "./types.js";
+export interface RateLimitConfig {
+    /** Global max auto-executions per hour (fallback) */
+    global_max_per_hour: number;
+    /** Per-autopilot-level limits (overrides global) */
+    per_level?: Partial<Record<0 | 1 | 2 | 3, number>>;
+    /** Per-workflow limits (overrides global and per-level) */
+    per_workflow?: Record<string, number>;
+}
+/**
+ * Load rate limit config from .vibe/config/rate_limit.json.
+ * Falls back to defaults if file doesn't exist or is invalid.
+ */
+export declare function loadRateLimitConfig(basePath: string): RateLimitConfig;
+/**
+ * Resolve the effective rate limit for a given context.
+ * Priority: per_workflow > per_level > global_max_per_hour > maxPerHour param
+ */
+export declare function resolveEffectiveLimit(config: RateLimitConfig, maxPerHour?: number, autopilotLevel?: AutopilotLevel, workflowId?: string): number;
+export interface FeedbackEntry {
+    timestamp: string;
+    workflow_id: string;
+    trace_id: string;
+    final_status: string;
+    step_count: number;
+    duration_ms: number;
+    re_evaluation?: {
+        new_risk_level?: string;
+        new_phase?: string;
+        escalated?: boolean;
+    };
+    notification?: {
+        type: 'workflow_completed' | 'rate_limit_hit' | 'escalation_blocked';
+        summary: string;
+    };
+}
+/**
+ * Feed workflow result back to BitNet for re-evaluation.
+ *
+ * @param workflowResult - The completed workflow result
+ * @param basePath - Workspace root path
+ * @param bitnetSignalFn - Optional function to call bitnetSignal (for re-evaluation)
+ * @returns New BitNet signal if re-evaluation was performed, null otherwise
+ */
+export declare function feedbackToSensor(workflowResult: WorkflowResult, basePath: string, bitnetSignalFn?: (input: Record<string, unknown>) => Promise<BitNetSignal>): Promise<BitNetSignal | null>;
+/**
+ * Check rate limit: max executions per hour.
+ * Returns true if within limit, false if exceeded.
+ *
+ * Backward compatible: checkRateLimit(basePath) or checkRateLimit(basePath, 10) still work.
+ * Extended: pass options for per-level/per-workflow limits.
+ */
+export declare function checkRateLimit(basePath: string, maxPerHour?: number, options?: {
+    autopilotLevel?: AutopilotLevel;
+    workflowId?: string;
+    config?: RateLimitConfig;
+}): Promise<boolean>;
+/**
+ * Check for consecutive FIX escalation.
+ * If the last N workflow results all ended in halted/blocked with FIX signals,
+ * returns true to indicate BLOCK escalation is needed.
+ */
+export declare function shouldEscalateToBlock(basePath: string, threshold?: number): Promise<boolean>;
+/**
+ * Get notification history from feedback log entries.
+ * Returns only entries that have a notification field.
+ */
+export declare function getNotificationHistory(basePath: string, limit?: number): Promise<Array<{
+    timestamp: string;
+    type: string;
+    summary: string;
+    workflow_id: string;
+    final_status: string;
+}>>;
+export declare function readFeedbackLog(basePath: string, limit?: number): Promise<FeedbackEntry[]>;

package/build/mcp/agents/feedback_loop.js

@@ -0,0 +1,241 @@
+/**
+ * Feedback Loop — Re-evaluation after workflow execution
+ *
+ * After a workflow completes, feeds the result back to BitNet for re-evaluation.
+ * Implements safety rules:
+ * - 3 consecutive FIX → BLOCK escalation
+ * - Rate limit: max 10 auto-executions per hour (Level 3)
+ * - Logs all feedback to .vibe/observer/feedback.jsonl
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { emitEvent } from "../events/emitter.js";
+import { logger } from "../../shared/logger.js";
+const RATE_LIMIT_PER_HOUR = 10;
+const FEEDBACK_LOG_FILE = "feedback.jsonl";
+const DEFAULT_RATE_LIMITS = {
+    global_max_per_hour: 10,
+    per_level: { 0: 0, 1: 5, 2: 15, 3: 30 },
+};
+/**
+ * Load rate limit config from .vibe/config/rate_limit.json.
+ * Falls back to defaults if file doesn't exist or is invalid.
+ */
+export function loadRateLimitConfig(basePath) {
+    const configPath = path.join(basePath, ".vibe", "config", "rate_limit.json");
+    try {
+        if (!fs.existsSync(configPath))
+            return DEFAULT_RATE_LIMITS;
+        const raw = fs.readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return {
+            global_max_per_hour: parsed.global_max_per_hour ?? DEFAULT_RATE_LIMITS.global_max_per_hour,
+            per_level: parsed.per_level ?? DEFAULT_RATE_LIMITS.per_level,
+            per_workflow: parsed.per_workflow,
+        };
+    }
+    catch {
+        return DEFAULT_RATE_LIMITS;
+    }
+}
+/**
+ * Resolve the effective rate limit for a given context.
+ * Priority: per_workflow > per_level > global_max_per_hour > maxPerHour param
+ */
+export function resolveEffectiveLimit(config, maxPerHour, autopilotLevel, workflowId) {
+    // Per-workflow limit (highest priority)
+    if (workflowId && config.per_workflow?.[workflowId] !== undefined) {
+        return config.per_workflow[workflowId];
+    }
+    // Per-level limit
+    if (autopilotLevel !== undefined && config.per_level) {
+        const levelLimit = config.per_level[autopilotLevel];
+        if (levelLimit !== undefined)
+            return levelLimit;
+    }
+    // Global config limit
+    if (config.global_max_per_hour !== undefined) {
+        return config.global_max_per_hour;
+    }
+    // Fallback to explicit param or default constant
+    return maxPerHour ?? RATE_LIMIT_PER_HOUR;
+}
+/**
+ * Feed workflow result back to BitNet for re-evaluation.
+ *
+ * @param workflowResult - The completed workflow result
+ * @param basePath - Workspace root path
+ * @param bitnetSignalFn - Optional function to call bitnetSignal (for re-evaluation)
+ * @returns New BitNet signal if re-evaluation was performed, null otherwise
+ */
+export async function feedbackToSensor(workflowResult, basePath, bitnetSignalFn) {
+    // Build notification based on status
+    const notification = buildNotification(workflowResult);
+    // Log the feedback entry
+    const entry = {
+        timestamp: new Date().toISOString(),
+        workflow_id: workflowResult.workflow_id,
+        trace_id: workflowResult.trace_id,
+        final_status: workflowResult.final_status,
+        step_count: workflowResult.steps.length,
+        duration_ms: workflowResult.total_duration_ms,
+        notification,
+    };
+    await logFeedback(basePath, entry);
+    // Emit feedback event
+    try {
+        emitEvent({
+            runId: "dispatcher",
+            type: "signal.feedback_evaluated",
+            reason: `workflow_${workflowResult.final_status}`,
+            paths: [],
+            component: "feedback_loop",
+            actor: "system",
+            workspaceRoot: basePath,
+            metadata: {
+                workflow_id: workflowResult.workflow_id,
+                final_status: workflowResult.final_status,
+                step_count: workflowResult.steps.length,
+            },
+        });
+    }
+    catch {
+        // Best-effort
+    }
+    // Re-evaluate after workflow (unless blocked — needs human intervention)
+    if (bitnetSignalFn &&
+        workflowResult.final_status !== "blocked") {
+        try {
+            const newSignal = await bitnetSignalFn({
+                event_source: "feedback",
+                workspace_root: basePath,
+            });
+            return newSignal;
+        }
+        catch (err) {
+            logger.error({ err }, "Feedback re-evaluation failed");
+        }
+    }
+    return null;
+}
+/**
+ * Check rate limit: max executions per hour.
+ * Returns true if within limit, false if exceeded.
+ *
+ * Backward compatible: checkRateLimit(basePath) or checkRateLimit(basePath, 10) still work.
+ * Extended: pass options for per-level/per-workflow limits.
+ */
+export async function checkRateLimit(basePath, maxPerHour, options) {
+    const config = options?.config ?? DEFAULT_RATE_LIMITS;
+    const effectiveLimit = resolveEffectiveLimit(config, maxPerHour ?? RATE_LIMIT_PER_HOUR, options?.autopilotLevel, options?.workflowId);
+    // Level 0 always returns false (observe only)
+    if (effectiveLimit <= 0)
+        return false;
+    const entries = await readFeedbackLog(basePath, 100);
+    const oneHourAgo = new Date(Date.now() - 3600_000).toISOString();
+    // If per-workflow limit, count only that workflow
+    let recentCount;
+    if (options?.workflowId && config.per_workflow?.[options.workflowId] !== undefined) {
+        recentCount = entries.filter((e) => e.timestamp > oneHourAgo && e.workflow_id === options.workflowId).length;
+    }
+    else {
+        recentCount = entries.filter((e) => e.timestamp > oneHourAgo).length;
+    }
+    if (recentCount >= effectiveLimit) {
+        logger.warn({ recentCount, effectiveLimit, workflowId: options?.workflowId, level: options?.autopilotLevel }, "Autopilot rate limit exceeded");
+        return false;
+    }
+    return true;
+}
+/**
+ * Check for consecutive FIX escalation.
+ * If the last N workflow results all ended in halted/blocked with FIX signals,
+ * returns true to indicate BLOCK escalation is needed.
+ */
+export async function shouldEscalateToBlock(basePath, threshold = 3) {
+    const entries = await readFeedbackLog(basePath, threshold);
+    if (entries.length < threshold)
+        return false;
+    // Check if all recent entries are halted/blocked
+    const recent = entries.slice(-threshold);
+    return recent.every((e) => e.final_status === "halted" || e.final_status === "blocked");
+}
+// ── Logging ──────────────────────────────────────────────────────────────────
+async function logFeedback(basePath, entry) {
+    const logDir = path.join(basePath, ".vibe", "observer");
+    const logPath = path.join(logDir, FEEDBACK_LOG_FILE);
+    try {
+        await fs.promises.mkdir(logDir, { recursive: true });
+        const line = JSON.stringify(entry) + "\n";
+        await fs.promises.appendFile(logPath, line, "utf-8");
+    }
+    catch {
+        // Graceful degradation
+    }
+}
+// ── Notification Helpers ──────────────────────────────────────────────────────
+function buildNotification(result) {
+    switch (result.final_status) {
+        case "done":
+            return {
+                type: "workflow_completed",
+                summary: `${result.workflow_id} completed successfully`,
+            };
+        case "halted":
+            return {
+                type: "workflow_completed",
+                summary: `${result.workflow_id} halted (manual review needed)`,
+            };
+        case "blocked":
+            return {
+                type: "escalation_blocked",
+                summary: `${result.workflow_id} blocked — human intervention required`,
+            };
+        case "timeout":
+            return {
+                type: "workflow_completed",
+                summary: `${result.workflow_id} timed out`,
+            };
+        default:
+            return undefined;
+    }
+}
+/**
+ * Get notification history from feedback log entries.
+ * Returns only entries that have a notification field.
+ */
+export async function getNotificationHistory(basePath, limit = 10) {
+    const entries = await readFeedbackLog(basePath, 50);
+    return entries
+        .filter((e) => e.notification)
+        .slice(-limit)
+        .map((e) => ({
+        timestamp: e.timestamp,
+        type: e.notification.type,
+        summary: e.notification.summary,
+        workflow_id: e.workflow_id,
+        final_status: e.final_status,
+    }));
+}
+export async function readFeedbackLog(basePath, limit = 20) {
+    const logPath = path.join(basePath, ".vibe", "observer", FEEDBACK_LOG_FILE);
+    try {
+        if (!fs.existsSync(logPath))
+            return [];
+        const content = await fs.promises.readFile(logPath, "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        const entries = [];
+        for (const line of lines.slice(-limit)) {
+            try {
+                entries.push(JSON.parse(line));
+            }
+            catch {
+                // Skip invalid lines
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}

package/build/mcp/agents/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Agent Automation Dispatcher — Barrel export
+ *
+ * Sense→Decide→Act loop:
+ * BitNet (sense) → Dispatcher (decide) → Workflow Engine + OPPA (act) → Feedback
+ */
+export type { AutopilotLevel, DispatchRule, DispatchRuleset, DispatchDecision, ExecutionPlan, SignalCondition, StepResult, WorkflowResult, ToolExecutor, OppaProfile, OppaProfileName, OppaExecutionResult, OppaMappingDef, AgentDef, WorkflowDef, WorkflowStepDef, PermissionDef, } from "./types.js";
+export { loadAgentsCatalog, loadWorkflowsCatalog, loadPermissionsCatalog, loadDispatchRules, loadOppaMappings, getWorkflow, getAgent, getPermissions, isToolAllowedForAgent, clearCatalogCaches, } from "./catalog_loader.js";
+export { matchSignalToWorkflow, matchesCondition, dispatch, canToolRunAuto, } from "./dispatcher.js";
+export { executeWorkflow } from "./workflow_engine.js";
+export { resolveOppaProfile, isOppaAvailable, executeViaOppa, getAllProfiles, clearProfileMapCache, } from "./oppa_router.js";
+export { createToolExecutor } from "./tool_executor.js";
+export { feedbackToSensor, checkRateLimit, shouldEscalateToBlock, readFeedbackLog, } from "./feedback_loop.js";

package/build/mcp/agents/index.js

@@ -0,0 +1,18 @@
+/**
+ * Agent Automation Dispatcher — Barrel export
+ *
+ * Sense→Decide→Act loop:
+ * BitNet (sense) → Dispatcher (decide) → Workflow Engine + OPPA (act) → Feedback
+ */
+// Catalog loader
+export { loadAgentsCatalog, loadWorkflowsCatalog, loadPermissionsCatalog, loadDispatchRules, loadOppaMappings, getWorkflow, getAgent, getPermissions, isToolAllowedForAgent, clearCatalogCaches, } from "./catalog_loader.js";
+// Dispatcher
+export { matchSignalToWorkflow, matchesCondition, dispatch, canToolRunAuto, } from "./dispatcher.js";
+// Workflow engine
+export { executeWorkflow } from "./workflow_engine.js";
+// OPPA router
+export { resolveOppaProfile, isOppaAvailable, executeViaOppa, getAllProfiles, clearProfileMapCache, } from "./oppa_router.js";
+// Tool executor
+export { createToolExecutor } from "./tool_executor.js";
+// Feedback loop
+export { feedbackToSensor, checkRateLimit, shouldEscalateToBlock, readFeedbackLog, } from "./feedback_loop.js";

package/build/mcp/agents/lifecycle_monitor.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Lifecycle Monitor — Periodic project-level health checks
+ *
+ * Runs on a configurable interval (default 60s) and checks project health:
+ * - System health via system.health tool
+ * - If issues detected, generates a BitNet signal with SYSTEM_HEALTH_FAIL tag
+ * - Signal is dispatched via the normal dispatcher → workflow engine path
+ *
+ * Distinct from pool-manager/remote-registry.ts which checks worker node health.
+ * This monitors the project itself (build status, test health, dependency security).
+ */
+export type LifecycleMonitorMode = "observe" | "act";
+export interface LifecycleMonitorOptions {
+    /** Check interval in ms (default 60s) */
+    intervalMs?: number;
+    /** "observe" = log-only (default), "act" = dispatch signals + execute workflows */
+    mode?: LifecycleMonitorMode;
+    /** Callback to run system health check. If not provided, uses tool executor. */
+    healthCheckFn?: () => Promise<HealthCheckResult>;
+}
+export interface HealthCheckResult {
+    healthy: boolean;
+    checks: Array<{
+        name: string;
+        ok: boolean;
+        message?: string;
+    }>;
+}
+export declare class LifecycleMonitor {
+    private interval;
+    private basePath;
+    private intervalMs;
+    private mode;
+    private healthCheckFn?;
+    private running;
+    constructor(basePath: string, options?: LifecycleMonitorOptions);
+    /**
+     * Start periodic health monitoring.
+     */
+    start(): void;
+    /**
+     * Stop periodic health monitoring.
+     */
+    stop(): void;
+    isRunning(): boolean;
+    /**
+     * Run a single health check cycle.
+     */
+    tick(): Promise<void>;
+    /**
+     * Run the health check. Uses custom healthCheckFn if provided,
+     * otherwise falls back to tool executor calling system.health.
+     */
+    private runHealthCheck;
+    /**
+     * Create a synthetic BitNet signal representing a health failure.
+     */
+    private createHealthFailSignal;
+}