@a1hvdy/cc-openclaw 0.29.0 → 0.31.0

package/dist/src/lib/error-formatter.d.ts

@@ -1,91 +0,0 @@
-/**
- * error-formatter — pure ({error, context}) => {jsonlRow, telegramText}
- *
- * Structured error taxonomy for cc-openclaw. Every catchable error site
- * should pass through here so errors are never "Error: undefined" in
- * Telegram or jsonl outputs.
- *
- * Error code taxonomy:
- *   CC_OPENCLAW_TOOL_FAILURE        — tool invocation failed
- *   CC_OPENCLAW_BUDGET_EXCEEDED     — quota/budget limit hit
- *   CC_OPENCLAW_GATEWAY_CRASH       — PM2 process exited unexpectedly
- *   CC_OPENCLAW_DRIFT_DETECTED      — cross-laptop version mismatch
- *   CC_OPENCLAW_HEALTH_PROBE_FAILED — /health endpoint unreachable
- *   CC_OPENCLAW_RECOVERY_FAILED     — auto-recovery did not succeed
- *   CC_OPENCLAW_RECOVERY_OK         — auto-recovery succeeded (info)
- *   CC_OPENCLAW_SESSION_ERROR       — session-level error
- *   CC_OPENCLAW_PARSE_ERROR         — stream parsing error
- *   CC_OPENCLAW_CONFIG_ERROR        — configuration/env error
- *   CC_OPENCLAW_NETWORK_ERROR       — upstream HTTP/network failure
- *   CC_OPENCLAW_TIMEOUT             — operation exceeded time limit
- *   CC_OPENCLAW_AUTH_ERROR          — authentication/API key failure
- *   CC_OPENCLAW_UNKNOWN             — unclassified error
- */
-export declare const ERROR_CODES: {
-    readonly TOOL_FAILURE: "CC_OPENCLAW_TOOL_FAILURE";
-    readonly BUDGET_EXCEEDED: "CC_OPENCLAW_BUDGET_EXCEEDED";
-    readonly GATEWAY_CRASH: "CC_OPENCLAW_GATEWAY_CRASH";
-    readonly DRIFT_DETECTED: "CC_OPENCLAW_DRIFT_DETECTED";
-    readonly HEALTH_PROBE_FAILED: "CC_OPENCLAW_HEALTH_PROBE_FAILED";
-    readonly RECOVERY_FAILED: "CC_OPENCLAW_RECOVERY_FAILED";
-    readonly RECOVERY_OK: "CC_OPENCLAW_RECOVERY_OK";
-    readonly SESSION_ERROR: "CC_OPENCLAW_SESSION_ERROR";
-    readonly PARSE_ERROR: "CC_OPENCLAW_PARSE_ERROR";
-    readonly CONFIG_ERROR: "CC_OPENCLAW_CONFIG_ERROR";
-    readonly NETWORK_ERROR: "CC_OPENCLAW_NETWORK_ERROR";
-    readonly TIMEOUT: "CC_OPENCLAW_TIMEOUT";
-    readonly AUTH_ERROR: "CC_OPENCLAW_AUTH_ERROR";
-    readonly UNKNOWN: "CC_OPENCLAW_UNKNOWN";
-};
-export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
-export type Severity = 'critical' | 'error' | 'warning' | 'info';
-export interface ErrorContext {
-    code: ErrorCode;
-    sessionId?: string;
-    laptopId?: string;
-    /** Additional structured key-value details */
-    details?: Record<string, unknown>;
-}
-export interface FormattedError {
-    /** NDJSON-ready row */
-    jsonlRow: ErrorJsonlRow;
-    /**
-     * Telegram message text (HTML parse_mode). v0.27.3 — converted from
-     * MarkdownV2 to HTML so the entire Telegram surface (live card + error
-     * alerts) renders through ONE parse mode. error-renderer sends this with
-     * parse_mode: 'HTML'.
-     */
-    telegramText: string;
-}
-interface ErrorJsonlRow {
-    ts: string;
-    code: ErrorCode;
-    severity: Severity;
-    message: string;
-    sessionId?: string;
-    laptopId?: string;
-    stack?: string;
-    details?: Record<string, unknown>;
-}
-/** Extract a usable message from unknown thrown values. */
-export declare function extractMessage(error: unknown): string;
-/**
- * Escape characters special to Telegram MarkdownV2.
- *
- * v0.27.3 — RETAINED for back-compat (and its own unit tests) but no longer
- * used by formatError, which now emits HTML (see the telegramText block) so the
- * whole Telegram surface renders through one parse mode. Kept exported in case a
- * caller still needs MarkdownV2 escaping.
- */
-export declare function escapeMdV2(text: string): string;
-/**
- * Pure formatter — no side effects on the return value, but DOES emit
- * trajectory + metrics events for centralized observability per Pillars A+B.
- *
- * @param error   The thrown value (Error instance, string, or unknown)
- * @param context Structured context including mandatory error code
- */
-export declare function formatError(error: unknown, context: ErrorContext): FormattedError;
-/** Shorthand for the common "unknown catch block" pattern. */
-export declare function formatUnknownError(error: unknown, sessionId?: string): FormattedError;
-export {};

package/dist/src/lib/error-renderer.d.ts

@@ -1,20 +0,0 @@
-/**
- * src/lib/error-renderer.ts — v0.25.0 M16 migration target.
- *
- * Migrated from src/channels/telegram/error-renderer.ts. Identical
- * behaviour; only the Telegram-API import path changes (legacy live-card
- * → new src/lib/telegram-bot-api).
- *
- * Sends a FormattedError to a configured Telegram chat with per-code 1h
- * dedup. Bot token comes from telegram-bot-api initialisation (driven
- * by the mirror channel's register() at boot). The drift JSONL writer
- * for warning+ severity is unchanged.
- */
-import type { FormattedError } from './error-formatter.js';
-export interface RenderOptions {
-    chatId?: string;
-    threadId?: string;
-    forceSend?: boolean;
-    writeJsonl?: boolean;
-}
-export declare function renderError(formatted: FormattedError, opts?: RenderOptions): Promise<boolean>;

package/dist/src/lib/heartbeat-config.d.ts

@@ -1,34 +0,0 @@
-/**
- * Heartbeat constants + env-gate — single source of truth shared by both the
- * SDK-layer workaround (`src/lib/heartbeat-workaround.ts`) and the engines-
- * layer guard (`src/engines/heartbeat-guard.ts`).
- *
- * v0.21.0 E2 — Reality differed from the plan: the two implementations are NOT
- * duplicates. They are layered defenses with different concerns:
- *   - WORKAROUND = proactive (force the right model at SDK call time)
- *   - GUARD = reactive (verify upstream honoured the override, refuse if not)
- *
- * Both layers were tracking the same constants and the same upstream bug, but
- * via DIFFERENT env-var names (`CC_OPENCLAW_DISABLE_HEARTBEAT_WORKAROUND` and
- * `OPENCLAW_HEARTBEAT_GUARD_DISABLE`) and DIFFERENT copies of `HEARTBEAT_FALL-
- * BACK_MODEL` / issue references. This module consolidates them so a single
- * change (e.g. when upstream ships a fix) updates BOTH layers atomically.
- *
- * Upstream issue refs: #9556, #13009, #14279.
- */
-/** Single canonical fallback model used by BOTH the workaround and the guard. */
-export declare const HEARTBEAT_FALLBACK_MODEL = "claude-haiku-4-5";
-/** Sentinel strings observed in upstream OpenClaw heartbeat payloads. */
-export declare const HEARTBEAT_SENTINELS: readonly ["__heartbeat__", "heartbeat:ping", "__keepalive__"];
-/** Upstream OpenClaw issue numbers that motivate both layers. */
-export declare const HEARTBEAT_ISSUE_REFS: readonly ["#9556", "#13009", "#14279"];
-/**
- * Unified env-var gate. Set `CC_OPENCLAW_HEARTBEAT_BYPASS=1` to disable BOTH
- * the SDK-layer workaround AND the engines-layer guard at once. This is what
- * you set when upstream OpenClaw ships a fix for #9556/#13009/#14279.
- *
- * Backward-compat: the legacy per-layer flags
- * (`CC_OPENCLAW_DISABLE_HEARTBEAT_WORKAROUND`, `OPENCLAW_HEARTBEAT_GUARD_DISABLE`)
- * still work but are deprecated. Prefer the unified flag.
- */
-export declare function isHeartbeatBypassed(): boolean;

package/dist/src/lib/heartbeat-workaround.d.ts

@@ -1,44 +0,0 @@
-/**
- * Heartbeat model workaround — SDK-call-layer override.
- *
- * Tracks OpenClaw issues #9556, #13009, #14279: heartbeat-triggered runs
- * ignore the heartbeat.model field and use the session's primary model
- * (typically Opus). This wastes tokens and adds latency on what should be
- * a cheap Haiku ping.
- *
- * applyHeartbeatWorkaround() inspects an SDK request payload, detects
- * heartbeat-shaped requests via heuristics (low input tokens + heartbeat
- * sentinel in messages), and forces the model field to the heartbeat.model
- * value (or HEARTBEAT_FALLBACK_MODEL when missing).
- *
- * Disable via CC_OPENCLAW_DISABLE_HEARTBEAT_WORKAROUND=1 — set this when
- * upstream OpenClaw ships a native fix.
- */
-export declare const HEARTBEAT_FALLBACK_MODEL = "claude-haiku-4-5";
-/** Sentinel strings observed in upstream OpenClaw heartbeat payloads. */
-export declare const HEARTBEAT_SENTINELS: readonly ["__heartbeat__", "heartbeat:ping", "__keepalive__"];
-export interface SdkRequestPayload {
-    model: string;
-    messages?: Array<{
-        role: string;
-        content: string | unknown;
-    }>;
-    metadata?: Record<string, unknown>;
-    /** Some payloads carry the intended heartbeat model in metadata or top-level */
-    heartbeat?: {
-        model?: string;
-    };
-}
-/**
- * Heuristic: a request is heartbeat-shaped if:
- *   - metadata.heartbeat or top-level heartbeat field is set, OR
- *   - any message content contains a heartbeat sentinel, OR
- *   - metadata flag `is_heartbeat: true`
- */
-export declare function isHeartbeatRequest(req: SdkRequestPayload): boolean;
-/**
- * Apply the workaround: if the request is heartbeat-shaped and the workaround
- * is not disabled, override the model to the heartbeat target. Returns a NEW
- * payload object (does not mutate input).
- */
-export declare function applyHeartbeatWorkaround(req: SdkRequestPayload): SdkRequestPayload;

package/dist/src/lib/html-render.d.ts

@@ -1,50 +0,0 @@
-/**
- * html-render — Telegram HTML parse_mode rendering (v0.27.0 M1).
- *
- * The CLI-fidelity rendering engine. Chosen over MarkdownV2 because Telegram's
- * HTML mode only requires escaping `& < >` (no "every . - ! must be backslashed"
- * fragility), and it supports `<pre><code class="language-bash">…</code></pre>` —
- * labeled, monospaced code blocks that mirror the terminal — plus `<blockquote>`
- * and `<tg-spoiler>`.
- *
- * Companion to markdown-v2.ts / markdown-to-mdv2.ts (the prior engine). This
- * module is the HTML path the card-renderer + telegram-bot-api now use.
- *
- * Telegram-supported tags (Bot API): b/strong, i/em, u, s, a, code, pre,
- * pre+code[class=language-X], blockquote, tg-spoiler. Everything else in text
- * content must have &, <, > escaped.
- */
-/** Escape the three HTML-significant chars for Telegram HTML text content. */
-export declare function escapeHtml(text: string | null | undefined): string;
-/** Inline monospace span: `<code>escaped</code>`. */
-export declare function code(s: string): string;
-/**
- * Strip Telegram HTML markup back to readable plain text (v0.27.3). Used
- * by editTg's plain-text fallback: when an HTML edit is rejected, re-sending the
- * SAME string without parse_mode would dump literal `<b>`/`<pre>` tags into the
- * chat. This removes the tags and decodes the basic entities so the fallback
- * stays legible. Not a general sanitizer — scoped to the tags this module emits.
- */
-export declare function stripHtml(input: string | null | undefined): string;
-/**
- * v0.27.5 M4 — close any unclosed Telegram-HTML tags this module emits, in LIFO
- * order. A hard truncation of a rendered card (renderTurn's 4096-char backstop)
- * can slice through an open `<pre>`/`<b>`/… ; left dangling, Telegram rejects the
- * edit and editTg falls back to plain text — dumping literal `<pre>`/`**`/`- `
- * markup into the chat. Closing the danglers keeps the truncated HTML well-formed
- * so the edit is accepted.
- *
- * Conservative by design: only the tags this module emits (pre, code, blockquote,
- * b, i, s, a) are tracked, balanced input passes through byte-identical, and
- * stray/mismatched closers are tolerated (pop nearest match, never go negative).
- * Attribute values here never contain a literal `>` (escapeHtml runs on class /
- * href), so `[^>]*` safely consumes the whole opening tag.
- */
-export declare function closeDanglingTags(html: string): string;
-/**
- * Fenced code block: `<pre><code class="language-LANG">escaped</code></pre>`.
- * Omits the class when no language is given. Body is HTML-escaped (the only
- * escaping Telegram requires inside pre/code).
- */
-export declare function pre(body: string, lang?: string): string;
-export declare function markdownToHtml(input: string | null | undefined): string;

package/dist/src/lib/http-agent.d.ts

@@ -1,47 +0,0 @@
-/**
- * M5 (perf overhaul idea #5) — undici keepAlive agent pool.
- *
- * Sets undici's global dispatcher to a keepAlive Agent so every Node 18+
- * `fetch()` call in cc-openclaw reuses TCP+TLS sockets per upstream origin.
- * For the Riyadh→US-East corridor (150-200ms RTT), eliminating one TLS 1.3
- * handshake saves roughly 1 TCP + 2 TLS round trips = 450-600ms tail latency
- * per reuse. Undici's `Agent` already pools per-origin internally; we just
- * tune `connections` (concurrent sockets) and `keepAliveTimeout` (idle hold).
- *
- * Flag: CC_OPENCLAW_PERF_KEEPALIVE (default OFF until M8 baseline confirms
- * the win — per plan, "default ON for safe ideas... once measured-good").
- *
- * Install is idempotent — second invocation in the same process is a no-op
- * so importing from multiple bootstrap entry points is safe. The previous
- * dispatcher is closed gracefully to avoid socket leaks during reinstall.
- *
- * Test hook: pass a custom factory to `installPerfKeepaliveAgent({ factory })`
- * so the test suite can verify install+settings without binding real sockets.
- */
-export interface KeepaliveOptions {
-    /** Max idle time a kept-alive socket stays open. Default 60s. */
-    keepAliveTimeout?: number;
-    /** Hard ceiling on idle socket age. Default 120s. */
-    keepAliveMaxTimeout?: number;
-    /** Concurrent sockets per origin. Default 8 — enough for cc-openclaw's
-     *  fan-out to Anthropic + OpenAI fallback without saturating either. */
-    connections?: number;
-}
-interface InstallSnapshot {
-    installed: boolean;
-    options: Required<KeepaliveOptions>;
-    installedAt: string;
-}
-/**
- * Install the keepAlive agent as undici's global dispatcher. Idempotent —
- * subsequent calls in the same process return the existing snapshot without
- * reinstalling. Returns null when the flag is off (no-op, no snapshot).
- *
- * `factory` exists for tests; production code never passes it.
- */
-export declare function installPerfKeepaliveAgent(opts?: KeepaliveOptions, factory?: (resolved: Required<KeepaliveOptions>) => unknown): InstallSnapshot | null;
-/** Inspect current install state — used by /health + diagnostics. */
-export declare function getPerfKeepaliveSnapshot(): InstallSnapshot | null;
-/** Test hook — clear the install snapshot so the next call reinstalls. */
-export declare function _resetPerfKeepaliveForTests(): void;
-export {};

package/dist/src/lib/json-array.d.ts

@@ -1,10 +0,0 @@
-/**
- * Safe JSON-array file reader — used by cwd-patch's resume-registry helpers.
- *
- * Extracted from `session-bootstrap/cwd-patch.ts` 2026-05-13 as a pure-function
- * hot-path decomposition. Bounded I/O (read-only); idempotent for the same
- * file contents; never throws.
- *
- * Returns `null` for missing/malformed/non-array files.
- */
-export declare function readJSONArraySafe(filePath: string): unknown[] | null;

package/dist/src/lib/markdown-to-mdv2.d.ts

@@ -1,53 +0,0 @@
-/**
- * markdown-to-mdv2 — v0.20.2 Slice 6 "rich render" converter.
- *
- * Converts a subset of CommonMark Markdown to Telegram MarkdownV2 with
- * STRUCTURE PRESERVED — `**bold**` becomes `*bold*` (Telegram bold), not
- * `\*\*bold\*\*` (literal asterisks). Companion to markdown-v2.ts whose
- * escapeMarkdownV2 escapes EVERYTHING including syntax markers.
- *
- * Why both: markdown-v2.ts is the safe fallback for content where loss of
- * formatting is acceptable but loss of punctuation isn't (v0.20.1 fix).
- * This module is the rich path — gated by CC_OPENCLAW_RICH_RENDER=1, off
- * by default in v0.20.2 so the chat-bubble path can opt in without
- * regressing the v0.20.1 guarantee for un-opted callers.
- *
- * Supported source syntax → Telegram MarkdownV2 output:
- *   `**bold**`          → `*bold*`
- *   `*italic*`          → `_italic_`        (single-asterisk italic)
- *   `_italic_`          → `_italic_`
- *   `` `inline code` `` → `` `inline code` ``  (content backslash-escaped)
- *   ` ```lang\n…\n``` ` → ` ```lang\n…\n``` `  (preserved verbatim)
- *   `# Header` / `## H2` / `### H3` … `###### H6` → `*Header*`
- *   `[label](url)`      → `[label](url)`     (label escaped, url paren-escaped)
- *   All other content   → backslash-escaped per MarkdownV2 spec
- *
- * Out of scope (intentional v0 limits — keeps the converter <150 LOC and
- * easy to reason about; expand in v0.20.3+ if A1 hits the gap):
- *   - Nested formatting (`**bold _italic_**`) — inner is escaped as plain text
- *   - Block quotes (`> quote`) — emitted as escaped text
- *   - Lists (`- item`, `1. item`) — markers escaped, content escaped (no list semantics in Telegram MarkdownV2 anyway)
- *   - Tables — markdown tables don't render in Telegram regardless
- *   - HTML tags — content-escaped
- *
- * Algorithm (placeholder substitution, NUL-sentinel keyed):
- *   1. Extract code fences → placeholders (highest priority — content inside is verbatim)
- *   2. Extract inline code → placeholders (same priority — content escape rules differ)
- *   3. Extract bold (`**…**`) → placeholders with body text-escaped
- *   4. Extract italic (`*…*` and `_…_`) → placeholders
- *   5. Extract headers (`#…`) at line start → placeholders
- *   6. Extract links (`[label](url)`) → placeholders
- *   7. Escape remaining body as plain text (every MarkdownV2 special char)
- *   8. Restore placeholders verbatim
- *
- * NUL (0x00) sentinels chosen because:
- *   - NUL is not in the MarkdownV2 special-char set (won't be escaped in step 7)
- *   - Digits in the index suffix are also not in the special-char set
- *   - "CODE"/"BOLD"/etc letters are not in the special-char set
- *   So placeholders survive the bulk-escape step intact.
- */
-/**
- * Convert standard CommonMark Markdown to Telegram MarkdownV2 with structural
- * syntax preserved. Returns '' for null/undefined.
- */
-export declare function markdownToMdv2(input: string | null | undefined): string;

package/dist/src/lib/markdown-v2.d.ts

@@ -1,27 +0,0 @@
-/**
- * markdown-v2 — Telegram MarkdownV2 escape utility.
- *
- * Ported from workspace/lib/telegram-ux/telegram-renderer.js (line 97 + the
- * MARKDOWNV2_SPECIAL_CHARS regex at line 56) so cc-openclaw's chat-bubble
- * path can pre-escape raw assistant text before sending to Telegram.
- *
- * Why this lives in cc-openclaw's lib (vs reusing the workspace function):
- * the workspace path is CommonJS and only available when the telegram-ux
- * module is loaded at runtime. Pre-escape must happen on the queue path,
- * before the workspace module is necessarily loaded, so we inline it.
- *
- * History — the prior fallback in card-renderer.ts stripped these same
- * chars from CONTENT when MarkdownV2 parse failed, producing the
- * "period-touches-cap" symptom (every `.` removed from the assistant
- * text). The escape function below makes the first MarkdownV2 send
- * succeed for raw text so the fallback is rarely reached at all.
- */
-/**
- * Escape every Telegram MarkdownV2 special char in `text` so the message
- * is rendered as plain content. Markdown syntax (bold/italic/code) is
- * also escaped — formatting will NOT render, but ALL content punctuation
- * is preserved (periods, hyphens, parens, etc.).
- *
- * Returns '' for null/undefined.
- */
-export declare function escapeMarkdownV2(text: string | null | undefined): string;

package/dist/src/lib/perf/async-compact.d.ts

@@ -1,26 +0,0 @@
-/**
- * M6 (perf overhaul idea #6) — async-lossless-compaction scheduler.
- *
- * Lossless-claw's DAG summarization currently runs on the hot path (turn N
- * blocks while compaction completes). This scheduler defers the work to a
- * setImmediate callback so turn N returns immediately; the summary lands
- * before turn N+1 reads it (or N+1 skips the stale summary if compaction
- * hasn't finished — that branch is the cost of the speedup).
- *
- * Flag: CC_OPENCLAW_PERF_ASYNC_COMPACT (default OFF, medium risk —
- * compaction freshness can drift if N+1 fires before N's compaction lands).
- *
- * Per-session serialization: only one async compaction in flight per
- * sessionKey at a time. Subsequent calls during in-flight work are dropped
- * (the in-flight one will pick up the latest state at execution time).
- */
-export interface AsyncCompactResult {
-    scheduled: boolean;
-    reason: 'flag_off' | 'in_flight' | 'scheduled';
-}
-/**
- * Schedule `compactFn` to run after the current turn returns. Returns
- * synchronously; the caller never awaits compaction completion.
- */
-export declare function scheduleAsyncCompaction(sessionKey: string, compactFn: () => Promise<void> | void): AsyncCompactResult;
-export declare function _resetAsyncCompactForTests(): void;

package/dist/src/lib/perf/direct-sdk.d.ts

@@ -1,26 +0,0 @@
-/**
- * M12 (perf overhaul idea #12) — direct claude-code SDK in-process.
- *
- * Bypasses the `claude` CLI subprocess entirely by calling the
- * `@anthropic-ai/claude-code` SDK in the cc-openclaw Node process.
- * Eliminates all subprocess overhead (Node bootstrap, bundle parse, auth
- * handshake) at the cost of losing CLI session/checkpoint features and
- * recoupling to upstream SDK API churn.
- *
- * Flag: CC_OPENCLAW_PERF_DIRECT_SDK (default OFF, HIGH RISK — ships LAST
- * with the resident-CLI pool as the fallback).
- *
- * Probes the SDK availability without bringing it as a hard dependency:
- * dynamic require with a swallowed ENOENT. The actual invocation is
- * delegated to the registered handler — session-manager owns the call
- * details (model, prompt, options) and decides whether the SDK supports
- * the requested feature set for this turn.
- */
-export interface DirectSdkAvailability {
-    enabled: boolean;
-    available: boolean;
-    reason: 'flag_off' | 'sdk_missing' | 'sdk_loaded' | 'probe_error';
-    version: string | null;
-}
-export declare function probeDirectSdkAvailability(): DirectSdkAvailability;
-export declare function _resetDirectSdkProbeForTests(): void;

package/dist/src/lib/perf/haiku-route.d.ts

@@ -1,19 +0,0 @@
-/**
- * M10 (perf overhaul idea #10) — Haiku 4.5 cheap-route classifier.
- *
- * Pattern-matches trivial queries that don't need Opus-level reasoning:
- * status checks, simple acks, short factual lookups. When matched, the
- * caller routes the request to Haiku via the OpenAI-compat fallback
- * pipeline (NOT direct Anthropic API — A1 has no anthropic.com key, only
- * Max 20x subscription). Sub-500ms; zero Max quota burn.
- *
- * Flag: CC_OPENCLAW_PERF_HAIKU_ROUTE (default OFF).
- *
- * Conservative by design: any uncertainty falls back to Opus. False positives
- * are user-visible quality regressions; false negatives just miss a perf win.
- */
-export interface RouteDecision {
-    routeToHaiku: boolean;
-    reason: 'trivial_pattern' | 'too_long' | 'complex_token' | 'flag_off' | 'no_match';
-}
-export declare function classifyForHaikuRoute(prompt: string): RouteDecision;

package/dist/src/lib/perf/predictive-continuation.d.ts

@@ -1,18 +0,0 @@
-/**
- * M11 (perf overhaul idea #11) — predictive continuation detector.
- *
- * Returns a confident yes/no when a user's incoming message is a pure
- * continuation request ("more", "continue", "and?", "go on"). When true,
- * the caller can start generation against the previous turn's tail before
- * the user finishes typing, giving the perceived-instant feel on common
- * follow-ups. False on ambiguous input keeps the regular dispatch path.
- *
- * Flag: CC_OPENCLAW_PERF_PREDICTIVE_CONTINUE (default OFF).
- */
-export interface ContinuationDecision {
-    /** True iff the text is a confident continuation request. */
-    isContinuation: boolean;
-    /** Matched pattern source for telemetry; empty when isContinuation=false. */
-    matched: string;
-}
-export declare function isPredictiveContinuation(text: string): ContinuationDecision;

package/dist/src/lib/perf/read-batch.d.ts

@@ -1,33 +0,0 @@
-/**
- * M7 (perf overhaul idea #7) — Read([paths]) parallel batch reader.
- *
- * The legacy flow is N serial Read tool calls = N LLM round trips. This
- * helper reads an array of paths concurrently in a single Node.js step,
- * returning a structured result the tool-router collapses into one
- * tool_result delta. Eliminates the per-file LLM round trip cost.
- *
- * Flag: CC_OPENCLAW_PERF_READ_BATCH (default OFF, medium risk — tool
- * schema change requires sub-agent training to use the batched form).
- *
- * Per-file failures are isolated: an unreadable file produces an error
- * entry in the result rather than failing the whole batch. Encoding is
- * fixed to utf8 to match the existing Read tool semantics.
- */
-export interface BatchReadEntry {
-    path: string;
-    content: string | null;
-    error: string | null;
-    bytes: number;
-}
-export interface BatchReadResult {
-    enabled: boolean;
-    entries: BatchReadEntry[];
-    totalBytes: number;
-    errorCount: number;
-}
-/**
- * Read up to MAX_BATCH_SIZE paths in parallel. When the flag is off,
- * returns `enabled: false` with an empty entry list — caller falls back
- * to the per-file path. Per-file failures populate `.error`, not throw.
- */
-export declare function batchReadPaths(paths: string[]): Promise<BatchReadResult>;

package/dist/src/lib/perf/skill-list-collapse.d.ts

@@ -1,22 +0,0 @@
-/**
- * M4 (perf overhaul idea #4) — collapse <available_skills> sysprompt block.
- *
- * The block is ~3K tokens of skill names + descriptions. Almost every turn
- * the user invokes 0 or 1 skill, so the full listing is dead weight in the
- * cache-relevant prefix. This collapses it to a one-line hint that points
- * the model at an on-demand `openclaw skills list` tool call.
- *
- * The collapse is text-level so it composes with sysprompt-strip.ts without
- * coupling to its pipeline. Caller invokes after the strip pass.
- *
- * Flag: CC_OPENCLAW_PERF_SKILL_ONDEMAND (default OFF).
- *
- * Idempotent — replacing an already-collapsed sysprompt is a no-op.
- */
-export interface CollapseResult {
-    content: string;
-    changed: boolean;
-    bytesRemoved: number;
-}
-/** Collapse the <available_skills> block; no-op when the flag is off. */
-export declare function collapseSkillList(sysprompt: string): CollapseResult;

package/dist/src/lib/perf/speculative-bubble.d.ts

@@ -1,27 +0,0 @@
-/**
- * src/lib/perf/speculative-bubble.ts — v0.25.0 M16 migration target.
- *
- * Migrated from src/channels/telegram/speculative-bubble.ts unchanged
- * except for the sendTg import path (legacy card-renderer → new
- * src/lib/telegram-bot-api.ts).
- *
- * M9 (perf overhaul idea #9). Fires a Telegram sendMessage at t≈50ms
- * after the user submits, BEFORE the model returns first token. Pure
- * perception fix — shortens the user-visible "did the bot get my
- * message?" window from ~400-800ms to ~50ms.
- *
- * Flag: CC_OPENCLAW_PERF_SPEC_BUBBLE (default OFF; opt-in via =1).
- */
-export interface SpeculativeBubbleOptions {
-    chatId: string;
-    threadId?: string | undefined;
-    /** Text to emit. Defaults to a one-cell braille spinner + "Thinking…". */
-    text?: string;
-    /** Reply-to message id (the user's submitted message). Optional. */
-    replyToMessageId?: number | null;
-}
-/**
- * Emit the speculative bubble. Returns the new message_id on success,
- * null if the flag is off / chatId is missing / send failed. Never throws.
- */
-export declare function emitSpeculativeThinking(opts: SpeculativeBubbleOptions): Promise<number | null>;

package/dist/src/lib/perf/typing-prefetch.d.ts

@@ -1,25 +0,0 @@
-/**
- * M2 (perf overhaul idea #2) — typing-prefetch subprocess warmup.
- *
- * Telegram emits `sendChatAction` upstream events while the user is typing
- * (the "typing…" indicator). This module debounces those signals into a
- * single "warm the subprocess pool for this chatId" trigger, then invokes
- * the registered warmup callback. The actual subprocess.spawn() is owned
- * by the session-manager / cli pool — this module is just the signal layer.
- *
- * Flag: CC_OPENCLAW_PERF_TYPING_PREFETCH (default OFF).
- *
- * Coalescing: at most one warmup per chatId per WARMUP_COOLDOWN_MS. Prevents
- * "typing… typing… typing…" hammer events from spawning N subprocesses.
- */
-export declare const WARMUP_COOLDOWN_MS = 4000;
-/** Register the actual warmup callback (called by session-manager bootstrap). */
-export declare function setWarmupHandler(fn: ((chatId: string) => void) | null): void;
-/**
- * Notify that user is typing in chatId. Triggers warmup at most once per
- * cooldown window. No-op when flag off, no handler registered, or in cooldown.
- * Returns true iff a warmup was actually triggered.
- */
-export declare function notifyTyping(chatId: string, now?: number): boolean;
-/** Test hook — reset the cooldown map. */
-export declare function _resetTypingPrefetchForTests(): void;

package/dist/src/lib/probes.d.ts

@@ -1,50 +0,0 @@
-/**
- * src/lib/probes.ts — Phase-0 empirical probe instrumentation (planning P0-A/B/C).
- *
- * OBSERVE-ONLY. Gated by `CC_OPENCLAW_PROBE=1` so it is completely silent — zero
- * behavior change, no log output — in normal operation. The operator (A1)
- * enables it for a single probe session, exercises the relevant Telegram
- * interaction, then greps stderr for the `[cc-openclaw/probe]` markers. The
- * runbook (PROBES-RUNBOOK in the planning dir) has the exact steps + how to read
- * the results.
- *
- * These resolve the load-bearing seams that CANNOT be read from source because
- * they depend on OpenClaw gateway runtime behavior:
- *   P0-A: does `enqueueNextTurnInjection` trigger a run, or only stage context
- *         for the next user message? (decides feature #1 Approve + #3 /send)
- *   P0-B: does an `ExitPlanMode` tool_use ever fire on the bypassPermissions
- *         Telegram path? (decides feature #1's trigger)
- *   P0-C: does a Telegram photo reach the plugin as an image block — at
- *         before_dispatch and/or in the openai-compat request body (where
- *         message-extractor strips non-text parts) — or is it gateway-stripped?
- *         (decides whether feature #2 is plugin-side feasible at all)
- */
-/**
- * P0-A — log each `enqueueNextTurnInjection` call site. The operator correlates
- * this with whether a reply arrives in Telegram WITHOUT typing a follow-up
- * message: if it does, injection triggers a run; if not, it only stages context.
- */
-export declare function probeInjectionEnqueued(sessionKey: string, source: string): void;
-/**
- * P0-B — log when a tool_use is `ExitPlanMode` (and any other tool name, for
- * context). Looks across the known event field paths, mirroring
- * inbound-handler.extractToolUse so it works whatever shape the gateway uses.
- */
-export declare function probeToolUse(ev: Record<string, unknown> | undefined): void;
-/**
- * P0-C (inbound surface) — dump the before_dispatch event, flagging whether it
- * carries any media field, so the operator sees whether photo/document surface
- * to the plugin at all.
- */
-export declare function probeInboundShape(event: unknown): void;
-/**
- * P0-C (openai-compat body) — the PRECISE probe. Does an image block survive to
- * the request body, where `message-extractor.ts` strips non-text parts? Logs
- * each non-text content-part type. If image parts appear here, feature #2 is
- * feasible plugin-side (preserve them through extractUserMessage); if nothing
- * non-text ever appears, the image is gateway-stripped upstream → hands-off-blocked.
- */
-export declare function probeMultimodalContent(messages: Array<{
-    role?: string;
-    content?: unknown;
-}> | undefined): void;