context-mode 1.0.106 → 1.0.108

package/build/adapters/vscode-copilot/hooks.d.ts

@@ -10,7 +10,6 @@
  * VS Code Copilot hook system reference:
  *   - Hooks are registered in .github/hooks/*.json
  *   - Hook names: PreToolUse, PostToolUse, PreCompact, SessionStart (PascalCase)
- *   - Additional hooks: Stop, SubagentStart, SubagentStop (unique to VS Code)
  *   - CRITICAL: matchers are parsed but IGNORED (all hooks fire on all tools)
  *   - Input: JSON on stdin
  *   - Output: JSON on stdout (or empty for passthrough)
@@ -22,9 +21,6 @@ export declare const HOOK_TYPES: {
     readonly POST_TOOL_USE: "PostToolUse";
     readonly PRE_COMPACT: "PreCompact";
     readonly SESSION_START: "SessionStart";
-    readonly STOP: "Stop";
-    readonly SUBAGENT_START: "SubagentStart";
-    readonly SUBAGENT_STOP: "SubagentStop";
 };
 export type HookType = (typeof HOOK_TYPES)[keyof typeof HOOK_TYPES];
 /** Map of hook types to their script file names. */

package/build/adapters/vscode-copilot/hooks.js

@@ -11,7 +11,6 @@ import { buildNodeCommand } from "../types.js";
  * VS Code Copilot hook system reference:
  *   - Hooks are registered in .github/hooks/*.json
  *   - Hook names: PreToolUse, PostToolUse, PreCompact, SessionStart (PascalCase)
- *   - Additional hooks: Stop, SubagentStart, SubagentStop (unique to VS Code)
  *   - CRITICAL: matchers are parsed but IGNORED (all hooks fire on all tools)
  *   - Input: JSON on stdin
  *   - Output: JSON on stdout (or empty for passthrough)
@@ -26,10 +25,6 @@ export const HOOK_TYPES = {
     POST_TOOL_USE: "PostToolUse",
     PRE_COMPACT: "PreCompact",
     SESSION_START: "SessionStart",
-    // Additional hooks unique to VS Code Copilot
-    STOP: "Stop",
-    SUBAGENT_START: "SubagentStart",
-    SUBAGENT_STOP: "SubagentStop",
 };
 // ─────────────────────────────────────────────────────────
 // Hook script file names
@@ -77,7 +72,12 @@ export function buildHookCommand(hookType, pluginRoot) {
         throw new Error(`No script defined for hook type: ${hookType}`);
     }
     if (pluginRoot) {
-        return buildNodeCommand(`${pluginRoot}/hooks/${scriptName}`);
+        // v1.0.107 fix — was `${pluginRoot}/hooks/${scriptName}` which resolved to
+        // the Claude-Code generic hook (`hooks/pretooluse.mjs`) instead of the
+        // VSCode-specific wrapper at `hooks/vscode-copilot/pretooluse.mjs`. JetBrains
+        // adapter already had the correct subdir (jetbrains-copilot/hooks.ts:98)
+        // so this brings VSCode to parity.
+        return buildNodeCommand(`${pluginRoot}/hooks/vscode-copilot/${scriptName}`);
     }
     return `context-mode hook vscode-copilot ${hookType.toLowerCase()}`;
 }

package/build/cli.js

@@ -50,6 +50,7 @@ const HOOK_MAP = {
         posttooluse: "hooks/cursor/posttooluse.mjs",
         sessionstart: "hooks/cursor/sessionstart.mjs",
         stop: "hooks/cursor/stop.mjs",
+        afteragentresponse: "hooks/cursor/afteragentresponse.mjs",
     },
     "codex": {
         pretooluse: "hooks/codex/pretooluse.mjs",
@@ -381,9 +382,26 @@ async function doctor() {
         }
         else {
             criticalFails++;
-            p.log.error(color.red("FTS5 / better-sqlite3: FAIL") +
-                ` — ${message}` +
-                color.dim("\n  Try: npm rebuild better-sqlite3"));
+            // Detect better-sqlite3 native bindings-missing pattern (issue #408).
+            // The `bindings` package throws "Could not locate the bindings file"
+            // when better_sqlite3.node failed to install — typical on Windows
+            // when prebuild-install was not on PATH so install fell through to
+            // node-gyp without an MSVC toolchain.
+            const isBindingsMissing = /Could not locate the bindings file/i.test(message) ||
+                /bindings\.node/i.test(message) ||
+                /\bbindings\b/i.test(message);
+            if (isBindingsMissing && process.platform === "win32") {
+                p.log.error(color.red("FTS5 / better-sqlite3: FAIL") +
+                    ` — ${message}` +
+                    color.dim("\n  Root cause: prebuild-install was likely not on PATH, so install fell through to node-gyp without an MSVC toolchain (Windows)." +
+                        "\n  Try (primary): npm install better-sqlite3   # re-resolves the dep tree and re-links the prebuild-install bin shim to fetch a prebuilt binary" +
+                        "\n  Try (fallback): npm rebuild better-sqlite3"));
+            }
+            else {
+                p.log.error(color.red("FTS5 / better-sqlite3: FAIL") +
+                    ` — ${message}` +
+                    color.dim("\n  Try: npm rebuild better-sqlite3"));
+            }
         }
     }
     // Version check — adapter-aware
@@ -544,6 +562,36 @@ async function upgrade() {
     let pluginRoot = getPluginRoot();
     const changes = [];
     const s = p.spinner();
+    // Step 0: Sync the marketplace clone (#418).
+    // Claude Code reads plugin metadata from ~/.claude/plugins/marketplaces/context-mode/.
+    // Without a git pull there, the marketplace stays pinned at the install-time
+    // commit and CC keeps reporting the old version even after our cache dir is
+    // updated — users then see "ctx-upgrade succeeded" but nothing actually
+    // changed at the plugin-system level.
+    const marketplaceDir = resolve(homedir(), ".claude", "plugins", "marketplaces", "context-mode");
+    if (existsSync(join(marketplaceDir, ".git"))) {
+        s.start("Syncing marketplace clone");
+        try {
+            // Preserve user dev edits (Mert-class users symlink the clone to a worktree).
+            const statusOut = execFileSync("git", ["-C", marketplaceDir, "status", "--porcelain"], { stdio: "pipe", encoding: "utf-8", timeout: 5000 });
+            if (statusOut.trim()) {
+                s.stop(color.yellow("Marketplace clone has local edits — skipping git pull"));
+                p.log.info(color.dim(`  Run manually: git -C "${marketplaceDir}" stash && git pull --ff-only`));
+            }
+            else {
+                execFileSync("git", ["-C", marketplaceDir, "fetch", "--tags", "origin"], { stdio: "pipe", timeout: 30000 });
+                execFileSync("git", ["-C", marketplaceDir, "reset", "--hard", "origin/HEAD"], { stdio: "pipe", timeout: 10000 });
+                s.stop(color.green("Marketplace clone synced"));
+                changes.push("Marketplace clone updated to upstream");
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            s.stop(color.yellow("Marketplace sync skipped"));
+            p.log.warn(color.yellow("git refresh on marketplace failed") + ` — ${message}`);
+            p.log.info(color.dim("  Continuing — cache dir update will still happen."));
+        }
+    }
     // Step 1: Pull latest from GitHub
     p.log.step("Pulling latest from GitHub...");
     const localVersion = getLocalVersion();
@@ -595,12 +643,16 @@ async function upgrade() {
             }
             catch { /* some files may not exist in source */ }
         }
-        // Write .mcp.json with resolved absolute path (fixes #132)
+        // Write .mcp.json with CLAUDE_PLUGIN_ROOT placeholder (fixes #411).
+        // Absolute paths bake-in the current pluginRoot dir, which sessionstart.mjs
+        // (#181) deletes after upgrade — breaking MCP server resolution. The literal
+        // ${CLAUDE_PLUGIN_ROOT} placeholder is resolved by Claude at load-time and
+        // stays valid across version cleanups. Matches .claude-plugin/plugin.json.
         const mcpConfig = {
             mcpServers: {
                 "context-mode": {
                     command: "node",
-                    args: [resolve(pluginRoot, "start.mjs")],
+                    args: ["${CLAUDE_PLUGIN_ROOT}/start.mjs"],
                 },
             },
         };
@@ -772,14 +824,43 @@ async function upgrade() {
  * statusline — forward to bin/statusline.mjs
  * ------------------------------------------------------- */
 function statuslineForward() {
-    const scriptPath = resolve(getPluginRoot(), "bin", "statusline.mjs");
-    if (!existsSync(scriptPath)) {
-        process.stderr.write(`statusline script missing: ${scriptPath}\n`);
-        process.exit(1);
+    // Try multiple plugin-root candidates in priority order. After ctx-upgrade,
+    // getPluginRoot() can resolve to a cache dir that sessionstart.mjs (#181)
+    // already cleaned, leaving bin/statusline.mjs missing. Falling back to the
+    // marketplace clone (#418-synced, stable across upgrades) and to the path
+    // Claude Code itself loads from (installed_plugins.json) keeps the bar
+    // alive instead of silently going blank.
+    const candidates = [
+        resolve(getPluginRoot(), "bin", "statusline.mjs"),
+        resolve(homedir(), ".claude", "plugins", "marketplaces", "context-mode", "bin", "statusline.mjs"),
+    ];
+    // installed_plugins.json may list one or more install paths CC actually
+    // loads from. Prefer those if they exist.
+    try {
+        const registryPath = resolve(homedir(), ".claude", "plugins", "installed_plugins.json");
+        if (existsSync(registryPath)) {
+            const registry = JSON.parse(readFileSync(registryPath, "utf-8"));
+            const entries = registry?.plugins?.["context-mode@context-mode"];
+            if (Array.isArray(entries)) {
+                for (const entry of entries) {
+                    const installPath = entry?.installPath;
+                    if (typeof installPath === "string" && installPath) {
+                        candidates.push(resolve(installPath, "bin", "statusline.mjs"));
+                    }
+                }
+            }
+        }
+    }
+    catch { /* registry malformed — fall through to other candidates */ }
+    const scriptPath = candidates.find((c) => existsSync(c));
+    if (!scriptPath) {
+        // Statusline output is the user-facing status bar; stderr surfaces visibly
+        // in some terminals. Exit silently — the bar simply stays empty until the
+        // next /ctx-upgrade or restart resolves the path.
+        process.exit(0);
     }
     // Re-exec via dynamic import so stdin/stdout are inherited cleanly.
-    import(pathToFileURL(scriptPath).href).catch((err) => {
-        process.stderr.write(`statusline failed: ${err?.message ?? err}\n`);
-        process.exit(1);
+    import(pathToFileURL(scriptPath).href).catch(() => {
+        process.exit(0);
     });
 }

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

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

@@ -0,0 +1,198 @@
+/**
+ * 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-plugin.d.ts

@@ -28,6 +28,7 @@
  *   - api.registerCommand() for auto-reply slash commands
  *   - Plugins run in-process with the Gateway (trusted code)
  */
+import type { OpenClawToolDef } from "./openclaw/mcp-tools.js";
 /** Context for auto-reply command handlers. */
 interface CommandContext {
     senderId?: string;
@@ -68,6 +69,14 @@ interface OpenClawPluginApi {
     }) => void, meta: {
         commands: string[];
     }): void;
+    /**
+     * Register an agent tool (OpenClaw native registerTool) — see
+     * refs/platforms/openclaw/docs/plugins/building-plugins.md:116. Optional in
+     * the type so we degrade silently on legacy hosts that pre-date this API.
+     */
+    registerTool?(tool: OpenClawToolDef, opts?: {
+        optional?: boolean;
+    }): void;
     logger?: {
         info: (...args: unknown[]) => void;
         error: (...args: unknown[]) => void;

package/build/openclaw-plugin.js

@@ -38,6 +38,24 @@ import { extractEvents, extractUserEvents } from "./session/extract.js";
 import { buildResumeSnapshot } from "./session/snapshot.js";
 import { WorkspaceRouter } from "./openclaw/workspace-router.js";
 import { buildNodeCommand } from "./adapters/types.js";
+import { OPENCLAW_TOOL_DEFS } from "./openclaw/mcp-tools.js";
+// ── System-reminder filter (CCv2 — SLICE OClaw-3) ─────────
+// Mirror hooks/userpromptsubmit.mjs:30-33: skip system-generated wrappers
+// so before_model_resolve never inserts spurious user-prompt events.
+const SYSTEM_REMINDER_PREFIXES = [
+    "<system-reminder>",
+    "<task-notification>",
+    "<context_guidance>",
+    "<tool-result>",
+];
+function isSystemReminderMessage(msg) {
+    const trimmed = msg.trimStart();
+    for (const prefix of SYSTEM_REMINDER_PREFIXES) {
+        if (trimmed.startsWith(prefix))
+            return true;
+    }
+    return false;
+}
 /** Plugin config schema for OpenClaw validation. */
 const configSchema = {
     type: "object",
@@ -114,27 +132,46 @@ export default {
         // Start with temp UUID — session_start will assign the real ID + sessionKey
         let sessionId = randomUUID();
         log.info("register() called, sessionId:", sessionId.slice(0, 8));
+        // SLICE OClaw-6 (F6 retraction): `resumeInjected` is correctly scoped
+        // per-register() singleton — Phase 7 confirmed F6 fabrication-as-tech-debt.
+        // Each OpenClaw agent session calls register() once and gets its own
+        // closure; the flag prevents double-injection of the resume snapshot in
+        // back-to-back before_prompt_build calls within the same session. Do not
+        // promote to module scope.
         let resumeInjected = false;
         let sessionKey;
         // Create temp session so after_tool_call events before session_start have a valid row
         db.ensureSession(sessionId, projectDir);
         const workspaceRouter = new WorkspaceRouter();
-        // Load routing instructions synchronously for prompt injection
+        // Async init: load routing module + dynamic routing-block factory.
+        // SLICE OClaw-2: replaced static readFileSync(configs/openclaw/AGENTS.md)
+        // with createRoutingBlock(createToolNamer("openclaw")) so OpenClaw-specific
+        // MCP-prefix substitution stays in lockstep with hooks/routing-block.mjs.
         let routingInstructions = "";
-        try {
-            const instructionsPath = resolve(buildDir, "..", "configs", "openclaw", "AGENTS.md");
-            if (existsSync(instructionsPath)) {
-                routingInstructions = readFileSync(instructionsPath, "utf-8");
-            }
-        }
-        catch {
-            // best effort
-        }
-        // Async init: load routing module. Hooks await this.
         const initPromise = (async () => {
             const routingPath = resolve(buildDir, "..", "hooks", "core", "routing.mjs");
             const routing = await import(pathToFileURL(routingPath).href);
             await routing.initSecurity(buildDir);
+            try {
+                const blockMod = await import(pathToFileURL(resolve(buildDir, "..", "hooks", "routing-block.mjs")).href);
+                const namingMod = await import(pathToFileURL(resolve(buildDir, "..", "hooks", "core", "tool-naming.mjs")).href);
+                const toolNamer = namingMod.createToolNamer("openclaw");
+                routingInstructions = blockMod.createRoutingBlock(toolNamer);
+            }
+            catch (err) {
+                log.warn?.("failed to build dynamic routing block", err);
+                // Fallback: legacy disk-read of AGENTS.md (kept for resilience only —
+                // primary path is the dynamic factory above).
+                try {
+                    const instructionsPath = resolve(buildDir, "..", "configs", "openclaw", "AGENTS.md");
+                    if (existsSync(instructionsPath)) {
+                        routingInstructions = readFileSync(instructionsPath, "utf-8");
+                    }
+                }
+                catch {
+                    // best effort
+                }
+            }
             return { routing };
         })();
         // ── 1. tool_call:before — Routing enforcement ──────────
@@ -359,6 +396,12 @@ export default {
                 log.debug("before_model_resolve", { hasMessage: !!messageText });
                 if (!messageText)
                     return;
+                // SLICE OClaw-3: skip system-generated wrappers so we never
+                // misclassify them as user prompts. Mirrors hooks/userpromptsubmit.mjs:30-33.
+                if (isSystemReminderMessage(messageText)) {
+                    log.debug("before_model_resolve[skip-system-reminder]");
+                    return;
+                }
                 const events = extractUserEvents(messageText);
                 for (const ev of events) {
                     db.insertEvent(sid, ev, "PostToolUse");
@@ -389,12 +432,85 @@ export default {
             }
         }, { priority: 10 });
         // ── 8. before_prompt_build — Routing instruction injection ──
-        if (routingInstructions) {
-            api.on("before_prompt_build", () => {
-                log.debug("before_prompt_build[routing]", { hasInstructions: !!routingInstructions });
-                return { appendSystemContext: routingInstructions };
-            }, { priority: 5 });
+        // SLICE OClaw-2: register unconditionally; routingInstructions is populated
+        // asynchronously by initPromise. The closure resolves the latest value at
+        // call-time, so the first prompt-build firing after dynamic-import resolution
+        // sees the dynamic ROUTING_BLOCK XML (matching hooks/routing-block.mjs).
+        api.on("before_prompt_build", () => {
+            if (!routingInstructions)
+                return undefined;
+            log.debug("before_prompt_build[routing]", { hasInstructions: !!routingInstructions });
+            // v1.0.107 — visible marker so OpenClaw users can verify the routing
+            // block reached the model (Mickey-class verification path; mirrors
+            // OpenCode + Pi adapters).
+            const marker = `<!-- context-mode: routing block injected (sessionID=${String(sessionId).slice(0, 8)}) -->`;
+            return { appendSystemContext: marker + "\n" + routingInstructions };
+        }, { priority: 5 });
+        // ── 8b. registerTool — Expose 11 ctx_* tools (SLICE OClaw-1) ────
+        // Phase 7 audit (v1.0.107-adapter-openclaw.json) flagged severity=CRITICAL:
+        // routing block tells agents to call ctx_execute / ctx_search / etc. but
+        // nothing called api.registerTool, so the tools didn't exist in the
+        // OpenClaw session. This loop fixes that — mirrors swarmvault MCP pattern
+        // (refs/plugin-examples/openclaw/swarmvault/packages/engine/src/mcp.ts:46-51).
+        if (api.registerTool) {
+            for (const def of OPENCLAW_TOOL_DEFS) {
+                try {
+                    api.registerTool(def);
+                }
+                catch (err) {
+                    log.warn?.("registerTool failed", { name: def.name }, err);
+                }
+            }
+            log.debug("registerTool[ctx_*]", { count: OPENCLAW_TOOL_DEFS.length });
         }
+        else {
+            log.warn?.("api.registerTool unavailable — ctx_* tools not exposed in this OpenClaw build");
+        }
+        // ── 8c. session_end — Finalize resume snapshot (SLICE OClaw-4) ───
+        // OpenClaw fires session_end at session lifecycle boundaries (per
+        // refs/platforms/openclaw/docs/plugins/hooks.md:110). We persist a final
+        // resume snapshot so a future session_start with resumedFrom can re-attach.
+        api.on("session_end", async () => {
+            try {
+                const sid = sessionId;
+                const allEvents = db.getEvents(sid);
+                log.debug("session_end", { sessionId: sid.slice(0, 8), events: allEvents.length });
+                if (allEvents.length === 0)
+                    return;
+                const freshStats = db.getSessionStats(sid);
+                const snapshot = buildResumeSnapshot(allEvents, {
+                    compactCount: freshStats?.compact_count ?? 0,
+                });
+                db.upsertResume(sid, snapshot, allEvents.length);
+            }
+            catch {
+                // best effort — never break session shutdown
+            }
+        });
+        // ── 8d. subagent_spawning — Inject routing block (SLICE OClaw-5) ─
+        // OpenClaw's subagent lifecycle (hooks.md:116) gives us a chance to seed
+        // every spawned subagent with the same routing block the parent agent
+        // sees. Without this, subagents have no MCP-routing guidance and degrade
+        // back to flooding the context with raw tool output.
+        api.on("subagent_spawning", (event) => {
+            try {
+                const e = (event ?? {});
+                const basePrompt = e?.input?.prompt ?? "";
+                if (!routingInstructions)
+                    return undefined;
+                const newPrompt = basePrompt
+                    ? `${basePrompt}\n\n${routingInstructions}`
+                    : routingInstructions;
+                log.debug("subagent_spawning[inject-routing]", {
+                    basePromptLen: basePrompt.length,
+                    blockLen: routingInstructions.length,
+                });
+                return { inputOverride: { ...(e.input ?? {}), prompt: newPrompt } };
+            }
+            catch {
+                return undefined;
+            }
+        });
         // ── 9. Context engine — Compaction management ──────────
         api.registerContextEngine("context-mode", () => ({
             info: {