@a1hvdy/cc-openclaw 0.30.0 → 0.32.0

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;

package/dist/src/lib/register-guard.d.ts

@@ -1,56 +0,0 @@
-/**
- * Centralized register-guard — eliminates listener stacking systemwide.
- * Each plugin module gets its own guard instance via createRegisterGuard().
- * Multiple register() calls with same (api, id) → no-op; new api → re-fire.
- *
- * Rationale (revised 2026-05-06 after observed dispatch-registry blackout):
- * The openclaw gateway 2026.4.29+ creates MULTIPLE plugin registries per
- * process when running in `gateway-bindable` runtime mode (origin=bundled
- * plugins activate it; the loader at loader-CLyHx60E.js:3690-3697 attempts
- * to merge subsequent default-mode loads into the gateway-bindable
- * registry, but this only succeeds when cache keys match). When cache keys
- * differ, the boot-time register() lands in registry A, and the dispatch
- * path reads from registry B — hooks register fine but never invoke.
- *
- * Process-wide id-only keying (the 2026-04-29 approach) blocked re-wiring
- * into registry B because the second register() call hits the guard and
- * skips its api.on() calls — leaving no listeners in the dispatch registry
- * even though they DID register in the boot registry.
- *
- * Current behavior: track per-(api, id) via WeakMap<api, Set<id>>. Same
- * api object passed twice → idempotent skip. New api object → fresh
- * Set, body re-fires, api.on() lands in the new registry. The 2026-04-29
- * stacking concern (multiple api instances wrapping ONE shared bus →
- * listener duplication) is resolved at the wrapApiWithDebugTap layer and
- * by api.on's own dedup; per-bus idempotency is the wrong layer here.
- *
- * Fallback: if api is null/undefined/primitive, use a process-wide Set
- * (no WeakMap key available). Preserves safety for synthetic test calls.
- *
- * Telemetry: when OPENCLAW_REGISTER_DEBUG=1, emits a structured event per
- * register call (id, registered_before, timestamp). Sibling agent
- * cco-hardening-B implements telemetry.ts which consumes these events.
- */
-export interface RegisterGuard {
-    /** Wraps the actual register body — runs once per (api, id) pair. */
-    guard(id: string, api: unknown, body: () => void): void;
-    /** Test-only reset (clears fallback only; WeakMap GCs naturally). */
-    _resetForTests(): void;
-    /** Inspector for tests / telemetry (fallback Set only). */
-    isRegistered(id: string): boolean;
-}
-export declare function createRegisterGuard(): RegisterGuard;
-/** Default singleton — most modules import this directly for simplicity. */
-export declare const defaultRegisterGuard: RegisterGuard;
-/**
- * `registerOnce(id, api, body)` — preferred shorthand for the v3 §5 hard-rule
- * contract: every `api.on(...)` call site must live inside an idempotency
- * wrapper. Delegates to `defaultRegisterGuard.guard(id, api, body)` —
- * semantically identical, just shorter at call sites.
- *
- * The CI check `scripts/check-register-once.sh` greps for any `api.on(`
- * line whose containing module does NOT also reference `registerOnce` or
- * `defaultRegisterGuard.guard`. Either form passes; bare `api.on()` calls
- * (no idempotency wrapper) fail.
- */
-export declare function registerOnce(id: string, api: unknown, body: () => void): void;

package/dist/src/lib/req-shape-log.d.ts

@@ -1,31 +0,0 @@
-/**
- * Diagnostic: privacy-safe request-shape logger.
- *
- * Purpose: investigate the "Acknowledged — no user request to act on" failure
- * mode where Claude responds as if no user turn exists in the conversation.
- * The leading hypothesis is that Savvy/OpenClaw is shipping `content` in a
- * shape that `message-extractor.ts:textOf` returns `''` for, producing an
- * empty user turn that Claude treats as no-input.
- *
- * Privacy contract: this logger NEVER writes content text. It records only
- * the structural shape of the incoming `messages[]` — kind, length, and
- * for content arrays, the key-set + type-field of each part. That's enough
- * to identify a field-name mismatch (e.g., `.value` vs `.text`) without
- * leaking the actual question text.
- *
- * Activation: `CC_OPENCLAW_REQ_SHAPE_LOG=1`. No-op when unset.
- *
- * Output: NDJSON appended to
- *   `~/.openclaw/workspace/memory/cc-openclaw-req-shape.jsonl`
- *
- * Lifecycle: enable for 24h, diagnose, then set the env flag to 0. The
- * env-gate keeps the cost at zero (one `process.env` check) when disabled,
- * so the module can stay in the tree as a dormant diagnostic primitive.
- */
-import type { OpenAIChatCompletionRequest } from '../openai-compat/openai-compat.js';
-/**
- * Append a shape-only record describing the incoming request. Best-effort:
- * any IO error is swallowed (we don't want diagnostic logging to break a
- * real request).
- */
-export declare function logReqShape(request: OpenAIChatCompletionRequest, sessionName: string): void;

package/dist/src/lib/safe-upstream-probes.d.ts

@@ -1,25 +0,0 @@
-/**
- * Safe upstream-probe helpers.
- *
- * openclaw's `loadConfig()` runs strict zod schema validation that REJECTS
- * cc-openclaw-specific keys (per Phase E#3 finding 4, 2026-05-13). For probe
- * use at boot phase 3, cc-openclaw needs to read openclaw.json without going
- * through that schema validation — exactly what the legacy `cwd-patch.ts`
- * applyPatch does via raw `JSON.parse(readFileSync(...))`.
- *
- * These helpers encapsulate the safe-read pattern so PatchSpec
- * `expectedBehavior` probes can verify config-related contracts without
- * triggering the schema-rejection failure mode.
- */
-/**
- * Read `~/.openclaw/openclaw.json` via raw JSON.parse — bypasses openclaw's
- * loadConfig schema validation. Returns null if the file is missing or
- * malformed (no throw — probe-friendly).
- */
-export declare function safeReadOpenclawJson(): unknown;
-/**
- * Verify openclaw.json is parsable + is an object. Used as a probe-safe
- * proxy for "openclaw config is reachable" without going through
- * `loadConfig()` (which throws on cc-openclaw-tuned configs).
- */
-export declare function probeOpenclawJsonReachable(): boolean;

package/dist/src/lib/session-registry.d.ts

@@ -1,66 +0,0 @@
-/**
- * src/lib/session-registry.ts — v0.25.0 M1: slug ↔ sessionName persistence.
- *
- * Telegram Terminal Mirror needs to remember which Claude session belongs to
- * each project slug ("cc-openclaw" / "loopedin" / "how-to-a1" / ...) across
- * gateway restarts. /sessions, /new, /stop, callback-data lookups all rely
- * on this mapping.
- *
- * Decision: ADR-003 — JSON file at ~/.openclaw/session-registry.json with
- * atomic tmpfile + rename writes; corrupted-file fallback to empty in-memory
- * state with a one-line warn log. Rationale: registry is tiny (≤50 entries,
- * ~120 bytes each), JSON is grep-able, survives gateway restarts; SQLite is
- * overkill at this scale; plugin-local files get blown away on upgrade.
- *
- * Atomic-write pattern mirrors src/session-bootstrap/resume-registry.ts —
- * the same writeFileSync(tmp) + renameSync(tmp, path) shape, which is the
- * canonical idiom in cc-openclaw.
- *
- * Concurrency model: in-process only. JS is single-threaded, so back-to-back
- * register() calls serialize naturally; the renameSync at the end of save()
- * is also atomic on POSIX. Cross-process writes (multiple gateways pointing
- * at the same HOME) are NOT supported and would race; cc-openclaw is
- * single-gateway-per-host by design.
- */
-export interface SessionRegistryEntry {
-    /** Short human-readable project identifier, e.g. "cc-openclaw". */
-    slug: string;
-    /** Claude session name used by PersistentClaudeSession / session-manager. */
-    sessionName: string;
-    /** ISO timestamp of the first register(slug, …) call. */
-    createdAt: string;
-    /** ISO timestamp of the most recent register or touch. */
-    lastUsedAt: string;
-}
-/**
- * Insert or update a slug → sessionName mapping. Returns the resulting
- * entry. Throws on empty slug or empty sessionName.
- */
-export declare function register(slug: string, sessionName: string): SessionRegistryEntry;
-/**
- * Remove the entry for the given slug. Returns true if an entry was removed,
- * false if no entry matched.
- */
-export declare function unregister(slug: string): boolean;
-/**
- * Snapshot copy of all registered entries. Caller may not mutate the result.
- */
-export declare function list(): SessionRegistryEntry[];
-/**
- * Lookup by slug; returns undefined when no entry matches.
- */
-export declare function getBySlug(slug: string): SessionRegistryEntry | undefined;
-/**
- * Lookup by sessionName; returns undefined when no entry matches.
- */
-export declare function getByName(sessionName: string): SessionRegistryEntry | undefined;
-/**
- * Touch lastUsedAt without changing sessionName. Useful for /sessions tap
- * activity tracking (M3). Returns the updated entry or undefined.
- */
-export declare function touch(slug: string): SessionRegistryEntry | undefined;
-/**
- * Test-only: clear the in-memory cache so the next load() re-reads disk.
- * Production code never calls this.
- */
-export declare function _resetForTests(): void;

package/dist/src/lib/spawn-async.d.ts

@@ -1,18 +0,0 @@
-/**
- * Promise-wrapped child_process.spawn with optional timeout.
- *
- * Extracted from `council/council.ts` 2026-05-13 as a pure-function hot-path
- * decomposition. No module state; safe to share across callers.
- *
- * Resolves with {stdout, stderr} on exit code 0; rejects with stderr on
- * non-zero exit, the literal Error 'spawn timeout' on timeout fire, or
- * the propagated spawn error.
- */
-export interface SpawnAsyncOptions {
-    timeout?: number;
-    cwd?: string;
-}
-export declare function spawnAsync(cmd: string, args: string[], opts?: SpawnAsyncOptions): Promise<{
-    stdout: string;
-    stderr: string;
-}>;

package/dist/src/lib/status-tee-reader.d.ts

@@ -1,29 +0,0 @@
-/**
- * status-tee-reader — reads quota status files written by the existing
- * telegram-ux/quota-fetcher.js process at /tmp/openclaw-ux-status/.
- *
- * The fetcher (in a different process, CJS) periodically polls Anthropic's
- * /api/oauth/usage and writes JSON snapshots to /tmp/openclaw-ux-status/.
- * cc-openclaw consumes them via this reader rather than importing the
- * fetcher directly (cross-process + CJS/ESM mismatch).
- *
- * If no fresh file exists (cold-boot, fetcher offline, >10min stale),
- * returns null. The /cc status panel renders "Plan: ?% (no data)" then.
- */
-interface QuotaWindow {
-    usedPercent: number;
-    resetsAt: number;
-}
-export interface QuotaSnapshot {
-    fiveHour: QuotaWindow | null;
-    sevenDay: QuotaWindow | null;
-    ageMs: number;
-}
-/** Read most recent status-tee file. Returns null if missing/stale/invalid. */
-export declare function readQuotaSnapshot(dir?: string): QuotaSnapshot | null;
-/**
- * Convert quota snapshot to a single-line panel summary.
- * Color emoji: 🟢 <60%, 🟡 60-85%, 🔴 >85%.
- */
-export declare function formatQuotaLine(snapshot: QuotaSnapshot | null): string;
-export {};

package/dist/src/lib/sysprompt-strip.d.ts

@@ -1,53 +0,0 @@
-/**
- * Sysprompt aggressive strip — canonical pure function.
- *
- * Default-on in cc-openclaw (vs upstream's opt-in OPENCLAW_AGGRESSIVE_STRIP=1).
- * Env semantic FLIPPED: OPENCLAW_AGGRESSIVE_STRIP=0 explicitly OPTS OUT;
- * any other value (including unset) keeps strip ENABLED.
- *
- * Cuts cold-turn sysprompt overhead from ~12,001 tok baseline / 6,100 tok
- * (upstream-strip-on) to target ≤4,000 tok (PRP NFR target).
- *
- * Called by src/session-bootstrap/sysprompt-strip.ts which adds the env
- * resolution + plugin lifecycle wiring on top.
- *
- * Source: savvy-claude-code/cwd-enhancer.js lines 800–856 (inside applyRoutePatch)
- * Original P1 port: src/session-bootstrap/sysprompt-strip.ts
- */
-export interface StripOptions {
-    /** Override env detection — force strip enabled. Used by tests + lifecycle wiring. */
-    forceEnabled?: boolean;
-    /** Override env detection to disable — used by tests. */
-    forceDisabled?: boolean;
-}
-export interface StripResult {
-    content: string;
-    /** true if any stripping was applied */
-    changed: boolean;
-    /** true if aggressive strip made additional changes (always true when enabled) */
-    aggressiveStripped: boolean;
-}
-/**
- * Resolve whether strip should run based on env + options.
- *
- * Default: ENABLED. Opt-out by setting OPENCLAW_AGGRESSIVE_STRIP=0, 'false', or 'off'.
- * Explicit OPENCLAW_AGGRESSIVE_STRIP=1 (upstream convention) also enables (backward compat).
- */
-export declare function isStripEnabled(opts?: StripOptions): boolean;
-/**
- * Strip volatile / redundant sections from an OpenClaw system prompt string.
- *
- * Strips (always when enabled):
- *   - SELF_IMPROVEMENT_REMINDER.md filename-marker headers
- *   - ## Self-Improvement Reminder blocks (through next heading or EOF)
- *   - <location>…</location> lines inside the skills catalog
- *     (~7,000 chars / ~1,750 tokens per cold turn — pure dead weight for model)
- *   - F2.1: **Tool escalation:** numbered cheat-sheet block (~600 chars / ~150 tokens)
- *     (F2.2 was removed 2026-04-25: the 45-bullet list no longer appears)
- *
- * Pure function — no side effects, no env reads (use isStripEnabled() for that).
- * Returns input unchanged when disabled via opts.
- *
- * Source: cwd-enhancer.js lines 800–856; P1 port: session-bootstrap/sysprompt-strip.ts
- */
-export declare function stripSysprompt(content: string, opts?: StripOptions): StripResult;

package/dist/src/lib/telegram-bot-api.d.ts

@@ -1,146 +0,0 @@
-/**
- * src/lib/telegram-bot-api.ts — v0.25.0 M16 extracted HTTP layer.
- *
- * Pre-M16 the Telegram Bot API helpers lived inside the legacy live-card +
- * card-renderer modules. M16 deletes those modules, but a handful of lib/
- * utilities (error-renderer.ts, perf/speculative-bubble.ts) still need to
- * dispatch Telegram messages. This file is the migrated, slim HTTP layer:
- *   • telegramApi(method, params)  — generic POST to api.telegram.org
- *   • sendTg(chatId, text, ...)    — sendMessage with MarkdownV2 + plain
- *                                    text fallback (preserves v0.20.1
- *                                    content-punctuation fix).
- *   • editTg(chatId, msgId, text…) — editMessageText with same fallback +
- *                                    429 retry handling.
- *   • BOT_TOKEN exported as a mutable getter (mutated via setBotToken /
- *     initBotTokenFromConfig at boot).
- *
- * Token sourcing on boot (initBotTokenFromConfig):
- *   1. api.config.channels.telegram.accounts[defaultAccount].botToken
- *   2. ~/.openclaw/openclaw.json → same JSON path
- *   3. fallthrough: BOT_TOKEN stays '' and renderer/sendTg return false.
- *
- * The mirror channel's register() (M0..M14 + M15-cutover-default) calls
- * initBotTokenFromConfig(api) at boot — the same shape the legacy live-card
- * used to do.
- */
-export declare const OPENCLAW_CONFIG_PATH: string;
-/**
- * Mutable getter for the current bot token. Callers should treat it as
- * read-only at runtime; use setBotToken / initBotTokenFromConfig to mutate.
- */
-export declare function getBotToken(): string;
-/**
- * Imperative setter — for tests + explicit init paths. Returns the
- * previous value so test cleanup can restore.
- */
-export declare function setBotToken(token: string): string;
-/**
- * Back-compat alias — legacy code did `import { BOT_TOKEN } from ...`. We
- * preserve the binding via a frozen wrapper that always reflects the
- * current token. Existing read-sites get the current value; existing
- * write-sites (none expected — legacy only wrote via setBotToken under
- * a different name) would need migration.
- *
- * Using a getter-backed object also lets `if (!BOT_TOKEN)` work
- * idiomatically; the property is read on every access.
- */
-export declare const BOT_TOKEN: {
-    readonly value: string;
-};
-/**
- * Boot-time initialiser. Reads the configured Telegram bot token from
- * either api.config.channels.telegram.accounts or ~/.openclaw/openclaw.json.
- * Returns true when a token was loaded.
- */
-export interface BotConfigSource {
-    config?: {
-        channels?: {
-            telegram?: {
-                defaultAccount?: string;
-                accounts?: Record<string, {
-                    botToken?: string;
-                }>;
-            };
-        };
-    };
-    logger?: {
-        info: (msg: string) => void;
-        warn: (msg: string) => void;
-    };
-}
-export declare function initBotTokenFromConfig(api?: BotConfigSource): boolean;
-export interface TelegramApiResponse {
-    ok: boolean;
-    result?: {
-        message_id?: number;
-    };
-    error_code?: number;
-    description?: string;
-    parameters?: {
-        retry_after?: number;
-    };
-}
-/**
- * Low-level POST to api.telegram.org. Resolves with the parsed JSON
- * response, or {ok:false} on JSON parse failure / network error
- * (rejection is the caller's signal for a truly unreachable endpoint).
- */
-export declare function telegramApi(method: string, params: Record<string, unknown>): Promise<TelegramApiResponse>;
-/**
- * v0.27.4 M6 — CLI-parity gap #8: split a message that exceeds Telegram's 4096
- * char cap into ≤max-char chunks so long cc-openclaw-originated content sends as
- * sequential messages instead of being rejected outright. Splits on newline
- * boundaries (never mid-line) so HTML constructs mostly stay intact; a single
- * line longer than max is hard-split. Returns [text] unchanged when ≤max (the
- * common path — no behavior change for normal messages).
- *
- * Scope note: this covers cc-openclaw's OWN sends (slash/error responses). The
- * live card is one edited message (truncated by design) and the model's final
- * answer is delivered by the OpenClaw gateway — neither flows through here.
- */
-export declare function splitForTelegram(text: string, max?: number): string[];
-/**
- * sendMessage with HTML parse_mode first + plain-text fallback. The fallback
- * is the v0.20.1 fix: prior implementation stripped punctuation on parse
- * errors; current behaviour retries with parse_mode omitted so all content
- * survives. (v0.27.0 switched the live mirror MarkdownV2 → HTML; v0.27.3
- * converted the last MarkdownV2 emitter, error-formatter, so the whole
- * Telegram surface is now one HTML render path.) v0.27.4 M6 — auto-chunks
- * over-cap text and the plain fallback now strips HTML (was: re-sent raw tags).
- */
-export declare function sendTg(chatId: string | number, text: string, threadId?: string | number, replyMarkup?: unknown, replyToMessageId?: number | null): Promise<TelegramApiResponse>;
-/**
- * editMessageText with HTML parse_mode + 429 retry-after handling +
- * plain-text fallback (v0.27.3 stripHtml fallback on rejection).
- */
-export declare function editTg(chatId: string | number, messageId: number, text: string, replyMarkup?: unknown): Promise<TelegramApiResponse>;
-export interface SendDocumentOptions {
-    caption?: string;
-    parseMode?: 'HTML' | 'MarkdownV2';
-    threadId?: string | number;
-    replyMarkup?: unknown;
-}
-/**
- * Build a multipart/form-data body for sendDocument. PURE — no I/O — so the
- * encoding (the R-3 risk) is unit-testable without a network round-trip.
- *
- * The document is sent as an inline InputFile (Content-Type text/markdown). The
- * boundary MUST NOT appear in any field value or the file content; callers use a
- * random 16-byte boundary (sendDocumentTg) so collision is astronomically
- * unlikely against Markdown plan bodies.
- */
-export declare function buildDocumentMultipart(opts: {
-    boundary: string;
-    chatId: string | number;
-    filename: string;
-    content: string;
-    caption?: string;
-    parseMode?: 'HTML' | 'MarkdownV2';
-    threadId?: string | number;
-    replyMarkup?: unknown;
-}): Buffer;
-/**
- * Upload a text document (e.g. a plan .md) to a chat via sendDocument. Returns
- * the API response, or {ok:false} on network/encoding failure (never throws).
- */
-export declare function sendDocumentTg(chatId: string | number, filename: string, content: string, opts?: SendDocumentOptions): Promise<TelegramApiResponse>;

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

@@ -1,38 +0,0 @@
-/**
- * cc-openclaw telemetry — append-only jsonl writers for per-turn metrics.
- *
- * Two streams:
- *  - cost: per-turn token cost (input/output/cache) — for A/B comparison
- *    against claude-local + future dashboards
- *  - register: register-guard events for stacking detection (PRP NFR target:
- *    0 stacking events per 1k starts)
- *
- * Defaults default-on (per PRP). Disabled when OPENCLAW_TOKEN_TELEMETRY=0
- * (cost) or OPENCLAW_REGISTER_DEBUG=0 (register).
- */
-export declare const COST_PATH: string;
-export declare const REGISTER_PATH: string;
-export interface CostEvent {
-    ts: string;
-    sessionId: string;
-    turn: number;
-    model: string;
-    inputTokens: number;
-    outputTokens: number;
-    cacheCreationTokens?: number;
-    cacheReadTokens?: number;
-    durationMs: number;
-    channel?: string;
-}
-export interface RegisterEvent {
-    ts: string;
-    type: 'register-guard.fire' | 'register-guard.skip';
-    id: string;
-    apiChanged?: boolean;
-    reason?: 'first' | 'same-api' | 'new-api';
-}
-export declare function recordCost(event: Omit<CostEvent, 'ts'>): void;
-export declare function recordRegister(event: Omit<RegisterEvent, 'ts'>): void;
-export declare function _setCostWriterForTests(writer: (event: CostEvent) => void): void;
-export declare function _setRegisterWriterForTests(writer: (event: RegisterEvent) => void): void;
-export declare function _restoreDefaultsForTests(): void;

package/dist/src/lib/test-mode.d.ts

@@ -1,26 +0,0 @@
-/**
- * Test-mode flag — gates eager-bootstrap side effects in plugin modules.
- *
- * When OPENCLAW_PLUGIN_TEST_MODE=1, eager bootstrap (process killing,
- * globalThis monkey-patches, file writes, gateway health checks, env
- * mutations) is skipped. api.on() listener wiring still happens — so
- * idempotency + register-guard + listener-stacking tests remain valid.
- *
- * Default off — production behavior unchanged when env unset / 0.
- *
- * Usage in eager-bootstrap blocks:
- *   if (isTestMode()) {
- *     // log skip + return early from the eager-bootstrap section,
- *     // but DO NOT skip api.on() wiring elsewhere in the same register()
- *   }
- *
- * Reason: A1's smoke test on 2026-04-27 revealed that running register()
- * outside of OpenClaw boot inadvertently touched live production state
- * (killed processes, patched globalThis.SessionManager, wrote shared
- * registry files). This flag preserves register-guard test ergonomics
- * while keeping production behavior intact.
- */
-export declare const TEST_MODE_ENV = "OPENCLAW_PLUGIN_TEST_MODE";
-export declare function isTestMode(): boolean;
-/** For tests — explicit set/unset (operates on process.env). */
-export declare function _setTestModeForTests(on: boolean): void;