context-mode 1.0.168 → 1.0.169

package/build/cache-heal.d.ts

@@ -1,48 +0,0 @@
-/**
- * Plugin cache self-heal — fixes broken CLAUDE_PLUGIN_ROOT references.
- *
- * Claude Code's plugin auto-update can leave installed_plugins.json pointing
- * to a non-existent directory (anthropics/claude-code#46915). This module
- * detects and repairs the mismatch by creating symlinks.
- *
- * 4-layer defense:
- *   1. start.mjs startup — reverse heal (registry → symlink to us)
- *   2. server.ts first tool call — mid-session heal
- *   3. postinstall.mjs — backward symlink on new install
- *   4. global hook auto-deploy — survives total plugin cache breakage
- */
-export interface HealResult {
-    healed: boolean;
-    action?: "symlink" | "global-hook" | "none";
-    from?: string;
-    to?: string;
-}
-/**
- * Core heal: if installed_plugins.json points to a non-existent directory,
- * create a symlink from that path to our actual directory.
- *
- * @param currentDir - The directory we're actually running from
- * @param installedPluginsPath - Path to installed_plugins.json (injectable for testing)
- */
-export declare function healRegistryMismatch(currentDir: string, installedPluginsPath?: string): HealResult;
-/**
- * Deploy a global SessionStart hook that heals plugin cache mismatches.
- * This hook lives outside the plugin directory, so it survives cache breakage.
- *
- * Written to ~/.claude/hooks/context-mode-cache-heal.sh
- */
-export declare function deployGlobalHealHook(): HealResult;
-/**
- * Backward symlink: during postinstall, if the registry points to a
- * non-existent OLD path, create a symlink from old → new (our directory).
- * Same as healRegistryMismatch but called from postinstall context.
- */
-export { healRegistryMismatch as healBackwardCompat };
-/**
- * Mid-session heal — call on first MCP tool invocation.
- * Checks if registry path differs from our running directory.
- * Creates symlink if needed. Runs only once per process.
- */
-export declare function healMidSession(currentDir: string): HealResult;
-/** Reset mid-session flag (for testing only) */
-export declare function _resetMidSession(): void;

package/build/cache-heal.js

@@ -1,150 +0,0 @@
-/**
- * Plugin cache self-heal — fixes broken CLAUDE_PLUGIN_ROOT references.
- *
- * Claude Code's plugin auto-update can leave installed_plugins.json pointing
- * to a non-existent directory (anthropics/claude-code#46915). This module
- * detects and repairs the mismatch by creating symlinks.
- *
- * 4-layer defense:
- *   1. start.mjs startup — reverse heal (registry → symlink to us)
- *   2. server.ts first tool call — mid-session heal
- *   3. postinstall.mjs — backward symlink on new install
- *   4. global hook auto-deploy — survives total plugin cache breakage
- */
-import { existsSync, readFileSync, symlinkSync, mkdirSync, writeFileSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { homedir } from "node:os";
-/**
- * Core heal: if installed_plugins.json points to a non-existent directory,
- * create a symlink from that path to our actual directory.
- *
- * @param currentDir - The directory we're actually running from
- * @param installedPluginsPath - Path to installed_plugins.json (injectable for testing)
- */
-export function healRegistryMismatch(currentDir, installedPluginsPath) {
-    const ipPath = installedPluginsPath ?? resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
-    if (!existsSync(ipPath))
-        return { healed: false, action: "none" };
-    if (!existsSync(currentDir))
-        return { healed: false, action: "none" };
-    let ip;
-    try {
-        ip = JSON.parse(readFileSync(ipPath, "utf-8"));
-    }
-    catch {
-        return { healed: false, action: "none" };
-    }
-    for (const [key, entries] of Object.entries(ip.plugins ?? {})) {
-        if (!key.toLowerCase().includes("context-mode"))
-            continue;
-        for (const entry of entries) {
-            const registryPath = entry.installPath;
-            if (!registryPath)
-                continue;
-            // Registry path exists — no healing needed
-            if (existsSync(registryPath))
-                continue;
-            // Registry path doesn't exist — create symlink to our directory
-            try {
-                const parent = dirname(registryPath);
-                if (!existsSync(parent))
-                    mkdirSync(parent, { recursive: true });
-                if (process.platform === "win32") {
-                    // Windows: use junction (no admin required)
-                    symlinkSync(currentDir, registryPath, "junction");
-                }
-                else {
-                    symlinkSync(currentDir, registryPath);
-                }
-                return { healed: true, action: "symlink", from: registryPath, to: currentDir };
-            }
-            catch {
-                return { healed: false, action: "none" };
-            }
-        }
-    }
-    return { healed: false, action: "none" };
-}
-/**
- * Deploy a global SessionStart hook that heals plugin cache mismatches.
- * This hook lives outside the plugin directory, so it survives cache breakage.
- *
- * Written to ~/.claude/hooks/context-mode-cache-heal.sh
- */
-export function deployGlobalHealHook() {
-    const hooksDir = resolve(homedir(), ".claude", "hooks");
-    const hookPath = resolve(hooksDir, "context-mode-cache-heal.sh");
-    // Already deployed
-    if (existsSync(hookPath))
-        return { healed: false, action: "none" };
-    try {
-        if (!existsSync(hooksDir))
-            mkdirSync(hooksDir, { recursive: true });
-        const script = `#!/usr/bin/env bash
-# context-mode plugin cache self-heal — auto-deployed by context-mode MCP server
-# Fixes anthropics/claude-code#46915: auto-update breaks CLAUDE_PLUGIN_ROOT
-# This hook runs at SessionStart (global, not plugin-level) so it works even
-# when the plugin cache is broken.
-
-set -euo pipefail
-
-PLUGINS_FILE="$HOME/.claude/plugins/installed_plugins.json"
-[[ -f "$PLUGINS_FILE" ]] || exit 0
-
-# Find context-mode entries and heal missing directories
-node -e '
-const fs = require("fs");
-const path = require("path");
-try {
-  const ip = JSON.parse(fs.readFileSync(process.argv[1], "utf-8"));
-  for (const [key, entries] of Object.entries(ip.plugins || {})) {
-    if (!key.toLowerCase().includes("context-mode")) continue;
-    for (const entry of entries) {
-      const p = entry.installPath;
-      if (!p || fs.existsSync(p)) continue;
-      const parent = path.dirname(p);
-      if (!fs.existsSync(parent)) continue;
-      const dirs = fs.readdirSync(parent).filter(d => /^\\d+\\.\\d+/.test(d) && fs.statSync(path.join(parent, d)).isDirectory());
-      if (dirs.length === 0) continue;
-      dirs.sort((a, b) => {
-        const pa = a.split(".").map(Number), pb = b.split(".").map(Number);
-        for (let i = 0; i < 3; i++) { if ((pa[i]||0) !== (pb[i]||0)) return (pa[i]||0) - (pb[i]||0); }
-        return 0;
-      });
-      const target = path.join(parent, dirs[dirs.length - 1]);
-      try { fs.symlinkSync(target, p); } catch {}
-    }
-  }
-} catch {}
-' "$PLUGINS_FILE" 2>/dev/null || true
-`;
-        writeFileSync(hookPath, script, { mode: 0o755 });
-        return { healed: true, action: "global-hook", from: hookPath };
-    }
-    catch {
-        return { healed: false, action: "none" };
-    }
-}
-/**
- * Backward symlink: during postinstall, if the registry points to a
- * non-existent OLD path, create a symlink from old → new (our directory).
- * Same as healRegistryMismatch but called from postinstall context.
- */
-export { healRegistryMismatch as healBackwardCompat };
-/** One-shot flag for mid-session heal in server.ts */
-let _midSessionHealed = false;
-/**
- * Mid-session heal — call on first MCP tool invocation.
- * Checks if registry path differs from our running directory.
- * Creates symlink if needed. Runs only once per process.
- */
-export function healMidSession(currentDir) {
-    if (_midSessionHealed)
-        return { healed: false, action: "none" };
-    _midSessionHealed = true;
-    return healRegistryMismatch(currentDir);
-}
-/** Reset mid-session flag (for testing only) */
-export function _resetMidSession() {
-    _midSessionHealed = false;
-}

package/build/concurrency/runPool.d.ts

@@ -1,36 +0,0 @@
-/**
- * Generic in-flight-capped worker pool.
- *
- * Used by:
- *   - runBatchCommands (ctx_batch_execute parallel branch)
- *   - runBatchFetch    (ctx_fetch_and_index batch path)
- *
- * Returns Promise.allSettled-style results so one job's throw cannot
- * strand siblings. Caller maps fulfilled/rejected per index. Output
- * order is preserved by input index (not completion order).
- *
- * Designed to be the SINGLE concurrency primitive for the project —
- * all "run N independent operations with at most M in flight" needs
- * route here. Avoids the worker-pool copy-paste flagged in the
- * concurrency PRD architectural review (finding G).
- */
-export interface PoolJob<T> {
-    run(): Promise<T>;
-}
-export interface RunPoolOptions {
-    /** Hard concurrency cap (1-N). Auto-clamped to job count. */
-    concurrency: number;
-    /** Optional: also clamp by `os.cpus().length` (memory-pressure safety). Default false. */
-    capByCpuCount?: boolean;
-    /** Optional: per-settled callback (e.g. for progress reporting / metrics). */
-    onSettled?: (idx: number, result: PromiseSettledResult<unknown>) => void;
-}
-export interface RunPoolResult<T> {
-    /** Per-index settled result, ordered by input index. */
-    settled: PromiseSettledResult<T>[];
-    /** Concurrency actually used after all caps applied. */
-    effectiveConcurrency: number;
-    /** True when effectiveConcurrency < requested concurrency. */
-    capped: boolean;
-}
-export declare function runPool<T>(jobs: PoolJob<T>[], opts: RunPoolOptions): Promise<RunPoolResult<T>>;

package/build/concurrency/runPool.js

@@ -1,51 +0,0 @@
-/**
- * Generic in-flight-capped worker pool.
- *
- * Used by:
- *   - runBatchCommands (ctx_batch_execute parallel branch)
- *   - runBatchFetch    (ctx_fetch_and_index batch path)
- *
- * Returns Promise.allSettled-style results so one job's throw cannot
- * strand siblings. Caller maps fulfilled/rejected per index. Output
- * order is preserved by input index (not completion order).
- *
- * Designed to be the SINGLE concurrency primitive for the project —
- * all "run N independent operations with at most M in flight" needs
- * route here. Avoids the worker-pool copy-paste flagged in the
- * concurrency PRD architectural review (finding G).
- */
-import { cpus } from "node:os";
-export async function runPool(jobs, opts) {
-    const { concurrency, capByCpuCount = false, onSettled } = opts;
-    if (jobs.length === 0) {
-        return { settled: [], effectiveConcurrency: 0, capped: false };
-    }
-    const requested = Math.max(1, concurrency);
-    const cpuCap = capByCpuCount ? Math.max(1, cpus().length) : requested;
-    const effectiveConcurrency = Math.min(requested, cpuCap, jobs.length);
-    const capped = effectiveConcurrency < requested;
-    const settled = new Array(jobs.length);
-    let nextIdx = 0;
-    async function worker() {
-        while (true) {
-            const idx = nextIdx++;
-            if (idx >= jobs.length)
-                return;
-            try {
-                const value = await jobs[idx].run();
-                settled[idx] = { status: "fulfilled", value };
-            }
-            catch (err) {
-                settled[idx] = { status: "rejected", reason: err };
-            }
-            onSettled?.(idx, settled[idx]);
-        }
-    }
-    const workers = [];
-    for (let w = 0; w < effectiveConcurrency; w++)
-        workers.push(worker());
-    // allSettled defends against any promise rejection escaping a worker
-    // (the worker already swallows its own errors, but this is belt-and-braces).
-    await Promise.allSettled(workers);
-    return { settled, effectiveConcurrency, capped };
-}

package/build/openclaw/mcp-tools.d.ts

@@ -1,54 +0,0 @@
-/**
- * OpenClaw MCP tool registry.
- *
- * Catalogs the 11 ctx_* tools that OpenClaw plugin must register via
- * api.registerTool(...) so the routing block (which nudges agents toward
- * ctx_execute, ctx_search, etc.) actually has tools to call. Without this,
- * Phase 7 audit (v1.0.107-adapter-openclaw.json) flagged severity=CRITICAL —
- * routing-block premise is broken when the named tools don't exist.
- *
- * Pattern mirrors the swarmvault MCP plugin
- * (refs/plugin-examples/openclaw/swarmvault/packages/engine/src/mcp.ts:46-51):
- *   server.registerTool(name, { description, inputSchema }, handler)
- *
- * OpenClaw signature is slightly different — see building-plugins.md:116
- *   api.registerTool({ name, description, parameters: TypeBox, execute(id, params) })
- *
- * Tool handlers are intentionally thin shims that delegate to the bundled CLI
- * (cli.bundle.mjs) — same fall-through pattern already used by ctx-doctor and
- * ctx-upgrade slash commands. This keeps the plugin's blast radius minimal:
- * we don't re-export the entire MCP server stack inside OpenClaw's process.
- *
- * The 11 tools mirror src/server.ts registerTool calls (lines 897, 1226, 1371,
- * 1497, 2034, 2256, 2440, 2501, 2592, 2712, 2808).
- */
-/** Minimal JSON-schema-like parameter spec accepted by OpenClaw registerTool. */
-export interface OpenClawToolParameters {
-    type: "object";
-    properties: Record<string, {
-        type: string;
-        description?: string;
-    }>;
-    required?: string[];
-    additionalProperties?: boolean;
-}
-/** Tool definition shape returned to OpenClaw via api.registerTool. */
-export interface OpenClawToolDef {
-    name: string;
-    description: string;
-    parameters: OpenClawToolParameters;
-    execute: (id: string, params: Record<string, unknown>) => Promise<{
-        content: Array<{
-            type: "text";
-            text: string;
-        }>;
-    }>;
-}
-/**
- * The 11 ctx_* tool definitions registered into OpenClaw via api.registerTool.
- * Names + descriptions mirror src/server.ts registerTool blocks 1:1 so prompts
- * referencing them (routing block, AGENTS.md) resolve to real callable tools.
- */
-export declare const OPENCLAW_TOOL_DEFS: readonly OpenClawToolDef[];
-/** Stable list of tool names — used by tests and manifest validation. */
-export declare const OPENCLAW_TOOL_NAMES: readonly string[];

package/build/openclaw/mcp-tools.js

@@ -1,198 +0,0 @@
-/**
- * OpenClaw MCP tool registry.
- *
- * Catalogs the 11 ctx_* tools that OpenClaw plugin must register via
- * api.registerTool(...) so the routing block (which nudges agents toward
- * ctx_execute, ctx_search, etc.) actually has tools to call. Without this,
- * Phase 7 audit (v1.0.107-adapter-openclaw.json) flagged severity=CRITICAL —
- * routing-block premise is broken when the named tools don't exist.
- *
- * Pattern mirrors the swarmvault MCP plugin
- * (refs/plugin-examples/openclaw/swarmvault/packages/engine/src/mcp.ts:46-51):
- *   server.registerTool(name, { description, inputSchema }, handler)
- *
- * OpenClaw signature is slightly different — see building-plugins.md:116
- *   api.registerTool({ name, description, parameters: TypeBox, execute(id, params) })
- *
- * Tool handlers are intentionally thin shims that delegate to the bundled CLI
- * (cli.bundle.mjs) — same fall-through pattern already used by ctx-doctor and
- * ctx-upgrade slash commands. This keeps the plugin's blast radius minimal:
- * we don't re-export the entire MCP server stack inside OpenClaw's process.
- *
- * The 11 tools mirror src/server.ts registerTool calls (lines 897, 1226, 1371,
- * 1497, 2034, 2256, 2440, 2501, 2592, 2712, 2808).
- */
-/** Wrap any handler so failures become a well-formed text error rather than crashing. */
-function safe(handler) {
-    return async (_id, params) => {
-        try {
-            return await handler(params ?? {});
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `[context-mode] tool error: ${message}`,
-                    },
-                ],
-            };
-        }
-    };
-}
-/** Stub handler — points users at the bundled CLI for full functionality. */
-function cliRedirect(toolName) {
-    return safe(async () => ({
-        content: [
-            {
-                type: "text",
-                text: `[context-mode] ${toolName} is exposed via the bundled context-mode CLI. Run 'context-mode ${toolName}' or invoke the MCP server directly. This OpenClaw stub registers the tool name so the routing block remains valid; full execution requires the standalone MCP transport.`,
-            },
-        ],
-    }));
-}
-/**
- * The 11 ctx_* tool definitions registered into OpenClaw via api.registerTool.
- * Names + descriptions mirror src/server.ts registerTool blocks 1:1 so prompts
- * referencing them (routing block, AGENTS.md) resolve to real callable tools.
- */
-export const OPENCLAW_TOOL_DEFS = [
-    {
-        name: "ctx_execute",
-        description: "Execute code in a sandboxed subprocess. Only stdout enters context. Prefer over Bash for any command producing >20 lines.",
-        parameters: {
-            type: "object",
-            properties: {
-                language: { type: "string", description: "Runtime language" },
-                code: { type: "string", description: "Source code to execute" },
-                timeout: { type: "number", description: "Max execution time in ms" },
-            },
-            required: ["language", "code"],
-            additionalProperties: true,
-        },
-        execute: cliRedirect("ctx_execute"),
-    },
-    {
-        name: "ctx_execute_file",
-        description: "Execute code with a file path. Only printed summary enters context — raw file stays in sandbox.",
-        parameters: {
-            type: "object",
-            properties: {
-                path: { type: "string", description: "File path" },
-                language: { type: "string", description: "Runtime language" },
-                code: { type: "string", description: "Source code" },
-            },
-            required: ["path", "language", "code"],
-            additionalProperties: true,
-        },
-        execute: cliRedirect("ctx_execute_file"),
-    },
-    {
-        name: "ctx_index",
-        description: "Store content in the FTS5 knowledge base for later search.",
-        parameters: {
-            type: "object",
-            properties: {
-                content: { type: "string", description: "Text to index" },
-                source: { type: "string", description: "Descriptive source label" },
-            },
-            required: ["content", "source"],
-            additionalProperties: true,
-        },
-        execute: cliRedirect("ctx_index"),
-    },
-    {
-        name: "ctx_search",
-        description: "Query indexed content via FTS5. Pass all questions as an array in ONE call.",
-        parameters: {
-            type: "object",
-            properties: {
-                queries: { type: "array", description: "Search queries" },
-                source: { type: "string", description: "Optional source filter" },
-                sort: { type: "string", description: "relevance | timeline" },
-            },
-            additionalProperties: true,
-        },
-        execute: cliRedirect("ctx_search"),
-    },
-    {
-        name: "ctx_fetch_and_index",
-        description: "Fetch a URL, chunk it, and index — raw HTML never enters context.",
-        parameters: {
-            type: "object",
-            properties: {
-                url: { type: "string", description: "URL to fetch" },
-                source: { type: "string", description: "Source label for indexed chunks" },
-            },
-            required: ["url"],
-            additionalProperties: true,
-        },
-        execute: cliRedirect("ctx_fetch_and_index"),
-    },
-    {
-        name: "ctx_batch_execute",
-        description: "Run multiple commands and search queries in ONE call. Primary research tool — replaces 30+ individual calls.",
-        parameters: {
-            type: "object",
-            properties: {
-                commands: { type: "array", description: "Array of {label, command} objects" },
-                queries: { type: "array", description: "Search queries to run after indexing" },
-            },
-            additionalProperties: true,
-        },
-        execute: cliRedirect("ctx_batch_execute"),
-    },
-    {
-        name: "ctx_stats",
-        description: "Show context-mode session statistics — token consumption and per-tool breakdown.",
-        parameters: {
-            type: "object",
-            properties: {},
-            additionalProperties: true,
-        },
-        execute: cliRedirect("ctx_stats"),
-    },
-    {
-        name: "ctx_doctor",
-        description: "Run context-mode diagnostics — runtimes, hooks, FTS5, plugin registration.",
-        parameters: {
-            type: "object",
-            properties: {},
-            additionalProperties: true,
-        },
-        execute: cliRedirect("ctx_doctor"),
-    },
-    {
-        name: "ctx_upgrade",
-        description: "Upgrade context-mode to the latest version.",
-        parameters: {
-            type: "object",
-            properties: {},
-            additionalProperties: true,
-        },
-        execute: cliRedirect("ctx_upgrade"),
-    },
-    {
-        name: "ctx_purge",
-        description: "Permanently delete all indexed content and reset session stats. Destructive.",
-        parameters: {
-            type: "object",
-            properties: {},
-            additionalProperties: true,
-        },
-        execute: cliRedirect("ctx_purge"),
-    },
-    {
-        name: "ctx_insight",
-        description: "Open the context-mode Insight analytics dashboard in the browser.",
-        parameters: {
-            type: "object",
-            properties: {},
-            additionalProperties: true,
-        },
-        execute: cliRedirect("ctx_insight"),
-    },
-];
-/** Stable list of tool names — used by tests and manifest validation. */
-export const OPENCLAW_TOOL_NAMES = OPENCLAW_TOOL_DEFS.map((def) => def.name);

package/build/openclaw/workspace-router.d.ts

@@ -1,29 +0,0 @@
-/**
- * Extract the agent workspace path from tool call params.
- * Looks for /openclaw/workspace-<name> patterns in cwd, file_path, and command.
- * Returns the workspace root (e.g. "/openclaw/workspace-trainer") or null.
- */
-export declare function extractWorkspace(params: Record<string, unknown>): string | null;
-/**
- * Maps agent workspaces to sessionIds using sessionKey convention.
- * sessionKey pattern: "agent:<name>:main" → workspace "/openclaw/workspace-<name>"
- *
- * Why this exists alongside per-session closures:
- * Each register() call creates its own closure with its own sessionId, which
- * naturally isolates sessions. The WorkspaceRouter acts as a safety net for
- * after_tool_call events where OpenClaw may deliver the event to the wrong
- * closure (e.g. tool calls interleaving across agents). It resolves the correct
- * sessionId from workspace paths in tool params, falling back to the closure
- * sessionId when no workspace is detected.
- */
-export declare class WorkspaceRouter {
-    private map;
-    /** Register a session from session_start event. */
-    registerSession(sessionKey: string, sessionId: string): void;
-    /** Remove a session (e.g. on command:stop). */
-    removeSession(sessionKey: string): void;
-    /** Resolve sessionId from tool call params. Returns null if no match. */
-    resolveSessionId(params: Record<string, unknown>): string | null;
-    /** Derive workspace path from sessionKey. */
-    private workspaceFromKey;
-}

package/build/openclaw/workspace-router.js

@@ -1,64 +0,0 @@
-/**
- * Extract the agent workspace path from tool call params.
- * Looks for /openclaw/workspace-<name> patterns in cwd, file_path, and command.
- * Returns the workspace root (e.g. "/openclaw/workspace-trainer") or null.
- */
-export function extractWorkspace(params) {
-    // Priority: cwd > file_path > command (most specific first)
-    const sources = [
-        params.cwd,
-        params.file_path,
-        params.command,
-    ].filter((v) => typeof v === "string");
-    for (const src of sources) {
-        const match = src.match(/\/openclaw\/workspace-[a-zA-Z0-9_-]+/);
-        if (match)
-            return match[0];
-    }
-    return null;
-}
-/**
- * Maps agent workspaces to sessionIds using sessionKey convention.
- * sessionKey pattern: "agent:<name>:main" → workspace "/openclaw/workspace-<name>"
- *
- * Why this exists alongside per-session closures:
- * Each register() call creates its own closure with its own sessionId, which
- * naturally isolates sessions. The WorkspaceRouter acts as a safety net for
- * after_tool_call events where OpenClaw may deliver the event to the wrong
- * closure (e.g. tool calls interleaving across agents). It resolves the correct
- * sessionId from workspace paths in tool params, falling back to the closure
- * sessionId when no workspace is detected.
- */
-export class WorkspaceRouter {
-    // workspace path → sessionId
-    map = new Map();
-    /** Register a session from session_start event. */
-    registerSession(sessionKey, sessionId) {
-        const workspace = this.workspaceFromKey(sessionKey);
-        if (workspace) {
-            this.map.set(workspace, sessionId);
-        }
-    }
-    /** Remove a session (e.g. on command:stop). */
-    removeSession(sessionKey) {
-        const workspace = this.workspaceFromKey(sessionKey);
-        if (workspace) {
-            this.map.delete(workspace);
-        }
-    }
-    /** Resolve sessionId from tool call params. Returns null if no match. */
-    resolveSessionId(params) {
-        const workspace = extractWorkspace(params);
-        if (!workspace)
-            return null;
-        return this.map.get(workspace) ?? null;
-    }
-    /** Derive workspace path from sessionKey. */
-    workspaceFromKey(key) {
-        // Pattern: "agent:<name>:main" or "agent:<name>:<channel>"
-        const match = key.match(/^agent:([^:]+):/);
-        if (!match)
-            return null;
-        return `/openclaw/workspace-${match[1]}`;
-    }
-}