@100xprompt/brain 0.1.4 → 0.1.6

package/src/gateway/connectors/antigravity.ts

@@ -1,6 +1,206 @@
-// Gateway connector for Antigravity: none. The IDE's agent runs in Google's `agy` language server against Google's backend
-// with a fixed model list; neither Antigravity IDE 1.107.0 (extensions/agy/package.json settings) nor its docs offer an
-// endpoint or key, and a settings.json "openai-compatible" attempt went unanswered (https://discuss.ai.google.dev/t/168654, 2026-06-01).
-import type { Connector } from "../common.ts"
+// Gateway connector for Antigravity (macOS): a launcher app, "Antigravity with 100xprompt", that opens Antigravity with its
+// agent on the gateway.
+//
+// Antigravity's agent is Google's `agy` (~/.gemini/bin/agy; the IDE starts it as `agy --hub`, passing its own environment).
+// agy 1.5 has an LLM gateway mode that only environment variables turn on (checked 2026-11-11 against agy 1.5.5 by running
+// it against a local stand-in for the gateway, with every other connection refused):
+//   AGY_LLM_GATEWAY_URL        the gateway's base: agy lists models with GET <base>/v1beta/models and calls
+//                              POST <base>/v1beta/models/<id>:streamGenerateContent?alt=sse (the Gemini API's shape,
+//                              wire protocol "genai", the default; "openai" is the other)
+//   AGY_LLM_GATEWAY_API_KEY    sent as `Authorization: Bearer <key>`; no Google sign-in is needed in this mode
+//   AGY_LLM_GATEWAY_TIER_PRO / _FLASH / _FLASH_LITE   the model ids agy uses for its own tiers (titles, summaries)
+//   (agy sizes a request from the model list: an id it does not know gets 4,096 tokens out and no thinking unless the
+//   gateway's list says more, which is why the gateway answers the list itself, on /flash and on /auto)
+//   AGY_LLM_GATEWAY_HEADERS    extra headers, a JSON object
+// Without them agy uses Google's backend as usual. settings.json has no place for the key (an "env" block there is not
+// read), and the IDE has no setting that reaches agy's environment.
+//
+// So the variables go only to Antigravity, at launch: the launcher runs `open -a "Antigravity IDE" --env ...`, reading the
+// key from brain's key file each time (it is never written into the launcher), and remembers which Antigravity it started.
+// An Antigravity that was already open without them keeps Google's models: the launcher says so instead of pretending.
+// Opening Antigravity the usual way (Dock, Spotlight) is unchanged. A shell-profile export was not used: it would hand the
+// key to every program started from that shell (the same reason as zed.ts).
+import { createHash } from "node:crypto"
+import { join } from "node:path"
+import { AUTO_MODEL, brainDir, EDIT_HEADER, isAuto, keyPath, routeUrl, type Codec, type Connector } from "../common.ts"
 
-export const connectors: Connector[] = []
+export const LAUNCHER_NAME = "Antigravity with 100xprompt"
+const BUNDLE_ID = "com.100xprompt.brain.antigravity"
+/** The names the Antigravity app has had (the launcher opens the first it finds, in /Applications or ~/Applications). */
+const APP_NAMES = ["Antigravity IDE", "Antigravity"]
+const MARK = "brain-antigravity-launcher"
+/** Bumped whenever launcherText changes, so a connect rewrites launchers made by an older brain. */
+const LAUNCHER_FORMAT = 3
+/** The model ids the gateway serves for 100xprompt Pro and Flash (its Gemini routes take them in the path). */
+const PRO = "gemini-3.8-flash"
+const FLASH = "gemini-3.7-flash"
+
+export const launcherApp = (home: string) => join(home, "Applications", `${LAUNCHER_NAME}.app`)
+const launcherScript = (home: string) => join(launcherApp(home), "Contents", "MacOS", "launch")
+const launcherPlist = (home: string) => join(launcherApp(home), "Contents", "Info.plist")
+/** The process id of the Antigravity the launcher started (so a second click only brings it forward). */
+const pidFile = (home: string) => join(brainDir(home), "antigravity-launch.pid")
+
+export interface LaunchSettings {
+  /** The launcher's own format: a newer brain with a changed launcher rewrites it on the next connect. */
+  format: number
+  url: string
+  keyFile: string
+  pidFile: string
+  pro: string
+  flash: string
+  headers?: Record<string, string>
+}
+
+const sq = (s: string) => `'${s.replace(/'/g, `'\\''`)}'`
+
+/** The launcher script for `v`. Its first comment line carries `v` back (codec `get`). No key in it. */
+export function launcherText(v: LaunchSettings): string {
+  const env: Array<[string, string]> = [
+    ["AGY_LLM_GATEWAY_URL", v.url],
+    ["AGY_LLM_GATEWAY_TIER_PRO", v.pro],
+    ["AGY_LLM_GATEWAY_TIER_FLASH", v.flash],
+    ["AGY_LLM_GATEWAY_TIER_FLASH_LITE", v.flash],
+    ...(v.headers && Object.keys(v.headers).length ? ([["AGY_LLM_GATEWAY_HEADERS", JSON.stringify(v.headers)]] as Array<[string, string]>) : []),
+  ]
+  // What Antigravity is started with (not the key): a running one started with other settings is told to restart.
+  const fingerprint = createHash("sha256").update(JSON.stringify(env)).digest("hex").slice(0, 16)
+  const alert = (title: string, text: string) => `osascript -e ${sq(`display alert ${JSON.stringify(title)} message ${JSON.stringify(text)}`)} >/dev/null 2>&1`
+  const apps = APP_NAMES.flatMap((n) => [`/Applications/${n}.app`, `$HOME/Applications/${n}.app`])
+  return [
+    "#!/bin/sh",
+    `# ${MARK} ${JSON.stringify(v)}`,
+    "# Opens Antigravity with its agent on the 100xprompt gateway. Written by `brain gateway connect --tool antigravity`;",
+    "# undo with `brain gateway disconnect --tool antigravity`. The key is read from brain's key file each time and given to",
+    "# Antigravity in open's environment: never kept here, never on a command line.",
+    "umask 077",
+    `pidfile=${sq(v.pidFile)}`,
+    `fp=${sq(fingerprint)}`,
+    "# The Antigravity app here (its name has changed between releases).",
+    'app=""',
+    `for a in ${apps.map((a) => (a.startsWith("$HOME") ? `"${a}"` : sq(a))).join(" ")}; do`,
+    '  if [ -d "$a" ]; then app=$a; break; fi',
+    "done",
+    'if [ -z "$app" ]; then',
+    `  ${alert("Antigravity is not on this computer", `Install Antigravity, then open ${LAUNCHER_NAME} again.`)}`,
+    "  exit 1",
+    "fi",
+    "# This person's own Antigravity only: a process of theirs whose command line starts with the app's binary.",
+    "app_pid() {",
+    '  for p in $(pgrep -U "$(id -u)" -f "/Contents/MacOS/"); do',
+    '    case "$(ps -o command= -p "$p" 2>/dev/null)" in "$app"/Contents/MacOS/*) echo "$p"; return 0 ;; esac',
+    "  done",
+    "}",
+    "pid=$(app_pid)",
+    'if [ -n "$pid" ]; then',
+    '  was_pid=""; was_fp=""',
+    '  if [ -f "$pidfile" ]; then read -r was_pid was_fp < "$pidfile"; fi',
+    '  if [ "$pid" = "$was_pid" ]; then',
+    `    [ "$fp" = "$was_fp" ] || ${alert("Antigravity is on older 100xprompt settings", `Your 100xprompt settings changed after Antigravity started. Quit Antigravity, then open ${LAUNCHER_NAME} again to use them.`)}`,
+    '    exec open -a "$app"',
+    "  fi",
+    `  ${alert("Antigravity is already open", `It uses 100xprompt models only when it starts from ${LAUNCHER_NAME}. Quit Antigravity, then open ${LAUNCHER_NAME} again.`)}`,
+    '  exec open -a "$app"',
+    "fi",
+    `key=$(head -n 1 ${sq(v.keyFile)} 2>/dev/null)`,
+    'if [ -z "$key" ]; then',
+    `  ${alert(LAUNCHER_NAME, "brain is not signed in to 100xprompt. Run: brain gateway login, then open this again.")}`,
+    "  exit 1",
+    "fi",
+    'out=$(AGY_LLM_GATEWAY_API_KEY="$key" open -a "$app" \\',
+    ...env.map(([k, val]) => `  --env ${sq(`${k}=${val}`)} \\`),
+    '  2>&1); rc=$?',
+    'case "$out" in *"already running"*|*"could not be set"*) rc=2 ;; esac',
+    'if [ "$rc" -ne 0 ]; then',
+    `  ${alert("Antigravity did not open on 100xprompt", `macOS could not start Antigravity with 100xprompt's settings (it may already be running). Quit Antigravity, then open ${LAUNCHER_NAME} again.`)}`,
+    "  exit 1",
+    "fi",
+    "i=0",
+    'while [ $i -lt 20 ]; do',
+    '  pid=$(app_pid); if [ -n "$pid" ]; then echo "$pid $fp" > "$pidfile"; exit 0; fi',
+    "  i=$((i + 1)); sleep 0.5",
+    "done",
+    "",
+  ].join("\n")
+}
+
+/** The launcher's Info.plist: a background app (no Dock icon of its own) that only starts Antigravity. */
+export function plistText(v: { name: string; id: string }): string {
+  const esc = (s: string) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    `<!-- ${MARK} ${JSON.stringify(v)} -->`,
+    '<plist version="1.0">',
+    "<dict>",
+    "  <key>CFBundleExecutable</key><string>launch</string>",
+    `  <key>CFBundleIdentifier</key><string>${esc(v.id)}</string>`,
+    `  <key>CFBundleName</key><string>${esc(v.name)}</string>`,
+    `  <key>CFBundleDisplayName</key><string>${esc(v.name)}</string>`,
+    "  <key>CFBundlePackageType</key><string>APPL</string>",
+    "  <key>CFBundleShortVersionString</key><string>1.0</string>",
+    "  <key>LSUIElement</key><true/>",
+    "</dict>",
+    "</plist>",
+    "",
+  ].join("\n")
+}
+
+/** A file brain writes whole: one key, whose value is carried in the file's marker line. Anyone else's file is left alone. */
+function wholeFile(key: string, render: (v: any) => string): Codec {
+  const marker = new RegExp(`${MARK} (\\{.*\\})`)
+  return {
+    check(text) {
+      return text.trim() && !marker.test(text) ? `it is not brain's ${LAUNCHER_NAME} launcher; left as it is` : undefined
+    },
+    get(text, k) {
+      if (k !== key) return undefined
+      const m = marker.exec(text)
+      if (!m) return undefined
+      try {
+        return JSON.parse(m[1]!)
+      } catch {
+        return undefined
+      }
+    },
+    set(_text, k, value) {
+      if (k !== key) throw new Error(`unknown launcher key ${k}`)
+      return value === undefined ? "" : render(value)
+    },
+  }
+}
+
+const antigravity: Connector = {
+  id: "antigravity",
+  label: "Antigravity",
+  file: (home) => launcherScript(home),
+  probe: [".gemini/bin/agy", ".gemini/antigravity"],
+  authHeader: "authorization",
+  edits: (home, s) => {
+    // Antigravity lists the route's models (Pro and Flash; on the auto route, auto alone) and calls the Gemini API's paths
+    // there. Its own tiers (titles, summaries) get Pro and Flash, or auto.
+    const auto = isAuto(s)
+    const launch: LaunchSettings = {
+      format: LAUNCHER_FORMAT,
+      url: routeUrl(s),
+      keyFile: keyPath(home),
+      pidFile: pidFile(home),
+      pro: auto ? AUTO_MODEL : PRO,
+      flash: auto ? AUTO_MODEL : FLASH,
+      ...(s.contextEdit ? { headers: { [EDIT_HEADER]: "on" } } : {}),
+    }
+    return [
+      { path: launcherPlist(home), format: "custom", codec: wholeFile("bundle", plistText), values: { bundle: { name: LAUNCHER_NAME, id: BUNDLE_ID } } },
+      { path: launcherScript(home), format: "custom", codec: wholeFile("launch", launcherText), values: { launch }, mode: 0o700 },
+    ]
+  },
+  notes: [
+    `open Antigravity from "${LAUNCHER_NAME}" (in ~/Applications; Spotlight finds it) to use 100xprompt's models; its model menu then lists them. Opened the usual way, Antigravity keeps Google's models.`,
+    "quit Antigravity first if it is open: the launcher can only give 100xprompt to an Antigravity it starts.",
+    "the key is read from brain's key file each time the launcher runs and given to Antigravity in its environment; it is not written into the launcher, nor put on a command line.",
+  ],
+  leftovers: (home) => [pidFile(home)],
+  stillRunning: "an Antigravity started from the launcher keeps using 100xprompt (with the key it started with) until you quit it.",
+}
+
+export const connectors: Connector[] = process.platform === "darwin" ? [antigravity] : []

package/src/gateway/connectors/claude-desktop.ts

@@ -0,0 +1,169 @@
+// Gateway connector for Claude Desktop (macOS): its own third-party mode, "Claude (third-party)", pointed at the gateway.
+//
+// Checked 2026-11-11 in Claude 4.23118.0 (app.asar, read only), and with the app's bundled Claude Code (2.1.317) against
+// the gateway's code:
+//   - Signed in with a Claude account the app talks to Anthropic only, and sets ANTHROPIC_BASE_URL for its Claude Code
+//     itself (so Claude Code's own settings do not move it).
+//   - Its third-party mode takes a gateway ("Configure Third-Party Inference…", or an admin's managed preferences): a
+//     config library in ~/Library/Application Support/Claude-3p/configLibrary, `_meta.json` ({appliedId, entries:
+//     [{id, name}]}) naming the applied `<id>.json`, whose flat keys are the settings: inferenceProvider "gateway",
+//     inferenceGatewayBaseUrl, inferenceCredentialKind "helper-script" + inferenceCredentialHelper (a program that prints
+//     the key; the app caches it for inferenceCredentialHelperTtlSec), inferenceGatewayAuthScheme "bearer",
+//     modelDiscoveryEnabled, inferenceModels ([{name, labelOverride, supports1m, prefer1m, anthropicFamilyTier}]),
+//     inferenceCustomHeaders ({name: value}).
+//   - The app gives its Claude Code ANTHROPIC_BASE_URL = the gateway, ANTHROPIC_AUTH_TOKEN = the helper's output and
+//     the model's name; Claude Code posts the Messages API to <base>/v1/messages, which the gateway's routes serve.
+//   - A model's name must read as an Anthropic model (contain claude, opus, sonnet, haiku or anthropic; never gemini and
+//     the like): so `anthropic/100x-pro` and `anthropic/100x-flash` (the gateway serves a name with "pro" as Pro and any
+//     other as Flash; the auto route serves any name), shown in the menu by their 100xprompt names (labelOverride). With
+//     "[1m]" (supports1m) Claude Code takes the 1M window the models have.
+//   - Third-party mode is a separate profile (its own sessions and settings, in Claude-3p). The app starts in it when a
+//     third-party configuration is applied and the person has not chosen their Claude account there; signing in with the
+//     Claude account again goes back.
+// brain writes its own entry (a fixed id) and applies it; the key never goes into the app's files: the helper reads it
+// from brain's key file each time the app asks.
+import { join } from "node:path"
+import { savedMode } from "../../adapters/claude-desktop/records.ts"
+import { AUTO_MODEL, brainDir, EDIT_HEADER, isAuto, keyPath, routeUrl, type Codec, type Connector } from "../common.ts"
+
+/** brain's entry in the app's config library (a UUID, as the app requires). */
+export const ENTRY_ID = "b7a1e0c0-0100-4000-8000-000000000100"
+const ENTRY_NAME = "100xprompt"
+const MARK = "brain-claude-desktop-key"
+
+export const thirdPartyDir = (home: string) => join(home, "Library", "Application Support", "Claude-3p")
+const libraryDir = (home: string) => join(thirdPartyDir(home), "configLibrary")
+export const metaPath = (home: string) => join(libraryDir(home), "_meta.json")
+export const entryPath = (home: string) => join(libraryDir(home), `${ENTRY_ID}.json`)
+export const helperPath = (home: string) => join(brainDir(home), "bin", "claude-desktop-key")
+
+/** The names the app sends; the gateway serves a name with "pro" as Pro, any other as Flash, and the auto route any. */
+const PRO = { name: "anthropic/100x-pro", labelOverride: "100xprompt Pro", supports1m: true, prefer1m: true, anthropicFamilyTier: "sonnet" }
+const FLASH = { name: "anthropic/100x-flash", labelOverride: "100xprompt Flash", supports1m: true, prefer1m: true, anthropicFamilyTier: "haiku" }
+const AUTO = { name: `anthropic/${AUTO_MODEL}`, labelOverride: "100xprompt Auto", supports1m: true, prefer1m: true, anthropicFamilyTier: "sonnet" }
+
+/** The helper the app runs for the key: it prints the first line of brain's key file. No key in it. */
+export function helperText(v: { keyFile: string }): string {
+  const sq = (s: string) => `'${s.replace(/'/g, `'\\''`)}'`
+  return [
+    "#!/bin/sh",
+    `# ${MARK} ${JSON.stringify(v)}`,
+    "# Prints the 100xprompt gateway key for Claude Desktop's third-party mode (its credential helper). Written by",
+    "# `brain gateway connect --tool claude-desktop`; undo with `brain gateway disconnect --tool claude-desktop`.",
+    `exec head -n 1 ${sq(v.keyFile)}`,
+    "",
+  ].join("\n")
+}
+
+/** The helper script, which brain writes whole; anyone else's file there is left alone. */
+const helperCodec: Codec = {
+  check(text) {
+    return text.trim() && !text.includes(MARK) ? "it is not brain's key helper; left as it is" : undefined
+  },
+  get(text, key) {
+    if (key !== "helper") return undefined
+    const m = new RegExp(`${MARK} (\\{.*\\})`).exec(text)
+    try {
+      return m ? JSON.parse(m[1]!) : undefined
+    } catch {
+      return undefined
+    }
+  },
+  set(_text, key, value) {
+    if (key !== "helper") throw new Error(`unknown helper key ${key}`)
+    return value === undefined ? "" : helperText(value as { keyFile: string })
+  },
+}
+
+type Meta = { appliedId: string; entries: Array<{ id: string; name: string; [k: string]: unknown }>; [k: string]: unknown }
+const parseMeta = (text: string): Meta => {
+  if (!text.trim()) return { appliedId: "", entries: [] }
+  const j = JSON.parse(text)
+  return { ...j, appliedId: typeof j.appliedId === "string" ? j.appliedId : "", entries: Array.isArray(j.entries) ? j.entries : [] }
+}
+
+/**
+ * The config library's list (`_meta.json`): brain's entry in it ("entry") and which entry is applied ("appliedId"). The
+ * person's own entries and anything else the app keeps there are left as they are. A list left with nothing in it is
+ * written empty, so a disconnect takes away a file only connect made.
+ */
+const metaCodec: Codec = {
+  check(text) {
+    if (!text.trim()) return undefined
+    try {
+      const j = JSON.parse(text)
+      if (!j || typeof j !== "object" || Array.isArray(j) || (j.entries !== undefined && !Array.isArray(j.entries))) return "it is not the app's config list; left as it is"
+    } catch {
+      return "it is not valid JSON; left as it is"
+    }
+    return undefined
+  },
+  get(text, key) {
+    const m = parseMeta(text)
+    // brain's entry by its id alone: renamed in the app, it is still brain's (and goes with brain's file at disconnect).
+    if (key === "entry") return m.entries.some((e) => e?.id === ENTRY_ID) ? { id: ENTRY_ID, name: ENTRY_NAME } : undefined
+    if (key === "appliedId") return text.trim() ? m.appliedId : undefined
+    return undefined
+  },
+  set(text, key, value) {
+    const m = parseMeta(text)
+    if (key === "entry") {
+      const at = m.entries.findIndex((e) => e?.id === ENTRY_ID)
+      if (value === undefined) {
+        if (at >= 0) m.entries.splice(at, 1)
+      } else if (at >= 0) m.entries[at] = value as Meta["entries"][number]
+      else m.entries.push(value as Meta["entries"][number])
+    } else if (key === "appliedId") {
+      // Never an id the list no longer has (the person deleted that configuration in the app meanwhile).
+      const id = typeof value === "string" ? value : ""
+      m.appliedId = id && m.entries.some((e) => e?.id === id) ? id : ""
+    }
+    else throw new Error(`unknown config list key ${key}`)
+    const rest = Object.keys(m).filter((k) => k !== "appliedId" && k !== "entries")
+    if (!m.entries.length && !m.appliedId && !rest.length) return ""
+    return `${JSON.stringify(m, null, 2)}\n`
+  },
+}
+
+const claudeDesktop: Connector = {
+  id: "claude-desktop",
+  label: "Claude Desktop",
+  file: (home) => entryPath(home),
+  probe: ["Library/Application Support/Claude"],
+  authHeader: "authorization",
+  edits: (home, s) => {
+    const auto = isAuto(s)
+    // The model the person chose comes first: the app starts a session on the first in the list.
+    const models = auto ? [AUTO] : s.model === "gemini-3.7-flash" ? [FLASH, PRO] : [PRO, FLASH]
+    return [
+      { path: helperPath(home), format: "custom", codec: helperCodec, values: { helper: { keyFile: keyPath(home) } }, mode: 0o700 },
+      {
+        path: entryPath(home),
+        format: "json",
+        values: {
+          inferenceProvider: "gateway",
+          inferenceGatewayBaseUrl: routeUrl(s),
+          inferenceGatewayAuthScheme: "bearer",
+          inferenceCredentialKind: "helper-script",
+          inferenceCredentialHelper: helperPath(home),
+          inferenceCredentialHelperTtlSec: 3600,
+          modelDiscoveryEnabled: false,
+          inferenceModels: models,
+          ...(s.contextEdit ? { inferenceCustomHeaders: { [EDIT_HEADER]: "on" } } : {}),
+        },
+      },
+      { path: metaPath(home), format: "custom", codec: metaCodec, values: { entry: { id: ENTRY_ID, name: ENTRY_NAME }, appliedId: ENTRY_ID } },
+    ]
+  },
+  notesHere: (home) =>
+    savedMode(home) === "1p"
+      ? ["Claude Desktop is set to start on your Claude account (you chose it in the app), so it keeps doing that: to use 100xprompt, choose Configure Third-Party Inference… in Claude's menu and switch to it there."]
+      : [],
+  notes: [
+    "this sets up Claude Desktop's third-party mode, \"Claude (third-party)\": a separate profile with its own sessions, on 100xprompt's models (shown as 100xprompt Pro and Flash, or Auto). Your Claude account's sessions stay where they are.",
+    "quit Claude and open it again: it starts in third-party mode. To go back to your Claude account, sign in with it again in the app; `brain gateway disconnect --tool claude-desktop` takes the setup away.",
+    "the key is read from brain's key file each time the app asks (its credential helper); it is not written into the app's files.",
+  ],
+}
+
+export const connectors: Connector[] = process.platform === "darwin" ? [claudeDesktop] : []

package/src/gateway/connectors/index.ts

@@ -31,6 +31,7 @@ import { connectors as c_cursor_cli } from "./cursor-cli.ts"
 import { connectors as c_copilot_cli } from "./copilot-cli.ts"
 import { connectors as c_windsurf } from "./windsurf.ts"
 import { connectors as c_antigravity } from "./antigravity.ts"
+import { connectors as c_claude_desktop } from "./claude-desktop.ts"
 import { connectors as c_amazon_q_cli } from "./amazon-q-cli.ts"
 import { connectors as c_amazon_q_ide } from "./amazon-q-ide.ts"
 import { connectors as c_kiro_cli } from "./kiro-cli.ts"
@@ -73,6 +74,7 @@ export const EXTRA_CONNECTORS: Connector[] = [
   ...c_copilot_cli,
   ...c_windsurf,
   ...c_antigravity,
+  ...c_claude_desktop,
   ...c_amazon_q_cli,
   ...c_amazon_q_ide,
   ...c_kiro_cli,

package/src/handoff.ts

@@ -72,12 +72,28 @@ function sameProject(h: Handoff, cwd: string, gitRemote?: string): boolean {
 const claimPath = (home: string, id: string, tool: string) => join(handoffDir(home), `${id}.${tool}.claimed`)
 
 /** The newest unexpired handoff for this project that `tool` has not received yet. */
-export function findHandoff(home: string, q: { cwd: string; tool: string; gitRemote?: string; now?: number }): Handoff | undefined {
+/**
+ * Desktop apps that run a CLI's session-start hook (the same agent inside): a brief for the app is delivered by that hook.
+ * Claude Desktop's Code tab runs Claude Code's hooks; the Codex app runs Codex's.
+ */
+export const HOOK_TOOL: Record<string, string> = { "claude-desktop": "claude-code", "codex-desktop": "codex" }
+
+/**
+ * Whether the hook running is the desktop app's (its Claude Code says so in CLAUDE_CODE_ENTRYPOINT: "claude-desktop",
+ * "claude-desktop-3p"). The Codex app's hook cannot be told from the CLI's, so a brief for the Codex app goes to either.
+ */
+export const fromDesktopApp = (target: string, env: Record<string, string | undefined> = process.env) =>
+  target !== "claude-desktop" || /^claude-desktop/.test(env.CLAUDE_CODE_ENTRYPOINT ?? "")
+
+export function findHandoff(
+  home: string,
+  q: { cwd: string; tool: string; gitRemote?: string; now?: number; env?: Record<string, string | undefined> },
+): Handoff | undefined {
   const now = q.now ?? Date.now()
   return listHandoffs(home).find(
     (h) =>
       Date.parse(h.expiresAt) > now &&
-      (h.target === q.tool || h.target === "any") &&
+      (h.target === q.tool || h.target === "any" || (HOOK_TOOL[h.target] === q.tool && fromDesktopApp(h.target, q.env))) &&
       !h.consumedBy.includes(q.tool) &&
       !existsSync(claimPath(home, h.id, q.tool)) &&
       sameProject(h, q.cwd, q.gitRemote),

package/src/hooks.ts

@@ -3,7 +3,7 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync, statSy
 import { dirname, join } from "node:path"
 import { toolLabel } from "./brief.ts"
 import { gitInfo, isDir, writeAtomic } from "./fsutil.ts"
-import { findHandoff, type Handoff, markConsumed } from "./handoff.ts"
+import { findHandoff, type Handoff, HOOK_TOOL, markConsumed } from "./handoff.ts"
 import { syncInBackground } from "./memory/sync.ts"
 import { withBrainLock } from "./lock.ts"
 
@@ -150,7 +150,7 @@ function tomlHasHooks(toml: string): boolean {
 }
 
 /** "cursor" is what `continue --in` calls Cursor; its handoffs are recorded for "cursor-ide". */
-const toolId = (tool: string) => (tool === "cursor" ? "cursor-ide" : tool)
+const toolId = (tool: string) => (tool === "cursor" ? "cursor-ide" : HOOK_TOOL[tool] ?? tool)
 
 const sh = (s: string) => (/^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`)
 

package/src/lock.ts

@@ -93,6 +93,9 @@ export function processStart(pid: number, now = Date.now()): number | undefined
 let started: number | undefined
 const myStart = () => (started ??= processStart(process.pid) ?? Math.round(performance.timeOrigin))
 
+/** This process's start, as holderGone() judges this process (what a loop records to be judged alive by itself too). */
+export const ownStart = () => myStart()
+
 function readOwner(home: string): LockOwner | undefined {
   try {
     const o = JSON.parse(readFileSync(ownerPath(home), "utf8"))

package/src/memory/mcp-install.ts

@@ -31,6 +31,11 @@ export interface McpTool {
 
 const plain = (command: string, args: string[]): Json => ({ command, args })
 
+/** The Claude app's folder, from home (its own MCP settings, claude_desktop_config.json, are there). */
+function claudeDesktopDir(): string {
+  return process.platform === "darwin" ? "Library/Application Support/Claude" : process.platform === "win32" ? "AppData/Roaming/Claude" : ".config/Claude"
+}
+
 function vscodeUser(): string {
   return process.platform === "darwin" ? "Library/Application Support/Code/User" : process.platform === "win32" ? "AppData/Roaming/Code/User" : ".config/Code/User"
 }
@@ -38,7 +43,11 @@ function vscodeUser(): string {
 export const MCP_TOOLS: McpTool[] = [
   { id: "claude-code", label: "Claude Code", file: ".claude.json", probe: [".claude.json", ".claude"], format: "json", key: "mcpServers", entry: plain },
   { id: "codex", label: "Codex", file: ".codex/config.toml", probe: [".codex"], format: "toml" },
+  // Claude Desktop: its chats and its Code tab's local tools.
+  { id: "claude-desktop", label: "Claude Desktop", file: `${claudeDesktopDir()}/claude_desktop_config.json`, probe: [`${claudeDesktopDir()}/claude_desktop_config.json`, claudeDesktopDir()], format: "json", key: "mcpServers", entry: plain },
   { id: "cursor", label: "Cursor", file: ".cursor/mcp.json", probe: [".cursor"], format: "json", key: "mcpServers", entry: plain },
+  // Antigravity (Google): its agent's MCP servers.
+  { id: "antigravity", label: "Antigravity", file: ".gemini/antigravity/mcp_config.json", probe: [".gemini/antigravity/mcp_config.json", ".gemini/antigravity"], format: "json", key: "mcpServers", entry: plain },
   { id: "gemini", label: "Gemini CLI", file: ".gemini/settings.json", probe: [".gemini"], format: "json", key: "mcpServers", entry: plain },
   {
     id: "opencode",

package/src/memory/sync.ts

@@ -5,6 +5,7 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
 import { gitInfo } from "../fsutil.ts"
+import type { SessionRef } from "../adapters/types.ts"
 import type { Session } from "../session/types.ts"
 import { distill } from "./distill.ts"
 import { projectKey } from "./project.ts"
@@ -17,6 +18,8 @@ export interface SessionSource {
   id: string
   cwd?: string
   updatedAt?: string
+  /** Ids the same session was listed under before (a desktop app's session that brain once listed as its CLI's). */
+  formerIds?: string[]
   read(): Promise<Session>
 }
 
@@ -104,7 +107,20 @@ async function defaultSessions(home: string): Promise<SessionSource[]> {
   const lists = await Promise.all(READERS.map((r) => r.list(home).then((refs) => refs.map((ref) => ({ r, ref }))).catch(() => [])))
   return lists
     .flat()
-    .map(({ r, ref }) => ({ id: `${ref.tool}:${ref.sourceId}`, ...(ref.cwd ? { cwd: ref.cwd } : {}), ...(ref.updatedAt ? { updatedAt: ref.updatedAt } : {}), read: () => r.read(ref, home) }))
+    .map(({ r, ref }) => {
+      const former = formerIds(ref)
+      return { id: `${ref.tool}:${ref.sourceId}`, ...(ref.cwd ? { cwd: ref.cwd } : {}), ...(ref.updatedAt ? { updatedAt: ref.updatedAt } : {}), ...(former.length ? { formerIds: former } : {}), read: () => r.read(ref, home) }
+    })
+}
+
+/** The ids a session was synced under before brain told the desktop apps apart from their CLIs. */
+function formerIds(ref: SessionRef): string[] {
+  if (ref.tool === "claude-desktop") {
+    const ids = [ref.extra?.cliSessionId, ...(Array.isArray(ref.extra?.priorCliSessionIds) ? ref.extra.priorCliSessionIds : [])]
+    return ids.filter((x): x is string => typeof x === "string").map((x) => `claude-code:${x}`)
+  }
+  if (ref.tool === "codex-desktop") return [`codex:${ref.sourceId}`]
+  return []
 }
 
 export async function syncMemory(o: SyncOptions, deps: { memory?: Memory; sessions?: () => Promise<SessionSource[]>; now?: () => number } = {}): Promise<SyncResult> {
@@ -135,9 +151,15 @@ export async function syncMemory(o: SyncOptions, deps: { memory?: Memory; sessio
       try {
         const session = await s.read()
         const items = distill(session)
-        if (items.length) {
+        const former = (s.formerIds ?? []).filter((id) => ledger[id])
+        if (items.length || former.length) {
           const key = projectKey({ ...session.header.project, ...(session.header.project.cwd ? gitInfo(session.header.project.cwd) : {}) })
-          await memory.ingest(key, items)
+          // What was learned from this session under its old id goes, so it is not kept twice (item ids hash the session id).
+          for (const id of former) {
+            await memory.forget(key, { source: id })
+            delete ledger[id]
+          }
+          if (items.length) await memory.ingest(key, items)
         }
         ledger[s.id] = { u: s.updatedAt ?? "none", n: items.length }
         result.ingested++