@100xprompt/brain 0.1.4 → 0.1.6

package/README.md

@@ -116,6 +116,8 @@ brain gateway logout
 | OpenCode (`opencode`) | reads brain's key file | yes | yes |
 | Gemini CLI (`gemini-cli`) | copy in `~/.gemini/.env`, private | no | yes (needs the gateway update that accepts `x-goog-api-key`) |
 | Aider (`aider`) | copy in its model settings, private | yes | yes |
+| Claude Desktop (`claude-desktop`, macOS) | its third-party mode's credential helper (`~/.brain/bin/claude-desktop-key`) reads brain's key file each time | yes | the app's own Claude Code (2.1.317) against the gateway's code; the app itself once you quit and reopen it |
+| Antigravity (`antigravity`, macOS) | its launcher, "Antigravity with 100xprompt" in `~/Applications`, reads brain's key file each time it starts Antigravity | yes | its agent (`agy` 1.5.5) against a local stand-in; the IDE through the launcher not yet (needs the gateway update with the model lists) |
 | Cline CLI (`cline-sdk`) | copy in its providers file, private | yes | yes |
 | Continue (`continue`) | copy in `~/.continue/.env`, private | yes | yes (`cn`) |
 | Copilot CLI (`copilot-cli`) | copy in its providers file, private | yes | yes |
@@ -141,12 +143,24 @@ brain gateway logout
 route with the key and the gateway's model, and `disconnect` gave every file back byte for byte (its original mode too).
 
 Some tools cannot be pointed at the gateway from a file brain can safely write and cleanly undo, so they have no connector:
-Cursor and the Cursor CLI, Windsurf, Antigravity, Amazon Q, Kiro, Auggie, Tabnine, Devin and Muse Code (their vendor's own
+Cursor and the Cursor CLI, Windsurf, Amazon Q, Kiro, Auggie, Tabnine, Devin and Muse Code (their vendor's own
 servers only); Zed (the key only in the keychain or its launch environment); Void (settings encrypted in the app's state);
 Roo Code and the Cline extension (they keep the key in the editor's own storage, so disconnect could not take it back);
 Codebuff and Qoder (custom endpoints only through their own sign-in or the keychain). The reason and its source are in each
 tool's file under `src/gateway/connectors/`.
 
+Claude Desktop connects through its own third-party mode, "Claude (third-party)": brain adds its entry to the app's
+third-party configurations and applies it, with a credential helper that prints the key from brain's key file. The app
+names gateway models as Anthropic ones, so the menu's 100xprompt Pro and Flash (or Auto) are sent as `anthropic/100x-pro`
+and `anthropic/100x-flash`. Third-party mode is a separate profile with its own sessions: quit Claude and open it again to
+start in it; sign in with your Claude account in the app to go back.
+
+Antigravity's agent takes the gateway only from its launch environment, so brain does not change Antigravity itself: it
+writes a launcher app that starts Antigravity with that environment (the key read from brain's key file at that moment,
+never written into the launcher). Open Antigravity from "Antigravity with 100xprompt" to get 100xprompt's models; opened
+the usual way it keeps Google's. If Antigravity is already open, quit it first: the launcher can only give the gateway to
+an Antigravity it starts, and says so when it finds another one running.
+
 Gemini CLI loads only the first `.env` it finds from the project folder up: in a project with its own `.env`, put the
 gateway lines there or export them. Letta Code uses the gateway for its local agents only (cloud agents call models from
 Letta's servers). Tools that read brain's key file stop working after `logout` until the next `login`; Kilo refuses to start
@@ -210,6 +224,31 @@ brain pair            # approve this computer in your 100xprompt account (in the
 brain pair status     # paired or not, and the last exchange with the account
 ```
 
+To have changes you make in the dashboard apply here by themselves, run brain in the background:
+
+```bash
+brain service install    # macOS (launchd) or Linux (systemd --user); every minute it takes and applies dashboard changes
+brain service status     # installed, running, and its last round
+brain service uninstall
+```
+
+It uses the folders and opt-outs your shell had when you last ran a brain command (`~/.brain/env.json`), restarts itself
+when you update brain, and waits longer between tries while you are offline. Its log is `~/.brain/logs/service.log`. Run
+`brain service uninstall` before removing brain (if you forget, it stops by itself). Without it, `brain status` or
+`brain sync` take dashboard changes by hand.
+
+A paired computer also sends its session list (each session's tool, title, project folder name and when; never chat
+text) so the dashboard lists every session, shows the command that opens it (`brain session open <id>`), and can move one
+to another tool with a button. A move from the dashboard runs here through the background service, and by default this
+computer asks you first:
+
+```bash
+brain settings set moves.fromDashboard ask    # ask first (default); allow: move without asking; off: refuse them
+brain settings set reports.sessions off        # stop sending the session list
+brain moves                                    # moves that wait for you here (when there was no way to ask)
+brain session open <id>                        # open a session again in its own tool, in its own folder
+```
+
 Pairing gives this computer its own token (`~/.brain/machine.key`, readable only by you), separate from the gateway key
 your tools use: model keys never read or change settings. A paired computer sends the changes made here to your account
 and takes the ones made there when you run `brain status`, `brain settings` or `brain sync` (a few seconds at most; the
@@ -266,6 +305,7 @@ brain status
 brain settings [list | get | set | unset | history | ids]
 brain sync
 brain pair [status | forget]
+brain service install | uninstall | status
 brain org login | logout | whoami | status | promote | demote | forget | admin ...
 brain expand <id>
 brain --version

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@100xprompt/brain",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "One working session, any AI coding tool: move sessions between Claude Code, Codex, Cursor, Gemini CLI, OpenCode and more, keep what projects learned, spend fewer tokens. Runs on Bun. By 100xprompt.",
   "license": "MIT",
   "author": "Nipurn Agarwal",

package/src/adapters/amazon-q-ide/writer.ts

@@ -314,7 +314,9 @@ export function amazonQWriter(opts: { server?: string; running?: () => boolean }
         way: "native",
         sessionId: historyId,
         written: had ? [file, join(backupDir, basename(file))] : [file],
-        open: `${editor} ${shellQuote(cwd)}   # Amazon Q reopens "${plan.tab.title as string}" when the folder opens; it is also in Amazon Q's History`,
+        // The title goes in the note, never the command: zsh at a prompt does not take # as a comment.
+        open: `${editor} ${shellQuote(cwd)}`,
+        note: `Amazon Q reopens "${plan.tab.title as string}" when the folder opens; it is also in Amazon Q's History`,
         lost: plan.lost,
         dryRun: !!w.dryRun,
       }

package/src/adapters/antigravity/reader.ts

@@ -57,7 +57,15 @@ function pathOfUri(uri: unknown): string | undefined {
   }
 }
 
-const WANTED = ["conversation_id", "title", "workspace_uris", "last_modified_time", "parent_conversation_id"]
+const WANTED = ["conversation_id", "title", "preview", "workspace_uris", "last_modified_time", "parent_conversation_id"]
+
+/** The IDE leaves `title` empty and keeps the person's first words in `preview`: its first line is the title then. */
+function titleOf(r: Record<string, unknown>): string | undefined {
+  if (typeof r.title === "string" && r.title.trim()) return r.title
+  if (typeof r.preview !== "string") return undefined
+  const line = r.preview.split(/\r?\n/).map((l) => l.replace(/\s+/g, " ").trim()).find(Boolean)
+  return line ? (line.length <= 80 ? line : `${line.slice(0, 79)}…`) : undefined
+}
 
 /** Summary rows by conversation id, from whichever of the wanted columns the table has. */
 function summaryRows(d: Database, id?: string): Map<string, Summary> {
@@ -76,8 +84,9 @@ function summaryRows(d: Database, id?: string): Map<string, Summary> {
     } catch {
       // no folder
     }
+    const title = titleOf(r)
     out.set(String(r.conversation_id), {
-      ...(typeof r.title === "string" && r.title.trim() ? { title: r.title } : {}),
+      ...(title ? { title } : {}),
       ...(cwd ? { cwd } : {}),
       ...(sqlTime(r.last_modified_time) ? { updatedAt: sqlTime(r.last_modified_time)! } : {}),
       ...(typeof r.parent_conversation_id === "string" && r.parent_conversation_id ? { parent: r.parent_conversation_id } : {}),
@@ -101,12 +110,19 @@ export const antigravityReader: Reader = {
   label: LABEL,
   async list(home) {
     const found = new Map<string, SessionRef>()
+    // Summaries from every store: the IDE keeps its live conversations in one store and their summaries (titles, folders)
+    // in another, so a conversation takes the summary of its id wherever it is (one with a title first).
+    const sums = new Map<string, Summary>()
+    for (const store of STORES)
+      for (const [id, s] of readSummaries(summariesPath(home, store))) {
+        const had = sums.get(id)
+        if (!had || (!had.title && s.title) || (!had.cwd && s.cwd && !!had.title === !!s.title)) sums.set(id, { ...s, ...(had?.title && !s.title ? { title: had.title } : {}), ...(had?.cwd && !s.cwd ? { cwd: had.cwd } : {}) })
+      }
     for (const store of STORES) {
       const dir = conversationsDir(home, store)
       // Only the SQLite conversations: the IDE's <uuid>.pb files are encrypted.
       const files = ls(dir).filter((n) => CONVERSATION_FILE.test(n))
       if (!files.length) continue
-      const sums = readSummaries(summariesPath(home, store))
       for (const name of files) {
         const id = name.slice(0, -3)
         const path = join(dir, name)
@@ -121,18 +137,20 @@ export const antigravityReader: Reader = {
           ...(updatedAt ? { updatedAt } : {}),
           extra: { store },
         }
-        // The same conversation in two stores: the newer copy.
+        // The same conversation in two stores: the copy written last (its file's time; both share one summary).
         const prev = found.get(id)
-        if (!prev || (ref.updatedAt ?? "") > (prev.updatedAt ?? "")) found.set(id, ref)
+        const fileAt = mtime(path) ?? ""
+        if (!prev || fileAt > String(prev.extra?.fileAt ?? "")) found.set(id, { ...ref, extra: { ...ref.extra, fileAt } })
       }
     }
     return [...found.values()].sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? ""))
   },
-  async read(ref) {
+  async read(ref, home) {
     if (!exists(ref.path)) throw new Error(`Antigravity conversation not found: ${ref.path}`)
     if (statSync(ref.path).size > MAX_DB_BYTES) throw new Error(`Antigravity conversation is larger than ${MAX_DB_BYTES} bytes: ${ref.path}`)
     const id = basename(ref.path).replace(/\.db$/i, "")
-    const s = readSummaries(join(dirname(dirname(ref.path)), "conversation_summaries.db"), id).get(id)
+    // Its own store's summary, else another store's (the IDE keeps them apart).
+    const s = readSummaries(join(dirname(dirname(ref.path)), "conversation_summaries.db"), id).get(id) ?? STORES.map((st) => readSummaries(summariesPath(home, st), id).get(id)).find(Boolean)
     const title = s?.title ?? ref.title
     const cwd = s?.cwd ?? ref.cwd
     const updatedAt = s?.updatedAt ?? ref.updatedAt

package/src/adapters/claude-code/reader.ts

@@ -7,6 +7,7 @@ import { peekCache } from "../../session/peekcache.ts"
 import { clip, header, iso, lossCounter, noteModel, toolKindOf } from "../../session/util.ts"
 import type { Reader, SessionRef } from "../types.ts"
 import { CHAIN_TYPES, CONTINUED_NOTE, FILE_ATTACHMENTS, HOUSEKEEPING, LABEL, SESSION_FILE, TOOL, projectSlug, projectsDir } from "./records.ts"
+import { desktopTranscriptIds } from "../claude-desktop/records.ts"
 
 // Reads Claude Code transcripts: <home>/.claude/projects/<project>/<session>.jsonl, with subagents in
 // <session>/subagents/ and spilled tool outputs in <session>/tool-results/.
@@ -592,10 +593,13 @@ export const claudeCodeReader: Reader = {
     const refs: SessionRef[] = []
     // Peeking opens every transcript; the result is reused while a file's size and time (and its title file's) are unchanged.
     const cache = peekCache(home, "claude-peek", 1)
+    // Sessions Claude Desktop keeps a record of are its sessions (listed as claude-desktop, with the app's titles).
+    const desktop = desktopTranscriptIds(home)
     for (const project of ls(root)) {
       const dir = join(root, project)
       for (const name of ls(dir)) {
         if (!SESSION_FILE.test(name)) continue
+        if (desktop.has(name.slice(0, -".jsonl".length))) continue
         const path = join(dir, name)
         try {
           const st = statSync(path)

package/src/adapters/claude-desktop/index.ts

@@ -0,0 +1,8 @@
+import type { Reader, Writer } from "../types.ts"
+import { claudeDesktopReader } from "./reader.ts"
+import { claudeDesktopNativeWriter } from "./writer.ts"
+
+// Claude Desktop (the Claude app's Code tab): its sessions are Claude Code transcripts the app keeps a record of (title,
+// folder, account). Read from those records; continued into the app as a transcript plus a record (records.ts).
+export const readers: Reader[] = [claudeDesktopReader]
+export const writers: Writer[] = [claudeDesktopNativeWriter]

package/src/adapters/claude-desktop/reader.ts

@@ -0,0 +1,140 @@
+// Claude Desktop's Code sessions: listed from the app's records (their titles, folders, last activity), read from the
+// Claude Code transcripts each record points at (records.ts). A record whose transcript is gone is not offered.
+//
+// A session the app resumed or rewound has several transcripts: the current one (cliSessionId) and the earlier ones
+// (priorCliSessionIds), each holding part of the history. Reading the session reads all of them, oldest first, so a move
+// carries the whole history; an earlier part that is gone is said in `lost`.
+import { existsSync, readdirSync, statSync } from "node:fs"
+import { join } from "node:path"
+import { claudeCodeReader } from "../claude-code/reader.ts"
+import { projectSlug, projectsDir } from "../claude-code/records.ts"
+import type { Reader, SessionRef } from "../types.ts"
+import type { Session, Turn } from "../../session/types.ts"
+import { LABEL, readRecords, TOOL } from "./records.ts"
+
+const iso = (ms?: number) => (typeof ms === "number" && Number.isFinite(ms) && ms > 0 ? new Date(ms).toISOString() : undefined)
+const mtime = (p: string) => {
+  try {
+    return statSync(p).mtimeMs
+  } catch {
+    return undefined
+  }
+}
+
+/** Where transcript `<id>.jsonl` is: in its folder's slug first, else anywhere under ~/.claude/projects. */
+function transcriptFinder(home: string): (id: string, cwd?: string) => string | undefined {
+  let all: Map<string, string> | undefined
+  return (id, cwd) => {
+    if (cwd) {
+      const p = join(projectsDir(home), projectSlug(cwd), `${id}.jsonl`)
+      if (existsSync(p)) return p
+    }
+    if (!all) {
+      all = new Map()
+      try {
+        for (const dir of readdirSync(projectsDir(home)))
+          try {
+            for (const f of readdirSync(join(projectsDir(home), dir))) if (f.endsWith(".jsonl") && !all.has(f)) all.set(f, join(projectsDir(home), dir, f))
+          } catch {}
+      } catch {}
+    }
+    return all.get(`${id}.jsonl`)
+  }
+}
+
+/** The same turn read twice (a transcript that starts with a copy of the one before): same kind, time and content. */
+const turnKey = (t: Turn) => (t.at ? `${t.kind}|${t.at}|${JSON.stringify(t).slice(0, 400)}` : undefined)
+
+/**
+ * The turns of a session's transcripts, oldest transcript first: each turn once, in time order (a turn without a time
+ * stays right after the turn before it in its own transcript).
+ */
+export function mergeTurns(parts: Session[]): Turn[] {
+  const seen = new Set<string>()
+  const out: { t: Turn; i: number; at: string }[] = []
+  let i = 0
+  for (const s of parts) {
+    let last = ""
+    for (const t of s.turns) {
+      if (t.at) last = t.at
+      const k = turnKey(t)
+      if (k) {
+        if (seen.has(k)) continue
+        seen.add(k)
+      }
+      out.push({ t, i: i++, at: last })
+    }
+  }
+  return out.sort((a, b) => a.at.localeCompare(b.at) || a.i - b.i).map((x) => x.t)
+}
+
+const firstAt = (s: Session) => s.turns.find((t) => t.at)?.at ?? s.header.startedAt ?? ""
+
+export const claudeDesktopReader: Reader = {
+  tool: TOOL,
+  label: LABEL,
+
+  async list(home: string): Promise<SessionRef[]> {
+    const find = transcriptFinder(home)
+    const refs: SessionRef[] = []
+    for (const r of readRecords(home)) {
+      if (!r.cliSessionId) continue
+      const path = find(r.cliSessionId, r.cwd)
+      if (!path) continue
+      // `claude --resume <id>` in a terminal adds to the same transcript without touching the app's record: the session's
+      // last activity is whichever is later.
+      const at = Math.max(r.lastActivityAt ?? 0, mtime(path) ?? 0)
+      refs.push({
+        tool: TOOL,
+        sourceId: r.sessionId,
+        path,
+        ...(r.title ? { title: r.title } : {}),
+        ...(r.cwd ? { cwd: r.cwd } : {}),
+        ...(iso(at) ? { updatedAt: iso(at) } : {}),
+        extra: { cliSessionId: r.cliSessionId, ...(r.priorCliSessionIds.length ? { priorCliSessionIds: r.priorCliSessionIds } : {}), archived: r.isArchived },
+      })
+    }
+    return refs
+  },
+
+  async read(ref: SessionRef, home: string): Promise<Session> {
+    const cli = typeof ref.extra?.cliSessionId === "string" ? ref.extra.cliSessionId : undefined
+    const s = await claudeCodeReader.read({ tool: "claude-code", sourceId: cli ?? ref.sourceId, path: ref.path }, home)
+    const priors = Array.isArray(ref.extra?.priorCliSessionIds) ? (ref.extra.priorCliSessionIds as unknown[]).filter((x): x is string => typeof x === "string" && x !== cli) : []
+    if (priors.length) {
+      const find = transcriptFinder(home)
+      const parts: Session[] = []
+      const gone: string[] = []
+      for (const id of [...new Set(priors)]) {
+        const path = find(id, s.header.project.cwd ?? ref.cwd)
+        if (!path) {
+          gone.push(id)
+          continue
+        }
+        try {
+          parts.push(await claudeCodeReader.read({ tool: "claude-code", sourceId: id, path }, home))
+        } catch {
+          gone.push(id)
+        }
+      }
+      parts.sort((a, b) => firstAt(a).localeCompare(firstAt(b)))
+      if (parts.length) {
+        s.turns = mergeTurns([...parts, s])
+        s.children = [...parts.flatMap((p) => p.children ?? []), ...(s.children ?? [])]
+        s.header.models = [...new Set([...parts.flatMap((p) => p.header.models), ...s.header.models])]
+        s.header.lost = [...new Set([...parts.flatMap((p) => p.header.lost), ...s.header.lost])]
+        const started = [parts[0]!.header.startedAt, s.header.startedAt].filter((x): x is string => !!x).sort()[0]
+        if (started) s.header.startedAt = started
+        // The earlier transcripts are this session's own history, not a fork of another session.
+        if (s.header.parent?.kind === "fork" && priors.some((p) => s.header.parent!.id === `claude-code:${p}`)) delete s.header.parent
+      }
+      if (gone.length) s.header.lost.push(`earlier part of this session no longer on this computer (${gone.length} transcript${gone.length === 1 ? "" : "s"})`)
+    }
+    // The same transcripts, but the session is the app's: its id, its title.
+    s.header.tool = TOOL
+    s.header.sourceId = ref.sourceId
+    s.header.id = `${TOOL}:${ref.sourceId}`
+    if (ref.title) s.header.title = ref.title
+    return s
+  },
+}

package/src/adapters/claude-desktop/records.ts

@@ -0,0 +1,191 @@
+// Claude Desktop (the Claude app's Code tab): its sessions are Claude Code transcripts (~/.claude/projects/<slug>/<cli
+// session id>.jsonl) plus one record per session that the app keeps:
+//   <app folder>/claude-code-sessions/<account>/<org>/local_<uuid>.json
+//     { sessionId: "local_<uuid>", cliSessionId, priorCliSessionIds?, cwd, title, titleSource, createdAt, lastActivityAt
+//       (epoch ms), isArchived, model, effort, permissionMode, ... }
+// The record is what makes a session show in the app (with its title); the app reads new records when it starts. The same
+// session can be kept under several accounts (copies drift): the one with the latest activity is the one that counts.
+// Only reads here; the writer (writer.ts) adds a record.
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs"
+import { join, sep } from "node:path"
+
+export const TOOL = "claude-desktop"
+export const LABEL = "Claude Desktop"
+
+type Env = Record<string, string | undefined>
+
+/** The Claude app's own folder (macOS, Windows; Linux builds keep it under ~/.config). */
+export function appDir(home: string, env: Env = process.env): string {
+  if (process.platform === "darwin") return join(home, "Library", "Application Support", "Claude")
+  if (process.platform === "win32") return join(env.APPDATA || join(home, "AppData", "Roaming"), "Claude")
+  return join(env.XDG_CONFIG_HOME || join(home, ".config"), "Claude")
+}
+export const sessionsRoot = (home: string, env?: Env) => join(appDir(home, env), "claude-code-sessions")
+/**
+ * Every place the app keeps Code session records: the Claude account's profile, and its third-party profile ("Claude
+ * (third-party)", the app's folder with "-3p" added), which keeps its own sessions the same way.
+ */
+export const sessionsRoots = (home: string, env?: Env) => [sessionsRoot(home, env), join(`${appDir(home, env)}-3p`, "claude-code-sessions")]
+/** The app's own MCP settings (its chats and its Code tab's local tools). */
+export const desktopConfigPath = (home: string, env?: Env) => join(appDir(home, env), "claude_desktop_config.json")
+
+export interface DesktopRecord {
+  sessionId: string
+  cliSessionId?: string
+  /** Earlier transcripts of the same session (a resume or a rewind started a new one). */
+  priorCliSessionIds: string[]
+  cwd?: string
+  title?: string
+  createdAt?: number
+  lastActivityAt?: number
+  isArchived: boolean
+  /** The record's file, and the account folder it is in. */
+  file: string
+  dir: string
+}
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+const LOCAL = /^local_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+const ls = (dir: string): string[] => {
+  try {
+    return readdirSync(dir)
+  } catch {
+    return []
+  }
+}
+const num = (v: unknown) => (typeof v === "number" && Number.isFinite(v) ? v : undefined)
+const str = (v: unknown) => (typeof v === "string" && v ? v : undefined)
+
+/** Every account folder (`<account>/<org>`) the app keeps Code sessions in. */
+export function accountDirs(home: string, env?: Env): string[] {
+  const out: string[] = []
+  for (const root of sessionsRoots(home, env))
+    for (const a of ls(root))
+      for (const o of ls(join(root, a))) {
+        const d = join(root, a, o)
+        try {
+          if (statSync(d).isDirectory()) out.push(d)
+        } catch {}
+      }
+  return out
+}
+
+/** Every session the app keeps, once each (the copy with the latest activity), newest first. Never throws. */
+export function readRecords(home: string, env?: Env): DesktopRecord[] {
+  const best = new Map<string, DesktopRecord>()
+  for (const dir of accountDirs(home, env)) {
+    for (const name of ls(dir)) {
+      if (!name.startsWith("local_") || !name.endsWith(".json")) continue
+      const file = join(dir, name)
+      let j: any
+      try {
+        j = JSON.parse(readFileSync(file, "utf8"))
+      } catch {
+        continue
+      }
+      const sessionId = str(j?.sessionId)
+      if (!sessionId || !LOCAL.test(sessionId)) continue
+      const cli = str(j.cliSessionId) ?? str(j.lastAssistantCliSessionId)
+      const r: DesktopRecord = {
+        sessionId,
+        ...(cli && UUID.test(cli) ? { cliSessionId: cli } : {}),
+        priorCliSessionIds: Array.isArray(j.priorCliSessionIds) ? j.priorCliSessionIds.filter((x: unknown) => typeof x === "string" && UUID.test(x)) : [],
+        ...(str(j.cwd) ? { cwd: j.cwd } : {}),
+        ...(str(j.title) ? { title: j.title } : {}),
+        ...(num(j.createdAt) !== undefined ? { createdAt: j.createdAt } : {}),
+        ...(num(j.lastActivityAt) !== undefined ? { lastActivityAt: j.lastActivityAt } : {}),
+        isArchived: j.isArchived === true,
+        file,
+        dir,
+      }
+      const had = best.get(sessionId)
+      if (!had || (r.lastActivityAt ?? 0) > (had.lastActivityAt ?? 0)) best.set(sessionId, r)
+    }
+  }
+  return [...best.values()].sort((a, b) => (b.lastActivityAt ?? 0) - (a.lastActivityAt ?? 0))
+}
+
+/** The transcripts the app's sessions use (now and before): Claude Code's reader leaves these to Claude Desktop. */
+export function desktopTranscriptIds(home: string, env?: Env): Set<string> {
+  const ids = new Set<string>()
+  if (!sessionsRoots(home, env).some((r) => existsSync(r))) return ids
+  for (const r of readRecords(home, env)) {
+    if (r.cliSessionId) ids.add(r.cliSessionId)
+    for (const p of r.priorCliSessionIds) ids.add(p)
+  }
+  return ids
+}
+
+/** The account the app says it is signed in to (its config.json), if it says. */
+export function signedInAccount(home: string, env?: Env): string | undefined {
+  try {
+    const id = JSON.parse(readFileSync(join(appDir(home, env), "config.json"), "utf8"))?.lastKnownAccountUuid
+    return typeof id === "string" && UUID.test(id) ? id : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** The mode the app was last chosen to start in ("1p": the Claude account, "3p": third-party), as its third-party profile keeps it. */
+export function savedMode(home: string, env?: Env): "1p" | "3p" | undefined {
+  try {
+    const m = JSON.parse(readFileSync(join(`${appDir(home, env)}-3p`, "claude_desktop_config.json"), "utf8"))?.deploymentMode
+    return m === "1p" || m === "3p" ? m : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * The account folder in use. In third-party mode (chosen, or its sessions are the newest), the third-party profile's
+ * folder with the latest session. Otherwise under the account the app is signed in to when it has a folder there (its org
+ * with the latest session, or its only org); otherwise the one whose sessions were active last.
+ */
+export function activeAccountDir(home: string, env?: Env): string | undefined {
+  const records = readRecords(home, env)
+  const thirdParty = sessionsRoots(home, env)[1]! + sep
+  const newest = records[0]
+  if (savedMode(home, env) === "3p" || newest?.dir.startsWith(thirdParty)) {
+    const there = records.find((r) => r.dir.startsWith(thirdParty))
+    if (there) return there.dir
+  }
+  const account = signedInAccount(home, env)
+  if (account) {
+    const mine = accountDirs(home, env).filter((d) => d.startsWith(join(sessionsRoot(home, env), account) + sep))
+    const latest = records.find((r) => mine.includes(r.dir))
+    if (latest) return latest.dir
+    if (mine.length === 1) return mine[0]
+  }
+  let best: { dir: string; at: number } | undefined
+  for (const r of records) if (!best || (r.lastActivityAt ?? 0) > best.at) best = { dir: r.dir, at: r.lastActivityAt ?? 0 }
+  if (best) return best.dir
+  // No session yet in any account: the only account folder there is, if there is exactly one.
+  const dirs = accountDirs(home, env)
+  return dirs.length === 1 ? dirs[0] : undefined
+}
+
+/** The newest record in an account folder, as the app wrote it: its model and effort are the app's current ones. */
+export function newestRecordIn(dir: string): Record<string, unknown> | undefined {
+  let best: { j: Record<string, unknown>; at: number } | undefined
+  for (const name of ls(dir)) {
+    if (!name.startsWith("local_") || !name.endsWith(".json")) continue
+    try {
+      const j = JSON.parse(readFileSync(join(dir, name), "utf8"))
+      const at = num(j?.lastActivityAt) ?? 0
+      if (!best || at > best.at) best = { j, at }
+    } catch {}
+  }
+  return best?.j
+}
+
+/** The Claude Code the app runs its sessions with: the newest version folder in `<app folder>/claude-code/`. */
+export function bundledVersion(home: string, env?: Env): string | undefined {
+  const parse = (v: string) => (/^\d+\.\d+\.\d+$/.test(v) ? v.split(".").map(Number) : undefined)
+  let best: { v: string; n: number[] } | undefined
+  for (const name of ls(join(appDir(home, env), "claude-code"))) {
+    const n = parse(name)
+    if (!n) continue
+    if (!best || n[0]! > best.n[0]! || (n[0] === best.n[0] && (n[1]! > best.n[1]! || (n[1] === best.n[1] && n[2]! > best.n[2]!)))) best = { v: name, n }
+  }
+  return best?.v
+}

package/src/adapters/claude-desktop/writer.ts

@@ -0,0 +1,112 @@
+// A session continued in Claude Desktop (the Claude app's Code tab): a new Claude Code transcript (claude-code/writer.ts),
+// plus the app's record for it in the account folder in use (records.ts), so it shows in the app's sessions with its title.
+// The record copies the app's current model and effort from its newest record; it never carries permissions (a moved
+// session starts in the default permission mode). The app reads new records when it starts: quit and open it again.
+import { randomUUID } from "node:crypto"
+import { chmodSync, existsSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { claudeCodeNativeWriter, claudeCodeWriter } from "../claude-code/writer.ts"
+import type { Readiness, WriteOptions, WriteResult, Writer } from "../types.ts"
+import { countTurns } from "../../session/util.ts"
+import type { Session } from "../../session/types.ts"
+import { activeAccountDir, bundledVersion, LABEL, newestRecordIn, sessionsRoots, TOOL } from "./records.ts"
+
+const isDir = (p: string) => {
+  try {
+    return statSync(p).isDirectory()
+  } catch {
+    return false
+  }
+}
+const real = (p: string) => {
+  try {
+    return realpathSync(p)
+  } catch {
+    return p
+  }
+}
+const OPEN = process.platform === "darwin" ? "open -a Claude" : "the Claude app"
+
+/**
+ * The transcript writer for the app: Claude Code's, checked against and stamped with the Claude Code the app bundles (not
+ * the one on PATH, which can differ); the installed CLI's when the app keeps no bundled copy where brain looks.
+ */
+const transcriptWriter = (home: string) => {
+  const v = bundledVersion(home)
+  return v ? claudeCodeWriter({ version: v }) : claudeCodeNativeWriter
+}
+
+export function claudeDesktopWriter(): Writer {
+  return {
+    tool: TOOL,
+    label: LABEL,
+    way: "native",
+
+    async ready(w: WriteOptions): Promise<Readiness> {
+      if (!sessionsRoots(w.home).some((r) => existsSync(r))) return { ok: false, why: "Claude Desktop is not on this computer, or its Code tab has not been opened yet" }
+      if (!activeAccountDir(w.home)) return { ok: false, why: "Claude Desktop has no account with Code sessions here yet: open its Code tab once" }
+      if (!isDir(w.cwd)) return { ok: false, why: `${w.cwd} is not a folder; Claude Desktop opens a session in the folder it belongs to` }
+      // The transcript's format: the same check Claude Code's own writer makes, against the app's Claude Code.
+      const t = await transcriptWriter(w.home).ready(w)
+      if (!t.ok) return { ok: false, why: t.why.replace(/^Claude Code is not installed.*/, "Claude Desktop's Claude Code was not found, and `claude --version` did not run") }
+      return { ok: true }
+    },
+
+    async write(session: Session, w: WriteOptions): Promise<WriteResult> {
+      const dir = activeAccountDir(w.home)
+      if (!dir) throw new Error("Claude Desktop has no account with Code sessions here yet: open its Code tab once")
+      // The transcript: the same one Claude Code itself would keep (read back and checked before it is kept).
+      const t = await transcriptWriter(w.home).write(session, w)
+      const localId = `local_${randomUUID()}`
+      const recordPath = join(dir, `${localId}.json`)
+      const title = (session.header.title ?? "").replace(/\s+/g, " ").trim().slice(0, 200) || "Continued with brain"
+      if (!w.dryRun) {
+        const template = newestRecordIn(dir) ?? {}
+        const cwd = real(w.cwd)
+        const now = Date.now()
+        const record = {
+          sessionId: localId,
+          cliSessionId: t.sessionId,
+          cwd,
+          originCwd: cwd,
+          lastFocusedAt: now,
+          createdAt: now,
+          lastActivityAt: now,
+          ...(typeof template.model === "string" ? { model: template.model } : {}),
+          ...(typeof template.effort === "string" ? { effort: template.effort } : {}),
+          isArchived: false,
+          title,
+          titleSource: "user",
+          permissionMode: "default",
+          remoteMcpServersConfig: [],
+          alwaysAllowedReasons: [],
+          sessionPermissionUpdates: [],
+          classifierSummaryEnabled: true,
+          spawnSeed: {},
+          completedTurns: countTurns(session).user,
+        }
+        try {
+          // "wx": a new record only; an existing one is never touched.
+          writeFileSync(recordPath, `${JSON.stringify(record, null, 2)}\n`, { flag: "wx", mode: 0o600 })
+          chmodSync(recordPath, 0o600)
+        } catch (e) {
+          // Without its record the transcript would be a Claude Code session nobody asked for: removed.
+          for (const f of t.written) rmSync(f, { force: true })
+          throw e
+        }
+      }
+      return {
+        tool: TOOL,
+        way: "native",
+        sessionId: localId,
+        written: [...t.written, recordPath],
+        open: OPEN,
+        note: `quit Claude and open it again (it reads new sessions when it starts); "${title.slice(0, 80)}" is then in the Code tab's sessions`,
+        lost: t.lost,
+        dryRun: !!w.dryRun,
+      }
+    },
+  }
+}
+
+export const claudeDesktopNativeWriter = claudeDesktopWriter()