@a1hvdy/cc-openclaw 0.30.0 → 0.31.0

package/dist/src/engines/heartbeat-guard.d.ts

@@ -1,93 +0,0 @@
-/**
- * HeartbeatGuard — enforce `heartbeat.model` override at the engines layer.
- *
- * Context
- * -------
- * OpenClaw issues #9556, #13009, #14279 document a recurring bug: heartbeat-
- * triggered runs ignore the `heartbeat.model` field in the agent config and
- * fall through to the session's primary model (typically Opus), burning
- * expensive tokens on what should be a cheap Haiku ping.
- *
- * The existing `src/lib/heartbeat-workaround.ts` patches this at the SDK
- * request layer. This guard operates one level higher — at the engines /
- * agent-config layer — to:
- *
- *   1. Read `heartbeat.model` from the resolved agent config.
- *   2. If present, enforce it on any heartbeat invocation.
- *   3. If the upstream runtime ignores the override (bug still present),
- *      REFUSE the heartbeat with a clear error that names the issue numbers.
- *
- * Usage
- * -----
- * ```ts
- * const guard = new HeartbeatGuard(agentConfig);
- * const result = guard.enforce(requestedModel);
- * if (!result.ok) throw result.error;
- * // use result.model for the heartbeat call
- * ```
- */
-export interface HeartbeatAgentConfig {
-    /**
-     * Optional heartbeat sub-config from the agent definition.
-     * Mirrors the upstream OpenClaw `agents.list[x].heartbeat` shape.
-     */
-    heartbeat?: {
-        /** The model that MUST be used for heartbeat turns. */
-        model?: string;
-        /** Whether heartbeats are enabled for this agent at all. */
-        enabled?: boolean;
-    };
-}
-export type GuardResult = {
-    ok: true;
-    model: string;
-} | {
-    ok: false;
-    error: HeartbeatGuardError;
-};
-export declare class HeartbeatGuardError extends Error {
-    /** The model the upstream runtime attempted to use. */
-    readonly requestedModel: string;
-    /** The model the guard expected. */
-    readonly expectedModel: string;
-    /** Upstream issue numbers that describe why this guard exists. */
-    readonly issueRefs: readonly ["#9556", "#13009", "#14279"];
-    constructor(requestedModel: string, expectedModel: string);
-}
-export declare class HeartbeatGuard {
-    private readonly config;
-    constructor(agentConfig: HeartbeatAgentConfig);
-    /**
-     * Enforce the heartbeat model override.
-     *
-     * @param requestedModel - The model string the upstream runtime resolved for
-     *   this heartbeat invocation (i.e. whatever it actually passed to the SDK).
-     *
-     * @returns `{ ok: true, model }` — the model the caller MUST use.
-     *          `{ ok: false, error }` — the upstream ignored the override; refuse.
-     *
-     * When no `heartbeat.model` is configured this is a pass-through:
-     * returns `{ ok: true, model: requestedModel }` unconditionally.
-     */
-    enforce(requestedModel: string): GuardResult;
-    /**
-     * Convenience: enforce and throw on refusal. Equivalent to:
-     *   const r = guard.enforce(model); if (!r.ok) throw r.error; return r.model;
-     */
-    enforceOrThrow(requestedModel: string): string;
-    /**
-     * Returns the configured heartbeat.model, or undefined if none is set.
-     */
-    get configuredModel(): string | undefined;
-    /**
-     * True if heartbeats are explicitly disabled in the agent config.
-     */
-    get heartbeatsDisabled(): boolean;
-}
-/**
- * Returns true when the guard should skip. Honours the legacy per-layer flag
- * (`OPENCLAW_HEARTBEAT_GUARD_DISABLE=1`) AND the unified bypass flag
- * (`CC_OPENCLAW_HEARTBEAT_BYPASS=1`) added in v0.21.0 E2. Prefer the unified
- * flag; the legacy one is kept for backward-compat.
- */
-export declare function isHeartbeatGuardDisabled(): boolean;

package/dist/src/engines/index.d.ts

@@ -1,8 +0,0 @@
-export * from './base-oneshot-session.js';
-export * from './persistent-session.js';
-export * from './persistent-codex-session.js';
-export * from './persistent-cursor-session.js';
-export * from './persistent-custom-session.js';
-export * from './persistent-gemini-session.js';
-export * from './subprocess-pool.js';
-export * from './heartbeat-guard.js';

package/dist/src/engines/persistent-codex-session.d.ts

@@ -1,16 +0,0 @@
-/**
- * Persistent Codex Session — wraps OpenAI `codex` CLI
- *
- * Unlike Claude Code, Codex does not maintain a persistent subprocess with
- * streaming JSON I/O.  Each send() spawns a new `codex` process in quiet +
- * full-auto mode.  The "session" is persistent in the sense that:
- *   - Working directory (cwd) carries accumulated code changes across sends
- *   - Stats, history, and cost are tracked continuously
- *   - The session has consistent lifecycle semantics (start/stop/pause/resume)
- */
-import type { SessionConfig, SessionSendOptions, TurnResult } from '../types.js';
-import { BaseOneShotSession } from './base-oneshot-session.js';
-export declare class PersistentCodexSession extends BaseOneShotSession {
-    constructor(config: SessionConfig, codexBin?: string);
-    protected _run(message: string, options: SessionSendOptions): Promise<TurnResult>;
-}

package/dist/src/engines/persistent-cursor-session.d.ts

@@ -1,21 +0,0 @@
-/**
- * Persistent Cursor Session — wraps `cursor-agent` CLI
- *
- * Like Codex/Gemini, each send() spawns a new `cursor-agent` process in
- * headless print mode. Cursor CLI supports `--output-format stream-json`
- * which provides NDJSON events similar to Gemini's stream protocol.
- *
- * The "session" is persistent in the same sense as Codex:
- *   - Working directory carries accumulated code changes across sends
- *   - Stats, history, and cost are tracked continuously
- *   - Consistent lifecycle semantics (start/stop/pause/resume)
- */
-import type { SessionConfig, SessionSendOptions, TurnResult } from '../types.js';
-import { BaseOneShotSession } from './base-oneshot-session.js';
-export declare class PersistentCursorSession extends BaseOneShotSession {
-    private _currentRl;
-    constructor(config: SessionConfig, cursorBin?: string);
-    protected _cleanupProc(): void;
-    protected _run(message: string, options: SessionSendOptions): Promise<TurnResult>;
-    private _handleStreamEvent;
-}

package/dist/src/engines/persistent-custom-session.d.ts

@@ -1,78 +0,0 @@
-/**
- * Persistent Custom Session — generic wrapper for any coding agent CLI
- *
- * Supports two operating modes based on CustomEngineConfig.persistent:
- *
- *   persistent=true  — long-running subprocess with stream-json I/O over
- *                       stdin/stdout (like Claude Code). Started once, messages
- *                       sent as JSON lines on stdin.
- *
- *   persistent=false — one-shot per send (like Gemini/Codex). Each send()
- *                      spawns a new process with the message as a CLI argument.
- *
- * The config maps OpenClaw session concepts (permission modes, models, etc.)
- * to the target CLI's flags, so any coding agent with a CLI can be integrated
- * without writing engine-specific code.
- */
-import { EventEmitter } from 'node:events';
-import { type SessionConfig, type SessionStats, type EffortLevel, type ISession, type SessionSendOptions, type TurnResult, type CostBreakdown } from '../types.js';
-export declare class PersistentCustomSession extends EventEmitter implements ISession {
-    private options;
-    private engineConfig;
-    private engineBin;
-    private sanitize;
-    private proc;
-    private _rl;
-    private _streamCallbacks;
-    private _contextHighFired;
-    private currentProc;
-    private _currentRl;
-    private _isReady;
-    private _isPaused;
-    private _isBusy;
-    private currentRequestId;
-    private _startTime;
-    private _history;
-    sessionId?: string;
-    private _stats;
-    constructor(config: SessionConfig);
-    get pid(): number | undefined;
-    get isReady(): boolean;
-    get isPaused(): boolean;
-    get isBusy(): boolean;
-    start(): Promise<this>;
-    private _startPersistent;
-    private _startOneShot;
-    send(message: string | unknown[], options?: SessionSendOptions): Promise<TurnResult | {
-        requestId: number;
-        sent: boolean;
-    }>;
-    private _sendPersistent;
-    private _sendOneShot;
-    private _runOneShot;
-    private _handlePersistentEvent;
-    private _handleOneShotEvent;
-    private _waitForTurnComplete;
-    getStats(): SessionStats & {
-        sessionId?: string;
-        uptime: number;
-    };
-    getHistory(limit?: number): Array<{
-        time: string;
-        type: string;
-        event: unknown;
-    }>;
-    compact(summary?: string): Promise<TurnResult | {
-        requestId: number;
-        sent: boolean;
-    }>;
-    getEffort(): EffortLevel;
-    setEffort(level: EffortLevel): void;
-    getCost(): CostBreakdown;
-    resolveModel(alias: string): string;
-    pause(): void;
-    resume(): void;
-    stop(): void;
-    private _appendPermissionArgs;
-    private _updateCost;
-}

package/dist/src/engines/persistent-gemini-session.d.ts

@@ -1,21 +0,0 @@
-/**
- * Persistent Gemini Session — wraps Google `gemini` CLI
- *
- * Like Codex, each send() spawns a new `gemini` process. Unlike Codex,
- * Gemini CLI supports `--output-format stream-json` which provides real
- * token usage data and structured tool call events instead of raw text.
- *
- * The "session" is persistent in the same sense as Codex:
- *   - Working directory carries accumulated code changes across sends
- *   - Stats, history, and cost are tracked continuously
- *   - Consistent lifecycle semantics (start/stop/pause/resume)
- */
-import type { SessionConfig, SessionSendOptions, TurnResult } from '../types.js';
-import { BaseOneShotSession } from './base-oneshot-session.js';
-export declare class PersistentGeminiSession extends BaseOneShotSession {
-    private _currentRl;
-    constructor(config: SessionConfig, geminiBin?: string);
-    protected _cleanupProc(): void;
-    protected _run(message: string, options: SessionSendOptions): Promise<TurnResult>;
-    private _handleStreamEvent;
-}

package/dist/src/engines/persistent-session.d.ts

@@ -1,95 +0,0 @@
-/**
- * Persistent Claude Code Session — wraps `claude` CLI via child_process.spawn
- *
- * Maintains a long-running Claude Code process with streaming JSON I/O.
- * Enables multi-turn agent loops, continuous conversation, and real-time streaming.
- */
-import { EventEmitter } from 'node:events';
-import { type SessionConfig, type SessionStats, type EffortLevel, type ISession, type SessionSendOptions, type TurnResult, type CostBreakdown } from '../types.js';
-export declare const THINKING_EVENT: "thinking";
-export interface ThinkingEventPayload {
-    /** Partial or complete thinking/reasoning text from the upstream CLI. */
-    text: string;
-    /** ISO timestamp when the event was captured. */
-    capturedAt: string;
-    /** Source: 'thinking_delta' from stream_event, or 'assistant_block' from aggregate block. */
-    source: 'thinking_delta' | 'assistant_block';
-}
-interface InternalStats {
-    turns: number;
-    toolCalls: number;
-    toolErrors: number;
-    tokensIn: number;
-    tokensOut: number;
-    cachedTokens: number;
-    costUsd: number;
-    startTime: string | null;
-    lastActivity: string | null;
-    /** v0.27.x — last PROGRESS event ts (excludes api_retry); watchdog keys off it. */
-    lastProgressAt: string | null;
-    /** v0.27.6 — count of tool calls currently in flight (dispatched onToolUse
-     *  without a matching onToolResult yet). The stalled-session watchdog treats
-     *  inFlightTools > 0 as "alive" so a long quiet Bash/build/test step is never
-     *  killed mid-run. Reset to 0 at turn boundaries (start / complete / close). */
-    inFlightTools: number;
-    history: Array<{
-        time: string;
-        type: string;
-        event: unknown;
-    }>;
-    retries: number;
-    lastRetryError?: string;
-    lastTurnContextTokens: number;
-}
-export declare class PersistentClaudeSession extends EventEmitter implements ISession {
-    private options;
-    private claudeBin;
-    private proc;
-    private _rl;
-    private _isReady;
-    private _isPaused;
-    private _isBusy;
-    private currentRequestId;
-    private _streamCallbacks;
-    private _textStreamedThisTurn;
-    private _contextHighFired;
-    private _contextHighLastFiredAt;
-    private _realModel;
-    sessionId?: string;
-    stats: InternalStats;
-    constructor(config: SessionConfig, claudeBin?: string);
-    get pid(): number | undefined;
-    get isReady(): boolean;
-    get isPaused(): boolean;
-    get isBusy(): boolean;
-    start(): Promise<this>;
-    private _handleEvent;
-    send(message: string | unknown[], options?: SessionSendOptions): Promise<TurnResult | {
-        requestId: number;
-        sent: boolean;
-    }>;
-    private _waitForTurnComplete;
-    getStats(): SessionStats & {
-        sessionId?: string;
-        uptime: number;
-    };
-    getHistory(limit?: number): Array<{
-        time: string;
-        type: string;
-        event: unknown;
-    }>;
-    compact(summary?: string): Promise<TurnResult | {
-        requestId: number;
-        sent: boolean;
-    }>;
-    getEffort(): EffortLevel;
-    setEffort(level: EffortLevel): void;
-    getCost(): CostBreakdown;
-    resolveModel(alias: string): string;
-    pause(): void;
-    resume(): void;
-    stop(): void;
-    private _updateCost;
-    private _fireHook;
-}
-export {};

package/dist/src/engines/resolve-bin.d.ts

@@ -1,14 +0,0 @@
-/**
- * Pure binary-path resolver for custom session engines.
- *
- * If `engineConfig.binEnv` names an env var that's set, returns its value.
- * Otherwise returns the configured `bin` fallback.
- *
- * Extracted from `persistent-custom-session.ts` 2026-05-13 as a pure-function
- * hot-path decomposition (no module state; reads only the named env var).
- */
-export interface ResolveBinConfig {
-    bin: string;
-    binEnv?: string;
-}
-export declare function resolveBin(engineConfig: ResolveBinConfig): string;

package/dist/src/engines/subprocess-pool.d.ts

@@ -1,78 +0,0 @@
-/**
- * SubprocessPool — warm claude CLI subprocess pool for conversation-boundary recycle.
- *
- * DARK-FLAGGED: only consulted when OPENCLAW_SUBPROCESS_POOL=1.
- * When the flag is off, this module is a no-op and all behaviour is
- * byte-identical to the pre-v0.16 code path.
- *
- * Goal: cut Telegram cold-turn wall-clock toward direct CLI baseline
- * (currently ~3× direct CLI) by keeping a pool of warm `claude` CLI
- * subprocesses ready to accept the first message of a new conversation,
- * amortising the ~800-1200ms spawn + init cost.
- *
- * Pool policy:
- *   - Maintains `minIdle` warm sessions (default 1).
- *   - On conversation start: borrow the head idle session; the pool
- *     immediately spawns a replacement to maintain the idle floor.
- *   - On conversation boundary (session.stop() / recycle()): return the
- *     session to the pool — the session's subprocess is killed, a fresh
- *     one is spawned and warmed, then placed back into the idle queue.
- *   - Hard cap: `maxSize` total (idle + borrowed) sessions (default 4).
- *   - Idle sessions are reaped after `idleTtlMs` (default 5 min) to
- *     avoid orphaning warm processes during quiet periods.
- */
-import { EventEmitter } from 'node:events';
-import { PersistentClaudeSession } from './persistent-session.js';
-import type { SessionConfig } from '../types.js';
-export interface SubprocessPoolOptions {
-    /** Minimum idle (pre-warmed) sessions to keep ready. Default 1. */
-    minIdle?: number;
-    /** Hard cap on total sessions (idle + borrowed). Default 4. */
-    maxSize?: number;
-    /** Idle TTL before a warm session is reaped (ms). Default 300_000 (5 min). */
-    idleTtlMs?: number;
-    /** Base config applied to every pool-spawned session. */
-    baseConfig: SessionConfig;
-    /** Override the claude binary path (test injection). */
-    claudeBin?: string;
-}
-/**
- * Returns true only when the pool feature flag is explicitly enabled.
- * Default off — behaviour is byte-identical to pre-v0.16 when off.
- */
-export declare function isSubprocessPoolEnabled(): boolean;
-export declare class SubprocessPool extends EventEmitter {
-    private readonly opts;
-    private idle;
-    private borrowed;
-    private reaperTimer;
-    private _destroyed;
-    constructor(options: SubprocessPoolOptions);
-    /**
-     * Start the pool: pre-warm `minIdle` sessions and schedule the idle reaper.
-     */
-    start(): Promise<void>;
-    /**
-     * Borrow a warm session for a new conversation.
-     * Returns null if pool is disabled or at capacity and no idle sessions exist.
-     * Callers MUST call recycle(session) when the conversation ends.
-     */
-    borrow(): Promise<PersistentClaudeSession | null>;
-    /**
-     * Recycle a borrowed session back into the pool.
-     * The session's subprocess is terminated; a fresh warmed session replaces it.
-     */
-    recycle(session: PersistentClaudeSession): Promise<void>;
-    /**
-     * Destroy the pool: kill all idle sessions and stop the reaper.
-     */
-    destroy(): void;
-    get stats(): {
-        idle: number;
-        borrowed: number;
-        maxSize: number;
-    };
-    private _fillIdle;
-    private _spawnWarm;
-    private _reapStale;
-}

package/dist/src/health/handler.d.ts

@@ -1,39 +0,0 @@
-/**
- * Health endpoint handler — GET /health → {status, version, sessions, uptime}.
- *
- * Architecturally a standalone module: exports getHealthInfo() (pure) and
- * healthRoute(req, res) (node:http handler). Wiring into the shared
- * embedded-server (:18796) is deferred — a follow-up edit to
- * src/session/embedded-server.ts will add `if (req.url === '/health') return healthRoute(req, res)`.
- *
- * Configurable port: CC_OPENCLAW_HEALTH_PORT (default 18796 — shares listener
- * with openai-compat by design).
- */
-import type { IncomingMessage, ServerResponse } from 'node:http';
-/** Default health port. Shares embedded-server :18796 by design. */
-export declare const DEFAULT_HEALTH_PORT = 18796;
-export declare function getHealthPort(): number;
-export interface HealthInfo {
-    status: 'ok' | 'degraded' | 'starting';
-    pluginId: string;
-    version: string;
-    sessions: {
-        active: number;
-        total: number;
-    };
-    uptime: {
-        seconds: number;
-        startedAt: string;
-    };
-    timestamp: string;
-}
-/** Called by plugin entry on register() to mark uptime baseline. */
-export declare function markStart(): void;
-/** Increment counters from session lifecycle hooks. */
-export declare function recordSessionStart(): void;
-export declare function recordSessionEnd(): void;
-/** Pure: compute current health info. */
-export declare function getHealthInfo(): HealthInfo;
-/** node:http compatible handler. */
-export declare function healthRoute(_req: IncomingMessage, res: ServerResponse): void;
-export declare function _resetForTests(): void;

package/dist/src/health/index.d.ts

@@ -1 +0,0 @@
-export { getHealthInfo, healthRoute, markStart, recordSessionStart, recordSessionEnd, getHealthPort, DEFAULT_HEALTH_PORT, _resetForTests, } from './handler.js';

package/dist/src/health/metrics.d.ts

@@ -1,52 +0,0 @@
-/**
- * In-memory metrics registry exposing Prometheus exposition format at /metrics.
- *
- * Pure singleton; no external deps. Counters increment monotonically. Gauges
- * track current value. Histograms accumulate observation buckets.
- *
- * v0.4.0 Pillar A — minimum viable observability set:
- *   cc_openclaw_requests_total{status}
- *   cc_openclaw_workers
- *   cc_openclaw_uptime_seconds
- *   cc_openclaw_errors_total{code}
- *   cc_openclaw_last_error_seconds
- *
- * Future v0.4.x can add tokens_total, ttft_seconds histogram, cache_hits/misses,
- * tool_uses_total. The serializer + endpoint don't need changes.
- */
-type LabelValues = Readonly<Record<string, string>>;
-declare class Counter {
-    readonly name: string;
-    readonly help: string;
-    private values;
-    constructor(name: string, help: string);
-    inc(labels?: LabelValues, by?: number): void;
-    serialize(): string;
-    reset(): void;
-}
-declare class Gauge {
-    readonly name: string;
-    readonly help: string;
-    private value;
-    private dynamic;
-    constructor(name: string, help: string);
-    set(v: number): void;
-    /** Bind to a function — read on every serialization (for things like uptime). */
-    bind(fn: () => number): void;
-    serialize(): string;
-    reset(): void;
-}
-declare class Registry {
-    readonly requestsTotal: Counter;
-    readonly workers: Gauge;
-    readonly uptimeSeconds: Gauge;
-    readonly errorsTotal: Counter;
-    readonly lastErrorSeconds: Gauge;
-    constructor();
-    serializePrometheus(): string;
-    recordError(code: string): void;
-    resetForTests(): void;
-}
-export declare const metricsRegistry: Registry;
-export declare const PROMETHEUS_CONTENT_TYPE = "text/plain; version=0.0.4; charset=utf-8";
-export {};

package/dist/src/index.d.ts

@@ -1,57 +0,0 @@
-/**
- * cc-openclaw plugin entry — A1xAI's Anthropic CLI bridge plugin for OpenClaw.
- *
- * Registers all module-level register() handlers through a single top-level
- * register(api) call. Each module owns its own register-guard idempotency,
- * so re-calls are safe; the top-level guard here protects against repeated
- * plugin loads emitting duplicate top-level wiring.
- *
- * Module wiring order matters for one reason: cwd-patch + runtime stub
- * injection must run BEFORE any session start so the cwd is already
- * adjusted by the time engines spawn. All others are order-independent.
- */
-import { getConfigService } from './lib/config-service.js';
-export declare const PLUGIN_ID = "cc-openclaw";
-export declare const VERSION = "0.1.0";
-/**
- * Unified PluginApi shape — superset of fields needed by every wired module.
- * cwd-patch and cc-handler both require `registerService`; both reference
- * `logger` and a `config.plugins.{entries,configs}` map (different agents shaped
- * the field name slightly differently). P2 cco-hardening will lift this into a
- * single shared definition imported by every module.
- */
-export interface PluginApi {
-    on(event: string, handler: (...args: unknown[]) => unknown | Promise<unknown>): void;
-    logger?: Console;
-    config?: {
-        plugins?: {
-            entries?: Record<string, {
-                config?: Record<string, unknown>;
-            }>;
-            configs?: Record<string, Record<string, unknown>>;
-        };
-    };
-    registerService(service: {
-        id: string;
-        start: () => Promise<void>;
-        stop: () => Promise<void> | void;
-    }): void;
-}
-export { getConfigService };
-/**
- * Top-level plugin entry. Idempotent — re-calls are no-op.
- * Guard centralized via defaultRegisterGuard (P2 cco-hardening).
- */
-export declare function register(api: PluginApi): void;
-/** Test-only helper to reset top-level registration state. */
-export declare function _resetRegisteredForTests(): void;
-/**
- * Test-only helper to reset the ConfigService singleton. Each test that
- * mutates `process.env` and re-invokes `register()` should call this first
- * so the config is re-parsed with the test's env, not the cached value
- * from a prior test. Also exported from `lib/config-service.ts` directly.
- */
-export declare function _resetConfigServiceForTests(): void;
-export type { ChannelAdapter, ChannelMessage, ChannelInbound, ChannelButton } from './channels/adapter.js';
-export { registerChannelAdapter } from './channels/adapter.js';
-export { selectEngine, captureSessionRoute, type Engine, type SessionRoute } from './lib/config-service.js';

package/dist/src/lib/auto-recovery.d.ts

@@ -1,43 +0,0 @@
-/**
- * auto-recovery — PM2 process exit → openclaw doctor --fix → health probe.
- *
- * Listens for PM2 bus events. On gateway crash:
- *   1. Runs `openclaw doctor --fix`
- *   2. Probes /health (up to 15s, 1s interval)
- *   3. On success: Telegram "recovered" message
- *   4. On failure: Telegram escalation
- *
- * Configurable via:
- *   OPENCLAW_CC_OPENCLAW_AUTO_RECOVERY=0   — disable
- */
-export interface RecoveryResult {
-    success: boolean;
-    durationMs: number;
-    doctorOutput?: string;
-    error?: string;
-}
-/** Minimal type for pm2 bus events. */
-interface Pm2BusEvent {
-    process?: {
-        name?: string;
-        pm_id?: number;
-    };
-    event?: string;
-    at?: number;
-}
-/** Test-only reset. */
-export declare function _resetRecoveryStateForTests(): void;
-export declare function _setOnProcessExitForTests(handler: ((event: Pm2BusEvent) => void) | null): void;
-/**
- * Connect to PM2 bus and listen for process:exit events.
- * No-ops if OPENCLAW_CC_OPENCLAW_AUTO_RECOVERY=0 or already connected.
- *
- * PM2 is a peer dependency — if not available this silently skips.
- */
-export declare function connectPm2Bus(): Promise<void>;
-/**
- * Directly trigger recovery for a named process without going through PM2 bus.
- * Used by chaos scripts and tests.
- */
-export declare function triggerRecovery(processName: string): Promise<RecoveryResult>;
-export {};