@a1hvdy/cc-openclaw 0.30.0 → 0.32.0

package/dist/src/council/council.d.ts

@@ -1,67 +0,0 @@
-/**
- * Council — Multi-agent collaboration engine
- *
- * Ported from three-minds and adapted to use SessionManager + ISession
- * directly (no HTTP/SSE to external services).
- *
- * Key patterns:
- * - Git worktree isolation per agent
- * - Two-phase protocol: planning round → execution rounds
- * - Consensus voting: all agents vote YES to complete
- * - Parallel execution via Promise.allSettled
- * - Engine-agnostic: agents can use Claude, Codex, or any ISession engine
- */
-import { EventEmitter } from 'node:events';
-import { type CouncilConfig, type CouncilSession, type CouncilReviewResult, type CouncilAcceptResult, type CouncilRejectResult, type SessionConfig, type SessionInfo, type SendOptions, type SendResult } from '../types.js';
-import { type Logger } from '../logger.js';
-interface SessionManagerLike {
-    startSession(config: Partial<SessionConfig> & {
-        name?: string;
-    }): Promise<SessionInfo>;
-    sendMessage(name: string, message: string, options?: Partial<SendOptions>): Promise<SendResult>;
-    stopSession(name: string): Promise<void>;
-}
-export declare class Council extends EventEmitter {
-    private config;
-    private manager;
-    private agentTimeoutMs;
-    private _aborted;
-    private _activeSessions;
-    private _session;
-    private _pendingInjection;
-    private logger;
-    constructor(config: CouncilConfig, manager: SessionManagerLike, logger?: Logger);
-    getSession(): CouncilSession | undefined;
-    injectMessage(message: string): void;
-    abort(): void;
-    private emitEvent;
-    private runSingleAgent;
-    init(task: string): CouncilSession;
-    run(task?: string): Promise<CouncilSession>;
-    private generateSummary;
-    private generateCompactContext;
-    private saveTranscript;
-    /**
-     * Produce a structured review of the council's output.
-     * Lists all changed files, branches, worktrees, plan.md status, and agent summaries.
-     * Does NOT modify any state — purely informational.
-     */
-    review(): Promise<CouncilReviewResult>;
-    /**
-     * Internal cleanup helper — removes worktrees, branches, plan.md, and reviews/.
-     * Each cleanup step is independently gated by the `options` flags.
-     */
-    private _cleanup;
-    /**
-     * Accept the council's work: clean up worktrees, branches, plan.md, and reviews/.
-     * Should only be called after reviewing via `review()`.
-     */
-    accept(): Promise<CouncilAcceptResult>;
-    /**
-     * Reject the council's work: rewrite plan.md with feedback.
-     * Does NOT delete any worktrees or branches — the council can retry.
-     */
-    reject(feedback: string): Promise<CouncilRejectResult>;
-}
-export declare function getDefaultCouncilConfig(projectDir: string): CouncilConfig;
-export {};

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

@@ -1,2 +0,0 @@
-export * from './council.js';
-export * from './consensus.js';

package/dist/src/council/system-prompt.d.ts

@@ -1,16 +0,0 @@
-/**
- * Council per-agent system prompt builder + config-path resolver.
- *
- * Extracted from `council.ts` 2026-05-13 as a pair (they're tightly coupled —
- * buildSystemPrompt always calls resolveConfigPath). Both are bounded I/O:
- * filesystem reads + string transformation, no module state.
- *
- * Note on path resolution: `import.meta.url` here points to
- * `src/council/system-prompt.ts` (same directory as `council.ts` was),
- * so the `../../configs` relative lookup resolves identically. Behavior
- * preservation verified.
- */
-import type { AgentPersona } from '../types.js';
-/** Resolve the path to configs/ relative to this module (works from both src/ and dist/) */
-export declare function resolveConfigPath(filename: string): string;
-export declare function buildSystemPrompt(agent: AgentPersona, allAgents: AgentPersona[], worktreePath: string): string;

package/dist/src/council/write-worktree-claude-md.d.ts

@@ -1,10 +0,0 @@
-/**
- * Writes a per-agent `.claude/CLAUDE.md` into the worktree directory, scoping
- * the agent's identity, working branch, workspace boundary, and efficiency
- * rules for council collaboration.
- *
- * Extracted from `council.ts` 2026-05-13 as a bounded-I/O hot-path
- * decomposition. Deterministic for the same inputs; only writes one file
- * under the given `wtDir`.
- */
-export declare function writeWorktreeClaudeMd(wtDir: string, agentName: string, emoji: string, projectDir: string): void;

package/dist/src/engines/base-oneshot-session.d.ts

@@ -1,87 +0,0 @@
-/**
- * Base class for one-shot (process-per-send) session engines.
- *
- * Shared by Codex, Gemini, and Cursor — eliminates ~200 LOC of duplication
- * per engine. Subclasses only implement _run() (engine-specific CLI invocation)
- * and optionally override _cleanupProc() for extra cleanup (readline, streams).
- */
-import { ChildProcess } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import { type SessionConfig, type SessionStats, type EffortLevel, type ISession, type SessionSendOptions, type TurnResult, type CostBreakdown } from '../types.js';
-/**
- * Parameterizes engine-specific behavior without requiring method overrides.
- * Passed to the BaseOneShotSession constructor by each subclass.
- */
-export interface OneShotEngineConfig {
-    /** Prefix for session ID generation, e.g. 'codex', 'gemini', 'cursor' */
-    enginePrefix: string;
-    /** Fallback model for pricing lookups when session has no explicit model */
-    defaultModel: string;
-    /** Model name shown in getCost() output; defaults to defaultModel if omitted */
-    defaultModelDisplay?: string;
-    /** Whether this engine tracks cached token pricing (Codex=false, Gemini/Cursor=true) */
-    supportsCachedTokens: boolean;
-    /** Human-readable engine name for compact() no-op message */
-    engineDisplayName: string;
-}
-export declare abstract class BaseOneShotSession extends EventEmitter implements ISession {
-    protected options: SessionConfig;
-    protected engineBin: string;
-    protected engineCfg: OneShotEngineConfig;
-    private _isReady;
-    private _isPaused;
-    private _isBusy;
-    protected currentProc: ChildProcess | null;
-    private currentRequestId;
-    private _startTime;
-    private _history;
-    sessionId?: string;
-    protected _stats: {
-        turns: number;
-        toolCalls: number;
-        toolErrors: number;
-        tokensIn: number;
-        tokensOut: number;
-        cachedTokens: number;
-        costUsd: number;
-        lastActivity: string | null;
-    };
-    constructor(config: SessionConfig, bin: string, engineCfg: OneShotEngineConfig);
-    get pid(): number | undefined;
-    get isReady(): boolean;
-    get isPaused(): boolean;
-    get isBusy(): boolean;
-    start(): Promise<this>;
-    send(message: string | unknown[], options?: SessionSendOptions): Promise<TurnResult | {
-        requestId: number;
-        sent: boolean;
-    }>;
-    /** Engine-specific: spawn the CLI and return a TurnResult. */
-    protected abstract _run(message: string, options: SessionSendOptions): Promise<TurnResult>;
-    getStats(): SessionStats & {
-        sessionId?: string;
-        uptime: number;
-    };
-    getHistory(limit?: number): Array<{
-        time: string;
-        type: string;
-        event: unknown;
-    }>;
-    compact(_summary?: string): Promise<TurnResult>;
-    getEffort(): EffortLevel;
-    setEffort(level: EffortLevel): void;
-    getCost(): CostBreakdown;
-    resolveModel(alias: string): string;
-    pause(): void;
-    resume(): void;
-    stop(): void;
-    /** Override in subclasses that need extra cleanup (readline, stream destroy). */
-    protected _cleanupProc(): void;
-    protected _getModelPricing(): import("../models.js").ModelPricing;
-    protected _recordTurnComplete(): void;
-    protected _addHistory(event: {
-        text: string;
-        code: number | null;
-    }): void;
-    protected _updateCost(): void;
-}

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';