brainjar 0.3.685 → 0.3.691

package/brainjar.js

@@ -107,7 +107,7 @@ var CLI_VERSION, CACHE, DAY;
 var init_version_check = __esm({
   "packages/cli/src/version-check.ts"() {
     "use strict";
-    CLI_VERSION = "0.3.685";
+    CLI_VERSION = "0.3.691";
     CACHE = path.join(os.homedir(), ".brainjar", "version-check.json");
     DAY = 864e5;
   }
@@ -238,8 +238,8 @@ var init_github = __esm({
         if (this.opts.token) h.Authorization = `Bearer ${this.opts.token}`;
         return h;
       }
-      async *paginate(path15, params) {
-        let url = this.buildUrl(path15, params);
+      async *paginate(path19, params) {
+        let url = this.buildUrl(path19, params);
         while (url) {
           const res = await this.fetchImpl(url, { headers: this.headers() });
           if (!res.ok) {
@@ -250,9 +250,9 @@ var init_github = __esm({
           url = parseNextLink(res.headers.get("link"));
         }
       }
-      buildUrl(path15, params) {
+      buildUrl(path19, params) {
         const url = new URL(
-          `${this.baseUrl}/repos/${this.opts.owner}/${this.opts.repo}${path15}`
+          `${this.baseUrl}/repos/${this.opts.owner}/${this.opts.repo}${path19}`
         );
         url.searchParams.set("per_page", String(this.perPage));
         for (const [k, v] of Object.entries(params)) {
@@ -3735,7 +3735,7 @@ var require_split2 = __commonJS({
 var require_helper = __commonJS({
   "node_modules/pgpass/lib/helper.js"(exports, module) {
     "use strict";
-    var path15 = __require("path");
+    var path19 = __require("path");
     var Stream2 = __require("stream").Stream;
     var split = require_split2();
     var util = __require("util");
@@ -3774,7 +3774,7 @@ var require_helper = __commonJS({
     };
     module.exports.getFileName = function(rawEnv) {
       var env = rawEnv || process.env;
-      var file = env.PGPASSFILE || (isWin ? path15.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path15.join(env.HOME || "./", ".pgpass"));
+      var file = env.PGPASSFILE || (isWin ? path19.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path19.join(env.HOME || "./", ".pgpass"));
       return file;
     };
     module.exports.usePgPass = function(stats, fname) {
@@ -3906,7 +3906,7 @@ var require_helper = __commonJS({
 var require_lib = __commonJS({
   "node_modules/pgpass/lib/index.js"(exports, module) {
     "use strict";
-    var path15 = __require("path");
+    var path19 = __require("path");
     var fs = __require("fs");
     var helper = require_helper();
     module.exports = function(connInfo, cb) {
@@ -8850,12 +8850,12 @@ var init_path = __esm({
   "node_modules/@anthropic-ai/sdk/internal/utils/path.mjs"() {
     init_error();
     EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
-    createPathTagFunction = (pathEncoder = encodeURIPath) => function path15(statics, ...params) {
+    createPathTagFunction = (pathEncoder = encodeURIPath) => function path19(statics, ...params) {
       if (statics.length === 1)
         return statics[0];
       let postPath = false;
       const invalidSegments = [];
-      const path16 = statics.reduce((previousValue, currentValue, index) => {
+      const path20 = statics.reduce((previousValue, currentValue, index) => {
         if (/[?#]/.test(currentValue)) {
           postPath = true;
         }
@@ -8872,7 +8872,7 @@ var init_path = __esm({
         }
         return previousValue + currentValue + (index === params.length ? "" : encoded);
       }, "");
-      const pathOnly = path16.split(/[?#]/, 1)[0];
+      const pathOnly = path20.split(/[?#]/, 1)[0];
       const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
       let match;
       while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
@@ -8893,10 +8893,10 @@ var init_path = __esm({
         }, "");
         throw new AnthropicError(`Path parameters result in path with invalid segments:
 ${invalidSegments.map((e) => e.error).join("\n")}
-${path16}
+${path20}
 ${underline}`);
       }
-      return path16;
+      return path20;
     };
     path3 = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
   }
@@ -11882,9 +11882,9 @@ var init_client = __esm({
       makeStatusError(status, error, message, headers) {
         return APIError.generate(status, error, message, headers);
       }
-      buildURL(path15, query, defaultBaseURL) {
+      buildURL(path19, query, defaultBaseURL) {
         const baseURL = !__classPrivateFieldGet(this, _BaseAnthropic_instances, "m", _BaseAnthropic_baseURLOverridden).call(this) && defaultBaseURL || this.baseURL;
-        const url = isAbsoluteURL(path15) ? new URL(path15) : new URL(baseURL + (baseURL.endsWith("/") && path15.startsWith("/") ? path15.slice(1) : path15));
+        const url = isAbsoluteURL(path19) ? new URL(path19) : new URL(baseURL + (baseURL.endsWith("/") && path19.startsWith("/") ? path19.slice(1) : path19));
         const defaultQuery = this.defaultQuery();
         if (!isEmptyObj(defaultQuery)) {
           query = { ...defaultQuery, ...query };
@@ -11915,24 +11915,24 @@ var init_client = __esm({
        */
       async prepareRequest(request, { url, options }) {
       }
-      get(path15, opts) {
-        return this.methodRequest("get", path15, opts);
+      get(path19, opts) {
+        return this.methodRequest("get", path19, opts);
       }
-      post(path15, opts) {
-        return this.methodRequest("post", path15, opts);
+      post(path19, opts) {
+        return this.methodRequest("post", path19, opts);
       }
-      patch(path15, opts) {
-        return this.methodRequest("patch", path15, opts);
+      patch(path19, opts) {
+        return this.methodRequest("patch", path19, opts);
       }
-      put(path15, opts) {
-        return this.methodRequest("put", path15, opts);
+      put(path19, opts) {
+        return this.methodRequest("put", path19, opts);
       }
-      delete(path15, opts) {
-        return this.methodRequest("delete", path15, opts);
+      delete(path19, opts) {
+        return this.methodRequest("delete", path19, opts);
       }
-      methodRequest(method, path15, opts) {
+      methodRequest(method, path19, opts) {
         return this.request(Promise.resolve(opts).then((opts2) => {
-          return { method, path: path15, ...opts2 };
+          return { method, path: path19, ...opts2 };
         }));
       }
       request(options, remainingRetries = null) {
@@ -12036,8 +12036,8 @@ var init_client = __esm({
         }));
         return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
       }
-      getAPIList(path15, Page2, opts) {
-        return this.requestAPIList(Page2, { method: "get", path: path15, ...opts });
+      getAPIList(path19, Page2, opts) {
+        return this.requestAPIList(Page2, { method: "get", path: path19, ...opts });
       }
       requestAPIList(Page2, options) {
         const request = this.makeRequest(options, null, void 0);
@@ -12124,8 +12124,8 @@ var init_client = __esm({
       }
       async buildRequest(inputOptions, { retryCount = 0 } = {}) {
         const options = { ...inputOptions };
-        const { method, path: path15, query, defaultBaseURL } = options;
-        const url = this.buildURL(path15, query, defaultBaseURL);
+        const { method, path: path19, query, defaultBaseURL } = options;
+        const url = this.buildURL(path19, query, defaultBaseURL);
         if ("timeout" in options)
           validatePositiveInteger("timeout", options.timeout);
         options.timeout = options.timeout ?? this.timeout;
@@ -12704,22 +12704,22 @@ async function gitHooksDir(root) {
   return path5.join(root, ".git", "hooks");
 }
 async function installGitPostCommitHook(root) {
-  const hooksDir = await gitHooksDir(root);
-  const file = path5.join(hooksDir, "post-commit");
+  const hooksDir2 = await gitHooksDir(root);
+  const file = path5.join(hooksDir2, "post-commit");
   const existing = existsSync2(file) ? await readFile2(file, "utf8") : null;
   if (existing?.includes(GIT_HOOK_MARKER)) return false;
   const content = existing === null ? `#!/bin/sh
 ${gitHookBlock()}
 ` : existing.replace(/\n*$/, "\n") + gitHookBlock() + "\n";
-  await mkdir(hooksDir, { recursive: true });
+  await mkdir(hooksDir2, { recursive: true });
   await writeFile(file, content, { mode: 493 });
   await chmod(file, 493).catch(() => {
   });
   return true;
 }
 async function removeGitPostCommitHook(root) {
-  const hooksDir = await gitHooksDir(root);
-  const file = path5.join(hooksDir, "post-commit");
+  const hooksDir2 = await gitHooksDir(root);
+  const file = path5.join(hooksDir2, "post-commit");
   if (!existsSync2(file)) return false;
   const content = await readFile2(file, "utf8");
   if (!content.includes(GIT_HOOK_MARKER)) return false;
@@ -13115,14 +13115,367 @@ var init_copilot_hooks = __esm({
   }
 });
 
+// packages/ingest/src/gemini-hooks.ts
+import { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir5 } from "node:fs/promises";
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "node:fs";
+import path9 from "node:path";
+async function installGeminiHooks(root) {
+  const file = settingsFile(root);
+  let settings = {};
+  if (existsSync6(file)) {
+    try {
+      settings = JSON.parse(await readFile6(file, "utf8"));
+    } catch {
+      settings = {};
+    }
+  }
+  const hooks = settings.hooks ??= {};
+  let changed = false;
+  for (const { event, subcommand, probe, timeout } of EVENTS4) {
+    const groups = hooks[event] ??= [];
+    if (groups.some((g) => g.hooks?.some((h) => h.command?.includes(probe))))
+      continue;
+    groups.push({
+      hooks: [
+        {
+          type: "command",
+          command: captureHookCommand(subcommand),
+          name: "brainjar",
+          timeout
+        }
+      ]
+    });
+    changed = true;
+  }
+  if (!changed) return false;
+  await mkdir5(path9.dirname(file), { recursive: true });
+  await writeFile5(file, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  return true;
+}
+function geminiHooksInstalled(root) {
+  const file = settingsFile(root);
+  if (!existsSync6(file)) return false;
+  try {
+    return readFileSync7(file, "utf8").includes(PROBE3);
+  } catch {
+    return false;
+  }
+}
+async function removeGeminiHooks(root) {
+  const file = settingsFile(root);
+  if (!existsSync6(file)) return false;
+  let settings;
+  try {
+    settings = JSON.parse(await readFile6(file, "utf8"));
+  } catch {
+    return false;
+  }
+  const hooks = settings.hooks;
+  if (!hooks) return false;
+  let changed = false;
+  for (const event of Object.keys(hooks)) {
+    const groups = hooks[event];
+    if (!Array.isArray(groups)) continue;
+    const kept = groups.filter((g) => !g.hooks?.some(ours2));
+    if (kept.length !== groups.length) {
+      changed = true;
+      if (kept.length === 0) delete hooks[event];
+      else hooks[event] = kept;
+    }
+  }
+  if (!changed) return false;
+  await writeFile5(file, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  return true;
+}
+var PROBE3, EVENTS4, PROBES2, settingsFile, ours2;
+var init_gemini_hooks = __esm({
+  "packages/ingest/src/gemini-hooks.ts"() {
+    "use strict";
+    init_bootstrap();
+    PROBE3 = "hook gemini";
+    EVENTS4 = [
+      {
+        event: "SessionStart",
+        subcommand: "constraints",
+        probe: "constraints --hook",
+        timeout: 15e3
+      },
+      {
+        event: "BeforeAgent",
+        subcommand: "hook gemini",
+        probe: PROBE3,
+        timeout: 3e4
+      },
+      {
+        event: "AfterTool",
+        subcommand: "hook gemini",
+        probe: PROBE3,
+        timeout: 3e4
+      },
+      {
+        event: "AfterAgent",
+        subcommand: "hook gemini",
+        probe: PROBE3,
+        timeout: 12e4
+      },
+      {
+        event: "SessionEnd",
+        subcommand: "hook gemini",
+        probe: PROBE3,
+        timeout: 1e4
+      }
+    ];
+    PROBES2 = EVENTS4.map((e) => e.probe);
+    settingsFile = (root) => path9.join(root, ".gemini", "settings.json");
+    ours2 = (h) => PROBES2.some((p) => h.command?.includes(p) ?? false);
+  }
+});
+
+// packages/ingest/src/kiro-hooks.ts
+import { readFile as readFile7, writeFile as writeFile6, mkdir as mkdir6, rm as rm3 } from "node:fs/promises";
+import { existsSync as existsSync7, readFileSync as readFileSync8 } from "node:fs";
+import path10 from "node:path";
+function render2() {
+  const hook = (name, trigger, command, timeout) => ({ name, trigger, action: { type: "command", command }, timeout });
+  return JSON.stringify(
+    {
+      version: "v1",
+      hooks: [
+        hook(
+          "brainjar-context",
+          "SessionStart",
+          `${captureHookCommand("constraints")} --plain`,
+          15
+        ),
+        hook(
+          "brainjar-prompt",
+          "UserPromptSubmit",
+          captureHookCommand("hook kiro"),
+          30
+        ),
+        hook(
+          "brainjar-tool",
+          "PostToolUse",
+          captureHookCommand("hook kiro"),
+          30
+        ),
+        hook("brainjar-stop", "Stop", captureHookCommand("hook kiro"), 120)
+      ]
+    },
+    null,
+    2
+  ) + "\n";
+}
+async function installKiroHooks(root) {
+  const file = hooksFile4(root);
+  const next = render2();
+  if (existsSync7(file) && await readFile7(file, "utf8") === next) return false;
+  await mkdir6(path10.dirname(file), { recursive: true });
+  await writeFile6(file, next, "utf8");
+  return true;
+}
+function kiroHooksInstalled(root) {
+  const file = hooksFile4(root);
+  if (!existsSync7(file)) return false;
+  try {
+    return readFileSync8(file, "utf8").includes(PROBE4);
+  } catch {
+    return false;
+  }
+}
+async function removeKiroHooks(root) {
+  if (!kiroHooksInstalled(root)) return false;
+  await rm3(hooksFile4(root), { force: true });
+  return true;
+}
+var PROBE4, hooksFile4;
+var init_kiro_hooks = __esm({
+  "packages/ingest/src/kiro-hooks.ts"() {
+    "use strict";
+    init_bootstrap();
+    PROBE4 = "hook kiro";
+    hooksFile4 = (root) => path10.join(root, ".kiro", "hooks", "brainjar.json");
+  }
+});
+
+// packages/ingest/src/opencode-plugin.ts
+import { readFile as readFile8, writeFile as writeFile7, mkdir as mkdir7, rm as rm4 } from "node:fs/promises";
+import { existsSync as existsSync8, readFileSync as readFileSync9 } from "node:fs";
+import path11 from "node:path";
+function render3() {
+  const cmd = captureHookCommand("hook opencode");
+  return `// BrainJar capture plugin, written by \`brainjar init\` (rewritten on every init; do not edit).
+// Ships prompts, tool calls, failures, and touched files of every OpenCode session to your Brain.
+import { spawn } from "node:child_process";
+
+export const BrainJar = async ({ directory }) => {
+  let session = "";
+  const seen = new Set();
+  const send = (payload) => {
+    try {
+      const child = spawn(${JSON.stringify(cmd)}, {
+        shell: true,
+        cwd: directory,
+        stdio: ["pipe", "ignore", "ignore"],
+      });
+      child.on("error", () => {});
+      child.stdin.end(
+        JSON.stringify({ source: "opencode", cwd: directory, session_id: session, ...payload }),
+      );
+    } catch {}
+  };
+  const target = (args) => {
+    if (!args || typeof args !== "object") return "";
+    for (const k of ["command", "filePath", "path"]) if (typeof args[k] === "string") return args[k];
+    return "";
+  };
+  return {
+    event: async ({ event }) => {
+      const p = event.properties ?? {};
+      switch (event.type) {
+        case "session.created":
+          session = p.info?.id ?? session;
+          send({ kind: "session_started" });
+          break;
+        case "session.idle":
+          if (p.sessionID) session = p.sessionID;
+          send({ kind: "turn_ended" });
+          break;
+        case "file.edited":
+          send({ kind: "file_changed", path: p.file });
+          break;
+        case "message.part.updated": {
+          const part = p.part;
+          if (part?.type === "tool" && part.state?.status === "error" && !seen.has(part.callID)) {
+            seen.add(part.callID);
+            session = part.sessionID ?? session;
+            send({ kind: "tool_failed", tool_name: part.tool, target: target(part.state.input), error: String(part.state.error ?? "") });
+          }
+          break;
+        }
+      }
+    },
+    "chat.message": async (input, output) => {
+      session = input.sessionID ?? session;
+      const text = (output.parts ?? []).filter((x) => x.type === "text").map((x) => x.text).join("\\n");
+      if (text.trim()) send({ kind: "prompt", text });
+    },
+    "tool.execute.after": async (input, output) => {
+      session = input.sessionID ?? session;
+      send({ kind: "tool_used", tool_name: input.tool, target: target(input.args), output: String(output.output ?? "").slice(0, 4000) });
+    },
+  };
+};
+`;
+}
+async function installOpencodePlugin(root) {
+  const file = pluginFile(root);
+  const next = render3();
+  if (existsSync8(file) && await readFile8(file, "utf8") === next) return false;
+  await mkdir7(path11.dirname(file), { recursive: true });
+  await writeFile7(file, next, "utf8");
+  return true;
+}
+function opencodePluginInstalled(root) {
+  const file = pluginFile(root);
+  if (!existsSync8(file)) return false;
+  try {
+    return readFileSync9(file, "utf8").includes(PROBE5);
+  } catch {
+    return false;
+  }
+}
+async function removeOpencodePlugin(root) {
+  if (!opencodePluginInstalled(root)) return false;
+  await rm4(pluginFile(root), { force: true });
+  return true;
+}
+var PROBE5, pluginFile;
+var init_opencode_plugin = __esm({
+  "packages/ingest/src/opencode-plugin.ts"() {
+    "use strict";
+    init_bootstrap();
+    PROBE5 = "hook opencode";
+    pluginFile = (root) => path11.join(root, ".opencode", "plugins", "brainjar.ts");
+  }
+});
+
+// packages/ingest/src/cline-hooks.ts
+import { readFile as readFile9, writeFile as writeFile8, mkdir as mkdir8, rm as rm5, chmod as chmod2 } from "node:fs/promises";
+import { existsSync as existsSync9, readFileSync as readFileSync10 } from "node:fs";
+import path12 from "node:path";
+async function installClineHooks(root) {
+  const dir = hooksDir(root);
+  let changed = false;
+  for (const { name, subcommand, flag } of SCRIPTS) {
+    const file = path12.join(dir, name);
+    const next = script(subcommand, flag);
+    if (existsSync9(file)) {
+      const current = await readFile9(file, "utf8");
+      if (current === next) continue;
+      if (!current.includes(MARK)) continue;
+    }
+    await mkdir8(dir, { recursive: true });
+    await writeFile8(file, next, { mode: 493 });
+    await chmod2(file, 493).catch(() => {
+    });
+    changed = true;
+  }
+  return changed;
+}
+function clineHooksInstalled(root) {
+  const file = path12.join(hooksDir(root), "TaskComplete");
+  if (!existsSync9(file)) return false;
+  try {
+    return readFileSync10(file, "utf8").includes("hook cline");
+  } catch {
+    return false;
+  }
+}
+async function removeClineHooks(root) {
+  let changed = false;
+  for (const { name } of SCRIPTS) {
+    const file = path12.join(hooksDir(root), name);
+    if (!existsSync9(file)) continue;
+    try {
+      if (!readFileSync10(file, "utf8").includes(MARK)) continue;
+    } catch {
+      continue;
+    }
+    await rm5(file, { force: true });
+    changed = true;
+  }
+  return changed;
+}
+var MARK, SCRIPTS, hooksDir, script;
+var init_cline_hooks = __esm({
+  "packages/ingest/src/cline-hooks.ts"() {
+    "use strict";
+    init_bootstrap();
+    MARK = "# brainjar-capture";
+    SCRIPTS = [
+      { name: "TaskStart", subcommand: "constraints", flag: " --cline" },
+      { name: "UserPromptSubmit", subcommand: "hook cline", flag: "" },
+      { name: "PostToolUse", subcommand: "hook cline", flag: "" },
+      { name: "TaskComplete", subcommand: "hook cline", flag: "" },
+      { name: "TaskCancel", subcommand: "hook cline", flag: "" }
+    ];
+    hooksDir = (root) => path12.join(root, ".clinerules", "hooks");
+    script = (subcommand, flag) => `#!/bin/sh
+${MARK}
+exec ${captureHookCommand(subcommand)}${flag}
+`;
+  }
+});
+
 // packages/ingest/src/tools.ts
-import { existsSync as existsSync6 } from "node:fs";
+import { existsSync as existsSync10 } from "node:fs";
 import os4 from "node:os";
-import path9 from "node:path";
+import path13 from "node:path";
 function detectedTools(root) {
   return CAPTURE_TOOLS.filter((t) => t.detect(root));
 }
-var claudeCode, cursor, codex, copilot, CAPTURE_TOOLS;
+var claudeCode, cursor, codex, copilot, gemini, kiro, opencode, cline, CAPTURE_TOOLS;
 var init_tools = __esm({
   "packages/ingest/src/tools.ts"() {
     "use strict";
@@ -13130,10 +13483,14 @@ var init_tools = __esm({
     init_cursor_hooks();
     init_codex_hooks();
     init_copilot_hooks();
+    init_gemini_hooks();
+    init_kiro_hooks();
+    init_opencode_plugin();
+    init_cline_hooks();
     claudeCode = {
       id: "claude-code",
       name: "Claude Code",
-      detect: (root) => existsSync6(path9.join(os4.homedir(), ".claude")) || existsSync6(path9.join(root, ".claude")),
+      detect: (root) => existsSync10(path13.join(os4.homedir(), ".claude")) || existsSync10(path13.join(root, ".claude")),
       install: installCaptureHook,
       installed: captureHookInstalled,
       remove: removeCaptureHook
@@ -13141,7 +13498,7 @@ var init_tools = __esm({
     cursor = {
       id: "cursor",
       name: "Cursor",
-      detect: (root) => existsSync6(path9.join(os4.homedir(), ".cursor")) || existsSync6(path9.join(root, ".cursor")),
+      detect: (root) => existsSync10(path13.join(os4.homedir(), ".cursor")) || existsSync10(path13.join(root, ".cursor")),
       install: installCursorHooks,
       installed: cursorHooksInstalled,
       remove: removeCursorHooks
@@ -13149,7 +13506,7 @@ var init_tools = __esm({
     codex = {
       id: "codex",
       name: "Codex",
-      detect: (root) => existsSync6(path9.join(os4.homedir(), ".codex")) || existsSync6(path9.join(root, ".codex")),
+      detect: (root) => existsSync10(path13.join(os4.homedir(), ".codex")) || existsSync10(path13.join(root, ".codex")),
       install: installCodexHooks,
       installed: codexHooksInstalled,
       remove: removeCodexHooks
@@ -13157,16 +13514,52 @@ var init_tools = __esm({
     copilot = {
       id: "copilot",
       name: "GitHub Copilot",
-      detect: (root) => existsSync6(path9.join(os4.homedir(), ".copilot")) || existsSync6(path9.join(root, ".github", "hooks")),
+      detect: (root) => existsSync10(path13.join(os4.homedir(), ".copilot")) || existsSync10(path13.join(root, ".github", "hooks")),
       install: installCopilotHooks,
       installed: copilotHooksInstalled,
       remove: removeCopilotHooks
     };
+    gemini = {
+      id: "gemini",
+      name: "Gemini CLI",
+      detect: (root) => existsSync10(path13.join(os4.homedir(), ".gemini")) || existsSync10(path13.join(root, ".gemini")),
+      install: installGeminiHooks,
+      installed: geminiHooksInstalled,
+      remove: removeGeminiHooks
+    };
+    kiro = {
+      id: "kiro",
+      name: "Kiro",
+      detect: (root) => existsSync10(path13.join(os4.homedir(), ".kiro")) || existsSync10(path13.join(root, ".kiro")),
+      install: installKiroHooks,
+      installed: kiroHooksInstalled,
+      remove: removeKiroHooks
+    };
+    opencode = {
+      id: "opencode",
+      name: "OpenCode",
+      detect: (root) => existsSync10(path13.join(os4.homedir(), ".config", "opencode")) || existsSync10(path13.join(root, ".opencode")),
+      install: installOpencodePlugin,
+      installed: opencodePluginInstalled,
+      remove: removeOpencodePlugin
+    };
+    cline = {
+      id: "cline",
+      name: "Cline",
+      detect: (root) => existsSync10(path13.join(os4.homedir(), "Documents", "Cline")) || existsSync10(path13.join(os4.homedir(), ".cline")) || existsSync10(path13.join(root, ".clinerules")),
+      install: installClineHooks,
+      installed: clineHooksInstalled,
+      remove: removeClineHooks
+    };
     CAPTURE_TOOLS = [
       claudeCode,
       cursor,
       codex,
-      copilot
+      copilot,
+      gemini,
+      kiro,
+      opencode,
+      cline
     ];
   }
 });
@@ -13643,8 +14036,8 @@ var init_doku_model = __esm({
 
 // packages/ingest/src/doku.ts
 import { createHash as createHash2 } from "node:crypto";
-import { mkdir as mkdir5, readFile as readFile6, rm as rm3, stat, writeFile as writeFile5 } from "node:fs/promises";
-import path10 from "node:path";
+import { mkdir as mkdir9, readFile as readFile10, rm as rm6, stat, writeFile as writeFile9 } from "node:fs/promises";
+import path14 from "node:path";
 function bodyLocations(o) {
   return Array.isArray(o.body.location) ? o.body.location.map(String) : [];
 }
@@ -13710,7 +14103,7 @@ async function loadDokuData(brainId, root) {
   if (root) {
     try {
       const pkg = JSON.parse(
-        await readFile6(path10.join(root, "package.json"), "utf8")
+        await readFile10(path14.join(root, "package.json"), "utf8")
       );
       description = pkg.description ?? null;
       scripts = pkg.scripts ?? null;
@@ -14293,11 +14686,11 @@ function dokuFilePath(kind, slug) {
   return `${DOKU_DIR}/${slug}.md`;
 }
 async function writeDokuTree(root, files) {
-  const dir = path10.join(root, DOKU_DIR);
-  const manifestPath = path10.join(dir, MANIFEST);
+  const dir = path14.join(root, DOKU_DIR);
+  const manifestPath = path14.join(dir, MANIFEST);
   let old = { files: {} };
   try {
-    old = JSON.parse(await readFile6(manifestPath, "utf8"));
+    old = JSON.parse(await readFile10(manifestPath, "utf8"));
     if (typeof old.files !== "object" || old.files === null)
       old = { files: {} };
   } catch {
@@ -14307,21 +14700,21 @@ async function writeDokuTree(root, files) {
   for (const file of files) {
     const hash = sha1(file.markdown);
     next[file.relPath] = { hash };
-    const abs = path10.join(root, file.relPath);
+    const abs = path14.join(root, file.relPath);
     if (old.files[file.relPath]?.hash === hash && await exists(abs)) continue;
-    await mkdir5(path10.dirname(abs), { recursive: true });
-    await writeFile5(abs, file.markdown, "utf8");
+    await mkdir9(path14.dirname(abs), { recursive: true });
+    await writeFile9(abs, file.markdown, "utf8");
     written++;
   }
   let deleted = 0;
   for (const rel of Object.keys(old.files)) {
     if (next[rel]) continue;
     if (rel !== DOKU_FILENAME && !rel.startsWith(`${DOKU_DIR}/`)) continue;
-    await rm3(path10.join(root, rel), { force: true });
+    await rm6(path14.join(root, rel), { force: true });
     deleted++;
   }
-  await mkdir5(dir, { recursive: true });
-  await writeFile5(
+  await mkdir9(dir, { recursive: true });
+  await writeFile9(
     manifestPath,
     JSON.stringify({ files: next }, null, 2),
     "utf8"
@@ -14474,8 +14867,8 @@ var init_ponytail_brief = __esm({
 });
 
 // packages/ingest/src/ponytail-debt.ts
-function isDebtScannable(path15) {
-  return !/\.(md|mdx|markdown|txt|jsonl|log|lock)$/i.test(path15);
+function isDebtScannable(path19) {
+  return !/\.(md|mdx|markdown|txt|jsonl|log|lock)$/i.test(path19);
 }
 function scanPonytailComments(files) {
   const out = [];
@@ -14642,6 +15035,10 @@ var init_src3 = __esm({
     init_cursor_hooks();
     init_codex_hooks();
     init_copilot_hooks();
+    init_gemini_hooks();
+    init_kiro_hooks();
+    init_opencode_plugin();
+    init_cline_hooks();
     init_commit_links();
     init_tool_failure();
     init_bootstrap();
@@ -14727,8 +15124,8 @@ __export(brief_exports, {
   refreshBrief: () => refreshBrief,
   upsertBriefBlock: () => upsertBriefBlock
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, existsSync as existsSync7 } from "node:fs";
-import path11 from "node:path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync3, existsSync as existsSync11 } from "node:fs";
+import path15 from "node:path";
 function claudeMdWithImport(existing) {
   let text = existing;
   const start = text.indexOf(BRIEF_START);
@@ -14782,12 +15179,12 @@ async function refreshBrief(cwd) {
     `/capture/brief?brain=${project.brainId}`
   );
   if (!text) return "skipped";
-  const file = path11.join(root, BRIEF_FILE);
-  const existing = existsSync7(file) ? readFileSync7(file, "utf8") : "";
+  const file = path15.join(root, BRIEF_FILE);
+  const existing = existsSync11(file) ? readFileSync11(file, "utf8") : "";
   const next = upsertBriefBlock(existing, text);
   if (next !== null) writeFileSync3(file, next);
-  const claudeFile = path11.join(root, "CLAUDE.md");
-  const claude = existsSync7(claudeFile) ? readFileSync7(claudeFile, "utf8") : "";
+  const claudeFile = path15.join(root, "CLAUDE.md");
+  const claude = existsSync11(claudeFile) ? readFileSync11(claudeFile, "utf8") : "";
   const claudeNext = claudeMdWithImport(claude);
   if (claudeNext !== null) writeFileSync3(claudeFile, claudeNext);
   return next !== null || claudeNext !== null ? "updated" : "unchanged";
@@ -14824,9 +15221,9 @@ __export(debt_exports, {
   scanDebtInRepo: () => scanDebtInRepo
 });
 import { execFile as execFile3 } from "node:child_process";
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile11 } from "node:fs/promises";
 import { promisify as promisify3 } from "node:util";
-import path12 from "node:path";
+import path16 from "node:path";
 async function scanDebtInRepo(root) {
   const { stdout } = await run3("git", ["-C", root, "ls-files"], {
     maxBuffer: 16 * 1048576
@@ -14836,7 +15233,7 @@ async function scanDebtInRepo(root) {
     const p = rel.trim();
     if (!p || !isDebtScannable(p)) continue;
     try {
-      const buf = await readFile7(path12.join(root, p));
+      const buf = await readFile11(path16.join(root, p));
       if (buf.length > 512 * 1024 || buf.includes(0)) continue;
       files.push({ path: p, content: buf.toString("utf8") });
     } catch {
@@ -15262,11 +15659,11 @@ var init_codex = __esm({
                 ...commits.length ? { commits } : {}
               });
               files.forEach(
-                (path15, i) => events.push({
+                (path19, i) => events.push({
                   ...base,
                   event_id: `file:${id}:${i}`,
                   kind: "file_changed",
-                  path: path15
+                  path: path19
                 })
               );
             }
@@ -15436,106 +15833,637 @@ var init_copilot = __esm({
   }
 });
 
-// packages/cli/src/adapters/index.ts
-var ADAPTERS;
-var init_adapters = __esm({
-  "packages/cli/src/adapters/index.ts"() {
-    "use strict";
-    init_claude_code();
-    init_cursor();
-    init_codex();
-    init_copilot();
-    ADAPTERS = {
-      [claudeCode2.id]: claudeCode2,
-      [cursor2.id]: cursor2,
-      [codex2.id]: codex2,
-      [copilot2.id]: copilot2
-    };
-  }
-});
-
-// packages/cli/src/hook.ts
-var hook_exports = {};
-__export(hook_exports, {
-  hookMain: () => hookMain,
-  readSpool: () => readSpool,
-  spoolPath: () => spoolPath
-});
-import {
-  appendFileSync,
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync3,
-  readdirSync,
-  readFileSync as readFileSync8,
-  rmSync,
-  statSync as statSync2
-} from "node:fs";
-import os5 from "node:os";
-import path13 from "node:path";
-function spoolPath(tool, sessionId) {
-  return path13.join(
-    os5.homedir(),
-    ".brainjar",
-    "spool",
-    tool,
-    `${sessionId.replace(/[^A-Za-z0-9._-]/g, "_")}.jsonl`
-  );
-}
-function readSpool(file) {
-  const out = [];
-  for (const line of readFileSync8(file, "utf8").split("\n")) {
-    if (!line.trim()) continue;
-    try {
-      out.push(clampCaptureEvent(JSON.parse(line)));
-    } catch {
-    }
+// packages/cli/src/adapters/gemini.ts
+import { createHash as createHash7 } from "node:crypto";
+function targetOf4(input) {
+  const i = input ?? {};
+  for (const k of ["command", "file_path"]) {
+    if (typeof i[k] === "string") return i[k];
   }
-  return out;
+  return "";
 }
-function pruneSpool(dir, keep, maxAgeMs = 7 * 864e5) {
-  try {
-    for (const f of readdirSync(dir)) {
-      const file = path13.join(dir, f);
-      if (file === keep) continue;
-      if (Date.now() - statSync2(file).mtimeMs > maxAgeMs)
-        rmSync(file, { force: true });
-    }
-  } catch {
+function commitShas5(v) {
+  const text = typeof v === "string" ? v : JSON.stringify(v ?? "");
+  const out = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(/\[[^\]\n]* ([0-9a-f]{7,40})\]/g)) {
+    out.add(m[1].toLowerCase());
   }
+  return [...out];
 }
-async function hookMain(argv) {
-  const eventFlag = argv.indexOf("--event");
-  const event = eventFlag >= 0 ? argv[eventFlag + 1] : void 0;
-  const tool = argv.find((a, i) => !a.startsWith("--") && i !== eventFlag + 1);
-  const adapter = tool ? ADAPTERS[tool] : void 0;
-  try {
-    if (!adapter) {
-      console.error(
-        `brainjar hook: unknown tool "${tool ?? ""}". Known: ${Object.keys(ADAPTERS).join(", ")}`
-      );
-      return;
-    }
-    let payload = null;
-    try {
-      payload = JSON.parse(readFileSync8(0, "utf8"));
-    } catch {
-      return;
-    }
-    const out = adapter.map(payload, (/* @__PURE__ */ new Date()).toISOString(), { event });
-    if (!out) return;
-    if (out.reply) process.stdout.write(out.reply);
-    const file = spoolPath(adapter.id, out.sessionId);
-    if (out.events.length) {
-      mkdirSync3(path13.dirname(file), { recursive: true });
-      appendFileSync(
-        file,
-        out.events.map((e) => JSON.stringify(clampCaptureEvent(e))).join("\n") + "\n"
-      );
-    }
-    if (!out.flush) return;
-    const root = await repoRoot(out.cwd ?? process.cwd());
-    const events = existsSync8(file) ? readSpool(file) : [];
-    if (events.length) {
+var EDIT_TOOLS3, short6, gemini2;
+var init_gemini = __esm({
+  "packages/cli/src/adapters/gemini.ts"() {
+    "use strict";
+    init_src();
+    EDIT_TOOLS3 = /* @__PURE__ */ new Set(["write_file", "replace"]);
+    short6 = (s) => createHash7("sha256").update(s).digest("hex").slice(0, 16);
+    gemini2 = {
+      id: "gemini",
+      map(payload, now) {
+        const p = payload;
+        if (!p || typeof p !== "object" || typeof p.session_id !== "string") {
+          return null;
+        }
+        const at = typeof p.timestamp === "string" && !Number.isNaN(Date.parse(p.timestamp)) ? new Date(p.timestamp).toISOString() : now;
+        const base = {
+          v: CAPTURE_EVENT_VERSION,
+          tool: "gemini",
+          session_id: p.session_id,
+          at,
+          cwd: p.cwd ?? null
+        };
+        const events = [];
+        let flush = false;
+        let end = false;
+        switch (p.hook_event_name) {
+          case "SessionStart":
+            events.push({
+              ...base,
+              event_id: `start:${p.session_id}`,
+              kind: "session_started"
+            });
+            break;
+          case "BeforeAgent":
+            if (typeof p.prompt === "string" && p.prompt.trim()) {
+              events.push({
+                ...base,
+                event_id: `prompt:${short6(at + p.prompt)}`,
+                kind: "prompt",
+                text: p.prompt
+              });
+            }
+            break;
+          case "AfterTool": {
+            const tool = p.tool_name ?? "tool";
+            const target = targetOf4(p.tool_input);
+            const id = short6(at + tool + target);
+            const err = p.tool_response?.error;
+            if (err && typeof err === "object") {
+              const error = String(err.message ?? err.type ?? "tool error");
+              events.push({
+                ...base,
+                event_id: `fail:${id}`,
+                kind: "tool_failed",
+                tool_name: tool,
+                ...target ? { target } : {},
+                error
+              });
+              break;
+            }
+            const commits = commitShas5(p.tool_response?.llmContent);
+            events.push({
+              ...base,
+              event_id: `use:${id}`,
+              kind: "tool_used",
+              tool_name: tool,
+              ...target ? { target } : {},
+              ...commits.length ? { commits } : {}
+            });
+            if (EDIT_TOOLS3.has(tool) && target) {
+              events.push({
+                ...base,
+                event_id: `file:${id}`,
+                kind: "file_changed",
+                path: target
+              });
+            }
+            break;
+          }
+          case "AfterAgent":
+            flush = true;
+            break;
+          case "SessionEnd":
+            events.push({
+              ...base,
+              event_id: `end:${p.session_id}`,
+              kind: "session_ended",
+              ...p.reason ? { reason: p.reason } : {}
+            });
+            flush = true;
+            end = true;
+            break;
+          default:
+            return null;
+        }
+        return { sessionId: p.session_id, cwd: p.cwd ?? null, events, flush, end };
+      }
+    };
+  }
+});
+
+// packages/cli/src/adapters/kiro.ts
+import { createHash as createHash8 } from "node:crypto";
+function targetOf5(input) {
+  const i = input ?? {};
+  for (const k of ["command", "cmd", "path", "file_path", "filePath"]) {
+    if (typeof i[k] === "string") return i[k];
+  }
+  return "";
+}
+function commitShas6(v) {
+  const text = typeof v === "string" ? v : JSON.stringify(v ?? "");
+  const out = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(/\[[^\]\n]* ([0-9a-f]{7,40})\]/g)) {
+    out.add(m[1].toLowerCase());
+  }
+  return [...out];
+}
+function failureOf2(response) {
+  if (!response || typeof response !== "object") return null;
+  const r = response;
+  if (r.success !== false) return null;
+  const text = [r.error, r.result, r.message].find(
+    (t) => typeof t === "string" && t.trim()
+  );
+  return (typeof text === "string" ? text : JSON.stringify(r)).trim();
+}
+var EDIT_TOOLS4, short7, EVENTS5, kiro2;
+var init_kiro = __esm({
+  "packages/cli/src/adapters/kiro.ts"() {
+    "use strict";
+    init_src();
+    EDIT_TOOLS4 = /* @__PURE__ */ new Set(["fs_write", "write", "str_replace", "fs_append"]);
+    short7 = (s) => createHash8("sha256").update(s).digest("hex").slice(0, 16);
+    EVENTS5 = {
+      agentSpawn: "start",
+      sessionStart: "start",
+      SessionStart: "start",
+      userPromptSubmit: "prompt",
+      UserPromptSubmit: "prompt",
+      promptSubmit: "prompt",
+      postToolUse: "tool",
+      PostToolUse: "tool",
+      postFileSave: "file",
+      PostFileSave: "file",
+      postFileCreate: "file",
+      PostFileCreate: "file",
+      stop: "stop",
+      Stop: "stop",
+      agentStop: "stop"
+    };
+    kiro2 = {
+      id: "kiro",
+      map(payload, now) {
+        const p = payload;
+        if (!p || typeof p !== "object" || typeof p.session_id !== "string") {
+          return null;
+        }
+        const base = {
+          v: CAPTURE_EVENT_VERSION,
+          tool: "kiro",
+          session_id: p.session_id,
+          at: now,
+          cwd: p.cwd ?? null
+        };
+        const events = [];
+        let flush = false;
+        switch (EVENTS5[p.hook_event_name ?? ""]) {
+          case "start":
+            events.push({
+              ...base,
+              event_id: `start:${p.session_id}`,
+              kind: "session_started"
+            });
+            break;
+          case "prompt":
+            if (typeof p.prompt === "string" && p.prompt.trim()) {
+              events.push({
+                ...base,
+                event_id: `prompt:${short7(now + p.prompt)}`,
+                kind: "prompt",
+                text: p.prompt
+              });
+            }
+            break;
+          case "tool": {
+            const tool = p.tool_name ?? "tool";
+            const target = targetOf5(p.tool_input);
+            const id = short7(now + tool + target);
+            const error = failureOf2(p.tool_response);
+            if (error) {
+              events.push({
+                ...base,
+                event_id: `fail:${id}`,
+                kind: "tool_failed",
+                tool_name: tool,
+                ...target ? { target } : {},
+                error
+              });
+              break;
+            }
+            const commits = commitShas6(p.tool_response);
+            events.push({
+              ...base,
+              event_id: `use:${id}`,
+              kind: "tool_used",
+              tool_name: tool,
+              ...target ? { target } : {},
+              ...commits.length ? { commits } : {}
+            });
+            if (EDIT_TOOLS4.has(tool) && target) {
+              events.push({
+                ...base,
+                event_id: `file:${id}`,
+                kind: "file_changed",
+                path: target
+              });
+            }
+            break;
+          }
+          case "file":
+            if (typeof p.file_path === "string" && p.file_path) {
+              events.push({
+                ...base,
+                event_id: `file:${short7(now + p.file_path)}`,
+                kind: "file_changed",
+                path: p.file_path
+              });
+            }
+            break;
+          case "stop":
+            flush = true;
+            break;
+          default:
+            return null;
+        }
+        return {
+          sessionId: p.session_id,
+          cwd: p.cwd ?? null,
+          events,
+          flush,
+          end: false
+        };
+      }
+    };
+  }
+});
+
+// packages/cli/src/adapters/opencode.ts
+import { createHash as createHash9 } from "node:crypto";
+function commitShas7(text) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of (text ?? "").matchAll(/\[[^\]\n]* ([0-9a-f]{7,40})\]/g)) {
+    out.add(m[1].toLowerCase());
+  }
+  return [...out];
+}
+var EDIT_TOOLS5, short8, opencode2;
+var init_opencode = __esm({
+  "packages/cli/src/adapters/opencode.ts"() {
+    "use strict";
+    init_src();
+    EDIT_TOOLS5 = /* @__PURE__ */ new Set(["edit", "write"]);
+    short8 = (s) => createHash9("sha256").update(s).digest("hex").slice(0, 16);
+    opencode2 = {
+      id: "opencode",
+      map(payload, now) {
+        const p = payload;
+        if (!p || typeof p !== "object" || p.source !== "opencode" || typeof p.session_id !== "string" || !p.session_id) {
+          return null;
+        }
+        const base = {
+          v: CAPTURE_EVENT_VERSION,
+          tool: "opencode",
+          session_id: p.session_id,
+          at: now,
+          cwd: p.cwd ?? null
+        };
+        const events = [];
+        let flush = false;
+        const target = p.target?.trim() ?? "";
+        const tool = p.tool_name ?? "tool";
+        switch (p.kind) {
+          case "session_started":
+            events.push({
+              ...base,
+              event_id: `start:${p.session_id}`,
+              kind: "session_started"
+            });
+            break;
+          case "prompt":
+            if (typeof p.text === "string" && p.text.trim()) {
+              events.push({
+                ...base,
+                event_id: `prompt:${short8(now + p.text)}`,
+                kind: "prompt",
+                text: p.text
+              });
+            }
+            break;
+          case "tool_used": {
+            const id = short8(now + tool + target);
+            const commits = commitShas7(p.output);
+            events.push({
+              ...base,
+              event_id: `use:${id}`,
+              kind: "tool_used",
+              tool_name: tool,
+              ...target ? { target } : {},
+              ...commits.length ? { commits } : {}
+            });
+            if (EDIT_TOOLS5.has(tool) && target) {
+              events.push({
+                ...base,
+                event_id: `file:${id}`,
+                kind: "file_changed",
+                path: target
+              });
+            }
+            break;
+          }
+          case "tool_failed": {
+            const error = (p.error ?? "").trim();
+            if (!error) break;
+            events.push({
+              ...base,
+              event_id: `fail:${short8(now + tool + target + error)}`,
+              kind: "tool_failed",
+              tool_name: tool,
+              ...target ? { target } : {},
+              error
+            });
+            break;
+          }
+          case "file_changed":
+            if (typeof p.path === "string" && p.path) {
+              events.push({
+                ...base,
+                event_id: `file:${short8(now + p.path)}`,
+                kind: "file_changed",
+                path: p.path
+              });
+            }
+            break;
+          case "turn_ended":
+            flush = true;
+            break;
+          default:
+            return null;
+        }
+        return {
+          sessionId: p.session_id,
+          cwd: p.cwd ?? null,
+          events,
+          flush,
+          end: false
+        };
+      }
+    };
+  }
+});
+
+// packages/cli/src/adapters/cline.ts
+import { createHash as createHash10 } from "node:crypto";
+function targetOf6(params) {
+  const i = params ?? {};
+  for (const k of ["command", "path"]) {
+    if (typeof i[k] === "string") return i[k];
+  }
+  return "";
+}
+function commitShas8(text) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of (text ?? "").matchAll(/\[[^\]\n]* ([0-9a-f]{7,40})\]/g)) {
+    out.add(m[1].toLowerCase());
+  }
+  return [...out];
+}
+function stamp2(ts, now) {
+  const n = typeof ts === "string" && /^\d+$/.test(ts) ? Number(ts) : ts;
+  if (typeof n === "number" && Number.isFinite(n))
+    return new Date(n).toISOString();
+  if (typeof ts === "string" && !Number.isNaN(Date.parse(ts)))
+    return new Date(ts).toISOString();
+  return now;
+}
+function clineContextEnvelope(text) {
+  return JSON.stringify({ cancel: false, contextModification: text });
+}
+var EDIT_TOOLS6, short9, CLINE_REPLY, cline2;
+var init_cline = __esm({
+  "packages/cli/src/adapters/cline.ts"() {
+    "use strict";
+    init_src();
+    EDIT_TOOLS6 = /* @__PURE__ */ new Set(["write_to_file", "replace_in_file", "apply_patch"]);
+    short9 = (s) => createHash10("sha256").update(s).digest("hex").slice(0, 16);
+    CLINE_REPLY = JSON.stringify({ cancel: false });
+    cline2 = {
+      id: "cline",
+      map(payload, now) {
+        const p = payload;
+        if (!p || typeof p !== "object" || typeof p.taskId !== "string") {
+          return null;
+        }
+        const at = stamp2(p.timestamp, now);
+        const cwd = p.workspaceRoots?.[0] ?? null;
+        const base = {
+          v: CAPTURE_EVENT_VERSION,
+          tool: "cline",
+          session_id: p.taskId,
+          at,
+          cwd
+        };
+        const events = [];
+        let flush = false;
+        let end = false;
+        switch (p.hookName) {
+          case "TaskStart":
+          case "TaskResume":
+            events.push({
+              ...base,
+              event_id: `start:${p.taskId}`,
+              kind: "session_started"
+            });
+            break;
+          case "UserPromptSubmit": {
+            const prompt = p.userPromptSubmit?.prompt;
+            if (typeof prompt === "string" && prompt.trim()) {
+              events.push({
+                ...base,
+                event_id: `prompt:${short9(at + prompt)}`,
+                kind: "prompt",
+                text: prompt
+              });
+            }
+            break;
+          }
+          case "PostToolUse": {
+            const t = p.postToolUse ?? {};
+            const tool = t.toolName ?? "tool";
+            const target = targetOf6(t.parameters);
+            const id = short9(at + tool + target);
+            if (t.success !== true) {
+              const error = (t.result ?? "").trim() || "tool failed";
+              events.push({
+                ...base,
+                event_id: `fail:${id}`,
+                kind: "tool_failed",
+                tool_name: tool,
+                ...target ? { target } : {},
+                error
+              });
+              break;
+            }
+            const commits = commitShas8(t.result);
+            events.push({
+              ...base,
+              event_id: `use:${id}`,
+              kind: "tool_used",
+              tool_name: tool,
+              ...target ? { target } : {},
+              ...commits.length ? { commits } : {}
+            });
+            if (EDIT_TOOLS6.has(tool) && target) {
+              events.push({
+                ...base,
+                event_id: `file:${id}`,
+                kind: "file_changed",
+                path: target
+              });
+            }
+            break;
+          }
+          case "TaskComplete":
+          case "TaskCancel":
+            events.push({
+              ...base,
+              event_id: `end:${p.taskId}`,
+              kind: "session_ended",
+              reason: p.hookName === "TaskCancel" ? "cancelled" : "completed"
+            });
+            flush = true;
+            end = true;
+            break;
+          default:
+            return null;
+        }
+        return {
+          sessionId: p.taskId,
+          cwd,
+          events,
+          flush,
+          end,
+          reply: CLINE_REPLY
+        };
+      }
+    };
+  }
+});
+
+// packages/cli/src/adapters/index.ts
+var ADAPTERS;
+var init_adapters = __esm({
+  "packages/cli/src/adapters/index.ts"() {
+    "use strict";
+    init_claude_code();
+    init_cursor();
+    init_codex();
+    init_copilot();
+    init_gemini();
+    init_kiro();
+    init_opencode();
+    init_cline();
+    ADAPTERS = {
+      [claudeCode2.id]: claudeCode2,
+      [cursor2.id]: cursor2,
+      [codex2.id]: codex2,
+      [copilot2.id]: copilot2,
+      [gemini2.id]: gemini2,
+      [kiro2.id]: kiro2,
+      [opencode2.id]: opencode2,
+      [cline2.id]: cline2
+    };
+  }
+});
+
+// packages/cli/src/hook.ts
+var hook_exports = {};
+__export(hook_exports, {
+  hookMain: () => hookMain,
+  parseHookArgs: () => parseHookArgs,
+  readSpool: () => readSpool,
+  spoolPath: () => spoolPath
+});
+import {
+  appendFileSync,
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync3,
+  readdirSync,
+  readFileSync as readFileSync12,
+  rmSync,
+  statSync as statSync2
+} from "node:fs";
+import os5 from "node:os";
+import path17 from "node:path";
+function spoolPath(tool, sessionId) {
+  return path17.join(
+    os5.homedir(),
+    ".brainjar",
+    "spool",
+    tool,
+    `${sessionId.replace(/[^A-Za-z0-9._-]/g, "_")}.jsonl`
+  );
+}
+function readSpool(file) {
+  const out = [];
+  for (const line of readFileSync12(file, "utf8").split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(clampCaptureEvent(JSON.parse(line)));
+    } catch {
+    }
+  }
+  return out;
+}
+function pruneSpool(dir, keep, maxAgeMs = 7 * 864e5) {
+  try {
+    for (const f of readdirSync(dir)) {
+      const file = path17.join(dir, f);
+      if (file === keep) continue;
+      if (Date.now() - statSync2(file).mtimeMs > maxAgeMs)
+        rmSync(file, { force: true });
+    }
+  } catch {
+  }
+}
+function parseHookArgs(argv) {
+  const eventFlag = argv.indexOf("--event");
+  const eventIndex = eventFlag >= 0 ? eventFlag + 1 : -1;
+  const event = eventIndex >= 0 ? argv[eventIndex] : void 0;
+  const tool = argv.find((a, i) => !a.startsWith("--") && i !== eventIndex);
+  return { tool, event };
+}
+async function hookMain(argv) {
+  const { tool, event } = parseHookArgs(argv);
+  const adapter = tool ? ADAPTERS[tool] : void 0;
+  try {
+    if (!adapter) {
+      console.error(
+        `brainjar hook: unknown tool "${tool ?? ""}". Known: ${Object.keys(ADAPTERS).join(", ")}`
+      );
+      return;
+    }
+    let payload = null;
+    try {
+      payload = JSON.parse(readFileSync12(0, "utf8"));
+    } catch {
+      return;
+    }
+    const out = adapter.map(payload, (/* @__PURE__ */ new Date()).toISOString(), { event });
+    if (!out) return;
+    if (out.reply) process.stdout.write(out.reply);
+    const file = spoolPath(adapter.id, out.sessionId);
+    if (out.events.length) {
+      mkdirSync3(path17.dirname(file), { recursive: true });
+      appendFileSync(
+        file,
+        out.events.map((e) => JSON.stringify(clampCaptureEvent(e))).join("\n") + "\n"
+      );
+    }
+    if (!out.flush) return;
+    const root = await repoRoot(out.cwd ?? process.cwd());
+    const events = existsSync12(file) ? readSpool(file) : [];
+    if (events.length) {
       const r = await captureApi("/capture/events", {
         method: "POST",
         body: {
@@ -15555,7 +16483,7 @@ async function hookMain(argv) {
       }
     }
     if (out.end) rmSync(file, { force: true });
-    pruneSpool(path13.dirname(file), file);
+    pruneSpool(path17.dirname(file), file);
     await syncRepo(root);
   } catch (e) {
     console.error("brainjar hook:", e instanceof Error ? e.message : e);
@@ -15678,7 +16606,7 @@ __export(init_exports, {
   init: () => init,
   initMain: () => initMain
 });
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 async function init(argv) {
   const skipTranscripts = argv.includes("--no-transcripts");
   const flag = (f) => argv.includes(f) ? argv[argv.indexOf(f) + 1] ?? null : null;
@@ -15763,7 +16691,7 @@ async function init(argv) {
     let skipped = 0;
     for (const f of files) {
       try {
-        const { text, truncated } = capTranscript(await readFile8(f, "utf8"));
+        const { text, truncated } = capTranscript(await readFile12(f, "utf8"));
         if (truncated) truncatedCount++;
         const r = await captureApi("/capture/transcript", {
           method: "POST",
@@ -15786,7 +16714,7 @@ async function init(argv) {
   const tools = detectedTools(root);
   if (tools.length === 0) {
     ok(
-      "no coding agent detected (looked for Claude Code, Cursor, Codex, GitHub Copilot); rerun init after installing one"
+      "no coding agent detected (looked for Claude Code, Cursor, Codex, GitHub Copilot, Gemini CLI, Kiro, OpenCode, Cline); rerun init after installing one"
     );
   }
   for (const tool of tools) {
@@ -15853,7 +16781,7 @@ __export(constraints_exports, {
   constraintsMain: () => constraintsMain,
   sessionStartEnvelope: () => sessionStartEnvelope
 });
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 function sessionStartEnvelope(text) {
   return JSON.stringify({
     hookSpecificOutput: {
@@ -15871,8 +16799,8 @@ async function constraintsMain(argv) {
     if (hook) {
       let cwd;
       try {
-        const payload = JSON.parse(readFileSync9(0, "utf8"));
-        cwd = payload.cwd;
+        const payload = JSON.parse(readFileSync13(0, "utf8"));
+        cwd = payload.cwd ?? payload.workspace_roots?.[0] ?? payload.workspaceRoots?.[0];
       } catch {
       }
       root = await repoRoot(cwd ?? process.cwd());
@@ -15893,8 +16821,9 @@ async function constraintsMain(argv) {
       }
       return;
     }
-    const envelope = argv.includes("--copilot") ? copilotContextEnvelope : sessionStartEnvelope;
+    const envelope = argv.includes("--copilot") ? copilotContextEnvelope : argv.includes("--cline") ? clineContextEnvelope : argv.includes("--plain") ? (text) => text : sessionStartEnvelope;
     if (r.text) console.log(hook ? envelope(r.text) : r.text);
+    else if (hook && argv.includes("--cline")) console.log(CLINE_REPLY);
     else if (!hook)
       console.log("No recorded failed approaches or rules for this Brain.");
     if (hook) {
@@ -15915,6 +16844,7 @@ var init_constraints = __esm({
     init_src3();
     init_api_client();
     init_copilot();
+    init_cline();
   }
 });
 
@@ -16066,8 +16996,8 @@ __export(deepscan_exports, {
   deepscanMain: () => deepscanMain,
   selectDeepScanFiles: () => selectDeepScanFiles
 });
-import { readdir as readdir3, readFile as readFile9, stat as stat2 } from "node:fs/promises";
-import path14 from "node:path";
+import { readdir as readdir3, readFile as readFile13, stat as stat2 } from "node:fs/promises";
+import path18 from "node:path";
 function selectDeepScanFiles(candidates, graph, maxFiles = MAX_FILES) {
   const picked = [];
   const has = /* @__PURE__ */ new Set();
@@ -16104,7 +17034,7 @@ async function walkCandidates(root) {
   for (const e of entries) {
     if (!e.isFile()) continue;
     const parent = e.parentPath ?? e.path ?? root;
-    const rel = path14.relative(root, path14.join(parent, e.name)).split(path14.sep).join("/");
+    const rel = path18.relative(root, path18.join(parent, e.name)).split(path18.sep).join("/");
     if (rel.split("/").some((seg) => SKIP_DIRS.has(seg))) continue;
     out.push(rel);
   }
@@ -16129,10 +17059,10 @@ async function deepscanMain() {
   const artifacts = [];
   for (const rel of files) {
     try {
-      const abs = path14.join(root, rel);
+      const abs = path18.join(root, rel);
       const info = await stat2(abs);
       if (info.size > RAW_SKIP_BYTES) continue;
-      const content = await readFile9(abs, "utf8");
+      const content = await readFile13(abs, "utf8");
       artifacts.push({
         source: "deepscan",
         kind: "source_file",