brainjar 0.3.688 → 0.3.694

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.688";
+    CLI_VERSION = "0.3.694";
     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) {
@@ -5665,6 +5665,30 @@ function findEnvFile(startDir = process.cwd()) {
     dir = parent;
   }
 }
+function projectsPath() {
+  return path2.join(os2.homedir(), ".brainjar", "projects.json");
+}
+function projectKey(root) {
+  return root.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+function readProjects(filePath = projectsPath()) {
+  try {
+    const parsed = JSON.parse(readFileSync2(filePath, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function projectLink(root, filePath = projectsPath()) {
+  const link = readProjects(filePath)[projectKey(root)];
+  return link && typeof link.brainId === "string" ? link : null;
+}
+function writeProjectLink(root, link, filePath = projectsPath()) {
+  const all = readProjects(filePath);
+  all[projectKey(root)] = link;
+  mkdirSync2(path2.dirname(filePath), { recursive: true });
+  writeFileSync2(filePath, JSON.stringify(all, null, 2) + "\n", "utf8");
+}
 function userConfigPath() {
   return path2.join(os2.homedir(), ".brainjar", "config");
 }
@@ -5995,17 +6019,6 @@ var init_vector = __esm({
 });
 
 // packages/db/src/repository.ts
-async function brainForProject(root, pool2 = getPool()) {
-  const normalized = root.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
-  const r = await pool2.query(
-    `SELECT brain_id FROM source
-     WHERE kind = 'git_local'
-       AND lower(regexp_replace(replace(config->>'cwd', '\\', '/'), '/+$', '')) = $1
-     ORDER BY created_at DESC LIMIT 1`,
-    [normalized]
-  );
-  return r.rows[0]?.brain_id ?? null;
-}
 async function getBrain(id, pool2 = getPool()) {
   return (await pool2.query("SELECT * FROM brain WHERE id = $1", [id])).rows[0] ?? null;
 }
@@ -6102,17 +6115,6 @@ var init_repository = __esm({
         const existing = (await this.listSources()).find((s) => s.kind === kind);
         return existing ?? await this.createSource(kind, name);
       }
-      /**
-       * The git_local source for THIS root (normalized like brainForProject), or null. One
-       * Brain can hold many checkouts; matching "any git_local" silently swallowed every root
-       * after the first (found 2026-08-21 via the benchmark's silent push).
-       */
-      async gitLocalSource(root) {
-        const normalized = root.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
-        return (await this.listSources()).find(
-          (s) => s.kind === "git_local" && String(s.config.cwd ?? "").replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase() === normalized
-        ) ?? null;
-      }
       async listSources() {
         return (await this.pool.query(
           "SELECT * FROM source WHERE brain_id = $1 ORDER BY created_at",
@@ -8850,12 +8852,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 +8874,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 +8895,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 +11884,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 +11917,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 +12038,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 +12126,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;
@@ -12602,12 +12604,25 @@ async function repoRoot(cwd = process.cwd()) {
 function repoName(root) {
   return path5.basename(root) || "project";
 }
-async function resolveCaptureBrain(root) {
+async function mainRepoRoot(root) {
   try {
-    return await brainForProject(await repoRoot(root));
+    const { stdout } = await run2(
+      "git",
+      ["rev-parse", "--path-format=absolute", "--git-common-dir"],
+      { cwd: root, windowsHide: true }
+    );
+    const common = path5.resolve(root, stdout.trim());
+    if (path5.basename(common) === ".git") return path5.dirname(common);
   } catch {
-    return null;
   }
+  return root;
+}
+async function captureProject(root, filePath) {
+  const top = await repoRoot(root);
+  return projectLink(top, filePath) ?? projectLink(await mainRepoRoot(top), filePath);
+}
+async function resolveCaptureBrain(root, filePath) {
+  return (await captureProject(root, filePath))?.brainId ?? null;
 }
 async function transcriptFiles(root) {
   const encoded = root.replace(/[:\\/]/g, "-");
@@ -12704,22 +12719,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;
@@ -12790,6 +12805,7 @@ var init_bootstrap = __esm({
   "packages/ingest/src/bootstrap.ts"() {
     "use strict";
     init_src2();
+    init_src();
     init_sync();
     init_extraction();
     init_structure();
@@ -13115,14 +13131,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 +13499,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 +13514,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 +13522,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 +13530,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 +14052,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 +14119,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 +14702,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 +14716,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 +14883,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 +15051,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();
@@ -14685,11 +15098,14 @@ function serverUrl() {
     ""
   );
 }
+function notConnected(root) {
+  return `brainjar: no Brain is connected to ${root} on this machine. Run \`npx brainjar init --brain <id>\` there (the id is under Settings > Connect).`;
+}
 async function captureApi(pathAndQuery, init2 = {}) {
   const token = loadEnv().BRAINJAR_TOKEN?.trim();
   if (!token) {
-    throw new Error(
-      "BRAINJAR_TOKEN is not set \u2014 create a token in the web app (setup wizard or Settings > API tokens) and add it to ~/.brainjar/config or the project .env"
+    throw new TokenError(
+      "BRAINJAR_TOKEN is not set. Create a token in the web app (setup wizard or Settings > Connect) and run `npx brainjar init --brain <id> --token <token>` once on this machine."
     );
   }
   const res = await fetch(serverUrl() + pathAndQuery, {
@@ -14701,6 +15117,7 @@ async function captureApi(pathAndQuery, init2 = {}) {
     ...init2.body !== void 0 ? { body: JSON.stringify(init2.body) } : {}
   });
   const body = await res.json().catch(() => null);
+  if (res.status === 401) throw new TokenError(TOKEN_HELP);
   if (!res.ok) {
     throw new Error(
       body?.error ?? `BrainJar server responded ${res.status} (${serverUrl()})`
@@ -14708,10 +15125,14 @@ async function captureApi(pathAndQuery, init2 = {}) {
   }
   return body;
 }
+var TokenError, TOKEN_HELP;
 var init_api_client = __esm({
   "packages/cli/src/api-client.ts"() {
     "use strict";
     init_src();
+    TokenError = class extends Error {
+    };
+    TOKEN_HELP = "BrainJar token revoked or invalid. Create a new token under Account in the web app, then run `npx brainjar init --brain <id> --token <token>` once in any project on this machine.";
   }
 });
 
@@ -14727,8 +15148,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);
@@ -14774,20 +15195,18 @@ ${BRIEF_END}
 async function refreshBrief(cwd) {
   if (loadEnv().BRAINJAR_NO_BRIEF === "1") return "skipped";
   const root = await repoRoot(cwd);
-  const project = await captureApi(
-    `/capture/project?root=${encodeURIComponent(root)}`
-  );
-  if (!project.brainId) return "skipped";
+  const link = await captureProject(root);
+  if (!link) return "skipped";
   const { text } = await captureApi(
-    `/capture/brief?brain=${project.brainId}`
+    `/capture/brief?brain=${link.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 +15243,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 +15255,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 {
@@ -14846,14 +15265,13 @@ async function scanDebtInRepo(root) {
 }
 async function debtMain() {
   const root = await repoRoot(process.cwd());
-  const r = await captureApi(`/capture/debt?root=${encodeURIComponent(root)}`);
-  if (!r.brainId) {
-    console.error(
-      `brainjar: no Brain is connected to ${root} \u2014 run \`npx brainjar init\``
-    );
+  const link = await captureProject(root);
+  if (!link) {
+    console.error(notConnected(root));
     process.exitCode = 1;
     return;
   }
+  const r = await captureApi(`/capture/debt?brain=${link.brainId}`);
   if (r.entries.length === 0) {
     console.log(
       "No ponytail debt on record. Either disciplined or undocumented."
@@ -15262,11 +15680,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,76 +15854,630 @@ 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,
-  parseHookArgs: () => parseHookArgs,
-  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];
 }
-function parseHookArgs(argv) {
-  const eventFlag = argv.indexOf("--event");
+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,
+  staleSpools: () => staleSpools
+});
+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 staleSpools(dir, keep, minAgeMs = 36e5) {
+  try {
+    return readdirSync(dir).map((f) => path17.join(dir, f)).filter(
+      (file) => file !== keep && Date.now() - statSync2(file).mtimeMs > minAgeMs
+    ).sort();
+  } catch {
+    return [];
+  }
+}
+async function linkForSpool(file) {
+  const cwd = readSpool(file).find((e) => e.cwd)?.cwd;
+  return cwd ? captureProject(await repoRoot(cwd)) : null;
+}
+async function shipSpool(file, link) {
+  const events = readSpool(file);
+  if (!events.length) return;
+  const r = await captureApi("/capture/events", {
+    method: "POST",
+    body: {
+      brain: link.brainId,
+      events,
+      author: loadEnv().BRAINJAR_AUTHOR?.trim() || null
+    }
+  });
+  console.error(
+    `brainjar: session captured \u2014 ${r.prompts ?? 0} intents, ${r.failures ?? 0} failures, ${(r.skippedNoise ?? 0) + (r.skippedFailures ?? 0)} noise skipped` + (r.consolidated ? `, ${r.consolidated} product facts` : "")
+  );
+}
+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);
@@ -15523,7 +16495,7 @@ async function hookMain(argv) {
     }
     let payload = null;
     try {
-      payload = JSON.parse(readFileSync8(0, "utf8"));
+      payload = JSON.parse(readFileSync12(0, "utf8"));
     } catch {
       return;
     }
@@ -15532,7 +16504,7 @@ async function hookMain(argv) {
     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 });
+      mkdirSync3(path17.dirname(file), { recursive: true });
       appendFileSync(
         file,
         out.events.map((e) => JSON.stringify(clampCaptureEvent(e))).join("\n") + "\n"
@@ -15540,28 +16512,22 @@ async function hookMain(argv) {
     }
     if (!out.flush) return;
     const root = await repoRoot(out.cwd ?? process.cwd());
-    const events = existsSync8(file) ? readSpool(file) : [];
-    if (events.length) {
-      const r = await captureApi("/capture/events", {
-        method: "POST",
-        body: {
-          root,
-          events,
-          author: loadEnv().BRAINJAR_AUTHOR?.trim() || null
-        }
-      });
-      if (!r.brainId) {
-        console.error(
-          `brainjar: no Brain is connected to ${root} \u2014 run \`npx brainjar init\` (skipping capture)`
-        );
-      } else {
-        console.error(
-          `brainjar: session captured \u2014 ${r.prompts ?? 0} intents, ${r.failures ?? 0} failures, ${(r.skippedNoise ?? 0) + (r.skippedFailures ?? 0)} noise skipped` + (r.consolidated ? `, ${r.consolidated} product facts` : "")
-        );
-      }
+    const link = await captureProject(root);
+    if (!link) {
+      console.error(notConnected(root));
+      if (out.end) rmSync(file, { force: true });
+      return;
     }
+    if (existsSync12(file)) await shipSpool(file, link);
     if (out.end) rmSync(file, { force: true });
-    pruneSpool(path13.dirname(file), file);
+    const dir = path17.dirname(file);
+    for (const other of staleSpools(dir, file)) {
+      const otherLink = await linkForSpool(other);
+      if (!otherLink) continue;
+      await shipSpool(other, otherLink);
+      rmSync(other, { force: true });
+    }
+    pruneSpool(dir, file);
     await syncRepo(root);
   } catch (e) {
     console.error("brainjar hook:", e instanceof Error ? e.message : e);
@@ -15596,13 +16562,12 @@ function capTranscript(text) {
 }
 async function syncRepo(root) {
   try {
-    const project = await captureApi(`/capture/project?root=${encodeURIComponent(root)}`);
-    if (!project.brainId) {
-      console.error(
-        `brainjar: no Brain is connected to ${root} \u2014 run \`npx brainjar init\` (skipping capture)`
-      );
+    const link = await captureProject(root);
+    if (!link) {
+      console.error(notConnected(root));
       return;
     }
+    const project = await captureApi(`/capture/project?brain=${link.brainId}&source=${link.sourceId}`);
     if (project.sourceId) {
       const connector = createConnector("git_local", { cwd: root }, {});
       const artifacts = await connector.sync(project.cursor ?? void 0);
@@ -15612,7 +16577,7 @@ async function syncRepo(root) {
           {
             method: "POST",
             body: {
-              root,
+              brain: link.brainId,
               sourceId: project.sourceId,
               artifacts,
               cursor: maxUpdatedAt(artifacts) ?? project.cursor
@@ -15627,7 +16592,7 @@ async function syncRepo(root) {
           const graph = await scanStructure(root);
           await captureApi("/capture/structure", {
             method: "POST",
-            body: { root, graph }
+            body: { brain: link.brainId, graph }
           });
         }
       }
@@ -15637,7 +16602,10 @@ async function syncRepo(root) {
       const entries = await scanDebtInRepo2(root);
       const r = await captureApi(
         "/capture/debt",
-        { method: "POST", body: { root, entries } }
+        {
+          method: "POST",
+          body: { brain: link.brainId, source: link.sourceId, entries }
+        }
       );
       if (r.added || r.resolved)
         console.error(
@@ -15684,7 +16652,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;
@@ -15713,13 +16681,23 @@ async function init(argv) {
     return 1;
   }
   step(2, "Connecting the project Brain\u2026");
+  const known = await captureProject(root);
+  const reuse = known && (!brainFlag || known.brainId === brainFlag) ? known : null;
   const conn = await captureApi("/capture/connect", {
     method: "POST",
-    body: { root, name, ...brainFlag ? { brainId: brainFlag } : {} }
+    body: {
+      name,
+      ...brainFlag ? { brainId: brainFlag } : reuse ? { brainId: reuse.brainId } : {},
+      ...reuse ? { sourceId: reuse.sourceId } : {}
+    }
   });
   ok(
     conn.createdBrain ? `created Brain "${name}" (${conn.brainId})` : `reusing Brain "${name}" (${conn.brainId})`
   );
+  writeProjectLink(root, { brainId: conn.brainId, sourceId: conn.sourceId });
+  ok(
+    `folder linked to the Brain in ${projectsPath()} (the path stays on this machine)`
+  );
   if (serverFlag || tokenFlag) {
     writeUserConfig({
       ...serverFlag ? { BRAINJAR_SERVER: serverFlag } : {},
@@ -15731,7 +16709,7 @@ async function init(argv) {
   const graph = await scanStructure(root);
   const structure = await captureApi(
     "/capture/structure",
-    { method: "POST", body: { root, graph } }
+    { method: "POST", body: { brain: conn.brainId, graph } }
   );
   const connector = createConnector("git_local", { cwd: root }, {});
   const artifacts = await connector.sync(conn.cursor ?? void 0);
@@ -15743,7 +16721,7 @@ async function init(argv) {
       {
         method: "POST",
         body: {
-          root,
+          brain: conn.brainId,
           sourceId: conn.sourceId,
           artifacts,
           cursor: maxUpdatedAt(artifacts) ?? conn.cursor
@@ -15769,11 +16747,11 @@ 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",
-          body: { root, text, author, backfill: true }
+          body: { brain: conn.brainId, text, author, backfill: true }
         });
         prompts += r.prompts;
         failures += r.failures;
@@ -15792,7 +16770,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) {
@@ -15816,7 +16794,7 @@ async function init(argv) {
     ok("skipped (server unreachable) \u2014 the sync hook will add it");
   }
   const final = await captureApi(
-    `/capture/project?root=${encodeURIComponent(root)}`
+    `/capture/project?brain=${conn.brainId}&source=${conn.sourceId}`
   );
   console.log(
     `
@@ -15859,7 +16837,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: {
@@ -15872,12 +16850,13 @@ async function constraintsMain(argv) {
   const hook = argv.includes("--hook");
   const brainFlag = argv[argv.indexOf("--brain") + 1];
   const brainOverride = argv.includes("--brain") ? brainFlag ?? null : null;
+  const envelope = argv.includes("--copilot") ? copilotContextEnvelope : argv.includes("--cline") ? clineContextEnvelope : argv.includes("--plain") ? (text) => text : sessionStartEnvelope;
   try {
     let root;
     if (hook) {
       let cwd;
       try {
-        const payload = JSON.parse(readFileSync9(0, "utf8"));
+        const payload = JSON.parse(readFileSync13(0, "utf8"));
         cwd = payload.cwd ?? payload.workspace_roots?.[0] ?? payload.workspaceRoots?.[0];
       } catch {
       }
@@ -15885,22 +16864,19 @@ async function constraintsMain(argv) {
     } else {
       root = await repoRoot();
     }
-    const q = new URLSearchParams({ root, limit: "5" });
-    if (brainOverride) q.set("brain", brainOverride);
-    const r = await captureApi(
-      `/capture/constraints?${q}`
-    );
-    if (!r.brainId) {
+    const brainId = brainOverride ?? (await captureProject(root))?.brainId;
+    if (!brainId) {
       if (!hook) {
-        console.error(
-          `brainjar: no Brain is connected to ${root}. Pass --brain <id> or run \`npx brainjar init\` first.`
-        );
+        console.error(notConnected(root));
         process.exitCode = 1;
       }
       return;
     }
-    const envelope = argv.includes("--copilot") ? copilotContextEnvelope : sessionStartEnvelope;
+    const r = await captureApi(
+      `/capture/constraints?brain=${encodeURIComponent(brainId)}&limit=5`
+    );
     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) {
@@ -15911,7 +16887,12 @@ async function constraintsMain(argv) {
       }
     }
   } catch (e) {
-    console.error("brainjar constraints:", e);
+    if (hook && e instanceof TokenError) console.log(envelope(e.message));
+    else
+      console.error(
+        "brainjar constraints:",
+        e instanceof Error ? e.message : e
+      );
     if (!hook) process.exitCode = 1;
   }
 }
@@ -15921,6 +16902,7 @@ var init_constraints = __esm({
     init_src3();
     init_api_client();
     init_copilot();
+    init_cline();
   }
 });
 
@@ -15972,22 +16954,27 @@ async function runDoctor(root, opts = {}) {
       `${serverUrl()} unreachable (${String(e).slice(0, 120)})`
     );
   }
+  const link = await captureProject(root);
   if (serverOk) {
     try {
-      const project = await captureApi(`/capture/project?root=${encodeURIComponent(root)}`);
+      const project = await captureApi(
+        link ? `/capture/project?brain=${link.brainId}&source=${link.sourceId}` : "/capture/project"
+      );
       add("token", true, "accepted");
       add(
         "brain",
         project.brainId !== null,
-        project.brainId !== null ? `${project.brainId} (${project.objects ?? 0} memory objects)` : "no Brain connected to this repo. Run npx brainjar init"
+        project.brainId !== null ? `${project.brainId} (${project.objects ?? 0} memory objects)` : "not connected on this machine. Run npx brainjar init --brain <id>"
       );
     } catch (e) {
-      add(
-        "token",
-        false,
-        String(e instanceof Error ? e.message : e).slice(0, 160)
-      );
-      add("brain", false, "skipped (token rejected)");
+      const msg = String(e instanceof Error ? e.message : e).slice(0, 200);
+      if (e instanceof TokenError) {
+        add("token", false, msg);
+        add("brain", false, "skipped (token rejected)");
+      } else {
+        add("token", true, "accepted");
+        add("brain", false, msg);
+      }
     }
   } else {
     add("token", false, "skipped (server unreachable)");
@@ -16072,8 +17059,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();
@@ -16110,7 +17097,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);
   }
@@ -16118,11 +17105,9 @@ async function walkCandidates(root) {
 }
 async function deepscanMain() {
   const root = await repoRoot();
-  const project = await captureApi(`/capture/project?root=${encodeURIComponent(root)}`);
-  if (!project.brainId || !project.sourceId) {
-    console.error(
-      `brainjar: no Brain is connected to ${root} \u2014 run \`npx brainjar init\` first`
-    );
+  const project = await captureProject(root);
+  if (!project) {
+    console.error(notConnected(root));
     process.exitCode = 1;
     return;
   }
@@ -16135,10 +17120,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",
@@ -16166,7 +17151,7 @@ async function deepscanMain() {
       {
         method: "POST",
         body: {
-          root,
+          brain: project.brainId,
           sourceId: project.sourceId,
           artifacts: chunk,
           // Only the final chunk kicks the server-side synthesis: one scan per run.