context-mode 1.0.150 → 1.0.152

package/skills/ctx-index/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: ctx-index
+description: |
+  Index a local file or directory into context-mode's persistent FTS5 knowledge base
+  so future ctx_search calls can retrieve focused snippets without rereading raw files.
+  Trigger: /context-mode:ctx-index
+user-invocable: true
+---
+
+# Context Mode Index
+
+Index local project content for later search.
+
+## Instructions
+
+1. Prefer the `ctx_index` MCP tool when it is available.
+2. Ask for a path only if the user did not provide one and the current project root is ambiguous.
+3. Use `path`, not large inline `content`, so file bytes do not enter the conversation.
+4. For repository indexing, pass conservative bounds and a clear source label:
+
+```javascript
+ctx_index({
+  path: ".",
+  source: "project:<name>",
+  maxDepth: 5,
+  maxFiles: 200
+})
+```
+
+5. If MCP tools are unavailable, fall back to the CLI:
+
+```bash
+context-mode index . --source project:<name>
+```
+
+6. Report the indexed source label, file count or section count, and the matching search command:
+
+```javascript
+ctx_search({ source: "project:<name>", queries: ["..."] })
+```
+
+## Safety
+
+- Do not index dependency directories, build outputs, secrets, or generated artifacts.
+- Prefer `--exclude` or `exclude` for project-specific noisy paths.
+- For broad repos, ask the user before raising `maxFiles` above 500.

package/skills/ctx-search/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: ctx-search
+description: |
+  Search context-mode's persistent FTS5 knowledge base for previously indexed
+  local project content, documentation, or session memory.
+  Trigger: /context-mode:ctx-search
+user-invocable: true
+---
+
+# Context Mode Search
+
+Search indexed content without rereading raw sources into conversation context.
+
+## Instructions
+
+1. Prefer the `ctx_search` MCP tool when it is available.
+2. Batch all related questions in one `queries` array.
+3. Scope with `source` when the user names a project or indexed label.
+4. Use short, specific queries of two to four technical terms.
+
+```javascript
+ctx_search({
+  source: "project:<name>",
+  queries: ["authentication middleware", "token refresh"],
+  limit: 5
+})
+```
+
+5. If MCP tools are unavailable, fall back to the CLI:
+
+```bash
+context-mode search "authentication middleware" --source project:<name> --limit 5
+```
+
+6. If the index is empty, tell the user to run `/context-mode:ctx-index` or `context-mode index <path>` first.

package/start.mjs

@@ -36,7 +36,7 @@ function resolveClaudeConfigDir() {
 // the env auto-set in that case; getProjectDir() defends a second time inside
 // server.ts via resolveProjectDir(). See src/util/project-dir.ts.
 const isPluginInstallPath = (p) =>
-  /[/\\]\.claude[/\\]plugins[/\\](cache|marketplaces)[/\\]/.test(p);
+  /[/\\]\.(claude|codex)[/\\]plugins[/\\](cache|marketplaces)[/\\]/.test(p);
 const safeOriginalCwd = isPluginInstallPath(originalCwd) ? null : originalCwd;
 
 if (!process.env.CLAUDE_PROJECT_DIR && safeOriginalCwd) {
@@ -121,11 +121,33 @@ if (cacheMatch) {
       });
       const newest = dirs[dirs.length - 1];
       if (newest && newest !== myVersion) {
+        // Issue #727: normalize hooks.json + plugin.json in the newest version
+        // dir BEFORE updating the registry. CC's auto-update carries forward
+        // files from the old cache dir, including hooks.json and plugin.json
+        // with absolute paths baked to the old version. start.mjs's Self-heal
+        // Layer 5 would catch this, but plugin.json's stale mcpServers path
+        // prevents the new start.mjs from ever booting — chicken-and-egg.
+        // Fix: normalize from HERE (the old start.mjs that CC CAN still launch)
+        // so the new dir's files are correct before the next session reads them.
+        const newestDir = resolve(cacheParent, newest);
+        try {
+          // #713: use narrow helper — wide normalizeHooksOnStartup would
+          // write plugin.json on the NEW cache dir, the exact #711 poison
+          // vector. Only hooks.json needs the placeholder→absolute rewrite
+          // pre-bump to close the first-hook-fire window.
+          const { normalizeHooksJsonOnly } = await import("./hooks/normalize-hooks.mjs");
+          normalizeHooksJsonOnly({
+            pluginRoot: newestDir,
+            nodePath: process.execPath,
+            platform: process.platform,
+          });
+        } catch { /* best effort — never block startup */ }
+
         const ip = JSON.parse(readFileSync(ipPath, "utf-8"));
         for (const [key, entries] of Object.entries(ip.plugins || {})) {
           if (key !== "context-mode@context-mode") continue;
           for (const entry of entries) {
-            entry.installPath = resolve(cacheParent, newest);
+            entry.installPath = newestDir;
             entry.version = newest;
             entry.lastUpdated = new Date().toISOString();
           }
@@ -253,11 +275,11 @@ try {
   if (existsSync(oldBashHook)) {
     try { unlinkSync(oldBashHook); } catch {}
   }
-  if (!existsSync(healHookPath)) {
-    if (!existsSync(globalHooksDir)) mkdirSync(globalHooksDir, { recursive: true });
-    const healScript = `#!/usr/bin/env node
+  if (!existsSync(globalHooksDir)) mkdirSync(globalHooksDir, { recursive: true });
+  const healScript = `#!/usr/bin/env node
 // context-mode plugin cache self-heal (auto-deployed)
 // Fixes anthropics/claude-code#46915: auto-update breaks CLAUDE_PLUGIN_ROOT
+// Issue #727: also normalizes stale version paths in existing installPaths
 // Honors CLAUDE_CONFIG_DIR (#577) — checked at this script's runtime so users
 // who set CLAUDE_CONFIG_DIR after install still get healed correctly.
 // Pure Node.js — no bash/shell dependency.
@@ -274,8 +296,25 @@ try{
     if(k!=="context-mode@context-mode")continue;
     for(const e of es){
       const p=e.installPath;
-      if(!p||existsSync(p))continue;
+      if(!p)continue;
       if(!resolve(p).startsWith(cacheRoot+sep))continue;
+      if(existsSync(p)){
+        // Issue #727: normalize stale version paths in existing installPaths.
+        // CC's auto-update can carry forward hooks.json/plugin.json with paths
+        // baked to a previous version dir. Import normalize-hooks from the
+        // installPath itself and let it detect + rewrite stale segments.
+        try{
+          // #713: narrow helper only — installPath belongs to a different
+          // version's cache dir; writing plugin.json there is the #711 vector.
+          const nhPath=join(p,"hooks","normalize-hooks.mjs");
+          if(existsSync(nhPath)){
+            const mod=await import(nhPath);
+            const fn=mod.normalizeHooksJsonOnly||mod.normalizeHooksOnStartup;
+            if(fn)fn({pluginRoot:p,nodePath:process.execPath,platform:process.platform});
+          }
+        }catch{}
+        continue;
+      }
       const parent=dirname(p);
       if(!existsSync(parent))continue;
       try{if(lstatSync(p).isSymbolicLink())unlinkSync(p)}catch{}
@@ -287,6 +326,13 @@ try{
   }
 }catch{}
 `;
+  // Deploy or update the heal hook when content changes (not just when missing).
+  // Allows new heal logic (e.g. #727 path normalization) to propagate on next boot.
+  let needsWrite = !existsSync(healHookPath);
+  if (!needsWrite) {
+    try { needsWrite = readFileSync(healHookPath, "utf-8") !== healScript; } catch { needsWrite = true; }
+  }
+  if (needsWrite) {
     writeFileSync(healHookPath, healScript, { mode: 0o755 });
   }
 
@@ -353,9 +399,20 @@ try{
 if (!process.env.VITEST) {
   try {
     const { normalizeHooksOnStartup } = await import("./hooks/normalize-hooks.mjs");
+    // #738: probe for Bun ≥1.0 and pass the resolved path so the static
+    // hooks/hooks.json rewrite swaps `node` → `bun` (~40-60ms cold-start win
+    // per hook). Probe is wrapped in its own try so resolveHookRuntime
+    // failures (missing build, missing module) never block boot.
+    let jsRuntimePath;
+    try {
+      const { resolveHookRuntime } = await import("./build/runtime.js");
+      const r = resolveHookRuntime();
+      if (r.isBun) jsRuntimePath = r.path;
+    } catch { /* best effort — fall through to nodePath default */ }
     normalizeHooksOnStartup({
       pluginRoot: __dirname,
       nodePath: process.execPath,
+      jsRuntimePath,
       platform: process.platform,
     });
   } catch { /* best effort — never block server startup */ }
@@ -415,6 +472,21 @@ if (!existsSync(resolve(__dirname, "cli.bundle.mjs")) && existsSync(resolve(__di
   if (process.platform !== "win32") chmodSync(shimPath, 0o755);
 }
 
+// ── Self-heal partial install from marketplace clone ──
+// Runs BEFORE the Algo-D4 integrity check so a fixable partial install
+// gets repaired rather than just reported. Best-effort and idempotent;
+// the integrity check below remains the authoritative gate that decides
+// whether boot proceeds. See hooks/heal-partial-install.mjs for the
+// failure-mode description and module contract.
+if (!process.env.VITEST) {
+  try {
+    const { healPartialInstallFromMarketplace } = await import(
+      "./hooks/heal-partial-install.mjs"
+    );
+    healPartialInstallFromMarketplace({ pluginRoot: __dirname });
+  } catch { /* best effort, never block boot */ }
+}
+
 // ── Algo-D4: plugin cache integrity check ──
 // Verify boot-critical siblings exist BEFORE importing server.bundle.mjs.
 // Without this, a partial install (#550) gives an opaque downstream
@@ -423,11 +495,12 @@ if (!existsSync(resolve(__dirname, "cli.bundle.mjs")) && existsSync(resolve(__di
 // external monitoring grep + the user both see the actionable signal.
 //
 // Runs AFTER the heal layers above so missing files they can fix
-// (cli.bundle.mjs shim, dangling symlinks) get a chance first. Helper
-// is shared with `ctx doctor` (Algo-D5) — single source of truth so
-// boot + diagnostic agree byte-for-byte. Skipped under VITEST so the
-// repo's own test invocations against in-tree start.mjs don't fail
-// when running before `npm run build` produces the bundles.
+// (cli.bundle.mjs shim, dangling symlinks, partial-install copy from
+// the marketplace clone) get a chance first. Helper is shared with
+// `ctx doctor` (Algo-D5) — single source of truth so boot + diagnostic
+// agree byte-for-byte. Skipped under VITEST so the repo's own test
+// invocations against in-tree start.mjs don't fail when running before
+// `npm run build` produces the bundles.
 if (!process.env.VITEST) {
   try {
     const { assertPluginCacheIntegrity, formatPartialInstallReport } =

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[];