@a1hvdy/cc-openclaw 0.3.2

package/dist/src/session-bootstrap/cwd-patch.js

@@ -0,0 +1,955 @@
+/**
+ * cwd-patch — OpenClaw plugin module
+ *
+ * Ports the core CWD-patching and compat-bridge infrastructure from
+ * savvy-claude-code/cwd-enhancer.js.
+ *
+ * Two jobs:
+ *
+ * 1. EAGER SERVER START — Creates a SessionManager + EmbeddedServer eagerly
+ *    at boot so :18796 is available immediately (before the first tool call).
+ *    When the main plugin's lazy init eventually fires, it sees EADDRINUSE
+ *    and gracefully skips.
+ *
+ * 2. CWD REDIRECT — Patches SessionManager.prototype.startSession so that
+ *    openai-compat-* sessions use the workspace directory instead of /tmp.
+ *    Gives Claude Code full project context when acting as Savvy's brain.
+ *
+ * Also includes:
+ *   - Resume registry mirror (parallel write-ahead for claude-sessions.json)
+ *   - Cache parity registry (Track B: OPENCLAW_CACHE_PARITY=1)
+ *   - CoS session naming helpers (cosSessionStore used by think-conflict-resolver)
+ *   - Runtime stub injection (ensureStatusRuntimeStubs)
+ *   - Sandbox binary permission self-healing (ensureSandboxPermissions)
+ *   - Route patch (applyRoutePatch: stable session keys, tool strip, sysprompt inline)
+ *   - Metrics endpoint (/enhancer/metrics)
+ *
+ * Source: savvy-claude-code/cwd-enhancer.js lines 1–1357 (primary concern)
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, chmodSync, statSync, } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { stripSysprompt } from './sysprompt-strip.js';
+import { defaultRegisterGuard } from '../lib/register-guard.js';
+import { isTestMode } from '../lib/test-mode.js';
+import { isCacheParityTrackB, isTokenTelemetryEnabled, isSyspromptDumpEnabled, getMaxConcurrentSessions, getSessionTtlMinutes, ensureUxBridgeAllSessionsDefault, } from '../lib/config.js';
+import { VENDOR_FILES } from '../lib/vendor-paths.js';
+// ── Constants ─────────────────────────────────────────────────────────────
+const TAG = '[cc-openclaw/cwd-patch]';
+const DEFAULT_PORT = 18796;
+const HOME = homedir();
+// PLUGIN_DIR: the plugin install root, where stubs/ and mcp-config.json live.
+// At runtime this file is at <plugin-root>/dist/src/session-bootstrap/cwd-patch.js,
+// so we walk up looking for openclaw.plugin.json — a stable marker that survives
+// any future build-output restructuring.
+const PLUGIN_DIR = (() => {
+    try {
+        let dir = dirname(new URL(import.meta.url).pathname);
+        for (let i = 0; i < 6; i++) {
+            if (existsSync(join(dir, 'openclaw.plugin.json')))
+                return dir;
+            const parent = dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        // fall through
+    }
+    return join(HOME, '.openclaw/extensions/cc-openclaw');
+})();
+const PATHS = {
+    workspace: join(HOME, '.openclaw'),
+    ccPlugin: VENDOR_FILES.sessionManager,
+    ccServer: VENDOR_FILES.embeddedServer,
+    ccModels: VENDOR_FILES.models,
+    mcpConfig: join(PLUGIN_DIR, 'mcp-config.json'),
+    stubsDir: join(PLUGIN_DIR, 'stubs'),
+    thinkSkill: join(HOME, '.openclaw/workspace/skills/think/SKILL.md'),
+    openclawDist: join(HOME, '.npm-global/lib/node_modules/openclaw/dist'),
+    openclawRoot: join(HOME, '.npm-global/lib/node_modules/openclaw'),
+    autoReplyDir: join(HOME, '.npm-global/lib/node_modules/auto-reply/reply'),
+    seccompBinaries: [
+        join(HOME, '.npm-global/lib/node_modules/@anthropic-ai/claude-code/vendor/seccomp/x64/apply-seccomp'),
+        join(HOME, '.npm-global/lib/node_modules/@anthropic-ai/claude-code/vendor/seccomp/arm64/apply-seccomp'),
+    ],
+};
+const DEPS_STUB_PATH = join(PATHS.openclawDist, 'commands-status-deps.runtime.js');
+const STATUS_STUB_PATH = join(PATHS.openclawRoot, 'status.runtime.js');
+const AUTO_REPLY_STATUS_PATH = join(PATHS.autoReplyDir, 'commands-status.runtime.js');
+const SAVVY_REGISTRY_PATH = join(HOME, '.openclaw/savvy-resume-registry.json');
+const CLAUDE_SESSIONS_PATH = join(HOME, '.openclaw/claude-sessions.json');
+const CACHE_PARITY_REGISTRY_PATH = join(HOME, '.openclaw/openclaw-cache-parity-registry.json');
+// Patch identity symbols (module-scoped, stable across re-imports within a process)
+const PATCH_MARKER = Symbol.for('claude-local-enhancer:patched');
+const ROUTE_PATCH_MARKER = Symbol.for('claude-local-enhancer:route-patched');
+// ── Metrics ───────────────────────────────────────────────────────────────
+const METRICS = {
+    cwdRedirects: 0,
+    toolStrips: 0,
+    sessionKeyInjections: 0,
+    staleSessionsKilled: 0,
+    cosNamesGenerated: 0,
+    claudeMdInjections: 0,
+    systemPromptInlined: 0,
+    uxMetaSeeded: 0,
+    cacheParityHits: 0,
+    cacheParityMisses: 0,
+    cacheParityRegistryWrites: 0,
+    cacheParityAppendInjections: 0,
+    startedAt: Date.now(),
+};
+// ── Module state ──────────────────────────────────────────────────────────
+let logger = console;
+let patchApplied = false;
+let serverStarted = false;
+// ── UX_META sweeper ───────────────────────────────────────────────────────
+// B5 — sweep stale telegram-ux-bridge metadata entries every 5 min.
+// Entries older than 10 min that were never consumed (error paths, name
+// mismatches, early session termination) leak indefinitely without this.
+// .unref() so the timer doesn't keep the process alive at shutdown.
+const _UX_META_KEY = Symbol.for('telegram-ux-bridge:metadata');
+const UX_META_MAX_AGE_MS = 10 * 60 * 1000;
+const UX_META_SWEEP_INTERVAL_MS = 5 * 60 * 1000;
+setInterval(() => {
+    // TODO(P2): refine type when full plugin types land
+    const meta = globalThis[_UX_META_KEY];
+    if (!(meta instanceof Map) || meta.size === 0)
+        return;
+    const cutoff = Date.now() - UX_META_MAX_AGE_MS;
+    let swept = 0;
+    for (const [key, val] of meta) {
+        if (val?.storedAt && val.storedAt < cutoff) {
+            meta.delete(key);
+            swept++;
+        }
+    }
+    if (swept > 0) {
+        logger.info(`${TAG} UX_META sweeper evicted ${swept} stale entries (size=${meta.size})`);
+    }
+}, UX_META_SWEEP_INTERVAL_MS).unref();
+const _systemInlineCache = new Map();
+const SYSTEM_INLINE_CACHE_MAX = 500;
+function _setSystemInlineCache(key, val) {
+    if (_systemInlineCache.size >= SYSTEM_INLINE_CACHE_MAX && !_systemInlineCache.has(key)) {
+        const oldest = _systemInlineCache.keys().next().value;
+        if (oldest !== undefined)
+            _systemInlineCache.delete(oldest);
+    }
+    _systemInlineCache.set(key, val);
+}
+// ── Tool dump hash guard ──────────────────────────────────────────────────
+let _lastToolDumpHash = null;
+// ── sessionId capture state ───────────────────────────────────────────────
+let _lastCapturedJson = '';
+// ── Resume registry helpers ───────────────────────────────────────────────
+function _readJSONArraySafe(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const raw = readFileSync(filePath, 'utf8');
+        const arr = JSON.parse(raw);
+        return Array.isArray(arr) ? arr : null;
+    }
+    catch {
+        return null;
+    }
+}
+function restoreClaudeSessionsFromBackup() {
+    try {
+        const backup = _readJSONArraySafe(SAVVY_REGISTRY_PATH);
+        if (!backup || backup.length === 0)
+            return;
+        const current = _readJSONArraySafe(CLAUDE_SESSIONS_PATH);
+        if (current && current.length > 0) {
+            logger.info(`${TAG} claude-sessions.json already has ${current.length} entries — skipping restore`);
+            return;
+        }
+        const tmp = CLAUDE_SESSIONS_PATH + '.savvy-restore.tmp';
+        writeFileSync(tmp, JSON.stringify(backup, null, 2));
+        renameSync(tmp, CLAUDE_SESSIONS_PATH);
+        logger.info(`${TAG} Restored ${backup.length} entries from savvy-resume-registry.json → claude-sessions.json`);
+    }
+    catch (err) {
+        logger.warn(`${TAG} Resume registry restore failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function writeBackupRegistry(entriesArray) {
+    try {
+        const tmp = SAVVY_REGISTRY_PATH + '.tmp';
+        writeFileSync(tmp, JSON.stringify(entriesArray, null, 2));
+        renameSync(tmp, SAVVY_REGISTRY_PATH);
+    }
+    catch { /* mirror is advisory; dist plugin still runs its own debounced save */ }
+}
+function _readCacheParityRegistry() {
+    if (!existsSync(CACHE_PARITY_REGISTRY_PATH))
+        return {};
+    try {
+        const raw = readFileSync(CACHE_PARITY_REGISTRY_PATH, 'utf8');
+        const obj = JSON.parse(raw);
+        return (obj && typeof obj === 'object' && !Array.isArray(obj))
+            ? obj
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function _writeCacheParityEntry(sessionKey, hash, sysContent) {
+    if (!sessionKey || sessionKey === 'unknown')
+        return;
+    try {
+        const registry = _readCacheParityRegistry();
+        registry[sessionKey] = { hash, sysContent, updatedAt: Date.now() };
+        const tmp = CACHE_PARITY_REGISTRY_PATH + '.tmp';
+        writeFileSync(tmp, JSON.stringify(registry, null, 2));
+        renameSync(tmp, CACHE_PARITY_REGISTRY_PATH);
+    }
+    catch (err) {
+        logger.warn(`${TAG} cache-parity registry write failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+// ── Resume registry mirror patch ──────────────────────────────────────────
+// Source: cwd-enhancer.js lines 163–181
+function applyResumeRegistryMirror(SessionManager) {
+    // TODO(P2): refine type when full plugin types land
+    const proto = SessionManager.prototype;
+    if (typeof proto['_persistSession'] !== 'function') {
+        logger.warn(`${TAG} _persistSession not on SessionManager.prototype — mirror skipped`);
+        return;
+    }
+    const orig = proto['_persistSession'];
+    if (orig.__savvyMirrored)
+        return;
+    const patched = function (...args) {
+        const ret = orig.apply(this, args);
+        try {
+            writeBackupRegistry(Array.from(this.persistedSessions.values()));
+        }
+        catch { /* swallow — mirror is advisory */ }
+        return ret;
+    };
+    patched.__savvyMirrored = true;
+    proto['_persistSession'] = patched;
+    logger.info(`${TAG} Resume registry mirror patch applied to SessionManager.prototype._persistSession`);
+}
+// ── Bootstrap resume registry ─────────────────────────────────────────────
+function bootstrapResumeRegistry(eagerManager) {
+    try {
+        const sessions = eagerManager?.persistedSessions;
+        if (!(sessions instanceof Map) || sessions.size === 0) {
+            logger.info(`${TAG} Bootstrap: persistedSessions is empty — nothing to dump`);
+            return;
+        }
+        writeBackupRegistry(Array.from(sessions.values()));
+        logger.info(`${TAG} Bootstrap: dumped ${sessions.size} active session(s) to savvy-resume-registry.json`);
+    }
+    catch (err) {
+        logger.warn(`${TAG} Bootstrap dump failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+// ── sessionId capture poller ──────────────────────────────────────────────
+// Stage 5b — bypasses the dist plugin's broken _persistSession gate.
+// Source: cwd-enhancer.js lines 197–256
+function capturePersistedSessionsFromManager(manager) {
+    try {
+        const mgr = manager;
+        if (!mgr?.sessions)
+            return;
+        const captured = [];
+        for (const [name, managedSession] of mgr.sessions) {
+            const sessionId = managedSession?.claudeSessionId ?? managedSession?.session?.sessionId;
+            if (!sessionId)
+                continue;
+            const entry = {
+                name,
+                claudeSessionId: sessionId,
+                cwd: managedSession?.config?.cwd
+                    || managedSession?.session?.cwd
+                    || managedSession?.session?.options?.cwd,
+                model: managedSession?.config?.model
+                    || managedSession?.session?.options?.model,
+                lastActivity: managedSession?.lastActivity || Date.now(),
+            };
+            captured.push(entry);
+            if (mgr.persistedSessions instanceof Map && !mgr.persistedSessions.has(name)) {
+                mgr.persistedSessions.set(name, entry);
+            }
+        }
+        if (captured.length === 0)
+            return;
+        const json = JSON.stringify(captured, null, 2);
+        if (json === _lastCapturedJson)
+            return;
+        _lastCapturedJson = json;
+        writeBackupRegistry(captured);
+        logger.info(`${TAG} sessionId capture: persisted ${captured.length} session(s) (forced-populate: ${captured.length} entries into dist Map)`);
+    }
+    catch (err) {
+        logger.warn(`${TAG} sessionId capture failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+// ── Path validation ───────────────────────────────────────────────────────
+function validatePaths() {
+    const critical = [
+        ['CC plugin (SessionManager)', PATHS.ccPlugin],
+        ['CC server (EmbeddedServer)', PATHS.ccServer],
+    ];
+    const missing = critical.filter(([, p]) => !existsSync(p));
+    if (missing.length) {
+        logger.warn(`${TAG} Missing critical files: ${missing.map(([label]) => label).join(', ')}`);
+    }
+}
+// ── Runtime stub injection ────────────────────────────────────────────────
+// Source: cwd-enhancer.js lines 415–437
+export function ensureStatusRuntimeStubs() {
+    let created = 0;
+    const stubs = [
+        { target: DEPS_STUB_PATH, source: join(PATHS.stubsDir, 'commands-status-deps.runtime.js'), mkdirTarget: false },
+        { target: STATUS_STUB_PATH, source: join(PATHS.stubsDir, 'status.runtime.js'), mkdirTarget: false },
+        { target: AUTO_REPLY_STATUS_PATH, source: join(PATHS.stubsDir, 'status.runtime.js'), mkdirTarget: true },
+    ];
+    for (const { target, source, mkdirTarget } of stubs) {
+        if (existsSync(target))
+            continue;
+        try {
+            const content = readFileSync(source, 'utf8');
+            if (mkdirTarget)
+                mkdirSync(dirname(target), { recursive: true });
+            writeFileSync(target, content, 'utf8');
+            logger.info(`${TAG} Created missing ${target}`);
+            created++;
+        }
+        catch (err) {
+            logger.error(`${TAG} Failed to create stub ${target}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (created === 0) {
+        logger.info(`${TAG} Status runtime files already present — no stubs needed`);
+    }
+}
+// ── Sandbox binary permission self-healing ────────────────────────────────
+// Source: cwd-enhancer.js lines 439–464
+function ensureSandboxPermissions() {
+    let fixed = 0;
+    for (const binPath of PATHS.seccompBinaries) {
+        if (!existsSync(binPath))
+            continue;
+        try {
+            const st = statSync(binPath);
+            if ((st.mode & 0o111) === 0) {
+                chmodSync(binPath, 0o755);
+                logger.info(`${TAG} Fixed sandbox binary permissions: ${binPath} (was ${(st.mode & 0o777).toString(8)}, now 755)`);
+                fixed++;
+            }
+        }
+        catch (err) {
+            logger.error(`${TAG} Failed to fix sandbox permissions for ${binPath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (fixed === 0) {
+        logger.info(`${TAG} Sandbox binaries already have execute permissions`);
+    }
+}
+let _ccModules = null;
+async function getCCModules() {
+    if (_ccModules)
+        return _ccModules;
+    const [smMod, esMod] = await Promise.all([
+        import(PATHS.ccPlugin),
+        import(PATHS.ccServer),
+    ]);
+    _ccModules = {
+        SessionManager: (smMod['SessionManager'] ?? smMod['default']?.['SessionManager']),
+        EmbeddedServer: (esMod['EmbeddedServer'] ?? esMod['default']?.['EmbeddedServer']),
+    };
+    return _ccModules;
+}
+// ── applyPatch ────────────────────────────────────────────────────────────
+// Patches SessionManager.prototype.startSession for CWD redirect + extras.
+// Source: cwd-enhancer.js lines 480–622
+async function applyPatch(workspaceCwd) {
+    if (patchApplied)
+        return;
+    patchApplied = true;
+    let SessionManager;
+    try {
+        ({ SessionManager } = await getCCModules());
+    }
+    catch (err) {
+        logger.error(`${TAG} Cannot import CC modules: ${err instanceof Error ? err.message : String(err)}`);
+        return;
+    }
+    if (!SessionManager) {
+        logger.error(`${TAG} SessionManager class not found in module`);
+        return;
+    }
+    applyResumeRegistryMirror(SessionManager);
+    // TODO(P2): refine type when full plugin types land
+    const proto = SessionManager.prototype;
+    const original = proto['startSession'];
+    if (!original) {
+        logger.error(`${TAG} startSession not found on SessionManager.prototype`);
+        return;
+    }
+    if (original[PATCH_MARKER]) {
+        logger.info(`${TAG} startSession already patched — skipping`);
+        return;
+    }
+    const patched = async function (config) {
+        if (typeof config.name === 'string' && config.name.startsWith('openai-')) {
+            // Fix 1: CWD redirect
+            if (typeof config.cwd === 'string' && config.cwd.includes('/tmp')) {
+                const originalCwd = config.cwd;
+                config.cwd = workspaceCwd;
+                METRICS.cwdRedirects++;
+                logger.info(`${TAG} Redirected CWD: ${config.name} | ${originalCwd} → ${workspaceCwd}`);
+            }
+            // Fix 2: Restore CLI built-in tools
+            if (config.tools === '') {
+                delete config.tools;
+                logger.info(`${TAG} Restored CLI tools for ${config.name} (bridge XML mode bypassed)`);
+            }
+            // Fix 4: Inject MCP config
+            const mcpJsonPath = PATHS.mcpConfig;
+            if (existsSync(mcpJsonPath) && !config.mcpConfig) {
+                config.mcpConfig = [mcpJsonPath];
+                logger.info(`${TAG} Injected MCP config: ${mcpJsonPath}`);
+            }
+            // Fix 5: Inject workspace CLAUDE.md as system prompt
+            if (!config.appendSystemPrompt) {
+                const claudeMdPath = join(typeof config.cwd === 'string' ? config.cwd : workspaceCwd, '.claude', 'CLAUDE.md');
+                if (existsSync(claudeMdPath)) {
+                    try {
+                        config.appendSystemPrompt = readFileSync(claudeMdPath, 'utf8');
+                        METRICS.claudeMdInjections++;
+                        logger.info(`${TAG} Injected CLAUDE.md for ${config.name}`);
+                    }
+                    catch (err) {
+                        logger.warn(`${TAG} Failed to read CLAUDE.md: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
+            }
+            // Track B — Cache parity append injection (OPENCLAW_CACHE_PARITY=1)
+            if (isCacheParityTrackB()) {
+                try {
+                    const reg = _readCacheParityRegistry();
+                    const entry = reg[config.name];
+                    if (entry?.sysContent) {
+                        const prev = config.appendSystemPrompt || '';
+                        config.appendSystemPrompt = prev ? `${prev}\n\n${entry.sysContent}` : entry.sysContent;
+                        METRICS.cacheParityAppendInjections++;
+                        logger.info(`${TAG} cache-parity: appended ${entry.sysContent.length} chars to ${config.name} appendSystemPrompt (hash=${entry.hash})`);
+                    }
+                }
+                catch (err) {
+                    logger.warn(`${TAG} cache-parity startSession injection failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            // Stage 5d / Fix 6 — Force resume injection past skipPersistence gate
+            if (!config.resumeSessionId) {
+                const persisted = this.persistedSessions?.get?.(config.name);
+                const resumeId = persisted?.claudeSessionId;
+                if (resumeId) {
+                    config.resumeSessionId = resumeId;
+                    METRICS['resumeInjections'] = (METRICS['resumeInjections'] || 0) + 1;
+                    logger.info(`${TAG} Resume injection for ${config.name}: ${resumeId.slice(0, 8)}...`);
+                }
+            }
+        }
+        return original.call(this, config);
+    };
+    patched[PATCH_MARKER] = true;
+    proto['startSession'] = patched;
+    logger.info(`${TAG} SessionManager.startSession patched — compat sessions use workspace CWD`);
+}
+// ── applyRoutePatch ───────────────────────────────────────────────────────
+// Patches EmbeddedServer.prototype.route for session keys, tool strip,
+// sysprompt inline, cache parity, stale session cleanup, UX meta seeding.
+// Source: cwd-enhancer.js lines 624–1013
+function applyRoutePatch(EmbeddedServer) {
+    const proto = EmbeddedServer.prototype;
+    const origRoute = proto['route'];
+    if (!origRoute || origRoute[ROUTE_PATCH_MARKER])
+        return;
+    // TODO(P2): refine type when full plugin types land
+    proto['route'] = async function patchedRoute(path, body, query, res, headers) {
+        const __perfRouteStart = performance.now();
+        // Metrics endpoint
+        if (path === '/enhancer/metrics') {
+            const payload = {
+                ...METRICS,
+                uptimeSeconds: Math.round((Date.now() - METRICS.startedAt) / 1000),
+            };
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(payload));
+            return;
+        }
+        // Session key injection
+        if (path === '/v1/chat/completions' && Array.isArray(body.messages)) {
+            const headerKey = headers?.['x-session-id'];
+            if (typeof headerKey === 'string' && headerKey.trim()) {
+                body.user = headerKey.trim();
+                METRICS.sessionKeyInjections++;
+                logger.info(`${TAG} Session key from X-Session-Id header: ${body.user}`);
+            }
+            else if (!body.user) {
+                const userMsgs = body.messages
+                    .filter(m => m?.role === 'user');
+                const anchor = userMsgs[1] || userMsgs[0];
+                const extractText = (c) => typeof c === 'string'
+                    ? c
+                    : Array.isArray(c)
+                        ? c
+                            .map(p => (p && (p.text ?? p.content)) || '')
+                            .filter(Boolean)
+                            .join('\n')
+                        : '';
+                const anchorText = extractText(anchor?.content);
+                body.user = 'gw-' + createHash('sha1').update(anchorText).digest('hex').slice(0, 12);
+                METRICS.sessionKeyInjections++;
+                logger.info(`${TAG} Stable session key: ${body.user} (userMsgs=${userMsgs.length}, anchorCh=${anchorText.length}, model=${body.model || '?'})`);
+            }
+        }
+        // UX meta seeding
+        if (path === '/v1/chat/completions' && body.user) {
+            const PENDING_CHAT_QUEUE = Symbol.for('claude-local-ux:pending-chat');
+            const UX_META_KEY = Symbol.for('telegram-ux-bridge:metadata');
+            const queue = globalThis[PENDING_CHAT_QUEUE];
+            if (Array.isArray(queue) && queue.length > 0) {
+                const meta = queue.shift();
+                if (meta?.chatId) {
+                    const g = globalThis;
+                    if (!g[UX_META_KEY])
+                        g[UX_META_KEY] = new Map();
+                    const sessionName = 'openai-' + body.user;
+                    g[UX_META_KEY].set(sessionName, {
+                        chatId: meta.chatId,
+                        threadId: meta.threadId,
+                        origMessageId: meta.origMessageId,
+                        storedAt: Date.now(),
+                    });
+                    METRICS.uxMetaSeeded++;
+                    logger.info(`${TAG} Seeded UX_META for ${sessionName} — chat=${meta.chatId} thread=${meta.threadId || 'none'}`);
+                }
+            }
+        }
+        // Tool strip
+        if (path === '/v1/chat/completions' && Array.isArray(body.tools) && body.tools.length > 0) {
+            const toolCount = body.tools.length;
+            try {
+                const dumpPath = join(PLUGIN_DIR, 'mcp-tools.json');
+                const toolsJson = JSON.stringify(body.tools);
+                const toolsHash = createHash('sha1').update(toolsJson).digest('hex').slice(0, 16);
+                if (_lastToolDumpHash !== toolsHash) {
+                    const tmpPath = dumpPath + '.tmp';
+                    writeFileSync(tmpPath, toolsJson);
+                    renameSync(tmpPath, dumpPath);
+                    _lastToolDumpHash = toolsHash;
+                    logger.info(`${TAG} Dumped ${toolCount} tool definitions for MCP bridge (hash ${toolsHash})`);
+                }
+                else {
+                    METRICS['toolDumpSkipped'] = (METRICS['toolDumpSkipped'] || 0) + 1;
+                }
+            }
+            catch (e) {
+                logger.warn(`${TAG} Tool dump failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            delete body.tools;
+            delete body.tool_choice;
+            METRICS.toolStrips++;
+        }
+        // Stale session auto-recovery
+        if (path === '/v1/chat/completions' && body.user && this.manager) {
+            const sessionName = 'openai-' + body.user;
+            try {
+                const mgr = this.manager;
+                const existing = mgr?.sessions?.get?.(sessionName);
+                const ready = existing?.session?.stats?.isReady ?? existing?.stats?.isReady;
+                if (existing && ready === false) {
+                    METRICS.staleSessionsKilled++;
+                    logger.info(`${TAG} Stale session detected: ${sessionName} — stopping for auto-recovery`);
+                    const stopFn = this.manager['stopSession'];
+                    if (stopFn)
+                        await stopFn.call(this.manager, sessionName).catch(() => { });
+                }
+            }
+            catch { /* best effort */ }
+        }
+        // System-prompt inline (Fix 6) + cache parity (Track B) + sysprompt strip
+        if (path === '/v1/chat/completions' && Array.isArray(body?.messages)) {
+            const extractText = (c) => typeof c === 'string'
+                ? c
+                : Array.isArray(c)
+                    ? c
+                        .map(p => (p && (p.text ?? p.content)) || '')
+                        .filter(Boolean)
+                        .join('\n')
+                    : '';
+            const messages = body.messages;
+            const sysMsgs = messages.filter(m => m?.role === 'system');
+            if (sysMsgs.length > 0) {
+                let sysContent = sysMsgs.map(m => extractText(m.content)).filter(Boolean).join('\n\n');
+                // Always-on strips (Path B + location strip)
+                const stripResult = stripSysprompt(sysContent);
+                sysContent = stripResult.content;
+                if (stripResult.changed) {
+                    METRICS['sysPromptVolatileStripped'] = (METRICS['sysPromptVolatileStripped'] || 0) + 1;
+                }
+                // Aggressive strip (F2.1) — default-on in cc-openclaw (P2 flip).
+                // Opt-out via OPENCLAW_AGGRESSIVE_STRIP=0/false/off.
+                // Legacy explicit OPENCLAW_AGGRESSIVE_STRIP=1 also enables (backward compat).
+                // stripSysprompt() already ran always-on strips above; call again with
+                // forceEnabled to ensure F2.1 runs regardless of env-parse in lib.
+                // Skip only when opt-out env is set (isStripEnabled() returns false).
+                {
+                    const aggrResult = stripSysprompt(sysContent);
+                    if (aggrResult.aggressiveStripped) {
+                        sysContent = aggrResult.content;
+                        METRICS['sysPromptAggressiveStripped'] = (METRICS['sysPromptAggressiveStripped'] || 0) + 1;
+                    }
+                }
+                let lastUserIdx = -1;
+                for (let i = messages.length - 1; i >= 0; i--) {
+                    if (messages[i]?.role === 'user') {
+                        lastUserIdx = i;
+                        break;
+                    }
+                }
+                // F2.5 — Per-turn token-cost telemetry (OPENCLAW_TOKEN_TELEMETRY=1)
+                if (isTokenTelemetryEnabled()) {
+                    try {
+                        const tlmSessionKey = body.user || 'unknown';
+                        const lastUserText = lastUserIdx >= 0 ? extractText(messages[lastUserIdx].content) : '';
+                        const sysChars = sysContent.length;
+                        const userChars = lastUserText.length;
+                        const totalChars = sysChars + userChars;
+                        const line = JSON.stringify({
+                            ts: new Date().toISOString(),
+                            sessionKey: tlmSessionKey,
+                            sysChars,
+                            sysTokensEst: Math.round(sysChars / 4),
+                            userChars,
+                            userTokensEst: Math.round(userChars / 4),
+                            totalChars,
+                            totalTokensEst: Math.round(totalChars / 4),
+                        }) + '\n';
+                        const tlmPath = join(HOME, '.openclaw/workspace/memory/sysprompt-cost.jsonl');
+                        try {
+                            writeFileSync(tlmPath, line, { flag: 'a' });
+                        }
+                        catch (e) {
+                            logger.warn(`${TAG} token telemetry write failed: ${e instanceof Error ? e.message : String(e)}`);
+                        }
+                    }
+                    catch (e) {
+                        logger.warn(`${TAG} token telemetry exception: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                }
+                if (sysContent && lastUserIdx >= 0) {
+                    const lu = messages[lastUserIdx];
+                    const origText = extractText(lu.content);
+                    const sysHash = createHash('sha1').update(sysContent).digest('hex').slice(0, 16);
+                    const sessionKey = body.user || 'unknown';
+                    // Track B — Cache parity check
+                    let cacheParityHandled = false;
+                    if (isCacheParityTrackB()) {
+                        try {
+                            const reg = _readCacheParityRegistry();
+                            const entry = reg[sessionKey];
+                            if (entry && entry.hash === sysHash) {
+                                body.messages = messages.filter(m => m?.role !== 'system');
+                                METRICS.cacheParityHits++;
+                                METRICS.systemPromptInlined++;
+                                cacheParityHandled = true;
+                            }
+                            else {
+                                _writeCacheParityEntry(sessionKey, sysHash, sysContent);
+                                METRICS.cacheParityMisses++;
+                                METRICS.cacheParityRegistryWrites++;
+                                logger.info(`${TAG} cache-parity miss: session=${sessionKey} oldHash=${entry?.hash || 'none'} newHash=${sysHash} sysLen=${sysContent.length} (registry updated; next session start will append)`);
+                            }
+                        }
+                        catch (err) {
+                            logger.warn(`${TAG} cache-parity branch failed: ${err instanceof Error ? err.message : String(err)} — falling back to legacy inlining`);
+                        }
+                    }
+                    // P1 — System-prompt inline cache (legacy path)
+                    if (!cacheParityHandled) {
+                        const cached = _systemInlineCache.get(sessionKey);
+                        let inlinedPrefix;
+                        if (cached && cached.hash === sysHash) {
+                            inlinedPrefix = cached.prefix;
+                            METRICS['systemPromptInlineCacheHits'] = (METRICS['systemPromptInlineCacheHits'] || 0) + 1;
+                        }
+                        else {
+                            inlinedPrefix = `<system>\n${sysContent}\n</system>\n\n`;
+                            _setSystemInlineCache(sessionKey, { hash: sysHash, prefix: inlinedPrefix });
+                            METRICS['systemPromptInlineCacheMisses'] = (METRICS['systemPromptInlineCacheMisses'] || 0) + 1;
+                            logger.info(`${TAG} system-prompt hash churn: session=${sessionKey} oldHash=${cached?.hash || 'none'} newHash=${sysHash} sysLen=${sysContent.length}`);
+                            // Diagnostic dump (OPENCLAW_SYSPROMPT_DUMP=1)
+                            if (isSyspromptDumpEnabled()) {
+                                try {
+                                    const debugDir = join(HOME, '.openclaw/workspace/debug/sysprompt');
+                                    mkdirSync(debugDir, { recursive: true });
+                                    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+                                    writeFileSync(`${debugDir}/${ts}_${sessionKey}_${sysHash}.txt`, sysContent);
+                                }
+                                catch (e) {
+                                    logger.warn(`${TAG} sysprompt debug dump failed: ${e instanceof Error ? e.message : String(e)}`);
+                                }
+                            }
+                        }
+                        lu.content = `${inlinedPrefix}${origText}`;
+                        body.messages = messages.filter(m => m?.role !== 'system');
+                        METRICS.systemPromptInlined++;
+                    }
+                }
+            }
+        }
+        // Stage 0 — record route-patch duration for ux-bridge correlation
+        try {
+            const sessionName = body?.user;
+            if (sessionName) {
+                const PERF_KEY = Symbol.for('claude-local:perf-timing');
+                const g = globalThis;
+                g[PERF_KEY] = g[PERF_KEY] || new Map();
+                const perfMap = g[PERF_KEY];
+                const prev = perfMap.get(sessionName) || {};
+                perfMap.set(sessionName, {
+                    ...prev,
+                    routePatchMs: performance.now() - __perfRouteStart,
+                    routePatchEndAbsMs: performance.now(),
+                });
+            }
+        }
+        catch { /* perf instrumentation must never block requests */ }
+        return origRoute.call(this, path, body, query, res, headers);
+    };
+    proto['route'][ROUTE_PATCH_MARKER] = true;
+    logger.info(`${TAG} EmbeddedServer.route patched — stable session keys active`);
+}
+// ── startEagerServer ──────────────────────────────────────────────────────
+// Source: cwd-enhancer.js lines 1015–1127
+async function startEagerServer(port) {
+    if (serverStarted)
+        return null;
+    serverStarted = true;
+    let SessionManager;
+    let EmbeddedServer;
+    try {
+        ({ SessionManager, EmbeddedServer } = await getCCModules());
+    }
+    catch (err) {
+        logger.error(`${TAG} Cannot import CC modules for eager server: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+    if (!SessionManager || !EmbeddedServer) {
+        logger.error(`${TAG} Missing SessionManager or EmbeddedServer class`);
+        return null;
+    }
+    applyRoutePatch(EmbeddedServer);
+    let eagerManager = null;
+    const maxRetries = 3;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            eagerManager = new SessionManager({
+                maxConcurrentSessions: getMaxConcurrentSessions(),
+                sessionTtlMinutes: getSessionTtlMinutes(),
+            });
+            const mgr = eagerManager;
+            logger.info(`${TAG} SessionManager idle TTL: ${mgr.pluginConfig?.sessionTtlMinutes ?? '?'} min (max sessions: ${mgr.pluginConfig?.maxConcurrentSessions ?? '?'})`);
+            const server = new EmbeddedServer(eagerManager, port);
+            await server.start();
+            logger.info(`${TAG} Eager EmbeddedServer started on :${port} — compat bridge ready`);
+            const SM_KEY = Symbol.for('claude-local-enhancer:session-manager');
+            globalThis[SM_KEY] = eagerManager;
+            logger.info(`${TAG} SessionManager exposed via globalThis for bridge access`);
+            // Model guard: verify main agent routes through claude-local/*
+            try {
+                const cfgPath = join(PATHS.workspace, 'openclaw.json');
+                const cfg = JSON.parse(readFileSync(cfgPath, 'utf8'));
+                const agentList = Array.isArray(cfg?.agents)
+                    ? cfg.agents
+                    : Array.isArray(cfg?.agents?.list)
+                        ? cfg.agents.list
+                        : [];
+                const mainAgent = agentList.find(a => a?.id === 'main');
+                const readPrimary = (m) => typeof m === 'string' ? m : m?.primary;
+                const mainPrimary = readPrimary(mainAgent?.model);
+                const defaultsPrimary = readPrimary(cfg?.agents?.defaults?.model);
+                const effective = mainPrimary || defaultsPrimary;
+                if (effective && !effective.startsWith('claude-local/') && !effective.startsWith('cc-openclaw/')) {
+                    logger.warn([
+                        '',
+                        '════════════════════════════════════════════════════════════════════',
+                        `${TAG} ⚠  SAVVY MAIN-AGENT EFFECTIVE PRIMARY MODEL IS '${effective}'`,
+                        `    (main override: ${mainPrimary ?? 'none'} | defaults: ${defaultsPrimary ?? 'none'})`,
+                        '  This is NOT a claude-local/* or cc-openclaw/* model → persistent sessions disabled.',
+                        '  Consequences:',
+                        '    • Savvy will forget context across every message',
+                        '    • Telegram live card will not populate (no TOOL_USE events)',
+                        '  Fix: set agents.list[id=main].model.primary (or agents.defaults.model.primary)',
+                        `        to cc-openclaw/claude-opus-4-7 in ${cfgPath}`,
+                        '════════════════════════════════════════════════════════════════════',
+                        '',
+                    ].join('\n'));
+                }
+                else if (effective) {
+                    logger.info(`${TAG} Savvy main-agent primary OK — ${effective} (source: ${mainPrimary ? 'main-override' : 'defaults'})`);
+                }
+                if (defaultsPrimary && !defaultsPrimary.startsWith('claude-local/') && !defaultsPrimary.startsWith('cc-openclaw/')) {
+                    logger.warn(`${TAG} ⚠  agents.defaults.model.primary is '${defaultsPrimary}' — subagents without a model override will be stateless`);
+                }
+            }
+            catch (err) {
+                logger.warn(`${TAG} model-guard skipped: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            // Boot health verification
+            try {
+                const healthRes = await fetch(`http://127.0.0.1:${port}/health`);
+                if (healthRes.ok) {
+                    const health = (await healthRes.json());
+                    logger.info(`${TAG} Health check OK — sessions: ${health.sessions ?? '?'}, version: ${health.version ?? '?'}`);
+                }
+            }
+            catch { /* non-critical */ }
+            // ── Prewarm Claude CLI subprocess ─────────────────────────────────────
+            // The Claude CLI subprocess (vendor/persistent-session.js spawn) is
+            // normally deferred to the first incoming request — which adds 30-60s
+            // of cold-start latency on the first chat completion after a gateway
+            // restart. Pre-spawning a session at boot moves that cost off the
+            // user-visible critical path. Non-blocking: failures here don't block
+            // gateway boot. The session is created with skipPersistence so it
+            // doesn't pollute the persisted-sessions map.
+            const _prewarmStartMs = Date.now();
+            eagerManager
+                .startSession({
+                name: 'cc-openclaw-prewarm',
+                model: 'claude-haiku-4-5',
+                skipPersistence: true,
+            })
+                .then(() => {
+                const elapsedMs = Date.now() - _prewarmStartMs;
+                logger.info(`${TAG} Prewarm session ready — Claude CLI subprocess hot (${elapsedMs}ms; first request will be fast)`);
+            })
+                .catch((err) => {
+                logger.warn(`${TAG} Prewarm session failed (cold-start optimization disabled this boot): ${err instanceof Error ? err.message : String(err)}`);
+            });
+            break;
+        }
+        catch (err) {
+            const e = err;
+            if (e.code === 'EADDRINUSE') {
+                logger.info(`${TAG} Port :${port} already in use — main plugin owns it, skipping`);
+                eagerManager = null;
+                break;
+            }
+            logger.error(`${TAG} Eager server start failed (attempt ${attempt + 1}/${maxRetries + 1}): ${e.message}`);
+            eagerManager = null;
+            if (attempt < maxRetries) {
+                const delay = 2000 * Math.pow(2, attempt);
+                await new Promise(r => setTimeout(r, delay));
+            }
+        }
+    }
+    return eagerManager;
+}
+// ── Stale session cleanup ─────────────────────────────────────────────────
+// Source: cwd-enhancer.js lines 1129–1146
+function cleanStaleSessions(manager) {
+    if (!manager)
+        return;
+    try {
+        const mgr = manager;
+        const sessions = mgr.listSessions();
+        if (!Array.isArray(sessions) || !sessions.length)
+            return;
+        const stale = sessions.filter(s => s.stats?.isReady === false);
+        if (!stale.length) {
+            logger.info(`${TAG} All ${sessions.length} bridge session(s) healthy`);
+            return;
+        }
+        logger.info(`${TAG} Cleaning ${stale.length} stale session(s)...`);
+        for (const s of stale) {
+            mgr.stopSession(s.name).catch(() => { });
+            logger.info(`${TAG} Stopped stale: ${s.name}`);
+        }
+    }
+    catch (e) {
+        logger.warn(`${TAG} Stale cleanup failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+// ── Register ──────────────────────────────────────────────────────────────
+/**
+ * Register the CWD-patch plugin.
+ * Idempotent: subsequent calls on the same api are no-ops.
+ */
+export function register(api) {
+    logger = api.logger ?? console;
+    defaultRegisterGuard.guard('session-bootstrap/cwd-patch', api, () => {
+        const pluginConfig = api.config?.plugins?.entries?.['claude-local-enhancer']?.config ?? {};
+        const workspaceCwd = pluginConfig['workspaceCwd'] || PATHS.workspace;
+        const port = pluginConfig['port'] || DEFAULT_PORT;
+        // registerService stub for API compliance — always wired, even in test mode
+        api.registerService({
+            id: 'claude-local-enhancer',
+            start: async () => { },
+            stop: async () => { },
+        });
+        if (isTestMode()) {
+            logger.info(`${TAG} TEST_MODE=1 — skipping eager bootstrap (validatePaths, UX_BRIDGE_ALL_SESSIONS mutation, pricing overrides, resume registry restore, self-healing stubs, applyPatch+startEagerServer)`);
+            return;
+        }
+        validatePaths();
+        logger.info(`${TAG} Registered — workspace CWD: ${workspaceCwd}, port: ${port}`);
+        // Enable UX bridge for ALL Claude Code sessions
+        // Changed 2026-04-26: explicit UX_BRIDGE_ALL_SESSIONS=false is respected.
+        // The mutation is centralized in config.ensureUxBridgeAllSessionsDefault().
+        const uxBridge = ensureUxBridgeAllSessionsDefault();
+        if (uxBridge.mutated) {
+            logger.info(`${TAG} UX_BRIDGE_ALL_SESSIONS enabled (set programmatically — was unset)`);
+        }
+        else {
+            logger.info(`${TAG} UX_BRIDGE_ALL_SESSIONS=${uxBridge.value} (env-file value, respected)`);
+        }
+        // Patch openclaw-claude-code model pricing table for opus-4-7 / haiku-4-5
+        import(PATHS.ccModels).then((mod) => {
+            const m = mod;
+            if (typeof m['overrideModelPricing'] !== 'function') {
+                logger.warn(`${TAG} overrideModelPricing not exported by models.js — skipping pricing patch`);
+                return;
+            }
+            m['overrideModelPricing']({
+                'claude-opus-4-7': { input: 5, output: 25, cached: 0.5 },
+                'claude-haiku-4-5': { input: 1, output: 5, cached: 0.1 },
+            });
+            logger.info(`${TAG} Pricing overrides applied for claude-opus-4-7 + claude-haiku-4-5`);
+        }).catch((err) => {
+            logger.warn(`${TAG} Pricing override import failed: ${err.message}`);
+        });
+        // Restore parallel resume registry BEFORE applyPatch + eagerServer
+        restoreClaudeSessionsFromBackup();
+        // Self-healing
+        ensureStatusRuntimeStubs();
+        ensureSandboxPermissions();
+        logger.info(`${TAG} Eagerly applying patch + starting server...`);
+        applyPatch(workspaceCwd)
+            .then(() => startEagerServer(port))
+            .then((manager) => {
+            bootstrapResumeRegistry(manager);
+            const captureInterval = setInterval(() => capturePersistedSessionsFromManager(manager), 5_000);
+            captureInterval.unref();
+            cleanStaleSessions(manager);
+            const cleanupInterval = setInterval(() => cleanStaleSessions(manager), 120_000);
+            cleanupInterval.unref();
+        })
+            .catch((err) => {
+            logger.error(`${TAG} Eager init failed: ${err.message}`);
+        });
+    }); // end defaultRegisterGuard.guard
+}
+//# sourceMappingURL=cwd-patch.js.map