@100xprompt/brain 0.1.4 → 0.1.6

package/src/dashboard/report.ts

@@ -49,12 +49,23 @@ export interface BrainReport {
     contextEdit: boolean
     connected: Array<{ tool: string; label: string; since: string | null }>
   }
-  memory: { available: true; projects: number; items: number } | { available: false }
+  memory: { available: true; projects: number; items: number; projectList?: Array<{ name: string; items: number }> } | { available: false }
   conversions: Conversion[]
   /** byMonth: conversions per month, UTC "YYYY-MM", the latest twelve months that have any. */
   totals: { conversions: number; byMonth: Record<string, number> }
   /** Every setting on this computer and its state (docs/settings-contract.md, section 3). Absent when it could not be read. */
   settings?: SettingsSection
+  // docs/sessions-contract.md, section 3: what the dashboard needs to show every feature. Each is optional.
+  /** Where a session can go from this computer, as `brain session targets` says. */
+  targets?: Array<{ tool: string; label: string; ways: Array<{ way: string; ready: boolean; why?: string }> }>
+  /** How often each kind of digested tool output is asked back (`brain tokens lookups`). */
+  tokens?: { lookups: Array<{ kind: string; stubbed: number; expanded: number }> }
+  /** Team memory (`brain org`): the server's host only, never its token. */
+  org?: { joined: true; server: string; scope: string | null } | { joined: false }
+  /** What was last sent of the session list (sessions.ts). */
+  sessions?: { total: number; uploadedAt: string | null; off: boolean }
+  /** Moves from the dashboard (moves.ts): this computer's setting, and how many wait here for the person. */
+  moves?: { setting: string; waiting: number }
 }
 
 export interface SettingsRow {
@@ -76,12 +87,16 @@ export interface SettingsRow {
   error?: string
   notes?: string[]
   remote: boolean
+  /** A change made here to this setting (any level) not sent to the account yet: being the later write, it will win. */
+  pending?: true
 }
 
 export interface SettingsSection {
   paired: boolean
   lastSyncAt: string | null
   waiting: number
+  /** brain's background service on this computer (docs/settings-contract.md, section 6). */
+  service: { installed: boolean; running: boolean; lastRunAt: string | null }
   rows: SettingsRow[]
 }
 
@@ -97,6 +112,9 @@ export async function settingsSection(home: string, env: Env): Promise<SettingsS
     const rows = await withTimeout(listSettings(home, env), 5_000)
     if (!rows) return undefined
     const st = exchangeState(home)
+    const { serviceState } = await import("../service.ts")
+    const { readSettingsFile } = await import("../settings/store.ts")
+    const unsent = new Set(readSettingsFile(home).doc.outbox.map((c) => c.id))
     const short = (v: unknown, type: { kind: string; choices?: string[] }): boolean | number | string | null => {
       if (v === undefined || v === null) return null
       if (typeof v === "boolean" || typeof v === "number") return v
@@ -108,6 +126,7 @@ export async function settingsSection(home: string, env: Env): Promise<SettingsS
       paired: st.paired,
       lastSyncAt: st.lastSyncAt ?? null,
       waiting: st.waiting,
+      service: serviceState(home),
       rows: rows.slice(0, 400).map((r): SettingsRow => {
         const t = r.family.type
         return {
@@ -126,6 +145,7 @@ export async function settingsSection(home: string, env: Env): Promise<SettingsS
           ...(r.error ? { error: clip(cleanText(r.error, home), 300) } : {}),
           ...(r.notes.length ? { notes: r.notes.slice(0, 5).map((n) => clip(cleanText(n, home), 300)) } : {}),
           remote: r.family.remote === "yes",
+          ...(st.paired && unsent.has(r.id) ? { pending: true as const } : {}),
         }
       }),
     }
@@ -226,7 +246,10 @@ async function memorySummary(home: string, env: Env): Promise<BrainReport["memor
           const s = await mem.status()
           if (!s.available) return { available: false as const }
           const projects = await mem.projects()
-          return { available: true as const, projects: projects.length, items: projects.reduce((n, p) => n + (Number(p.items) || 0), 0) }
+          // A project's name as memory labels it; a path in it is written from the home folder (~).
+          const name = (l: string) => clip(String(l ?? "").replaceAll(home, "~").replace(/[\u0000-\u001f\u007f]/g, " ").trim(), 80) || "(unnamed)"
+          const projectList = [...projects].sort((a, b) => (Number(b.items) || 0) - (Number(a.items) || 0)).slice(0, 50).map((p) => ({ name: name(p.label), items: Math.max(0, Math.floor(Number(p.items) || 0)) }))
+          return { available: true as const, projects: projects.length, items: projects.reduce((n, p) => n + (Number(p.items) || 0), 0), projectList }
         })(),
         5_000,
       )
@@ -294,6 +317,11 @@ export async function harnesses(home: string, counts: Record<string, ToolCount>
   }
   for (const t of MCP_TOOLS) add(mcpToolId(t.id), t.label, mcpToolHere(t, home, env) || mcpInstalled.get(mcpToolId(t.id)) === true)
   for (const id of HOOK_TOOLS) add(id, toolLabel(id), hookOn(id))
+  // The Codex app (its threads share ~/.codex with the CLI).
+  try {
+    const { codexAppHere } = await import("../adapters/codex/records.ts")
+    add("codex-desktop", "Codex Desktop", codexAppHere(home))
+  } catch {}
   const mcpIds = new Set(MCP_TOOLS.map((t) => mcpToolId(t.id)))
   const connectorIds = new Set(CONNECTORS.map((c) => c.id))
   return [...known.entries()]
@@ -303,9 +331,11 @@ export async function harnesses(home: string, counts: Record<string, ToolCount>
       label: clip(k.label, 80),
       sessions: counts?.[id] ? counts[id]!.sessions : null,
       lastSessionAt: counts?.[id]?.lastSessionAt ?? null,
-      gateway: connected[id] ? "connected" : (ownClient(id, home, env) ?? (connectorIds.has(id) ? "available" : "unsupported")),
-      mcp: mcpIds.has(id) ? mcpInstalled.get(id) === true : null,
-      hooks: HOOK_TOOLS.includes(id) ? hookOn(id) : null,
+      // The Codex app reads Codex's own settings (~/.codex): its gateway and MCP tools are Codex's.
+      gateway: id === "codex-desktop" ? (connected.codex ? "connected" : "available") : connected[id] ? "connected" : (ownClient(id, home, env) ?? (connectorIds.has(id) ? "available" : "unsupported")),
+      mcp: id === "codex-desktop" ? mcpInstalled.get("codex") === true : mcpIds.has(id) ? mcpInstalled.get(id) === true : null,
+      // Claude Desktop's Code tab runs Claude Code's hooks.
+      hooks: HOOK_TOOLS.includes(id) ? hookOn(id) : id === "claude-desktop" ? hookOn("claude-code") : id === "codex-desktop" && HOOK_TOOLS.includes("codex") ? hookOn("codex") : null,
     }))
     .sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id))
 }
@@ -344,9 +374,72 @@ export async function buildReport(home: string, o: { counts?: Record<string, Too
     conversions: list,
     totals: { conversions: total, byMonth },
     ...(settings ? { settings } : {}),
+    ...(await featureParts(home)),
   }
 }
 
+/** Where a session can go from this computer: each tool brain writes, and whether each way is ready now (dry run). */
+export async function targetsPart(home: string): Promise<BrainReport["targets"]> {
+  const { WRITERS, readerFor } = await import("../adapters/index.ts")
+  const { cleanText } = await import("../settings/catalog.ts")
+  const byTool = new Map<string, { tool: string; label: string; ways: Array<{ way: string; ready: boolean; why?: string }> }>()
+  await Promise.all(
+    WRITERS.map(async (w) => {
+      let ready = false
+      let why: string | undefined
+      try {
+        const r = await w.ready({ home, cwd: home, dryRun: true })
+        ready = r.ok
+        if (!r.ok) why = clip(cleanText(r.why, home), 200)
+      } catch (e) {
+        why = clip(cleanText(String((e as Error)?.message ?? e), home), 200)
+      }
+      const t = byTool.get(w.tool) ?? { tool: w.tool, label: clip(readerFor(w.tool === "cursor" ? "cursor-ide" : w.tool)?.label ?? w.label ?? w.tool, 60), ways: [] }
+      t.ways.push({ way: w.way, ready, ...(why ? { why } : {}) })
+      byTool.set(w.tool, t)
+    }),
+  )
+  const order = new Map(WRITERS.map((w, i) => [w.tool, i]))
+  return [...byTool.values()].sort((a, b) => (order.get(a.tool) ?? 0) - (order.get(b.tool) ?? 0)).slice(0, 60)
+}
+
+/** Works out where a session can go from here now and keeps it for the reports that follow (explicit commands only). */
+export async function refreshTargets(home: string, timeoutMs = 15_000): Promise<void> {
+  const list = await withTimeout(targetsPart(home), timeoutMs)
+  if (list?.length) updateCache(home, (c) => {
+    c.targets = { at: new Date().toISOString(), list }
+  })
+}
+
+/** The additions the dashboard's every-feature panel reads (docs/sessions-contract.md, section 3); each one alone may fail. */
+async function featureParts(home: string): Promise<Pick<BrainReport, "targets" | "tokens" | "org" | "sessions" | "moves">> {
+  const out: Pick<BrainReport, "targets" | "tokens" | "org" | "sessions" | "moves"> = {}
+  // From the last `brain dashboard` / `brain sync`: a writer's check may run its tool (`--version`), never in the background.
+  const targets = readCache(home).targets?.list
+  if (Array.isArray(targets) && targets.length) out.targets = targets.slice(0, 60)
+  try {
+    const { lookupRates } = await import("../memory/lookups.ts")
+    out.tokens = { lookups: lookupRates(home).slice(0, 30).map((r) => ({ kind: clip(r.kind, 40), stubbed: r.stubbed, expanded: r.expanded })) }
+  } catch {}
+  try {
+    const cfg = readOrgConfig(home)
+    let host = ""
+    try {
+      host = cfg ? new URL(cfg.server).host : ""
+    } catch {}
+    out.org = cfg && host ? { joined: true, server: clip(host, 120), scope: typeof cfg.defaultScope === "string" ? clip(cfg.defaultScope, 20) : null } : { joined: false }
+  } catch {}
+  try {
+    const { sessionsState } = await import("./sessions.ts")
+    out.sessions = sessionsState(home)
+  } catch {}
+  try {
+    const { movesState } = await import("../moves.ts")
+    out.moves = movesState(home)
+  } catch {}
+  return out
+}
+
 /** The report as it is sent: at most MAX_BYTES of JSON, the oldest conversions dropped first if it is bigger. */
 export function reportBody(r: BrainReport, maxBytes = MAX_BYTES): string {
   let body = JSON.stringify(r)

package/src/dashboard/sessions.ts

@@ -0,0 +1,127 @@
+// This computer's session list, for the dashboard's Sessions panel (docs/sessions-contract.md, section 1): every session
+// brain can list, by id, tool, title, project folder name and when; never chat text, never a full path. Sent with the
+// computer's token (only a paired computer sends it), from the background service when the list changed (looked at no
+// more than every 5 minutes) and from `brain dashboard` / `brain sync`.
+import { createHash } from "node:crypto"
+import { basename } from "node:path"
+import type { Env } from "../gateway/common.ts"
+import { cleanText } from "../settings/catalog.ts"
+import { sessionsListOn } from "../settings/values.ts"
+import { gatewayUrl, safeUrl, sendingOff } from "./send.ts"
+import { machineId, readCache, readMachineToken, updateCache } from "./state.ts"
+
+export const SESSIONS_PATH = "/api/brain/sessions"
+/** The background service looks at the list (and sends it when it changed) at most this often. */
+export const SESSIONS_EVERY_MS = 5 * 60_000
+export const MAX_SESSIONS = 20_000
+const TOOL = /^[a-z0-9][a-z0-9-]{0,39}$/
+// biome-ignore lint/suspicious/noControlCharactersInRegex: control characters are what it finds
+const CONTROL = /[\u0000-\u001f\u007f-\u009f]/
+/** Control, bidirectional and zero-width characters: never in what the dashboard shows. */
+// biome-ignore lint/suspicious/noControlCharactersInRegex: control characters are what it removes
+const UNSHOWN = /[\u0000-\u001f\u007f-\u009f\u061c\u200b-\u200f\u202a-\u202e\u2060-\u2069\ufeff]/g
+/** The upload stays under the gateway's 4 MB: sessions past this many bytes are left out (the newest are kept). */
+export const MAX_UPLOAD_BYTES = 3_900_000
+
+export interface ListedSession {
+  id: string
+  tool: string
+  title: string | null
+  project: string | null
+  updatedAt: string | null
+}
+
+export interface SessionsUpload {
+  machine: string
+  sentAt: string
+  total: number
+  off: boolean
+  sessions: ListedSession[]
+}
+
+const clip = (s: string, n: number) => (s.length <= n ? s : `${s.slice(0, n - 1)}…`)
+const iso = (v: unknown): string | null => {
+  const t = typeof v === "string" ? Date.parse(v) : NaN
+  return Number.isFinite(t) ? new Date(t).toISOString() : null
+}
+
+/** The upload as it would go now: the list (or nothing, with `off`, when reports.sessions is off here). */
+export async function buildSessionsUpload(home: string, o: { now?: Date } = {}): Promise<SessionsUpload> {
+  const base = { machine: machineId(home), sentAt: (o.now ?? new Date()).toISOString() }
+  if (!sessionsListOn(home)) return { ...base, total: 0, off: true, sessions: [] }
+  const { listSessions } = await import("../session/ops.ts")
+  const { refs } = await listSessions(home)
+  const sessions: ListedSession[] = []
+  let bytes = 200
+  for (const r of refs) {
+    if (sessions.length >= MAX_SESSIONS) break
+    const id = `${r.tool}:${r.sourceId}`
+    if (!TOOL.test(r.tool) || id.length > 200 || CONTROL.test(id) || /[\u061c\u200b-\u200f\u202a-\u202e\u2060-\u2069\ufeff]/.test(id)) continue
+    const title = r.title ? clip(cleanText(r.title, home).replace(UNSHOWN, " ").replace(/\s+/g, " ").trim(), 120) : ""
+    // The project is its folder's name; a session in the home folder itself has none worth naming.
+    const project = r.cwd && r.cwd !== home ? clip(basename(r.cwd).replace(UNSHOWN, " ").replace(/\s+/g, " ").trim(), 80) : ""
+    const s: ListedSession = { id, tool: r.tool, title: title || null, project: project || null, updatedAt: iso(r.updatedAt) }
+    bytes += Buffer.byteLength(JSON.stringify(s)) + 1
+    if (bytes > MAX_UPLOAD_BYTES) break
+    sessions.push(s)
+  }
+  return { ...base, total: refs.length, off: false, sessions }
+}
+
+/** What changes when the list changes (not when it was sent). */
+export const sessionsHash = (u: SessionsUpload) => createHash("sha256").update(JSON.stringify([u.off, u.total, u.sessions])).digest("hex").slice(0, 32)
+
+export type SessionsSent = { sent: true; total: number } | { sent: false; why: string }
+
+/**
+ * Sends the list when it is due: `force` (brain dashboard, brain sync) always; otherwise when SESSIONS_EVERY_MS passed
+ * since the last look and the list changed. Only a paired computer with reports on. Never throws.
+ */
+export async function sendSessions(home: string, o: { env?: Env; force?: boolean; fetchImpl?: typeof fetch; timeoutMs?: number; now?: number } = {}): Promise<SessionsSent> {
+  const env = o.env ?? process.env
+  try {
+    const token = readMachineToken(home)
+    if (!token) return { sent: false, why: "not paired (brain pair)" }
+    const off = sendingOff(home, env)
+    if (off) return { sent: false, why: off }
+    const now = o.now ?? Date.now()
+    const cache = readCache(home).sessions ?? {}
+    if (!o.force && cache.lastLookMs && now - cache.lastLookMs < SESSIONS_EVERY_MS) return { sent: false, why: "not due" }
+    const upload = await buildSessionsUpload(home)
+    const hash = sessionsHash(upload)
+    updateCache(home, (c) => {
+      c.sessions = { ...c.sessions, lastLookMs: now }
+    })
+    if (!o.force && hash === cache.hash && cache.lastSentAt) return { sent: false, why: "unchanged" }
+    const url = `${gatewayUrl(home)}${SESSIONS_PATH}`
+    if (!safeUrl(url)) return { sent: false, why: `the gateway address ${gatewayUrl(home)} is not https; the token is never sent over it` }
+    let why: string | undefined
+    try {
+      const res = await (o.fetchImpl ?? fetch)(url, {
+        method: "PUT",
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+        body: JSON.stringify(upload),
+        redirect: "manual",
+        signal: AbortSignal.timeout(o.timeoutMs ?? 20_000),
+      })
+      await res.text().catch(() => "")
+      if (!res.ok) why = res.status === 401 ? "your account no longer takes this computer's token: pair it again with `brain pair`" : res.status === 429 ? "too many uploads for now; the next one carries everything" : `the gateway answered HTTP ${res.status}`
+    } catch (e) {
+      const n = (e as Error)?.name
+      why = n === "TimeoutError" || n === "AbortError" ? "the gateway did not answer in time" : `could not reach ${gatewayUrl(home)}`
+    }
+    const at = new Date(now).toISOString()
+    updateCache(home, (c) => {
+      c.sessions = why ? { ...c.sessions, lastError: why } : { lastLookMs: now, hash, lastSentAt: at, total: upload.total, off: upload.off }
+    })
+    return why ? { sent: false, why } : { sent: true, total: upload.total }
+  } catch (e) {
+    return { sent: false, why: `the session list could not be made: ${String((e as Error)?.message ?? e).slice(0, 200)}` }
+  }
+}
+
+/** What the report says about it: what was last sent. */
+export function sessionsState(home: string): { total: number; uploadedAt: string | null; off: boolean } {
+  const c = readCache(home).sessions ?? {}
+  return { total: typeof c.total === "number" ? c.total : 0, uploadedAt: typeof c.lastSentAt === "string" ? c.lastSentAt : null, off: c.off === true || !sessionsListOn(home) }
+}

package/src/dashboard/state.ts

@@ -8,8 +8,9 @@
 //                         (when the last report went out, a push that is waiting to run).
 // Every write re-reads the file first and changes only its own fields, then replaces the file atomically.
 import { createHash } from "node:crypto"
-import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs"
+import { chmodSync, linkSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs"
 import { dirname, join } from "node:path"
+import { withBrainLockSync } from "../lock.ts"
 
 export const brainDir = (home: string) => join(home, ".brain")
 export const machinePath = (home: string) => join(brainDir(home), "machine.json")
@@ -41,6 +42,17 @@ export interface DashboardCache {
     /** Why the last attempt failed (cleared by a success). */
     lastError?: string
   }
+  /** Where a session can go from here, from the last `brain dashboard` / `brain sync` (each writer's check can run its tool). */
+  targets?: { at: string; list: Array<{ tool: string; label: string; ways: Array<{ way: string; ready: boolean; why?: string }> }> }
+  /** The session list for the dashboard (sessions.ts): when it was last looked at, and what was last sent. */
+  sessions?: {
+    lastLookMs?: number
+    hash?: string
+    lastSentAt?: string
+    total?: number
+    off?: boolean
+    lastError?: string
+  }
 }
 
 function readJson<T extends object>(path: string): T {
@@ -133,9 +145,40 @@ export function hardwareHash(env: Record<string, string | undefined> = process.e
  * another computer (its hardware hash differs) gets a new id too, and that computer's token is dropped here: the copy is
  * a computer of its own, and is paired on its own.
  */
+/**
+ * Writes `value` to `path` only when there is no file there yet (link of a finished file: never a half-written one). True
+ * when this call made it; false when one was there already.
+ */
+function createPrivateJson(path: string, value: unknown): boolean {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 })
+  const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2, 8)}.brain-new`
+  try {
+    writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 })
+    chmodSync(tmp, 0o600)
+    linkSync(tmp, path)
+    return true
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException)?.code === "EEXIST") return false
+    throw e
+  } finally {
+    rmSync(tmp, { force: true })
+  }
+}
+
 export function machineId(home: string): string {
   const m = readJson<{ id?: unknown; createdAt?: unknown; hw?: unknown }>(machinePath(home))
   const here = hardwareHash()
+  const fresh = (id: string) => ({ id, createdAt: new Date().toISOString(), ...(here ? { hw: here } : {}) })
+  if (m.id === undefined) {
+    // The first id: made once, even when two brains start at the same moment (`brain gateway login` leaves a report
+    // starting in the background as `brain pair` begins): whichever makes the file first, both use its id.
+    const id = crypto.randomUUID()
+    try {
+      if (createPrivateJson(machinePath(home), fresh(id))) return id
+      const made = readJson<{ id?: unknown }>(machinePath(home))
+      if (typeof made.id === "string" && UUID.test(made.id)) return made.id
+    } catch {}
+  }
   if (typeof m.id === "string" && UUID.test(m.id)) {
     if (!here || m.hw === here) return m.id
     if (m.hw === undefined) {
@@ -149,9 +192,25 @@ export function machineId(home: string): string {
       rmSync(machineKeyPath(home), { force: true })
     } catch {}
   }
-  const id = crypto.randomUUID()
+  // A damaged file, or one made on another computer: replaced once, under the brain lock, so two brains doing it at the
+  // same moment keep one id (the second finds the first one's).
   try {
-    writePrivateJson(machinePath(home), { id, createdAt: new Date().toISOString(), ...(here ? { hw: here } : {}) })
-  } catch {}
-  return id
+    return withBrainLockSync(
+      home,
+      () => {
+        const again = readJson<{ id?: unknown; hw?: unknown }>(machinePath(home))
+        if (typeof again.id === "string" && UUID.test(again.id) && again.id !== m.id && (!here || again.hw === here)) return again.id
+        const id = crypto.randomUUID()
+        writePrivateJson(machinePath(home), fresh(id))
+        return id
+      },
+      { what: "this computer's id" },
+    )
+  } catch {
+    const id = crypto.randomUUID()
+    try {
+      writePrivateJson(machinePath(home), fresh(id))
+    } catch {}
+    return id
+  }
 }

package/src/gateway/common.ts

@@ -145,6 +145,8 @@ export interface FileEdit {
   holdsKey?: boolean
   /** Keys among `values` whose value contains the key: never shown or recorded, and replaced when the person signs in again. */
   secretKeys?: string[]
+  /** The mode the file is written with (a launcher script brain writes whole: 0700); otherwise the file keeps its own. */
+  mode?: number
 }
 
 export interface Connector {
@@ -161,6 +163,12 @@ export interface Connector {
   authHeader: "x-api-key" | "authorization" | "x-goog-api-key"
   /** What the person should know (shown on connect). */
   notes: string[]
+  /** What the person should know at connect that depends on this computer (shown after `notes`). */
+  notesHere?(home: string, env: Env): string[]
+  /** Files the tool's own launcher writes while it runs (not edits): removed on disconnect. */
+  leftovers?(home: string): string[]
+  /** What keeps using the gateway after a disconnect or a sign-out until the person quits it (said then). */
+  stillRunning?: string
 }
 
 // ---- JSON paths --------------------------------------------------------------------------------------------------------

package/src/gateway/connect.ts

@@ -33,6 +33,7 @@ import {
   type GatewaySettings,
   getAt,
   type Json,
+  modelId,
   keyPath,
   MODEL_NAMES,
   modelName,
@@ -284,6 +285,7 @@ function logoutLocked(home: string, env: Record<string, string | undefined>): st
     out.push(`${names(readers)} ${readers.length === 1 ? "reads" : "read"} the key from that file, so ${readers.length === 1 ? "it" : "they"} cannot reach the gateway until you sign in again (brain gateway login), and a tool that reads it at start may refuse to start; brain gateway disconnect --tool <id> puts ${readers.length === 1 ? "it" : "them"} back as before.`)
   if (copies.length)
     out.push(`${names(copies)} ${copies.length === 1 ? "keeps its" : "keep their"} own copy of the key and still ${copies.length === 1 ? "reaches" : "reach"} the gateway with it (signing out here does not revoke a key): brain gateway disconnect --tool <id> removes the copy.`)
+  for (const c of connected) if (c.stillRunning) out.push(c.stillRunning)
   return out
 }
 
@@ -395,7 +397,12 @@ export const CONNECTORS: Connector[] = [...BUILT_IN, ...EXTRA_CONNECTORS]
 const SECRET_KEYS = new Set(["GEMINI_API_KEY", "model_providers/brain-gateway"])
 const isSecret = (e: FileEdit, key: string) => SECRET_KEYS.has(key) || !!e.secretKeys?.includes(key)
 
-export const connectorFor = (id: string) => CONNECTORS.find((c) => c.id === id || c.label.toLowerCase() === id.toLowerCase())
+/** Tools that have no connection of their own: they use another tool's (the Codex app reads Codex's ~/.codex). */
+const SAME_CONNECTION: Record<string, string> = { "codex-desktop": "codex", "codex desktop": "codex" }
+export const connectorFor = (id: string) => {
+  const want = SAME_CONNECTION[id.toLowerCase()] ?? id
+  return CONNECTORS.find((c) => c.id === want || c.label.toLowerCase() === want.toLowerCase())
+}
 
 // ---- reading and writing each format ---------------------------------------------------------------------------------
 
@@ -691,6 +698,12 @@ export async function connect(
     usePrefs?: boolean
     /** Called after the files are written, still under the brain lock, with the settings used (to record them). */
     onWritten?: (s: GatewaySettings) => void
+    /**
+     * A reconnect for one setting (model, context editing): the values that setting decides are set again (a hand edit of
+     * them is replaced, as asking for the value again means); any other value the person changed since brain set it stays
+     * theirs (Claude Desktop's applied configuration they chose again in the app, say). A connect asked for takes all back.
+     */
+    keepTheirs?: { for: "model" | "contextEdit" }
   } = {},
 ): Promise<Result> {
   const env = o.env ?? process.env
@@ -738,6 +751,17 @@ export async function connect(
     const s = fresh
     // Read and check every file first: nothing is written unless all of them can be changed.
     const edits = c.edits(home, s, env)
+    // The values the setting being applied decides: those that differ when it is set otherwise.
+    const decided = new Set<string>()
+    if (o.keepTheirs) {
+      const other = o.keepTheirs.for === "model" ? { ...s, model: s.model === modelId("pro") ? modelId("flash") : modelId("pro") } : { ...s, contextEdit: !s.contextEdit }
+      const alt = c.edits(home, other, env)
+      for (const e of edits)
+        for (const k of Object.keys(e.values)) {
+          const v = alt.find((x) => x.path === e.path)?.values[k]
+          if (JSON.stringify(v) !== JSON.stringify(e.values[k])) decided.add(`${e.path}\u0000${k}`)
+        }
+    }
     const docs: Array<{ e: FileEdit; d: Doc }> = []
     for (const e of edits) {
       const d = load(e.format, e.path, e.codec)
@@ -754,6 +778,10 @@ export async function connect(
           // A reconnect keeps the value from before the FIRST connect, so disconnect still restores the person's own.
           const was = prior.find((x) => x.file === e.path && x.key === key)
           const secret = isSecret(e, key)
+          if (o.keepTheirs && !decided.has(`${e.path}\u0000${key}`) && was && was.after !== "(contains the key)" && !secret && !same(current, was.after)) {
+            changes.push(was)
+            continue
+          }
           changes.push({ file: e.path, format: e.format, key, before: was ? was.before : current, after: secret ? "(contains the key)" : after })
           if (!same(current, after)) setKey(d, key, after)
           shown.push(`  ${basename(e.path)}: ${key.replace(/\//g, ".")} = ${secret ? "(gateway settings and key)" : shownValue(after)}`)
@@ -785,7 +813,7 @@ export async function connect(
       } catch {}
     }
     const first = !st.tools[c.id]
-    for (const { e, d } of docs) writeToolFile(home, c.id, e.path, render(d), e.holdsKey ? 0o600 : undefined, first)
+    for (const { e, d } of docs) writeToolFile(home, c.id, e.path, render(d), e.holdsKey ? 0o600 : e.mode, first)
     st.settings = s
     st.tools[c.id] = { at: new Date().toISOString(), changes, ...(created.size ? { created: [...created] } : {}), ...(createdDirs.size ? { createdDirs: [...createdDirs] } : {}), ...(Object.keys(modes).length ? { modes } : {}), settings: s }
     saveState(home, st)
@@ -801,6 +829,7 @@ export async function connect(
         "changed:",
         ...shown,
         ...c.notes.map((n) => `note: ${n}`),
+        ...(c.notesHere?.(home, env) ?? []).map((n) => `note: ${n}`),
         `undo: brain gateway disconnect --tool ${c.id}`,
       ],
     }
@@ -855,10 +884,11 @@ function disconnectLocked(home: string, c: Connector, o: { dryRun?: boolean; env
       } catch {}
     }
   if (!o.dryRun) {
+    for (const f of c.leftovers?.(home) ?? []) rmSync(f, { force: true })
     delete st.tools[c.id]
     saveState(home, st)
   }
-  return { ok: true, lines: [`${o.dryRun ? "would disconnect" : "disconnected"} ${c.label}:`, ...lines] }
+  return { ok: true, lines: [`${o.dryRun ? "would disconnect" : "disconnected"} ${c.label}:`, ...lines, ...(c.stillRunning ? [`note: ${c.stillRunning}`] : [])] }
 }
 
 export function status(home: string, env: Record<string, string | undefined> = process.env): string[] {