@100xprompt/brain 0.1.2 → 0.1.4

package/src/gateway/connectors/continue.ts

@@ -30,7 +30,8 @@
 //                         apiKey: ${{ secrets.BRAIN_GATEWAY_KEY }}, roles chat/edit/apply/summarize,
 //                         capabilities tool_use and image_input (Continue only guesses tool support for provider openai from
 //                         gpt-/o- model names, toolSupport.ts ~277661, so without it Agent mode would be off),
-//                         contextLength 1048576 (an unknown model gets 32768, ~238017), and the context-edit header.
+//                         contextLength 1048576 (an unknown model gets 32768, ~238017; for 100xprompt Auto the
+//                         smallest window auto may serve, common.ts limitsFor), and the context-edit header.
 //                       First in the list makes it the default: the extension and the CLI take the first chat model unless
 //                       one was picked before (extension rectifySelectedModelsFromGlobalContext ~798703; CLI
 //                       services/ModelService.ts:53-120 and util/modelPersistence.ts, `cliSelectedModel`).
@@ -42,7 +43,7 @@
 // stay, and removing the entry gives back the exact bytes, including an empty `models: []` or a list that was not there.
 import { existsSync, readFileSync } from "node:fs"
 import { isAbsolute, join, resolve } from "node:path"
-import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, type Json, modelName, readKey, routeUrl, yamlTopLevel } from "../common.ts"
+import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, type Json, limitsFor, modelName, readKey, routeUrl, yamlTopLevel } from "../common.ts"
 
 /** The name the key is kept under in the tool's .env, and that its config refers to. */
 export const SECRET = "BRAIN_GATEWAY_KEY"
@@ -50,8 +51,6 @@ export const SECRET = "BRAIN_GATEWAY_KEY"
 const OWN_CONFIG = "100xprompt gateway"
 /** The codec key of brain's entry in the models list (the entry itself is found by its apiKey, so a model switch keeps it). */
 export const ENTRY_KEY = "models/100xprompt gateway"
-/** Gemini models' context window; Continue assumes 32768 for a model it does not know. */
-const CONTEXT = 1048576
 
 const same = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b)
 const isPlainObject = (v: unknown): v is Json => !!v && typeof v === "object" && !Array.isArray(v)
@@ -521,7 +520,7 @@ const headers = (s: GatewaySettings) => (s.contextEdit ? { requestOptions: { hea
 
 /** The models entry in config.json form (older Continue, PearAI): `title`, the key by env name. */
 export function jsonEntry(s: GatewaySettings, extra: Json = {}): Json {
-  return { title: modelName(s.model), provider: "openai", model: s.model, apiBase: `${routeUrl(s)}/v1`, apiKey: SECRET, contextLength: CONTEXT, ...extra, ...headers(s) }
+  return { title: modelName(s.model), provider: "openai", model: s.model, apiBase: `${routeUrl(s)}/v1`, apiKey: SECRET, contextLength: limitsFor(s).context, ...extra, ...headers(s) }
 }
 
 /** The .env edit both Continue and PearAI read their secret from. */
@@ -557,7 +556,7 @@ export const connectors: Connector[] = [
         apiKey: `\${{ secrets.${SECRET} }}`,
         roles: ["chat", "edit", "apply", "summarize"],
         capabilities: ["tool_use", "image_input"],
-        defaultCompletionOptions: { contextLength: CONTEXT },
+        defaultCompletionOptions: { contextLength: limitsFor(s).context },
         ...headers(s),
       }
       return [

package/src/gateway/connectors/crush.ts

@@ -30,7 +30,7 @@
 // A model list is given, so Crush does not ask the gateway for /v1/models (403 there).
 import { existsSync } from "node:fs"
 import { isAbsolute, join, resolve } from "node:path"
-import { type Codec, type Connector, EDIT_HEADER, type Env, getAt, type Json, keyPath, modelName, routeUrl, shellQuote } from "../common.ts"
+import { type Codec, type Connector, EDIT_HEADER, type Env, getAt, type Json, keyPath, limitsFor, modelName, routeUrl, shellQuote } from "../common.ts"
 
 /** Crush's data file, resolved as Crush does; the env overrides describe the person's real home, so they count only there. */
 export function crushDataFile(home: string, env: Env): string {
@@ -297,7 +297,7 @@ export const connectors: Connector[] = [
               base_url: `${routeUrl(s)}/v1`,
               api_key: `$(cat ${shellQuote(keyPath(home))})`,
               ...(s.contextEdit ? { extra_headers: { [EDIT_HEADER]: "on" } } : {}),
-              models: [{ id: s.model, name: modelName(s.model), context_window: 1048576, default_max_tokens: 65536, capabilities: { vision: true } }],
+              models: [{ id: s.model, name: modelName(s.model), context_window: limitsFor(s).context, default_max_tokens: limitsFor(s).output, capabilities: { vision: true } }],
             },
             "models/large": pick,
             "models/small": pick,

package/src/gateway/connectors/factory-droid.ts

@@ -14,6 +14,10 @@
 //     stdout."), run with shell:true, cached for 5 minutes (apiKeyHelperTtlMs, FACTORY_API_KEY_HELPER_TTL_MS). So the key
 //     is read from the brain's key file at run time, never copied, and a new sign-in reaches Droid without a reconnect.
 //   - `extraHeaders` is sent with every request (case-insensitively unique names), so the context-edit header can go.
+//   - Context window and output limit: Droid infers a custom model's from its model id (the built-in model whose
+//     matchPatterns match it: gemini-3.8-flash gets Gemini 3.8 Flash's 1M in and 64K out), and an entry's maxContextLimit
+//     and maxOutputTokens take precedence (k4e and ev in the binary). 100xprompt Auto's id matches nothing, so for auto they
+//     are given: what every model auto may serve takes (common.ts limitsFor). Images stay on (noImageSupport unset).
 //   - A model's id is `custom:<displayName with spaces as ->-<n>` unless the entry names its own `id`; this connector gives
 //     its entry the id `custom:brain-gateway`, so the default stays put whatever else is in the list.
 //   - The default model is `sessionDefaultSettings.model` (older top-level `model` is folded into it on read and only
@@ -27,7 +31,7 @@
 //   - Checked for real (scripts/gateway-real/factory-droid.ts): `droid exec` with no -m, no Factory login, sends its
 //     request to <route>/v1/messages with x-api-key from the helper, the context-edit header and the gateway's model.
 import { join } from "node:path"
-import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, type Json, keyPath, modelName, routeUrl, shellQuote } from "../common.ts"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, isAuto, type Json, keyPath, limitsFor, modelName, routeUrl, shellQuote } from "../common.ts"
 
 /** The id of the connector's entry in customModels, and the default model value that selects it. */
 export const DROID_MODEL_ID = "custom:brain-gateway"
@@ -295,6 +299,7 @@ export const connectors: Connector[] = [
             provider: "anthropic",
             apiKeyHelper: `cat ${shellQuote(keyPath(home))}`,
             ...(s.contextEdit ? { extraHeaders: { [EDIT_HEADER]: "on" } } : {}),
+            ...(isAuto(s) ? { maxContextLimit: limitsFor(s).context, maxOutputTokens: limitsFor(s).output } : {}),
           },
           "sessionDefaultSettings/model": DROID_MODEL_ID,
         },

package/src/gateway/connectors/goose.ts

@@ -22,12 +22,10 @@
 //   The binary's strings list the same field names (`strings goose | grep api_key_env`), and the real-tool check
 //   (scripts/gateway-real/goose.ts) runs this exact setup.
 import { isAbsolute, join, resolve } from "node:path"
-import { type Connector, EDIT_HEADER, type Env, keyPath, modelName, routeUrl, yamlTopLevel } from "../common.ts"
+import { type Connector, EDIT_HEADER, type Env, keyPath, limitsFor, modelName, routeUrl, yamlTopLevel } from "../common.ts"
 
 /** The provider id (the custom provider's file name and `name`, and GOOSE_PROVIDER), as Codex and OpenCode name it. */
 export const GOOSE_PROVIDER = "brain-gateway"
-/** The context window Goose is told (it compacts the conversation near it): the Gemini Flash models' 1,048,576 tokens. */
-const CONTEXT_LIMIT = 1_048_576
 
 /** Goose's config folder, found the way Goose finds it. XDG_CONFIG_HOME describes the real home, so it counts only there. */
 export function gooseDir(home: string, env: Env): string {
@@ -56,7 +54,9 @@ export const connectors: Connector[] = [
           display_name: "100xprompt gateway",
           description: `${modelName(s.model)} through the 100xprompt gateway (set up by brain gateway connect --tool goose)`,
           base_url: `${routeUrl(s)}/v1`,
-          models: [{ name: s.model, context_limit: CONTEXT_LIMIT }],
+          // The window Goose is told (it compacts the conversation near it): the Gemini Flash models' 1,048,576 tokens, or
+          // for 100xprompt Auto the smallest window it may serve (common.ts limitsFor).
+          models: [{ name: s.model, context_limit: limitsFor(s).context }],
           ...(s.contextEdit ? { headers: { [EDIT_HEADER]: "on" } } : {}),
           supports_streaming: true,
           requires_auth: true,

package/src/gateway/connectors/hermes.ts

@@ -19,7 +19,10 @@
 //   - `extra_headers` on the provider entry is sent with every request on the OpenAI wire (runtime_provider.py
 //     _lift_extra_headers), so the context-edit header can go.
 //   - The gateway's /v1/models answers 403; Hermes then takes the context window from its catalog ("gemini" → 1M,
-//     agent/model_metadata.py), so nothing else needs setting.
+//     agent/model_metadata.py), so nothing else needs setting for a Gemini id. 100xprompt Auto's id is in no catalog (Hermes
+//     would assume 256,000: DEFAULT_FALLBACK_CONTEXT), so for auto the entry also gets `models: {<id>: {context_length}}`,
+//     the per-model override Hermes checks before any catalog (hermes_cli/config.py get_custom_provider_context_length,
+//     matched by the entry's base_url): what every model auto may serve takes (common.ts limitsFor).
 //   - $HERMES_HOME replaces ~/.hermes when set (a Hermes profile is its own HERMES_HOME).
 //   - Checked for real (scripts/gateway-real/hermes.ts): `hermes chat -q` sends its request to <route>/v1/chat/completions
 //     with Authorization: Bearer <key from .env>, the context-edit header and the gateway's model, even with the person's
@@ -27,7 +30,7 @@
 // config.yaml is YAML with comments; the codec below edits `<section>/<entry>` lines in place and leaves every other line
 // as it was.
 import { join } from "node:path"
-import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, type Json, readKey, routeUrl, yamlTopLevel } from "../common.ts"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, isAuto, type Json, limitsFor, readKey, routeUrl, yamlTopLevel } from "../common.ts"
 
 export const HERMES_PROVIDER = "brain-gateway"
 export const HERMES_KEY_VAR = "BRAIN_GATEWAY_API_KEY"
@@ -102,7 +105,7 @@ function section(lines: string[], name: string): Section | undefined {
   const at = lines.findIndex((l) => keyLine("", name).test(l))
   if (at < 0) return undefined
   const inline = inlineValue(lines[at]!)
-  if (inline && !/^(?:\{\s*\}|null|~)$/.test(inline)) throw new Error(`${name}: is written on one line (${inline.slice(0, 40)}), not as a section`)
+  if (inline && !/^(?:\{\s*\}|null|~)$/.test(inline)) throw new Error(`${name}: is written on one line, not as a section`)
   const end = blockEnd(lines, at)
   const first = lines.slice(at + 1, end).find((l) => !blank(l))
   const indent = first ? indentOf(first) : ""
@@ -209,6 +212,7 @@ export const connectors: Connector[] = [
             api_mode: "chat_completions",
             default_model: s.model,
             ...(s.contextEdit ? { extra_headers: { [EDIT_HEADER]: "on" } } : {}),
+            ...(isAuto(s) ? { models: { [s.model]: { context_length: limitsFor(s).context } } } : {}),
           },
           "model/provider": `custom:${HERMES_PROVIDER}`,
           "model/default": s.model,

package/src/gateway/connectors/kimi-code.ts

@@ -26,7 +26,7 @@
 // back the exact bytes. Before any change the codec makes a trial edit and refuses a file where that would not land
 // exactly on brain's entries (an inline `providers = {...}`, dotted keys, sub-tables of brain's tables, ...).
 import { join } from "node:path"
-import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Json, modelName, readKey, routeUrl } from "../common.ts"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Json, limitsFor, modelName, readKey, routeUrl } from "../common.ts"
 
 export const kimiConfig = (home: string, env: Record<string, string | undefined>) => join(dirFromEnv(env, "KIMI_CODE_HOME", join(home, ".kimi-code")), "config.toml")
 
@@ -227,7 +227,7 @@ export const connectors: Connector[] = [
           [`models/${PROVIDER}`]: {
             provider: PROVIDER,
             model: s.model,
-            max_context_size: 1048576,
+            max_context_size: limitsFor(s).context,
             capabilities: ["image_in", "tool_use"],
             display_name: modelName(s.model),
           },

package/src/gateway/connectors/letta-code.ts

@@ -33,7 +33,7 @@
 // (src/backend/dev/pi-request-headers.ts).
 import { existsSync } from "node:fs"
 import { isAbsolute, join } from "node:path"
-import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, type Json, keyPath, modelName, routeUrl } from "../common.ts"
+import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, type Json, keyPath, limitsFor, modelName, routeUrl } from "../common.ts"
 
 export const MOD_FILE = "brain-gateway.mjs"
 const MARK = "// Written by `brain gateway connect --tool letta-code`"
@@ -136,18 +136,15 @@ export const lettaMod: Codec = {
   },
 }
 
-/** What 100xprompt's models take (Gemini 3.x Flash: 1M tokens in, 64k out). */
-const CONTEXT_WINDOW = 1_048_576
-const MAX_TOKENS = 65_536
-
 const modValues = (home: string, s: GatewaySettings): Record<string, unknown> => ({
   provider: "brain-gateway",
   name: "100xprompt gateway",
   baseUrl: `${routeUrl(s)}/v1`,
   model: s.model,
   modelName: modelName(s.model),
-  contextWindow: CONTEXT_WINDOW,
-  maxTokens: MAX_TOKENS,
+  // What the model takes (Gemini 3.x Flash: 1M tokens in, 64k out; for 100xprompt Auto, what every model it may serve takes).
+  contextWindow: limitsFor(s).context,
+  maxTokens: limitsFor(s).output,
   keyFile: keyPath(home),
   ...(s.contextEdit ? { headers: { [EDIT_HEADER]: "on" } } : {}),
 })

package/src/gateway/connectors/openhands.ts

@@ -25,9 +25,14 @@
 //     (routing metadata for the previous endpoint; chat_options.py:83-85 sends it as extra_body). All of them come back
 //     on disconnect.
 //   - OpenHands has no named providers or model list (no profile is used by the CLI), so the LLM entry itself is switched.
+//   - With max_input_tokens and max_output_tokens null, the SDK looks the model up in LiteLLM's catalog, under the id and
+//     under the part after the last "/" (sdk/llm/utils/model_info.py get_litellm_model_info): gemini-3.8-flash is there
+//     (1,048,576 in, 65,536 out, images). 100xprompt Auto's id is not, so for auto both are set to what every model auto may
+//     serve takes (common.ts limitsFor). Images: OpenHands decides them from that same catalog only (llm.py
+//     _supports_vision; there is no setting to turn them on), so with auto it sends no images.
 import { readFileSync } from "node:fs"
 import { join } from "node:path"
-import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, type GatewaySettings, type Json, readKey, routeUrl } from "../common.ts"
+import { type Codec, type Connector, dirFromEnv, EDIT_HEADER, type Env, type GatewaySettings, isAuto, type Json, limitsFor, readKey, routeUrl } from "../common.ts"
 
 // ---- JSON edited in place ------------------------------------------------------------------------------------------------
 
@@ -261,8 +266,8 @@ const llmValues = (prefix: string, home: string, s: GatewaySettings): Record<str
   [`${prefix}/api_key`]: readKey(home),
   [`${prefix}/extra_headers`]: s.contextEdit ? { [EDIT_HEADER]: "on" } : null,
   [`${prefix}/model_canonical_name`]: null,
-  [`${prefix}/max_input_tokens`]: null,
-  [`${prefix}/max_output_tokens`]: null,
+  [`${prefix}/max_input_tokens`]: isAuto(s) ? limitsFor(s).context : null,
+  [`${prefix}/max_output_tokens`]: isAuto(s) ? limitsFor(s).output : null,
   [`${prefix}/litellm_extra_body`]: {},
 })
 
@@ -289,7 +294,7 @@ export const connectors: Connector[] = [
     },
     notes: [
       "OpenHands keeps the key in its agent_settings.json (it has no key-file option), so the file is now readable by you only (0600); a new sign-in replaces the key there.",
-      "Its agent and memory-condenser LLM now use the gateway's model over OpenAI Chat Completions; the model limits OpenHands had stored for your previous model are cleared so it looks them up again.",
+      "Its agent and memory-condenser LLM now use the gateway's model over OpenAI Chat Completions; the model limits OpenHands had stored for your previous model are cleared so it looks them up again (with 100xprompt Auto they are set instead, and OpenHands sends no images: it decides that from the model's name alone).",
       "Run without --override-with-envs (or without LLM_API_KEY, LLM_BASE_URL and LLM_MODEL set): those override this file. Changing the LLM in OpenHands' settings screen replaces these values, and disconnect then leaves your choice alone.",
     ],
   },

package/src/gateway/connectors/qwen-code.ts

@@ -20,13 +20,18 @@
 //     under a name of its own (BRAIN_GATEWAY_KEY, so no OPENAI_API_KEY of the person's is touched), and that file is 0600.
 //   - Custom headers: generationConfig.customHeaders is sent with every request (chunks/chunk-ESPAP3UW.js buildHeaders),
 //     so `x-100x-context-edit: on` goes there.
+//   - Context window and input kinds: Qwen Code takes them from the model id (chunks/chunk-5TODR7F6.js tokenLimit and
+//     defaultModalities: gemini-* gets 1,000,000 tokens and every input kind; an id it does not know gets 200,000 and text
+//     only), unless the provider entry's generationConfig gives contextWindowSize and modalities (chunks/chunk-KUBWE5YV.js
+//     ModelRegistry, MODEL_GENERATION_CONFIG_FIELDS). 100xprompt Auto's id is one it cannot know, so for auto they are given:
+//     what every model auto may serve takes (common.ts limitsFor), images and text.
 // What connect writes: settings.json gets a "brain-gateway" provider ("100xprompt gateway", model shown as its 100xprompt
 // name), its providerProtocol mapping, and the selection (auth type, model.name, model.baseUrl); ~/.qwen/.env gets the
 // key. The person's own providers, models and comments are left as they are; disconnect puts every key back.
 // Needs Qwen Code 0.23 or later (custom provider ids through providerProtocol); older ones skip the provider.
 import { existsSync } from "node:fs"
 import { join } from "node:path"
-import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, type Json, modelName, readKey, routeUrl } from "../common.ts"
+import { type Codec, type Connector, EDIT_HEADER, type Env, type GatewaySettings, isAuto, type Json, limitsFor, modelName, readKey, routeUrl } from "../common.ts"
 
 // ---- JSON with comments, edited in place ----------------------------------------------------------------------------
 //
@@ -372,6 +377,15 @@ export function qwenDir(home: string, env: Env): string {
 
 const base = (s: GatewaySettings) => `${routeUrl(s)}/v1`
 
+/** The provider entry's generationConfig: the context-edit header, and for auto the window and input kinds (see above). */
+function generationConfig(s: GatewaySettings): Json | undefined {
+  const g: Json = {
+    ...(s.contextEdit ? { customHeaders: { [EDIT_HEADER]: "on" } } : {}),
+    ...(isAuto(s) ? { contextWindowSize: limitsFor(s).context, modalities: { image: true } } : {}),
+  }
+  return Object.keys(g).length ? g : undefined
+}
+
 export const connectors: Connector[] = [
   {
     id: "qwen-code",
@@ -392,7 +406,7 @@ export const connectors: Connector[] = [
               description: "100xprompt gateway",
               baseUrl: base(s),
               envKey: QWEN_KEY_VAR,
-              ...(s.contextEdit ? { generationConfig: { customHeaders: { [EDIT_HEADER]: "on" } } } : {}),
+              ...(generationConfig(s) ? { generationConfig: generationConfig(s) } : {}),
             },
           ],
           [`providerProtocol/${PROVIDER}`]: "openai",

package/src/gateway/connectors/vscode-copilot.ts

@@ -27,13 +27,10 @@
 // Only the default VS Code profile and VS Code Stable ("Code") are handled; Insiders, VSCodium and other profiles keep
 // their own User folders.
 import { join, resolve } from "node:path"
-import { type Codec, type Connector, EDIT_HEADER, type Env, type Json, modelName, readKey, routeUrl } from "../common.ts"
+import { type Codec, type Connector, EDIT_HEADER, type Env, type Json, limitsFor, modelName, readKey, routeUrl } from "../common.ts"
 
 const GROUP = "100xprompt gateway"
 const VENDOR = "customendpoint"
-/** Gemini 3.x Flash, which the gateway's models are: a 1M-token window, 64K out. */
-const MAX_OUTPUT = 65_536
-const MAX_INPUT = 1_048_576 - MAX_OUTPUT
 
 /** VS Code's user folder: ~/Library/Application Support/Code/User on macOS, $XDG_CONFIG_HOME/Code/User or ~/.config/Code/User elsewhere. */
 export function vscodeUserDir(home: string, env: Env, platform: string = process.platform): string {
@@ -268,8 +265,9 @@ export const connectors: Connector[] = [
                 apiType: "chat-completions",
                 toolCalling: true,
                 vision: true,
-                maxInputTokens: MAX_INPUT,
-                maxOutputTokens: MAX_OUTPUT,
+                // The window less the output (Gemini 3.x Flash: 1M in, 64K out; 100xprompt Auto: what all it may serve take).
+                maxInputTokens: limitsFor(s).context - limitsFor(s).output,
+                maxOutputTokens: limitsFor(s).output,
                 requestHeaders: { Authorization: `Bearer ${readKey(home)}`, ...(s.contextEdit ? { [EDIT_HEADER]: "on" } : {}) },
               },
             ],

package/src/gateway/signin.ts

@@ -118,8 +118,38 @@ export interface SignInDeps {
 
 export type SignIn = { ok: true; key: string; email?: string; via: "browser" | "code" } | { ok: false; why: string }
 
+type Took = { ok: true; key: string; email?: string } | { ok: false; why: string }
+
+/**
+ * Which browser round trip to run: the sign-in (`brain gateway login`: /auth/cli, a gateway key comes back) or pairing
+ * (`brain pair`: /auth/brain, the computer's own token comes back). Everything else (the loopback server, the state,
+ * the paste fallback) is the same.
+ */
+export interface BrowserFlow {
+  /** The command the person ran, named in the refusal page. */
+  command: string
+  /** The site's page, and what else it is told. */
+  path: string
+  params?: Record<string, string>
+  /** What a callback's token or a pasted text must be to be kept. */
+  accept(token: string): Took
+  /** Words: what the browser is opened for, the page shown when it worked, and what to paste. */
+  opening: string
+  done: (email?: string) => { title: string; body: string }
+  paste: string
+}
+
+export const SIGN_IN_FLOW: BrowserFlow = {
+  command: "brain gateway login",
+  path: "/auth/cli",
+  accept: (token) => callbackKey(token),
+  opening: "sign in to 100xprompt",
+  done: (email) => ({ title: "Signed in", body: `brain is now signed in to the 100xprompt gateway${email ? ` as ${email}` : ""}. You can close this tab and go back to your terminal.` }),
+  paste: "Paste the key from the page's Copy key button, or the address the browser could not open",
+}
+
 /** Signs in through the browser (or a pasted code). Does not store anything: the caller does. */
-export async function browserSignIn(d: SignInDeps): Promise<SignIn> {
+export async function browserSignIn(d: SignInDeps, flow: BrowserFlow = SIGN_IN_FLOW): Promise<SignIn> {
   const base = signInBase(d.authUrl)
   if (!base) return { ok: false, why: "HUNDREDXPROMPT_AUTH_URL must be an http:// or https:// address" }
   const { challenge } = await pkce()
@@ -145,35 +175,37 @@ export async function browserSignIn(d: SignInDeps): Promise<SignIn> {
       const got = url.searchParams.get("state") ?? ""
       const error = url.searchParams.get("error")
       // Only the page this command opened knows the state: anything else is refused and the wait goes on.
-      if (!/^[0-9a-f]{64}$/.test(got) || !sameState(got, state)) return page("Sign-in refused", "This link was not started by this brain gateway login. Start again from your terminal.", 400)
+      if (!/^[0-9a-f]{64}$/.test(got) || !sameState(got, state)) return page("Sign-in refused", `This link was not started by this ${flow.command}. Start again from your terminal.`, 400)
       if (error) {
         settle({ ok: false, why: `the sign-in page said: ${error.slice(0, 200)}` })
         return page("Sign-in failed", `${error.slice(0, 200)}. Go back to your terminal.`, 400)
       }
-      const c = callbackKey(url.searchParams.get("token") ?? "")
+      const c = flow.accept(url.searchParams.get("token") ?? "")
       if (!c.ok) {
         settle({ ok: false, why: c.why })
         return page("Sign-in failed", "No usable key came back. Go back to your terminal.", 400)
       }
       const email = url.searchParams.get("email") || c.email || undefined
       settle({ ok: true, key: c.key, ...(email ? { email } : {}), via: "browser" })
-      return page("Signed in", `brain is now signed in to the 100xprompt gateway${email ? ` as ${email}` : ""}. You can close this tab and go back to your terminal.`)
+      const done = flow.done(email)
+      return page(done.title, done.body)
     },
   })
-  const url = `${base}/auth/cli?port=${server.port}&state=${state}&challenge=${challenge}`
+  const extra = Object.entries(flow.params ?? {}).map(([k, v]) => `&${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("")
+  const url = `${base}${flow.path}?port=${server.port}&state=${state}&challenge=${challenge}${extra}`
   const stopAsking = new AbortController()
   const timer = setTimeout(() => settle({ ok: false, why: `no sign-in came back within ${Math.round((d.timeoutMs ?? TIMEOUT_MS) / 60_000) || 1} minutes` }), d.timeoutMs ?? TIMEOUT_MS)
   try {
-    if (d.browser === false) d.say(`Open this address in a browser to sign in to 100xprompt:\n  ${url}`)
+    if (d.browser === false) d.say(`Open this address in a browser to ${flow.opening}:\n  ${url}`)
     else {
-      d.say(`Opening your browser to sign in to 100xprompt:\n  ${url}`)
+      d.say(`Opening your browser to ${flow.opening}:\n  ${url}`)
       try {
         ;(d.open ?? openInBrowser)(url)
       } catch {}
     }
     if (d.ask) {
       d.say(
-        "Waiting for the browser. Signing in on another machine (SSH)? Paste the key from the page's Copy key button, or the address the browser could not open, then press Enter (Escape cancels).",
+        `Waiting for the browser. Signing in on another machine (SSH)? ${flow.paste}, then press Enter (Escape cancels).`,
       )
       // The paste runs alongside the browser: whichever comes first wins. A bad paste asks again; Escape ends the sign-in
       // (an abandoned hidden prompt would leave the terminal echoing whatever is pasted next, and the shell reading it).
@@ -183,7 +215,7 @@ export async function browserSignIn(d: SignInDeps): Promise<SignIn> {
           if (settled) return
           if (pasted === undefined) return settle({ ok: false, why: "sign-in cancelled" })
           if (!pasted.trim()) continue
-          const c = fromPaste(pasted.trim(), state)
+          const c = fromPaste(pasted.trim(), state, flow)
           if (c.ok) return settle({ ok: true, key: c.key, ...(c.email ? { email: c.email } : {}), via: "code" })
           if ("fatal" in c) return settle({ ok: false, why: c.why })
           d.say(`  ${c.why}`)
@@ -207,7 +239,7 @@ export async function browserSignIn(d: SignInDeps): Promise<SignIn> {
  * 127.0.0.1 on the wrong machine, and the address it could not open holds the key). An address must carry this sign-in's
  * state, so one from another sign-in, or one made up, is refused.
  */
-export function fromPaste(pasted: string, state: string): { ok: true; key: string; email?: string } | { ok: false; why: string } | { ok: false; why: string; fatal: true } {
+export function fromPaste(pasted: string, state: string, flow: BrowserFlow = SIGN_IN_FLOW): { ok: true; key: string; email?: string } | { ok: false; why: string } | { ok: false; why: string; fatal: true } {
   if (/^https?:\/\//i.test(pasted)) {
     let u: URL
     try {
@@ -220,12 +252,12 @@ export function fromPaste(pasted: string, state: string): { ok: true; key: strin
     if (!/^[0-9a-f]{64}$/.test(got) || !sameState(got, state)) return { ok: false, why: "that address is from another sign-in: paste the one from this sign-in" }
     const error = u.searchParams.get("error")
     if (error) return { ok: false, why: `the sign-in page said: ${error.slice(0, 200)}`, fatal: true }
-    const c = callbackKey(u.searchParams.get("token") ?? "")
+    const c = flow.accept(u.searchParams.get("token") ?? "")
     if (!c.ok) return c
     const email = u.searchParams.get("email") || c.email
     return { ok: true, key: c.key, ...(email ? { email } : {}) }
   }
-  return checkCredential(pasted)
+  return flow === SIGN_IN_FLOW ? checkCredential(pasted) : flow.accept(pasted)
 }
 
 /**

package/src/hooks.ts

@@ -1,10 +1,11 @@
 import { CLI_PATH, selfArgs, stableBun } from "./self.ts"
-import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs"
+import { copyFileSync, existsSync, mkdirSync, readFileSync, realpathSync, statSync, unlinkSync } from "node:fs"
 import { dirname, join } from "node:path"
 import { toolLabel } from "./brief.ts"
-import { gitInfo, isDir } from "./fsutil.ts"
+import { gitInfo, isDir, writeAtomic } from "./fsutil.ts"
 import { findHandoff, type Handoff, markConsumed } from "./handoff.ts"
 import { syncInBackground } from "./memory/sync.ts"
+import { withBrainLock } from "./lock.ts"
 
 // Session-start hooks: how a pending handoff (handoff.ts) reaches the model in the target tool without the
 // person pasting anything. Each tool runs `<bun> brain/src/cli.ts session hook session-start --tool <tool>`
@@ -193,19 +194,15 @@ function save(path: string, config: Json, indent: string) {
   const real = existsSync(path) ? realpathSync(path) : path
   mkdirSync(dirname(real), { recursive: true })
   if (existsSync(real) && !existsSync(backupOf(path))) copyFileSync(real, backupOf(path))
-  const tmp = `${real}.brain-tmp`
   let mode: number | undefined
   try {
     mode = statSync(real).mode & 0o777
   } catch {
     // A new file keeps the default mode.
   }
-  // Create the copy with the file's own mode: Claude Code's settings are 0600 and can hold API keys, so they must
-  // not sit readable by everyone, even for a moment. A copy left by an interrupted run would keep its old mode.
-  rmSync(tmp, { force: true })
-  writeFileSync(tmp, `${JSON.stringify(config, null, indent)}\n`, mode === undefined ? {} : { mode })
-  if (mode !== undefined) chmodSync(tmp, mode)
-  renameSync(tmp, real)
+  // The copy is created with the file's own mode: Claude Code's settings are 0600 and can hold API keys, so they must
+  // not sit readable by everyone, even for a moment.
+  writeAtomic(real, `${JSON.stringify(config, null, indent)}\n`, mode)
 }
 
 interface Pos {
@@ -256,6 +253,12 @@ export function hookInstalled(tool: string, home: string): boolean {
   return Array.isArray(list) && positions(list, spec, id).length > 0 && !spec.off?.(loaded.config)
 }
 
+/** Whether `tool` has a session-start hook brain can install, and has run here (its folder exists). */
+export function hookToolHere(tool: string, home: string): boolean {
+  const spec = SPECS[toolId(tool)]
+  return !!spec && isDir(join(home, spec.dir))
+}
+
 export interface HookChange {
   tool: string
   /** The config file changed (or that would be). */
@@ -287,6 +290,10 @@ function prepare(tool: string, home: string): { id: string; spec: Spec; path: st
  * the hook command (`<bun> <cli.ts>`); the rest stays, since that is how uninstall finds the entry.
  */
 export async function installHooks(tools: string[], home: string, opts: { dryRun?: boolean; command?: string } = {}): Promise<HookChange[]> {
+  return opts.dryRun ? installLocked(tools, home, opts) : withBrainLock(home, () => installLocked(tools, home, opts), { what: "installing session hooks" })
+}
+
+async function installLocked(tools: string[], home: string, opts: { dryRun?: boolean; command?: string }): Promise<HookChange[]> {
   const out: HookChange[] = []
   for (const tool of [...new Set(tools)]) {
     const p = prepare(tool, home)
@@ -333,6 +340,10 @@ export async function installHooks(tools: string[], home: string, opts: { dryRun
 
 /** Removes exactly what installHooks added. */
 export async function uninstallHooks(tools: string[], home: string, opts: { dryRun?: boolean } = {}): Promise<HookChange[]> {
+  return opts.dryRun ? uninstallLocked(tools, home, opts) : withBrainLock(home, () => uninstallLocked(tools, home, opts), { what: "removing session hooks" })
+}
+
+async function uninstallLocked(tools: string[], home: string, opts: { dryRun?: boolean }): Promise<HookChange[]> {
   const out: HookChange[] = []
   for (const tool of [...new Set(tools)]) {
     const p = prepare(tool, home)