@a1hvdy/cc-openclaw 0.22.0 → 0.24.0

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

@@ -0,0 +1,47 @@
+/**
+ * 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/http-agent.js

@@ -0,0 +1,86 @@
+/**
+ * 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.
+ */
+// undici is lazy-loaded inside installPerfKeepaliveAgent to keep the
+// cold-start import budget at zero when the flag is off (which is the
+// default). Eager `import from 'undici'` here pushed the plugin-entry
+// import time over the 2000ms cold-start budget enforced by
+// tests/perf/cold-start.test.ts.
+import { createRequire } from 'node:module';
+import { getPerfKeepaliveEnabled, isLogLevelDebug } from './config.js';
+const requireFromHere = createRequire(import.meta.url);
+let snapshot = null;
+const DEFAULTS = {
+    keepAliveTimeout: 60_000,
+    keepAliveMaxTimeout: 120_000,
+    connections: 8,
+};
+/**
+ * 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 function installPerfKeepaliveAgent(opts = {}, factory) {
+    if (!getPerfKeepaliveEnabled())
+        return null;
+    if (snapshot)
+        return snapshot;
+    const resolved = {
+        keepAliveTimeout: opts.keepAliveTimeout ?? DEFAULTS.keepAliveTimeout,
+        keepAliveMaxTimeout: opts.keepAliveMaxTimeout ?? DEFAULTS.keepAliveMaxTimeout,
+        connections: opts.connections ?? DEFAULTS.connections,
+    };
+    try {
+        // Lazy-load undici only when actually installing. Cost is amortized
+        // across the rest of the process lifetime (Node caches require()).
+        const undici = requireFromHere('undici');
+        const prev = undici.getGlobalDispatcher();
+        // Default factory uses the just-loaded undici.Agent. Tests inject
+        // their own factory to avoid binding real sockets.
+        const realFactory = factory ?? ((r) => new undici.Agent(r));
+        const next = realFactory(resolved);
+        undici.setGlobalDispatcher(next);
+        // Close the previous dispatcher to release pooled sockets, but never
+        // throw — install must not break the gateway boot path on this branch.
+        if (prev && typeof prev.close === 'function') {
+            void prev.close().catch(() => { });
+        }
+        snapshot = { installed: true, options: resolved, installedAt: new Date().toISOString() };
+        return snapshot;
+    }
+    catch (err) {
+        if (isLogLevelDebug()) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[http-agent] install failed: ${msg}\n`);
+        }
+        return null;
+    }
+}
+/** Inspect current install state — used by /health + diagnostics. */
+export function getPerfKeepaliveSnapshot() {
+    return snapshot;
+}
+/** Test hook — clear the install snapshot so the next call reinstalls. */
+export function _resetPerfKeepaliveForTests() {
+    snapshot = null;
+}
+//# sourceMappingURL=http-agent.js.map

package/dist/src/lib/http-agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-agent.js","sourceRoot":"","sources":["../../../src/lib/http-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,qEAAqE;AACrE,sEAAsE;AACtE,sEAAsE;AACtE,4DAA4D;AAC5D,iCAAiC;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEvE,MAAM,eAAe,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAkBvD,IAAI,QAAQ,GAA2B,IAAI,CAAC;AAE5C,MAAM,QAAQ,GAA+B;IAC3C,gBAAgB,EAAE,MAAM;IACxB,mBAAmB,EAAE,OAAO;IAC5B,WAAW,EAAE,CAAC;CACf,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,yBAAyB,CACvC,OAAyB,EAAE,EAC3B,OAA2D;IAE3D,IAAI,CAAC,uBAAuB,EAAE;QAAE,OAAO,IAAI,CAAC;IAC5C,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAE9B,MAAM,QAAQ,GAA+B;QAC3C,gBAAgB,EAAE,IAAI,CAAC,gBAAgB,IAAI,QAAQ,CAAC,gBAAgB;QACpE,mBAAmB,EAAE,IAAI,CAAC,mBAAmB,IAAI,QAAQ,CAAC,mBAAmB;QAC7E,WAAW,EAAE,IAAI,CAAC,WAAW,IAAI,QAAQ,CAAC,WAAW;KACtD,CAAC;IAEF,IAAI,CAAC;QACH,oEAAoE;QACpE,mEAAmE;QACnE,MAAM,MAAM,GAAG,eAAe,CAAC,QAAQ,CAItC,CAAC;QACF,MAAM,IAAI,GAAG,MAAM,CAAC,mBAAmB,EAAE,CAAC;QAC1C,kEAAkE;QAClE,mDAAmD;QACnD,MAAM,WAAW,GAAG,OAAO,IAAI,CAAC,CAAC,CAA6B,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACxF,MAAM,IAAI,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;QACnC,MAAM,CAAC,mBAAmB,CAAC,IAAa,CAAC,CAAC;QAC1C,qEAAqE;QACrE,uEAAuE;QACvE,IAAI,IAAI,IAAI,OAAQ,IAA2C,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;YACrF,KAAM,IAA0C,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;QAC3E,CAAC;QACD,QAAQ,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC;QACzF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACtB,IAAI,eAAe,EAAE,EAAE,CAAC;YACtB,MAAM,GAAG,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC7D,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,gCAAgC,GAAG,IAAI,CAAC,CAAC;QAChE,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,qEAAqE;AACrE,MAAM,UAAU,wBAAwB;IACtC,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,0EAA0E;AAC1E,MAAM,UAAU,2BAA2B;IACzC,QAAQ,GAAG,IAAI,CAAC;AAClB,CAAC"}

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

@@ -0,0 +1,26 @@
+/**
+ * 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/async-compact.js

@@ -0,0 +1,42 @@
+/**
+ * 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).
+ */
+import { getPerfAsyncCompactEnabled } from '../config.js';
+const inFlight = new Set();
+/**
+ * Schedule `compactFn` to run after the current turn returns. Returns
+ * synchronously; the caller never awaits compaction completion.
+ */
+export function scheduleAsyncCompaction(sessionKey, compactFn) {
+    if (!getPerfAsyncCompactEnabled())
+        return { scheduled: false, reason: 'flag_off' };
+    if (!sessionKey || !compactFn)
+        return { scheduled: false, reason: 'flag_off' };
+    if (inFlight.has(sessionKey))
+        return { scheduled: false, reason: 'in_flight' };
+    inFlight.add(sessionKey);
+    setImmediate(() => {
+        void Promise.resolve()
+            .then(() => compactFn())
+            .catch(() => { })
+            .finally(() => inFlight.delete(sessionKey));
+    });
+    return { scheduled: true, reason: 'scheduled' };
+}
+export function _resetAsyncCompactForTests() {
+    inFlight.clear();
+}
+//# sourceMappingURL=async-compact.js.map

package/dist/src/lib/perf/async-compact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-compact.js","sourceRoot":"","sources":["../../../../src/lib/perf/async-compact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AAE1D,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;AAOnC;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CACrC,UAAkB,EAClB,SAAqC;IAErC,IAAI,CAAC,0BAA0B,EAAE;QAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IACnF,IAAI,CAAC,UAAU,IAAI,CAAC,SAAS;QAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IAC/E,IAAI,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC;QAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;IAC/E,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACzB,YAAY,CAAC,GAAG,EAAE;QAChB,KAAK,OAAO,CAAC,OAAO,EAAE;aACnB,IAAI,CAAC,GAAG,EAAE,CAAC,SAAS,EAAE,CAAC;aACvB,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC;aACf,OAAO,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC;IAChD,CAAC,CAAC,CAAC;IACH,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC;AAClD,CAAC;AAED,MAAM,UAAU,0BAA0B;IACxC,QAAQ,CAAC,KAAK,EAAE,CAAC;AACnB,CAAC"}

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

@@ -0,0 +1,26 @@
+/**
+ * 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/direct-sdk.js

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+import { createRequire } from 'node:module';
+import { getPerfDirectSdkEnabled } from '../config.js';
+const requireFromHere = createRequire(import.meta.url);
+let cachedProbe = null;
+export function probeDirectSdkAvailability() {
+    if (!getPerfDirectSdkEnabled()) {
+        return { enabled: false, available: false, reason: 'flag_off', version: null };
+    }
+    if (cachedProbe && cachedProbe.reason !== 'probe_error')
+        return cachedProbe;
+    try {
+        // Dynamic require path — never bring the SDK as a hard dependency.
+        const mod = requireFromHere('@anthropic-ai/claude-code');
+        if (!mod) {
+            cachedProbe = { enabled: true, available: false, reason: 'sdk_missing', version: null };
+            return cachedProbe;
+        }
+        cachedProbe = {
+            enabled: true,
+            available: true,
+            reason: 'sdk_loaded',
+            version: mod.VERSION ?? null,
+        };
+        return cachedProbe;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes('Cannot find module')) {
+            cachedProbe = { enabled: true, available: false, reason: 'sdk_missing', version: null };
+        }
+        else {
+            cachedProbe = { enabled: true, available: false, reason: 'probe_error', version: null };
+        }
+        return cachedProbe;
+    }
+}
+export function _resetDirectSdkProbeForTests() {
+    cachedProbe = null;
+}
+//# sourceMappingURL=direct-sdk.js.map

package/dist/src/lib/perf/direct-sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"direct-sdk.js","sourceRoot":"","sources":["../../../../src/lib/perf/direct-sdk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAEvD,MAAM,eAAe,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AASvD,IAAI,WAAW,GAAiC,IAAI,CAAC;AAErD,MAAM,UAAU,0BAA0B;IACxC,IAAI,CAAC,uBAAuB,EAAE,EAAE,CAAC;QAC/B,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IACjF,CAAC;IACD,IAAI,WAAW,IAAI,WAAW,CAAC,MAAM,KAAK,aAAa;QAAE,OAAO,WAAW,CAAC;IAC5E,IAAI,CAAC;QACH,mEAAmE;QACnE,MAAM,GAAG,GAAG,eAAe,CAAC,2BAA2B,CAAqC,CAAC;QAC7F,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,WAAW,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;YACxF,OAAO,WAAW,CAAC;QACrB,CAAC;QACD,WAAW,GAAG;YACZ,OAAO,EAAE,IAAI;YACb,SAAS,EAAE,IAAI;YACf,MAAM,EAAE,YAAY;YACpB,OAAO,EAAE,GAAG,CAAC,OAAO,IAAI,IAAI;SAC7B,CAAC;QACF,OAAO,WAAW,CAAC;IACrB,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACtB,MAAM,GAAG,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC7D,IAAI,GAAG,CAAC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,CAAC;YACvC,WAAW,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAC1F,CAAC;aAAM,CAAC;YACN,WAAW,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAC1F,CAAC;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;AACH,CAAC;AAED,MAAM,UAAU,4BAA4B;IAC1C,WAAW,GAAG,IAAI,CAAC;AACrB,CAAC"}

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

@@ -0,0 +1,19 @@
+/**
+ * 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/haiku-route.js

@@ -0,0 +1,49 @@
+/**
+ * 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.
+ */
+import { getPerfHaikuRouteEnabled } from '../config.js';
+const TRIVIAL_PATTERNS = [
+    /^(status|ping|hi|hello|hey|yo|ack|ok|okay|thanks|thx|ty)\s*[.!?]?\s*$/i,
+    /^(what'?s\s+(?:the\s+)?(?:time|date|day))\s*\??\s*$/i,
+    /^(are\s+you\s+(?:there|alive|up|online))\s*\??\s*$/i,
+    /^(version|uptime|health)\s*\??\s*$/i,
+];
+const COMPLEX_TOKENS = [
+    'write', 'create', 'build', 'implement', 'fix', 'debug', 'analyze',
+    'explain', 'refactor', 'review', 'design', 'plan', 'why', 'how',
+    'compare', 'recommend', 'suggest', 'should', 'would', 'could',
+];
+const TRIVIAL_MAX_CHARS = 60;
+export function classifyForHaikuRoute(prompt) {
+    if (!getPerfHaikuRouteEnabled())
+        return { routeToHaiku: false, reason: 'flag_off' };
+    if (!prompt || typeof prompt !== 'string')
+        return { routeToHaiku: false, reason: 'no_match' };
+    const trimmed = prompt.trim();
+    if (trimmed.length === 0)
+        return { routeToHaiku: false, reason: 'no_match' };
+    if (trimmed.length > TRIVIAL_MAX_CHARS)
+        return { routeToHaiku: false, reason: 'too_long' };
+    const lower = trimmed.toLowerCase();
+    for (const token of COMPLEX_TOKENS) {
+        if (lower.includes(token))
+            return { routeToHaiku: false, reason: 'complex_token' };
+    }
+    for (const pat of TRIVIAL_PATTERNS) {
+        if (pat.test(trimmed))
+            return { routeToHaiku: true, reason: 'trivial_pattern' };
+    }
+    return { routeToHaiku: false, reason: 'no_match' };
+}
+//# sourceMappingURL=haiku-route.js.map

package/dist/src/lib/perf/haiku-route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"haiku-route.js","sourceRoot":"","sources":["../../../../src/lib/perf/haiku-route.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAExD,MAAM,gBAAgB,GAAa;IACjC,wEAAwE;IACxE,sDAAsD;IACtD,qDAAqD;IACrD,qCAAqC;CACtC,CAAC;AAEF,MAAM,cAAc,GAAG;IACrB,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS;IAClE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;IAC/D,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO;CAC9D,CAAC;AAOF,MAAM,iBAAiB,GAAG,EAAE,CAAC;AAE7B,MAAM,UAAU,qBAAqB,CAAC,MAAc;IAClD,IAAI,CAAC,wBAAwB,EAAE;QAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IACpF,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ;QAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IAC9F,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;IAC9B,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IAC7E,IAAI,OAAO,CAAC,MAAM,GAAG,iBAAiB;QAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;IAC3F,MAAM,KAAK,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IACpC,KAAK,MAAM,KAAK,IAAI,cAAc,EAAE,CAAC;QACnC,IAAI,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC;IACrF,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,gBAAgB,EAAE,CAAC;QACnC,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC;YAAE,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAClF,CAAC;IACD,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;AACrD,CAAC"}

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

@@ -0,0 +1,18 @@
+/**
+ * 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/predictive-continuation.js

@@ -0,0 +1,37 @@
+/**
+ * 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).
+ */
+import { getPerfPredictiveContinueEnabled } from '../config.js';
+const CONTINUATION_PATTERNS = [
+    /^\s*(more|continue|go\s*on|keep\s*going|next|and\??|then\??|\.\.\.)\s*[.!?]?\s*$/i,
+    /^\s*(go|do)\s+(on|ahead)\s*[.!?]?\s*$/i,
+    /^\s*(yes|yep|yeah|ok|okay|sure)[,!.?]?\s+(more|continue|go\s*on|please)\s*[.!?]?\s*$/i,
+];
+export function isPredictiveContinuation(text) {
+    if (!getPerfPredictiveContinueEnabled()) {
+        return { isContinuation: false, matched: '' };
+    }
+    if (!text || typeof text !== 'string') {
+        return { isContinuation: false, matched: '' };
+    }
+    const trimmed = text.trim();
+    // Hard length cap — anything over 40 chars is too substantive to predict.
+    if (trimmed.length === 0 || trimmed.length > 40) {
+        return { isContinuation: false, matched: '' };
+    }
+    for (const pat of CONTINUATION_PATTERNS) {
+        if (pat.test(trimmed)) {
+            return { isContinuation: true, matched: pat.source };
+        }
+    }
+    return { isContinuation: false, matched: '' };
+}
+//# sourceMappingURL=predictive-continuation.js.map

package/dist/src/lib/perf/predictive-continuation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"predictive-continuation.js","sourceRoot":"","sources":["../../../../src/lib/perf/predictive-continuation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,gCAAgC,EAAE,MAAM,cAAc,CAAC;AAEhE,MAAM,qBAAqB,GAAa;IACtC,mFAAmF;IACnF,wCAAwC;IACxC,uFAAuF;CACxF,CAAC;AASF,MAAM,UAAU,wBAAwB,CAAC,IAAY;IACnD,IAAI,CAAC,gCAAgC,EAAE,EAAE,CAAC;QACxC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IAChD,CAAC;IACD,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QACtC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IAChD,CAAC;IACD,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAC5B,0EAA0E;IAC1E,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,IAAI,OAAO,CAAC,MAAM,GAAG,EAAE,EAAE,CAAC;QAChD,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IAChD,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,qBAAqB,EAAE,CAAC;QACxC,IAAI,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YACtB,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC;QACvD,CAAC;IACH,CAAC;IACD,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;AAChD,CAAC"}

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

@@ -0,0 +1,33 @@
+/**
+ * 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/read-batch.js

@@ -0,0 +1,48 @@
+/**
+ * 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.
+ */
+import { readFile } from 'node:fs/promises';
+import { getPerfReadBatchEnabled } from '../config.js';
+const MAX_BATCH_SIZE = 16;
+const PER_FILE_BYTE_CAP = 1_048_576;
+/**
+ * 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 async function batchReadPaths(paths) {
+    if (!getPerfReadBatchEnabled()) {
+        return { enabled: false, entries: [], totalBytes: 0, errorCount: 0 };
+    }
+    if (!Array.isArray(paths) || paths.length === 0) {
+        return { enabled: true, entries: [], totalBytes: 0, errorCount: 0 };
+    }
+    const slice = paths.slice(0, MAX_BATCH_SIZE);
+    const entries = await Promise.all(slice.map(async (p) => {
+        try {
+            const buf = await readFile(p, 'utf8');
+            const content = buf.length > PER_FILE_BYTE_CAP ? buf.slice(0, PER_FILE_BYTE_CAP) : buf;
+            return { path: p, content, error: null, bytes: content.length };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return { path: p, content: null, error: msg, bytes: 0 };
+        }
+    }));
+    const totalBytes = entries.reduce((s, e) => s + e.bytes, 0);
+    const errorCount = entries.filter((e) => e.error !== null).length;
+    return { enabled: true, entries, totalBytes, errorCount };
+}
+//# sourceMappingURL=read-batch.js.map

package/dist/src/lib/perf/read-batch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-batch.js","sourceRoot":"","sources":["../../../../src/lib/perf/read-batch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAgBvD,MAAM,cAAc,GAAG,EAAE,CAAC;AAC1B,MAAM,iBAAiB,GAAG,SAAS,CAAC;AAEpC;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,KAAe;IAClD,IAAI,CAAC,uBAAuB,EAAE,EAAE,CAAC;QAC/B,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC;IACvE,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAChD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC;IACtE,CAAC;IACD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;IAC7C,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,EAA2B,EAAE;QAC7C,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;YACtC,MAAM,OAAO,GAAG,GAAG,CAAC,MAAM,GAAG,iBAAiB,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;YACvF,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;QAClE,CAAC;QAAC,OAAO,GAAY,EAAE,CAAC;YACtB,MAAM,GAAG,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC7D,OAAO,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;QAC1D,CAAC;IACH,CAAC,CAAC,CACH,CAAC;IACF,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC5D,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC,MAAM,CAAC;IAClE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;AAC5D,CAAC"}

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

@@ -0,0 +1,22 @@
+/**
+ * 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/skill-list-collapse.js

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+import { getPerfSkillOnDemandEnabled } from '../config.js';
+const SKILL_BLOCK_RE = /<available_skills>[\s\S]*?<\/available_skills>/g;
+const HINT_LINE = '<available_skills>Skills are available via the `openclaw skills list` tool. Invoke it when the user mentions a slash-command or asks "what skills are available?" — do not list them proactively.</available_skills>';
+/** Collapse the <available_skills> block; no-op when the flag is off. */
+export function collapseSkillList(sysprompt) {
+    if (!getPerfSkillOnDemandEnabled()) {
+        return { content: sysprompt, changed: false, bytesRemoved: 0 };
+    }
+    let bytesRemoved = 0;
+    let changed = false;
+    const content = sysprompt.replace(SKILL_BLOCK_RE, (match) => {
+        if (match === HINT_LINE)
+            return match;
+        bytesRemoved += match.length - HINT_LINE.length;
+        changed = true;
+        return HINT_LINE;
+    });
+    return { content, changed, bytesRemoved };
+}
+//# sourceMappingURL=skill-list-collapse.js.map

package/dist/src/lib/perf/skill-list-collapse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-list-collapse.js","sourceRoot":"","sources":["../../../../src/lib/perf/skill-list-collapse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,2BAA2B,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,cAAc,GAAG,iDAAiD,CAAC;AACzE,MAAM,SAAS,GACb,sNAAsN,CAAC;AAQzN,yEAAyE;AACzE,MAAM,UAAU,iBAAiB,CAAC,SAAiB;IACjD,IAAI,CAAC,2BAA2B,EAAE,EAAE,CAAC;QACnC,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC;IACjE,CAAC;IACD,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC,KAAK,EAAE,EAAE;QAC1D,IAAI,KAAK,KAAK,SAAS;YAAE,OAAO,KAAK,CAAC;QACtC,YAAY,IAAI,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,CAAC;QAChD,OAAO,GAAG,IAAI,CAAC;QACf,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC,CAAC;IACH,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC;AAC5C,CAAC"}

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

@@ -0,0 +1,25 @@
+/**
+ * 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;