@@ -340,7 +340,7 @@ WATCHER_SRCS = src/watcher/watcher.c
 GIT_SRCS = src/git/git_context.c
 
 # CLI module (new)
-CLI_SRCS = src/cli/cli.c src/cli/progress_sink.c src/cli/hook_augment.c \
+CLI_SRCS = src/cli/cli.c src/cli/progress_sink.c src/cli/hook_augment.c src/cli/client_adapter.c \
 	src/cli/agent_clients.c src/cli/agent_profiles.c \
 	src/cli/config_json_like.c src/cli/config_toml_edit.c src/cli/config_yaml_edit.c \
 	src/cli/config_text_edit.c src/cli/activation_transaction.c
 
@@ -0,0 +1,240 @@
+/*
+ * client_adapter.c — Generate client extension modules from the MCP tool registry.
+ *
+ * See client_adapter.h for why these are generated rather than shipped.
+ */
+#include "cli/client_adapter.h"
+
+#include "foundation/constants.h"
+#include "mcp/mcp.h"
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* A generated module is small and bounded by the registry size; grow a plain
+ * buffer rather than pulling in a builder for two call sites. */
+typedef struct {
+    char *buf;
+    size_t len;
+    size_t cap;
+    bool failed;
+} adapter_sb_t;
+
+static void sb_append(adapter_sb_t *sb, const char *s) {
+    if (sb->failed || !s) {
+        return;
+    }
+    size_t add = strlen(s);
+    if (sb->len + add + 1 > sb->cap) {
+        size_t want = sb->cap ? sb->cap : CBM_SZ_2K;
+        while (want < sb->len + add + 1) {
+            if (want > SIZE_MAX / PAIR_LEN) {
+                sb->failed = true;
+                return;
+            }
+            want *= PAIR_LEN;
+        }
+        char *grown = realloc(sb->buf, want);
+        if (!grown) {
+            sb->failed = true;
+            return;
+        }
+        sb->buf = grown;
+        sb->cap = want;
+    }
+    memcpy(sb->buf + sb->len, s, add);
+    sb->len += add;
+    sb->buf[sb->len] = '\0';
+}
+
+bool cbm_client_adapter_escape_js(const char *in, char *out, size_t out_sz) {
+    if (!in || !out || out_sz == 0) {
+        return false;
+    }
+    size_t o = 0;
+    for (const char *p = in; *p; p++) {
+        /* Only these four can terminate or corrupt a single-quoted literal.
+         * Escaping more would be harmless but makes the emitted path harder to
+         * read when a user opens the generated file. */
+        const char *esc = NULL;
+        switch (*p) {
+        case '\\':
+            esc = "\\\\";
+            break;
+        case '\'':
+            esc = "\\'";
+            break;
+        case '\n':
+            esc = "\\n";
+            break;
+        case '\r':
+            esc = "\\r";
+            break;
+        default:
+            break;
+        }
+        size_t need = esc ? strlen(esc) : 1U;
+        if (o + need + 1 > out_sz) {
+            out[0] = '\0';
+            return false; /* never emit a truncated literal */
+        }
+        if (esc) {
+            memcpy(out + o, esc, need);
+        } else {
+            out[o] = *p;
+        }
+        o += need;
+    }
+    out[o] = '\0';
+    return true;
+}
+
+/* Shared preamble: the ownership markers and a note telling whoever opens the
+ * file that edits inside the block are overwritten. */
+static void emit_header(adapter_sb_t *sb, const char *client) {
+    sb_append(sb, CBM_ADAPTER_MARKER_START);
+    sb_append(sb, "\n// Generated by codebase-memory-mcp for ");
+    sb_append(sb, client);
+    sb_append(sb,
+              ".\n"
+              "// Regenerated on install/update from the MCP tool registry, so it cannot\n"
+              "// drift from the tools the server actually serves. Edits inside this block\n"
+              "// are overwritten; edit outside it, or remove the markers to take ownership.\n");
+}
+
+char *cbm_client_adapter_pi(const char *binary_path) {
+    if (!binary_path || !binary_path[0]) {
+        return NULL;
+    }
+    char bin[CBM_SZ_1K];
+    if (!cbm_client_adapter_escape_js(binary_path, bin, sizeof(bin))) {
+        return NULL;
+    }
+    int count = cbm_mcp_tool_count();
+    if (count <= 0) {
+        return NULL;
+    }
+
+    adapter_sb_t sb = {0};
+    emit_header(&sb, "pi");
+    sb_append(&sb, "import { spawn } from 'node:child_process';\n\n");
+    sb_append(&sb, "const BIN = '");
+    sb_append(&sb, bin);
+    sb_append(&sb, "';\n\n");
+
+    /* One shared invoker: the binary prints JSON on stdout, so take the last
+     * line that parses rather than trusting the first — a stray log line on
+     * stdout must not break the bridge. */
+    sb_append(
+        &sb, "async function call(tool, args, signal) {\n"
+             "  return new Promise((resolve) => {\n"
+             "    const child = spawn(BIN, ['cli', tool, JSON.stringify(args ?? {})], {\n"
+             "      stdio: ['ignore', 'pipe', 'pipe'],\n"
+             "      env: { ...process.env, CBM_LOG_LEVEL: 'error' },\n"
+             "    });\n"
+             "    let out = '';\n"
+             "    const onAbort = () => { if (!child.killed) child.kill(); };\n"
+             "    signal?.addEventListener('abort', onAbort, { once: true });\n"
+             "    child.stdout.on('data', (d) => (out += d.toString()));\n"
+             "    child.on('error', (e) => {\n"
+             "      signal?.removeEventListener('abort', onAbort);\n"
+             "      resolve({ error: String(e && e.message ? e.message : e) });\n"
+             "    });\n"
+             "    child.on('close', () => {\n"
+             "      signal?.removeEventListener('abort', onAbort);\n"
+             "      const lines = out.split('\\n').map((l) => l.trim()).filter(Boolean);\n"
+             "      for (let i = lines.length - 1; i >= 0; i--) {\n"
+             "        try { return resolve(JSON.parse(lines[i])); } catch { /* keep scanning */ }\n"
+             "      }\n"
+             "      resolve({ error: 'no JSON response from codebase-memory-mcp' });\n"
+             "    });\n"
+             "  });\n"
+             "}\n\n");
+
+    /* Register every tool the registry advertises — never a hand-picked subset,
+     * which is the drift this generator exists to prevent. */
+    sb_append(&sb, "export function register(pi) {\n");
+    for (int i = 0; i < count; i++) {
+        const char *name = cbm_mcp_tool_name(i);
+        if (!name || !name[0]) {
+            continue;
+        }
+        sb_append(&sb, "  pi.registerTool({ name: '");
+        sb_append(&sb, name);
+        sb_append(&sb, "', run: (args, ctx) => call('");
+        sb_append(&sb, name);
+        sb_append(&sb, "', args, ctx?.signal) });\n");
+    }
+    sb_append(&sb, "}\n");
+    sb_append(&sb, CBM_ADAPTER_MARKER_END);
+    sb_append(&sb, "\n");
+
+    if (sb.failed) {
+        free(sb.buf);
+        return NULL;
+    }
+    return sb.buf;
+}
+
+char *cbm_client_adapter_opencode(const char *binary_path) {
+    if (!binary_path || !binary_path[0]) {
+        return NULL;
+    }
+    char bin[CBM_SZ_1K];
+    if (!cbm_client_adapter_escape_js(binary_path, bin, sizeof(bin))) {
+        return NULL;
+    }
+
+    adapter_sb_t sb = {0};
+    emit_header(&sb, "OpenCode");
+    sb_append(&sb, "// OpenCode already reaches every tool over MCP; this adds only the\n"
+                   "// automatic graph lookup before a grep/glob, which other clients get\n"
+                   "// through their own hook configuration.\n");
+    sb_append(&sb, "import { spawn } from 'node:child_process';\n\n");
+    sb_append(&sb, "const BIN = '");
+    sb_append(&sb, bin);
+    sb_append(&sb, "';\n\n");
+
+    /* hook-augment requires hook_event_name and accepts Grep/Glob only under
+     * PreToolUse; omitting it makes the whole hook a silent no-op. */
+    sb_append(&sb, "function augment(tool, args) {\n"
+                   "  return new Promise((resolve) => {\n"
+                   "    const child = spawn(BIN, ['hook-augment'], {\n"
+                   "      stdio: ['pipe', 'pipe', 'ignore'],\n"
+                   "      env: { ...process.env, CBM_LOG_LEVEL: 'error' },\n"
+                   "    });\n"
+                   "    let out = '';\n"
+                   "    child.stdout.on('data', (d) => (out += d.toString()));\n"
+                   "    child.on('error', () => resolve(''));\n"
+                   "    child.on('close', () => resolve(out));\n"
+                   "    child.stdin.end(JSON.stringify({\n"
+                   "      hook_event_name: 'PreToolUse',\n"
+                   "      tool_name: tool,\n"
+                   "      tool_input: args ?? {},\n"
+                   "    }));\n"
+                   "  });\n"
+                   "}\n\n");
+
+    sb_append(&sb,
+              "export const CodebaseMemory = async () => ({\n"
+              "  'tool.execute.after': async (input, output) => {\n"
+              "    const tool = input?.tool === 'grep' ? 'Grep' : input?.tool === 'glob' ? 'Glob' "
+              ": null;\n"
+              "    if (!tool) return;\n"
+              "    const extra = await augment(tool, output?.args);\n"
+              "    if (extra && typeof output?.output === 'string') {\n"
+              "      output.output += '\\n' + extra;\n"
+              "    }\n"
+              "  },\n"
+              "});\n");
+    sb_append(&sb, CBM_ADAPTER_MARKER_END);
+    sb_append(&sb, "\n");
+
+    if (sb.failed) {
+        free(sb.buf);
+        return NULL;
+    }
+    return sb.buf;
+}
@@ -0,0 +1,69 @@
+/*
+ * client_adapter.h — Generate client extension modules from the MCP tool registry.
+ *
+ * Some clients have no MCP support (pi), and some have no declarative hook
+ * configuration (OpenCode); their only extension point is a JavaScript/TypeScript
+ * module. We do not ship such a module as a repository asset — it would be a
+ * second, hand-maintained copy of the tool surface, and hand-maintained copies of
+ * the tool list have already produced defects here.
+ *
+ * Instead the module is GENERATED at install time from the live registry
+ * (cbm_mcp_tool_count / cbm_mcp_tool_name), so it cannot drift: adding a tool to
+ * TOOLS[] adds it to every generated adapter with no second edit.
+ *
+ * Generated text is returned heap-allocated; the caller frees it. Nothing here
+ * touches the filesystem — writing is the caller's job, so dry-run and
+ * owned-block semantics stay in one place.
+ */
+#ifndef CBM_CLI_CLIENT_ADAPTER_H
+#define CBM_CLI_CLIENT_ADAPTER_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+/* Marker lines delimiting the generated region inside a client's extension
+ * module. A file carrying these is ours to rewrite; one without them is the
+ * user's and is left alone. Kept in the comment syntax shared by JS and TS. */
+#define CBM_ADAPTER_MARKER_START "// codebase-memory-mcp:start"
+#define CBM_ADAPTER_MARKER_END "// codebase-memory-mcp:end"
+
+/* Emit a pi extension registering every tool in the MCP registry.
+ *
+ * pi has no MCP client, so this bridge is the only route to the graph for it.
+ * Each registered tool shells out to `<binary> cli <tool> '<json-args>'`, which
+ * is an existing public entry point rather than a private one.
+ *
+ * `binary_path` is embedded as a JS string literal and is escaped; a Windows
+ * path such as C:\Users\x\bin\cbm.exe must not corrupt the module or, worse,
+ * produce a file that fails to parse inside an auto-loaded extension directory.
+ *
+ * Returns NULL on allocation failure or when binary_path is NULL/empty. */
+char *cbm_client_adapter_pi(const char *binary_path);
+
+/* Emit an OpenCode plugin that augments grep/glob results from the graph.
+ *
+ * OpenCode HAS MCP (see cbm_upsert_opencode_mcp), so this adds no tools — it
+ * only supplies the automatic "consult the graph before grepping" reflex that
+ * other clients get through their own native hook configuration. OpenCode has
+ * no such configuration; a plugin module is its only extension point.
+ *
+ * NOTE for maintainers: this hooks `tool.execute.after`, whose ability to
+ * modify a tool's output is NOT part of OpenCode's documented plugin contract
+ * (only `tool.execute.before`'s argument mutation is). If OpenCode changes it,
+ * augmentation stops silently — no error, no signal. That risk is accepted
+ * deliberately and recorded here so it is not rediscovered as a mystery.
+ *
+ * Returns NULL on allocation failure or when binary_path is NULL/empty. */
+char *cbm_client_adapter_opencode(const char *binary_path);
+
+/* Escape a path for embedding in a single-quoted JS string literal: backslash,
+ * single quote, and the newline/CR that would terminate the literal outright.
+ * Writes at most out_sz-1 characters plus NUL. Returns false when the escaped
+ * form would not fit, so a caller never emits a truncated literal.
+ *
+ * Exposed for tests: the escaping is the part most likely to break a user's
+ * install on Windows, and it deserves direct coverage rather than only being
+ * reachable through a full generate call. */
+bool cbm_client_adapter_escape_js(const char *in, char *out, size_t out_sz);
+
+#endif /* CBM_CLI_CLIENT_ADAPTER_H */