open-research 1.0.0 → 1.0.1

package/dist/cli.js

@@ -2,7 +2,16 @@
 import {
   appendSessionEvent,
   loadSessionHistory
-} from "./chunk-ZUSIRA5S.js";
+} from "./chunk-HRVDYJEC.js";
+import {
+  GEMINI_CODE_ASSIST_URL,
+  clearStoredAuth,
+  loadGeminiAuth,
+  loadStoredAuth,
+  refreshGeminiAccessToken,
+  saveGeminiAuth,
+  saveStoredAuth
+} from "./chunk-3GZIDCV2.js";
 import {
   ensureOpenResearchConfig,
   executeFetchUrl,
@@ -15,19 +24,26 @@ import {
   getOpenAlexApiKey,
   getSemanticScholarApiKey,
   loadOpenResearchConfig,
-  readJsonFile,
   saveOpenResearchConfig,
-  themeValues,
+  themeValues
+} from "./chunk-3KZN54JZ.js";
+import {
+  readJsonFile,
   writeJsonFile
-} from "./chunk-TQSQRNX6.js";
+} from "./chunk-77Q5B5H7.js";
 import {
-  getOpenResearchAuthFile,
   getOpenResearchRoot,
   getOpenResearchSkillsDir,
   getWorkspaceMetaDir,
   getWorkspaceProjectFile,
   getWorkspaceSessionsDir
-} from "./chunk-I5NVYKG7.js";
+} from "./chunk-4HCPHCC2.js";
+import {
+  getAvailableModels,
+  getDefaultModel,
+  getProviderCatalog,
+  selectModelForTask
+} from "./chunk-GVEVKDGV.js";
 import {
   __require
 } from "./chunk-3RG5ZIWI.js";
@@ -164,7 +180,7 @@ ${markdown}`;
 }
 
 // src/lib/auth/import-codex.ts
-import fs4 from "fs/promises";
+import fs3 from "fs/promises";
 import path3 from "path";
 
 // src/lib/storage/credential-types.ts
@@ -193,30 +209,6 @@ function getBootstrapCredentialValidation() {
   };
 }
 
-// src/lib/auth/store.ts
-import fs3 from "fs/promises";
-var AUTH_FILE_MODE = 384;
-async function ensureCliHome(options) {
-  const root = getOpenResearchRoot(options);
-  await fs3.mkdir(root, { recursive: true, mode: 448 });
-  return root;
-}
-async function saveStoredAuth(auth2, options) {
-  await ensureCliHome(options);
-  const authFile = getOpenResearchAuthFile(options);
-  await writeJsonFile(authFile, auth2, AUTH_FILE_MODE);
-  await fs3.chmod(authFile, AUTH_FILE_MODE);
-  return authFile;
-}
-async function loadStoredAuth(options) {
-  const authFile = getOpenResearchAuthFile(options);
-  return readJsonFile(authFile, null);
-}
-async function clearStoredAuth(options) {
-  const authFile = getOpenResearchAuthFile(options);
-  await fs3.rm(authFile, { force: true });
-}
-
 // src/lib/auth/openai-oauth.ts
 import { createHash, randomBytes } from "crypto";
 var OPENAI_AUTH_URL = "https://auth.openai.com/oauth/authorize";
@@ -309,7 +301,7 @@ async function importCodexAuth(options = {}) {
   const now = options.now ?? Date.now;
   const codexAuthPath = options.codexAuthFilePath ?? path3.join(options.homeDir ?? process.env.HOME ?? "", ".codex", "auth.json");
   const parsed = JSON.parse(
-    await fs4.readFile(codexAuthPath, "utf8")
+    await fs3.readFile(codexAuthPath, "utf8")
   );
   if (parsed.auth_mode !== "chatgpt") {
     throw new Error("Codex is not signed in with OpenAI on this device.");
@@ -480,54 +472,6 @@ var OPENAI_AUTH_ONLY = process.env.OPENAI_AUTH_ONLY !== "false";
 var CODEX_RESPONSES_URL = process.env.CODEX_RESPONSES_URL ?? "https://chatgpt.com/backend-api/codex/responses";
 var OPENAI_VALIDATION_STALE_MS = 15 * 60 * 1e3;
 
-// src/lib/llm/provider-catalog.ts
-var OPENAI_PROVIDER_MODELS = [
-  "gpt-5.4",
-  "gpt-5.4-mini",
-  "o3",
-  "o4-mini"
-];
-var OPENAI_CATALOG = {
-  family: "openai",
-  displayName: "OpenAI",
-  models: OPENAI_PROVIDER_MODELS,
-  defaultModel: "gpt-5.4",
-  backgroundModel: "gpt-5.4-mini"
-};
-function getProviderCatalog(providerKind) {
-  switch (providerKind) {
-    case "openai_auth":
-    case "openai_api_key":
-    default:
-      return OPENAI_CATALOG;
-  }
-}
-function getAvailableModels(providerKind) {
-  return getProviderCatalog(providerKind).models;
-}
-function isSupportedModel(model, providerKind) {
-  if (!model) return false;
-  return getAvailableModels(providerKind).includes(model);
-}
-function getDefaultModel(providerKind) {
-  return getProviderCatalog(providerKind).defaultModel;
-}
-function selectModelForTask(providerKind, requestedModel, task) {
-  const catalog = getProviderCatalog(providerKind);
-  const selected = isSupportedModel(requestedModel, providerKind) ? requestedModel : catalog.defaultModel;
-  switch (task) {
-    case "conversation":
-      return selected;
-    case "compaction":
-      return selected.includes("5.4") ? catalog.backgroundModel : selected;
-    case "memory":
-    case "workspace":
-      return catalog.backgroundModel;
-    default:
-      return selected;
-  }
-}
-
 // src/lib/llm/openai-connection.ts
 var VALIDATION_INSTRUCTIONS = "You are validating whether this OpenAI Codex connection can execute a minimal request. Reply with the single word ok.";
 function buildHeaders(token, accountId) {
@@ -645,44 +589,42 @@ function trimCredential(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : void 0;
 }
-async function resolveConfiguredProvider(options) {
-  const [config, stored] = await Promise.all([
-    loadOpenResearchConfig({ homeDir: options?.homeDir }),
-    loadStoredAuth({ homeDir: options?.homeDir })
-  ]);
+function resolveOpenAI(stored, config) {
   if (stored) {
-    return {
-      kind: "openai_auth",
-      source: "stored_auth",
-      stored
-    };
+    return { kind: "openai_auth", source: "stored_auth", stored };
   }
   const envKey = trimCredential(process.env.OPENAI_API_KEY);
-  if (envKey) {
-    return {
-      kind: "openai_api_key",
-      source: "env",
-      apiKey: envKey
-    };
-  }
+  if (envKey) return { kind: "openai_api_key", source: "env", apiKey: envKey };
   const providerKey = trimCredential(config?.providers?.openai?.apiKey);
-  if (providerKey) {
-    return {
-      kind: "openai_api_key",
-      source: "providers.openai.apiKey",
-      apiKey: providerKey
-    };
-  }
+  if (providerKey) return { kind: "openai_api_key", source: "providers.openai.apiKey", apiKey: providerKey };
   const legacyKey = trimCredential(config?.apiKeys?.openai);
-  if (legacyKey) {
-    return {
-      kind: "openai_api_key",
-      source: "apiKeys.openai",
-      apiKey: legacyKey
-    };
-  }
+  if (legacyKey) return { kind: "openai_api_key", source: "apiKeys.openai", apiKey: legacyKey };
   return null;
 }
+function resolveGemini(stored, config) {
+  if (stored) {
+    return { kind: "gemini_auth", source: "stored_auth", stored };
+  }
+  const envKey = trimCredential(process.env.GEMINI_API_KEY);
+  if (envKey) return { kind: "gemini_api_key", source: "env", apiKey: envKey };
+  const providerKey = trimCredential(config?.providers?.gemini?.apiKey);
+  if (providerKey) return { kind: "gemini_api_key", source: "providers.gemini.apiKey", apiKey: providerKey };
+  const legacyKey = trimCredential(config?.apiKeys?.gemini);
+  if (legacyKey) return { kind: "gemini_api_key", source: "apiKeys.gemini", apiKey: legacyKey };
+  return null;
+}
+async function resolveConfiguredProvider(options) {
+  const [config, openaiStored, geminiStored] = await Promise.all([
+    loadOpenResearchConfig({ homeDir: options?.homeDir }),
+    loadStoredAuth({ homeDir: options?.homeDir }),
+    loadGeminiAuth({ homeDir: options?.homeDir })
+  ]);
+  const activeProvider = config?.activeProvider ?? "openai";
+  if (activeProvider === "gemini") {
+    return resolveGemini(geminiStored, config) ?? resolveOpenAI(openaiStored, config);
+  }
+  return resolveOpenAI(openaiStored, config) ?? resolveGemini(geminiStored, config);
+}
 async function hasConfiguredProvider(options) {
   return await resolveConfiguredProvider(options) !== null;
 }
@@ -691,24 +633,22 @@ async function getConfiguredProviderSummary(options) {
   if (!resolved) {
     return {
       connected: false,
-      message: "No OpenAI credentials configured. Set OPENAI_API_KEY, run /config apikey <key>, or run /auth."
+      message: "No credentials configured. Run /auth (OpenAI), /auth-gemini (Google), or /config apikey <key>."
     };
   }
   if (resolved.kind === "openai_auth") {
-    return {
-      connected: true,
-      kind: resolved.kind,
-      source: resolved.source,
-      message: "OpenAI account connected."
-    };
+    return { connected: true, kind: resolved.kind, source: resolved.source, message: "OpenAI account connected." };
   }
-  const sourceMessage = resolved.source === "env" ? "OPENAI_API_KEY" : resolved.source === "providers.openai.apiKey" ? "providers.openai.apiKey" : "apiKeys.openai";
-  return {
-    connected: true,
-    kind: resolved.kind,
-    source: resolved.source,
-    message: `OpenAI API key configured via ${sourceMessage}.`
-  };
+  if (resolved.kind === "openai_api_key") {
+    return { connected: true, kind: resolved.kind, source: resolved.source, message: `OpenAI API key configured via ${resolved.source}.` };
+  }
+  if (resolved.kind === "gemini_auth") {
+    return { connected: true, kind: resolved.kind, source: resolved.source, message: `Google account connected (${resolved.stored.tokens.email}).` };
+  }
+  if (resolved.kind === "gemini_api_key") {
+    return { connected: true, kind: resolved.kind, source: resolved.source, message: `Gemini API key configured via ${resolved.source}.` };
+  }
+  return { connected: false, message: "Unknown provider state." };
 }
 
 // src/lib/auth/status.ts
@@ -743,7 +683,7 @@ async function getAuthStatus(options) {
 }
 
 // src/lib/skills/registry.ts
-import fs5 from "fs/promises";
+import fs4 from "fs/promises";
 import fsSync from "fs";
 import path4 from "path";
 import matter from "gray-matter";
@@ -756,13 +696,13 @@ function normalizeSkillName(name) {
 }
 async function ensureUserSkillsDir(options) {
   const dir = getOpenResearchSkillsDir(options);
-  await fs5.mkdir(dir, { recursive: true });
+  await fs4.mkdir(dir, { recursive: true });
   return dir;
 }
 async function readSkillSummary(skillDir, source2) {
   const skillFile = path4.join(skillDir, "SKILL.md");
   try {
-    const raw = await fs5.readFile(skillFile, "utf8");
+    const raw = await fs4.readFile(skillFile, "utf8");
     const parsed = matter(raw);
     const name = String(parsed.data.name ?? "").trim();
     const description = String(parsed.data.description ?? "").trim();
@@ -781,7 +721,7 @@ async function readSkillSummary(skillDir, source2) {
   }
 }
 async function listSkillsInDirectory(rootDir, source2) {
-  const entries = await fs5.readdir(rootDir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs4.readdir(rootDir, { withFileTypes: true }).catch(() => []);
   const results = await Promise.all(
     entries.filter((entry) => entry.isDirectory()).map((entry) => readSkillSummary(path4.join(rootDir, entry.name), source2))
   );
@@ -798,7 +738,7 @@ async function listAvailableSkills(options) {
 async function validateSkillDirectory(input2) {
   const errors = [];
   const skillFile = path4.join(input2.skillDir, "SKILL.md");
-  const raw = await fs5.readFile(skillFile, "utf8").catch(() => "");
+  const raw = await fs4.readFile(skillFile, "utf8").catch(() => "");
   if (!raw) {
     return { ok: false, errors: ["SKILL.md is missing."] };
   }
@@ -829,9 +769,9 @@ async function createSkillScaffold(input2) {
   const skillsDir = await ensureUserSkillsDir({ homeDir: input2.homeDir });
   const name = normalizeSkillName(input2.name);
   const skillDir = path4.join(skillsDir, name);
-  await fs5.mkdir(path4.join(skillDir, "scripts"), { recursive: true });
-  await fs5.mkdir(path4.join(skillDir, "references"), { recursive: true });
-  await fs5.mkdir(path4.join(skillDir, "assets"), { recursive: true });
+  await fs4.mkdir(path4.join(skillDir, "scripts"), { recursive: true });
+  await fs4.mkdir(path4.join(skillDir, "references"), { recursive: true });
+  await fs4.mkdir(path4.join(skillDir, "assets"), { recursive: true });
   const body = `---
 name: ${name}
 description: ${input2.description}
@@ -851,7 +791,7 @@ ${input2.examples.map((example) => `- ${example}`).join("\n")}
 
 ${input2.workflow}
 `;
-  await fs5.writeFile(path4.join(skillDir, "SKILL.md"), body, "utf8");
+  await fs4.writeFile(path4.join(skillDir, "SKILL.md"), body, "utf8");
   return skillDir;
 }
 
@@ -889,7 +829,7 @@ function formatDateTime(value) {
 }
 
 // src/lib/cli/version.ts
-var PACKAGE_VERSION = "1.0.0";
+var PACKAGE_VERSION = "1.0.1";
 function getPackageVersion() {
   return PACKAGE_VERSION;
 }
@@ -2355,7 +2295,7 @@ function useTheme() {
 }
 
 // src/lib/workspace/scan.ts
-import fs6 from "fs/promises";
+import fs5 from "fs/promises";
 import path5 from "path";
 var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
   ".md",
@@ -2386,7 +2326,7 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   ".turbo"
 ]);
 async function walkDir(rootDir, currentDir, out) {
-  const entries = await fs6.readdir(currentDir, { withFileTypes: true });
+  const entries = await fs5.readdir(currentDir, { withFileTypes: true });
   for (const entry of entries) {
     if (IGNORED_DIRS.has(entry.name)) {
       continue;
@@ -2404,7 +2344,7 @@ async function walkDir(rootDir, currentDir, out) {
       key: `path:${relativePath}`,
       label: relativePath,
       path: relativePath,
-      content: await fs6.readFile(fullPath, "utf8")
+      content: await fs5.readFile(fullPath, "utf8")
     });
   }
 }
@@ -2563,14 +2503,14 @@ function createOpenAIAuthProvider(credentials, onTokenRefresh, onValidationChang
     }
     return creds.accessToken;
   }
-  const sessionId = crypto.randomUUID();
+  const sessionId2 = crypto.randomUUID();
   function buildHeaders3(token) {
     const headers = {
       Authorization: `Bearer ${token}`,
       "Content-Type": "application/json",
       originator: "open-research",
       "User-Agent": `open-research/${getPackageVersion()} (${process.platform} ${process.arch})`,
-      session_id: sessionId
+      session_id: sessionId2
     };
     if (creds.accountId) {
       headers["ChatGPT-Account-Id"] = creds.accountId;
@@ -3085,12 +3025,478 @@ function createOpenAIAPIKeyProvider(apiKey) {
   };
 }
 
+// src/lib/llm/gemini-format.ts
+function convertMessagesToGemini(messages) {
+  const systemParts = [];
+  const rawContents = [];
+  const toolCallNames = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    if (msg.role === "assistant" && msg.tool_calls) {
+      for (const tc of msg.tool_calls) {
+        toolCallNames.set(tc.id, tc.function.name);
+      }
+    }
+  }
+  for (const msg of messages) {
+    if (msg.role === "system") {
+      const text = typeof msg.content === "string" ? msg.content : "";
+      if (text.trim()) systemParts.push(text);
+      continue;
+    }
+    if (msg.role === "user") {
+      const text = typeof msg.content === "string" ? msg.content : "";
+      if (text.trim()) {
+        rawContents.push({ role: "user", parts: [{ text }] });
+      }
+      continue;
+    }
+    if (msg.role === "assistant") {
+      const parts = [];
+      const text = typeof msg.content === "string" ? msg.content : "";
+      if (text.trim()) {
+        parts.push({ text });
+      }
+      if (msg.tool_calls) {
+        for (const tc of msg.tool_calls) {
+          let args = {};
+          try {
+            args = JSON.parse(tc.function.arguments);
+          } catch {
+          }
+          parts.push({
+            functionCall: { name: tc.function.name, args },
+            thoughtSignature: "skip_thought_signature_validator"
+          });
+        }
+      }
+      if (parts.length > 0) {
+        rawContents.push({ role: "model", parts });
+      }
+      continue;
+    }
+    if (msg.role === "tool") {
+      const name = msg.tool_call_id ? toolCallNames.get(msg.tool_call_id) ?? "unknown" : "unknown";
+      const content = typeof msg.content === "string" ? msg.content : "";
+      rawContents.push({
+        role: "user",
+        parts: [{ functionResponse: { name, response: { content } } }]
+      });
+      continue;
+    }
+  }
+  const merged = [];
+  for (const content of rawContents) {
+    const last = merged[merged.length - 1];
+    if (last && last.role === content.role) {
+      last.parts.push(...content.parts);
+    } else {
+      merged.push({ role: content.role, parts: [...content.parts] });
+    }
+  }
+  return {
+    systemInstruction: systemParts.length > 0 ? { parts: systemParts.map((text) => ({ text })) } : void 0,
+    contents: merged
+  };
+}
+function convertToolsToGemini(tools) {
+  if (!tools || tools.length === 0) return void 0;
+  return {
+    functionDeclarations: tools.map((t) => ({
+      name: t.function.name,
+      description: t.function.description,
+      parameters: t.function.parameters
+    }))
+  };
+}
+function mapReasoningEffort(effort, model) {
+  if (!effort || effort === "none") return void 0;
+  if (model.includes("gemini-3")) {
+    const levelMap = {
+      low: "THINKING_LEVEL_LOW",
+      medium: "THINKING_LEVEL_MEDIUM",
+      high: "THINKING_LEVEL_HIGH",
+      xhigh: "THINKING_LEVEL_HIGH"
+    };
+    return {
+      thinkingConfig: {
+        thinkingLevel: levelMap[effort] ?? "THINKING_LEVEL_MEDIUM",
+        includeThoughts: true
+      }
+    };
+  }
+  const budgetMap = {
+    low: 1024,
+    medium: 8192,
+    high: 16384,
+    xhigh: 32768
+  };
+  return {
+    thinkingConfig: {
+      thinkingBudget: budgetMap[effort] ?? 8192,
+      includeThoughts: true
+    }
+  };
+}
+function mapJsonSchema(schema) {
+  if (!schema) return void 0;
+  return {
+    responseMimeType: "application/json",
+    responseSchema: schema.schema
+  };
+}
+
+// src/lib/llm/providers/gemini-auth.ts
+var REFRESH_BUFFER_MS = 6e4;
+var GEMINI_CLI_VERSION = "0.30.0";
+var sessionId = crypto.randomUUID();
+function createGeminiAuthProvider(credentials, onTokenRefresh) {
+  let currentToken = credentials.accessToken;
+  let currentExpiry = credentials.expiresAt;
+  let refreshing = null;
+  async function ensureValidToken() {
+    if (Date.now() < currentExpiry - REFRESH_BUFFER_MS) {
+      return currentToken;
+    }
+    if (!refreshing) {
+      refreshing = (async () => {
+        const result = await refreshGeminiAccessToken(credentials.refreshToken);
+        currentToken = result.access_token;
+        currentExpiry = Date.now() + result.expires_in * 1e3;
+        if (result.refresh_token) {
+          credentials.refreshToken = result.refresh_token;
+        }
+        await onTokenRefresh({
+          ...credentials,
+          accessToken: currentToken,
+          expiresAt: currentExpiry
+        });
+      })();
+    }
+    try {
+      await refreshing;
+    } finally {
+      refreshing = null;
+    }
+    return currentToken;
+  }
+  function buildHeaders3(token, model) {
+    return {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "User-Agent": `GeminiCLI/${GEMINI_CLI_VERSION}/${model} (${process.platform}; ${process.arch})`,
+      "x-activity-request-id": Math.random().toString(36).slice(2, 10)
+    };
+  }
+  function buildRequestBody(options, model) {
+    const messages = options.messages;
+    const { systemInstruction, contents } = convertMessagesToGemini(messages);
+    const generationConfig = {};
+    if (options.temperature !== void 0) generationConfig.temperature = options.temperature;
+    if (options.maxTokens !== void 0) generationConfig.maxOutputTokens = options.maxTokens;
+    const thinking = mapReasoningEffort(options.reasoningEffort, model);
+    if (thinking) Object.assign(generationConfig, thinking);
+    if ("jsonSchema" in options && options.jsonSchema) {
+      const schema = mapJsonSchema(options.jsonSchema);
+      if (schema) Object.assign(generationConfig, schema);
+    }
+    const request = {
+      contents,
+      generationConfig,
+      session_id: sessionId
+    };
+    if (systemInstruction) request.systemInstruction = systemInstruction;
+    if ("tools" in options && options.tools) {
+      const geminiTools = convertToolsToGemini(options.tools);
+      if (geminiTools) request.tools = [geminiTools];
+    }
+    return {
+      project: credentials.projectId,
+      model,
+      user_prompt_id: crypto.randomUUID(),
+      request
+    };
+  }
+  async function callLLM(options) {
+    const model = options.model ?? "gemini-3.1-pro-preview";
+    const token = await ensureValidToken();
+    const body = buildRequestBody(options, model);
+    const startTime = Date.now();
+    const response = await fetch(
+      `${GEMINI_CODE_ASSIST_URL}/v1internal:generateContent`,
+      {
+        method: "POST",
+        headers: buildHeaders3(token, model),
+        body: JSON.stringify(body)
+      }
+    );
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Gemini API error: ${response.status} ${text}`);
+    }
+    const data = await response.json();
+    const inner = data.response ?? data;
+    const parts = inner.candidates?.[0]?.content?.parts ?? [];
+    const content = parts.map((p) => p.text ?? "").join("");
+    const usage = inner.usageMetadata ?? {};
+    return {
+      content,
+      model,
+      usage: {
+        promptTokens: usage.promptTokenCount ?? 0,
+        completionTokens: usage.candidatesTokenCount ?? 0,
+        totalTokens: usage.totalTokenCount ?? 0
+      },
+      latencyMs: Date.now() - startTime
+    };
+  }
+  async function* callLLMStreaming(options) {
+    const model = options.model ?? "gemini-3.1-pro-preview";
+    const token = await ensureValidToken();
+    const body = buildRequestBody(options, model);
+    const response = await fetch(
+      `${GEMINI_CODE_ASSIST_URL}/v1internal:streamGenerateContent?alt=sse`,
+      {
+        method: "POST",
+        headers: {
+          ...buildHeaders3(token, model),
+          Accept: "text/event-stream"
+        },
+        body: JSON.stringify(body),
+        signal: options.signal
+      }
+    );
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Gemini streaming error: ${response.status} ${text}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("No response body");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let fullText = "";
+    const toolCalls = [];
+    let toolCallIndex = 0;
+    let lastUsage;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      while (buffer.includes("\n")) {
+        const lineEnd = buffer.indexOf("\n");
+        const line = buffer.slice(0, lineEnd).trim();
+        buffer = buffer.slice(lineEnd + 1);
+        if (!line.startsWith("data: ")) continue;
+        const jsonStr = line.slice(6);
+        if (jsonStr === "[DONE]") continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(jsonStr);
+        } catch {
+          continue;
+        }
+        const inner = parsed.response ?? parsed;
+        const candidates = inner.candidates ?? [];
+        const candidate = candidates[0];
+        if (!candidate) continue;
+        const parts = candidate.content?.parts ?? [];
+        for (const part of parts) {
+          if (typeof part.text === "string" && part.text) {
+            if (part.thought === true) continue;
+            fullText += part.text;
+            yield { type: "text_delta", content: part.text };
+          }
+          if (part.functionCall) {
+            const fc = part.functionCall;
+            const id = `call_${crypto.randomUUID().slice(0, 8)}`;
+            const args = JSON.stringify(fc.args ?? {});
+            toolCalls.push({ id, name: fc.name, arguments: args });
+            yield { type: "tool_call_start", index: toolCallIndex, id, name: fc.name };
+            yield { type: "tool_call_delta", index: toolCallIndex, arguments: args };
+            toolCallIndex++;
+          }
+        }
+        const usage = inner.usageMetadata;
+        if (usage) {
+          lastUsage = {
+            promptTokens: usage.promptTokenCount ?? 0,
+            completionTokens: usage.candidatesTokenCount ?? 0,
+            totalTokens: usage.totalTokenCount ?? 0,
+            cachedTokens: usage.cachedContentTokenCount ?? 0,
+            reasoningTokens: usage.thoughtsTokenCount ?? 0
+          };
+        }
+      }
+    }
+    yield {
+      type: "done",
+      content: fullText,
+      toolCalls,
+      usage: lastUsage
+    };
+  }
+  return {
+    kind: "gemini_auth",
+    callLLM,
+    callLLMStreaming
+  };
+}
+
+// src/lib/llm/providers/gemini-api-key.ts
+var GEMINI_API_BASE = "https://generativelanguage.googleapis.com/v1beta";
+function createGeminiAPIKeyProvider(apiKey) {
+  function buildRequestBody(options, model) {
+    const { systemInstruction, contents } = convertMessagesToGemini(options.messages);
+    const generationConfig = {};
+    if (options.temperature !== void 0) generationConfig.temperature = options.temperature;
+    if (options.maxTokens !== void 0) generationConfig.maxOutputTokens = options.maxTokens;
+    const thinking = mapReasoningEffort(options.reasoningEffort, model);
+    if (thinking) Object.assign(generationConfig, thinking);
+    if ("jsonSchema" in options && options.jsonSchema) {
+      const schema = mapJsonSchema(options.jsonSchema);
+      if (schema) Object.assign(generationConfig, schema);
+    }
+    const body = {
+      contents,
+      generationConfig
+    };
+    if (systemInstruction) body.systemInstruction = systemInstruction;
+    if ("tools" in options && options.tools) {
+      const geminiTools = convertToolsToGemini(options.tools);
+      if (geminiTools) body.tools = [geminiTools];
+    }
+    return body;
+  }
+  async function callLLM(options) {
+    const model = options.model ?? "gemini-3-flash-preview";
+    const body = buildRequestBody(options, model);
+    const startTime = Date.now();
+    const response = await fetch(
+      `${GEMINI_API_BASE}/models/${model}:generateContent`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": apiKey
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Gemini API error: ${response.status} ${text}`);
+    }
+    const data = await response.json();
+    const parts = data.candidates?.[0]?.content?.parts ?? [];
+    const content = parts.map((p) => p.text ?? "").join("");
+    const usage = data.usageMetadata ?? {};
+    return {
+      content,
+      model,
+      usage: {
+        promptTokens: usage.promptTokenCount ?? 0,
+        completionTokens: usage.candidatesTokenCount ?? 0,
+        totalTokens: usage.totalTokenCount ?? 0
+      },
+      latencyMs: Date.now() - startTime
+    };
+  }
+  async function* callLLMStreaming(options) {
+    const model = options.model ?? "gemini-3-flash-preview";
+    const body = buildRequestBody(options, model);
+    const response = await fetch(
+      `${GEMINI_API_BASE}/models/${model}:streamGenerateContent?alt=sse`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-goog-api-key": apiKey,
+          Accept: "text/event-stream"
+        },
+        body: JSON.stringify(body),
+        signal: options.signal
+      }
+    );
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Gemini streaming error: ${response.status} ${text}`);
+    }
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("No response body");
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let fullText = "";
+    const toolCalls = [];
+    let toolCallIndex = 0;
+    let lastUsage;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      while (buffer.includes("\n")) {
+        const lineEnd = buffer.indexOf("\n");
+        const line = buffer.slice(0, lineEnd).trim();
+        buffer = buffer.slice(lineEnd + 1);
+        if (!line.startsWith("data: ")) continue;
+        const jsonStr = line.slice(6);
+        if (jsonStr === "[DONE]") continue;
+        let parsed;
+        try {
+          parsed = JSON.parse(jsonStr);
+        } catch {
+          continue;
+        }
+        const candidates = parsed.candidates ?? [];
+        const candidate = candidates[0];
+        if (!candidate) continue;
+        const parts = candidate.content?.parts ?? [];
+        for (const part of parts) {
+          if (typeof part.text === "string" && part.text) {
+            if (part.thought === true) continue;
+            fullText += part.text;
+            yield { type: "text_delta", content: part.text };
+          }
+          if (part.functionCall) {
+            const fc = part.functionCall;
+            const id = `call_${crypto.randomUUID().slice(0, 8)}`;
+            const args = JSON.stringify(fc.args ?? {});
+            toolCalls.push({ id, name: fc.name, arguments: args });
+            yield { type: "tool_call_start", index: toolCallIndex, id, name: fc.name };
+            yield { type: "tool_call_delta", index: toolCallIndex, arguments: args };
+            toolCallIndex++;
+          }
+        }
+        const usage = parsed.usageMetadata;
+        if (usage) {
+          lastUsage = {
+            promptTokens: usage.promptTokenCount ?? 0,
+            completionTokens: usage.candidatesTokenCount ?? 0,
+            totalTokens: usage.totalTokenCount ?? 0,
+            cachedTokens: usage.cachedContentTokenCount ?? 0,
+            reasoningTokens: usage.thoughtsTokenCount ?? 0
+          };
+        }
+      }
+    }
+    yield {
+      type: "done",
+      content: fullText,
+      toolCalls,
+      usage: lastUsage
+    };
+  }
+  return {
+    kind: "gemini_api_key",
+    callLLM,
+    callLLMStreaming
+  };
+}
+
 // src/lib/llm/provider-factory.ts
 async function createProviderFromStoredAuth(options) {
   const resolved = await resolveConfiguredProvider({ homeDir: options?.homeDir });
   if (!resolved) {
     throw new Error(
-      "No OpenAI credentials found. Run /auth to connect via OAuth (free), set OPENAI_API_KEY, or run /config apikey <key>."
+      "No credentials found. Run /auth (OpenAI), /auth-gemini (Google), or /config apikey <key>."
     );
   }
   if (resolved.kind === "openai_auth") {
@@ -3117,7 +3523,32 @@ async function createProviderFromStoredAuth(options) {
       }
     );
   }
-  return createOpenAIAPIKeyProvider(resolved.apiKey);
+  if (resolved.kind === "openai_api_key") {
+    return createOpenAIAPIKeyProvider(resolved.apiKey);
+  }
+  if (resolved.kind === "gemini_auth") {
+    const stored = resolved.stored;
+    return createGeminiAuthProvider(
+      {
+        accessToken: stored.tokens.access,
+        refreshToken: stored.tokens.refresh,
+        expiresAt: stored.tokens.expires,
+        email: stored.tokens.email,
+        projectId: stored.tokens.projectId
+      },
+      async (newCreds) => {
+        stored.tokens.access = newCreds.accessToken;
+        stored.tokens.refresh = newCreds.refreshToken;
+        stored.tokens.expires = newCreds.expiresAt;
+        stored.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        await saveGeminiAuth(stored, { homeDir: options?.homeDir });
+      }
+    );
+  }
+  if (resolved.kind === "gemini_api_key") {
+    return createGeminiAPIKeyProvider(resolved.apiKey);
+  }
+  throw new Error("Unknown provider kind.");
 }
 
 // src/lib/agent/tool-schemas.ts
@@ -3668,7 +4099,7 @@ Root: ${process.cwd()}`,
 }
 
 // src/lib/agent/tools/read-file.ts
-import fs7 from "fs/promises";
+import fs6 from "fs/promises";
 import { createReadStream } from "fs";
 import path6 from "path";
 import os2 from "os";
@@ -3732,7 +4163,7 @@ function isBinaryByExtension(filePath) {
   return BINARY_EXTENSIONS.has(path6.extname(filePath).toLowerCase());
 }
 async function isBinaryByContent(filePath) {
-  const handle = await fs7.open(filePath, "r");
+  const handle = await fs6.open(filePath, "r");
   try {
     const buf = Buffer.alloc(4096);
     const { bytesRead } = await handle.read(buf, 0, 4096, 0);
@@ -3797,7 +4228,7 @@ async function executeReadFile(args, ctx) {
   const resolved = path6.isAbsolute(filePath) ? filePath : path6.resolve(filePath);
   let stat;
   try {
-    stat = await fs7.stat(resolved);
+    stat = await fs6.stat(resolved);
   } catch {
     if (filePath in ctx.workspaceFiles) {
       return formatFromString(filePath, ctx.workspaceFiles[filePath], offset, limit);
@@ -3805,7 +4236,7 @@ async function executeReadFile(args, ctx) {
     return `Error: File not found: ${args.file_path}`;
   }
   if (stat.isDirectory()) {
-    const entries = await fs7.readdir(resolved, { withFileTypes: true });
+    const entries = await fs6.readdir(resolved, { withFileTypes: true });
     const lines = entries.sort((a, b) => {
       if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
       return a.name.localeCompare(b.name);
@@ -3869,7 +4300,7 @@ ${outputLines.join("\n")}${footer}
 }
 
 // src/lib/agent/tools/list-directory.ts
-import fs8 from "fs/promises";
+import fs7 from "fs/promises";
 import path7 from "path";
 var MAX_ENTRIES = 200;
 var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
@@ -3887,7 +4318,7 @@ var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
   ".env"
 ]);
 async function listEntries(dirPath, ignore) {
-  const entries = await fs8.readdir(dirPath, { withFileTypes: true });
+  const entries = await fs7.readdir(dirPath, { withFileTypes: true });
   const results = [];
   for (const entry of entries) {
     if (ignore.has(entry.name) || entry.name.startsWith(".") && DEFAULT_IGNORE.has(entry.name)) {
@@ -3896,7 +4327,7 @@ async function listEntries(dirPath, ignore) {
     let size = 0;
     if (!entry.isDirectory()) {
       try {
-        const stat = await fs8.stat(path7.join(dirPath, entry.name));
+        const stat = await fs7.stat(path7.join(dirPath, entry.name));
         size = stat.size;
       } catch {
       }
@@ -3954,7 +4385,7 @@ async function executeListDirectory(args) {
   const maxDepth = Math.min(args.depth ?? 2, 5);
   const ignore = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...args.ignore ?? []]);
   try {
-    const stat = await fs8.stat(dirPath);
+    const stat = await fs7.stat(dirPath);
     if (!stat.isDirectory()) {
       return `Error: ${dirPath} is not a directory.`;
     }
@@ -3969,7 +4400,7 @@ async function executeListDirectory(args) {
 
 // src/lib/agent/tools/run-command.ts
 import { spawn } from "child_process";
-import fs9 from "fs/promises";
+import fs8 from "fs/promises";
 import path8 from "path";
 var DEFAULT_TIMEOUT_MS = 2 * 60 * 1e3;
 var MAX_TIMEOUT_MS = 10 * 60 * 1e3;
@@ -3981,7 +4412,7 @@ async function executeRunCommand(args, signal) {
   }
   const workdir = args.workdir ? path8.isAbsolute(args.workdir) ? args.workdir : path8.resolve(args.workdir) : process.cwd();
   try {
-    const stat = await fs9.stat(workdir);
+    const stat = await fs8.stat(workdir);
     if (!stat.isDirectory()) {
       return `Error: workdir is not a directory: ${workdir}`;
     }
@@ -4391,7 +4822,7 @@ function executeCreatePaper(args, ctx) {
 
 // src/lib/agent/tools/read-pdf.ts
 import path9 from "path";
-import fs10 from "fs/promises";
+import fs9 from "fs/promises";
 var MAX_OUTPUT_BYTES3 = 5e4;
 function parsePages(pages) {
   const range = pages.match(/^(\d+)\s*-\s*(\d+)$/);
@@ -4402,7 +4833,7 @@ function parsePages(pages) {
 }
 async function executeReadPdf(args) {
   const resolved = path9.resolve(args.file_path);
-  const stat = await fs10.stat(resolved).catch(() => null);
+  const stat = await fs9.stat(resolved).catch(() => null);
   if (!stat || !stat.isFile()) {
     return `Error: file not found: ${resolved}`;
   }
@@ -5589,7 +6020,7 @@ ${summary}`,
 }
 
 // src/lib/skills/runtime.ts
-import fs11 from "fs/promises";
+import fs10 from "fs/promises";
 import path10 from "path";
 import matter2 from "gray-matter";
 async function loadRuntimeSkillByName(input2) {
@@ -5598,7 +6029,7 @@ async function loadRuntimeSkillByName(input2) {
   if (!match) {
     return null;
   }
-  const raw = await fs11.readFile(path10.join(match.skillDir, "SKILL.md"), "utf8");
+  const raw = await fs10.readFile(path10.join(match.skillDir, "SKILL.md"), "utf8");
   const parsed = matter2(raw);
   return {
     id: match.name,
@@ -5610,14 +6041,15 @@ async function loadRuntimeSkillByName(input2) {
 }
 async function readSkillReferenceFile(skillDir, referencePath) {
   const fullPath = path10.join(skillDir, "references", referencePath);
-  return fs11.readFile(fullPath, "utf8");
+  return fs10.readFile(fullPath, "utf8");
 }
 
 // src/lib/agent/subagent/configs.ts
 var exploreConfig = {
   id: "explore",
   name: "Explore",
-  model: "gpt-5.4-mini",
+  model: void 0,
+  // Resolved at runtime from provider catalog (backgroundModel)
   reasoningEffort: "high",
   allowedTools: /* @__PURE__ */ new Set([
     "read_file",
@@ -5714,7 +6146,7 @@ ${input2.context}` : input2.goal;
     for await (const chunk of input2.provider.callLLMStreaming({
       messages,
       tools,
-      model: config.model,
+      model: config.model ?? getProviderCatalog(input2.provider.kind).backgroundModel,
       reasoningEffort: config.reasoningEffort,
       signal: input2.signal
     })) {
@@ -5775,7 +6207,7 @@ ${input2.context}` : input2.goal;
     let finalText = "";
     for await (const chunk of input2.provider.callLLMStreaming({
       messages,
-      model: config.model,
+      model: config.model ?? getProviderCatalog(input2.provider.kind).backgroundModel,
       reasoningEffort: config.reasoningEffort,
       signal: input2.signal
     })) {
@@ -5816,7 +6248,7 @@ function describeSubAgentTool(name, args) {
 
 // src/lib/agent/tools/tasks.ts
 import path11 from "path";
-import fs12 from "fs/promises";
+import fs11 from "fs/promises";
 var tasks = [];
 var storePath = null;
 function shortId() {
@@ -5826,9 +6258,9 @@ async function persist() {
   if (!storePath) return;
   const live = tasks.filter((t) => t.status !== "deleted");
   const tmpPath = storePath + ".tmp";
-  await fs12.mkdir(path11.dirname(storePath), { recursive: true });
-  await fs12.writeFile(tmpPath, JSON.stringify({ version: 1, tasks: live }, null, 2));
-  await fs12.rename(tmpPath, storePath);
+  await fs11.mkdir(path11.dirname(storePath), { recursive: true });
+  await fs11.writeFile(tmpPath, JSON.stringify({ version: 1, tasks: live }, null, 2));
+  await fs11.rename(tmpPath, storePath);
 }
 async function initTaskStore(workspaceDir) {
   storePath = path11.join(workspaceDir, ".open-research", "tasks.json");
@@ -5960,7 +6392,7 @@ async function executeTool(name, args, ctx, activeSkills, homeDir, signal, provi
       return { result: out.result, searchResults: out.sources };
     }
     case "web_search": {
-      const { executeWebSearch } = await import("./web-search-B7D5WMHU.js");
+      const { executeWebSearch } = await import("./web-search-TKBFSU3M.js");
       const out = await executeWebSearch(
         args,
         provider
@@ -6039,7 +6471,7 @@ ${meta}` };
       if (!provider) {
         return { result: "Error: query_ontology requires an LLM provider." };
       }
-      const { runQueryAgent } = await import("./query-agent-LRUUJR4F.js");
+      const { runQueryAgent } = await import("./query-agent-WM6UNZ37.js");
       const workspaceDir = ctx.workspaceDir ?? process.cwd();
       const answer = await runQueryAgent({
         query: String(args.query ?? ""),
@@ -6101,7 +6533,9 @@ var MODEL_CONTEXT_WINDOWS = {
   "gpt-4o": 128e3,
   "gpt-5.4-mini": 128e3,
   "o3": 2e5,
-  "o4-mini": 2e5
+  "o4-mini": 2e5,
+  "gemini-3.1-pro-preview": 1048576,
+  "gemini-3-flash-preview": 1048576
 };
 var DEFAULT_CONTEXT_WINDOW = 128e3;
 var AUTO_COMPACT_TOKEN_LIMIT = 25e4;
@@ -6315,7 +6749,7 @@ async function manualCompact(messages, model, provider, usage, customInstruction
 }
 
 // src/lib/memory/store.ts
-import fs13 from "fs/promises";
+import fs12 from "fs/promises";
 import path12 from "path";
 function getGlobalMemoryFile(options) {
   return path12.join(getOpenResearchRoot(options), "memory.json");
@@ -6325,7 +6759,7 @@ function getProjectMemoryFile(workspaceDir) {
 }
 async function loadMemoryFile(filePath) {
   try {
-    const raw = await fs13.readFile(filePath, "utf8");
+    const raw = await fs12.readFile(filePath, "utf8");
     const store = JSON.parse(raw);
     return store.memories ?? [];
   } catch {
@@ -6333,9 +6767,9 @@ async function loadMemoryFile(filePath) {
   }
 }
 async function saveMemoryFile(filePath, memories) {
-  await fs13.mkdir(path12.dirname(filePath), { recursive: true });
+  await fs12.mkdir(path12.dirname(filePath), { recursive: true });
   const store = { version: 2, memories };
-  await fs13.writeFile(filePath, JSON.stringify(store, null, 2), "utf8");
+  await fs12.writeFile(filePath, JSON.stringify(store, null, 2), "utf8");
 }
 async function loadGlobalMemories(options) {
   const mems = await loadMemoryFile(getGlobalMemoryFile(options));
@@ -6667,18 +7101,18 @@ async function extractAndStoreMemories(input2) {
 }
 
 // src/lib/workspace/agents-md.ts
-import fs14 from "fs/promises";
+import fs13 from "fs/promises";
 import path13 from "path";
 var AGENTS_MD_FILENAME = "AGENTS.md";
 async function readAgentsMd(workspaceDir) {
   try {
-    return await fs14.readFile(path13.join(workspaceDir, AGENTS_MD_FILENAME), "utf8");
+    return await fs13.readFile(path13.join(workspaceDir, AGENTS_MD_FILENAME), "utf8");
   } catch {
     return "";
   }
 }
 async function writeAgentsMd(workspaceDir, content) {
-  await fs14.writeFile(path13.join(workspaceDir, AGENTS_MD_FILENAME), content, "utf8");
+  await fs13.writeFile(path13.join(workspaceDir, AGENTS_MD_FILENAME), content, "utf8");
 }
 var UPDATE_SYSTEM_PROMPT = `You maintain an AGENTS.md file for a research workspace. This file gives future agent sessions instant context about the project \u2014 what it's about, what's been done, key files, and current direction.
 
@@ -6881,7 +7315,7 @@ async function runAgentTurn(input2) {
   const isPlanning = input2.mode === "planning";
   const tools = isPlanning ? getToolsForMode("planning") : TOOL_SCHEMAS;
   const systemPrompt = isPlanning ? buildPlanningSystemPrompt(input2.workspace, activeSkills) : buildSystemPrompt(input2.workspace, activeSkills);
-  const model = input2.model ?? "gpt-5.4";
+  const model = input2.model ?? getProviderCatalog(input2.provider.kind).defaultModel;
   const usage = input2.sessionUsage ?? createSessionUsage();
   const allMemories = await loadAllMemories({
     homeDir: input2.homeDir,
@@ -6895,7 +7329,7 @@ async function runAgentTurn(input2) {
   if (input2.workspace.workspaceDir) {
     try {
       const { loadOntology } = await import("./store-LT5EGDOI.js");
-      const { runRelevanceAgent } = await import("./relevance-agent-CCN7JGTM.js");
+      const { runRelevanceAgent } = await import("./relevance-agent-H3U6TROD.js");
       const { buildScaffoldingContext } = await import("./scaffolding-MSAICMWV.js");
       const ontology = await loadOntology(input2.workspace.workspaceDir);
       const relevantIds = await runRelevanceAgent({
@@ -6996,7 +7430,7 @@ ${agentsMd}` : null,
         });
       }
       if (input2.workspace.workspaceDir) {
-        import("./manager-queue-F4VVZMTE.js").then(({ enqueueOntologyManager }) => {
+        import("./manager-queue-FBAUCAGI.js").then(({ enqueueOntologyManager }) => {
           enqueueOntologyManager({
             userMessage: input2.message,
             agentResponse: fullText,
@@ -7155,7 +7589,7 @@ function classifyUpdateRisk(update) {
 }
 
 // src/lib/workspace/apply-update.ts
-import fs15 from "fs/promises";
+import fs14 from "fs/promises";
 import path14 from "path";
 function resolveRelativePath(update) {
   if (update.key.startsWith("path:")) {
@@ -7178,8 +7612,8 @@ function resolveRelativePath(update) {
 async function applyProposedUpdate(workspaceDir, update) {
   const relativePath = resolveRelativePath(update);
   const absolutePath = path14.join(workspaceDir, relativePath);
-  await fs15.mkdir(path14.dirname(absolutePath), { recursive: true });
-  await fs15.writeFile(absolutePath, update.content, "utf8");
+  await fs14.mkdir(path14.dirname(absolutePath), { recursive: true });
+  await fs14.writeFile(absolutePath, update.content, "utf8");
   return absolutePath;
 }
 
@@ -7397,7 +7831,7 @@ function SessionPicker({ sessions, onSelect, onCancel }) {
 }
 
 // src/lib/cli/update-check.ts
-import fs16 from "fs/promises";
+import fs15 from "fs/promises";
 import path15 from "path";
 import os3 from "os";
 var PACKAGE_NAME = "open-research";
@@ -7405,7 +7839,7 @@ var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
 var STATE_FILE = path15.join(os3.homedir(), ".open-research", "update-check.json");
 async function readState() {
   try {
-    const raw = await fs16.readFile(STATE_FILE, "utf8");
+    const raw = await fs15.readFile(STATE_FILE, "utf8");
     const parsed = JSON.parse(raw);
     return {
       lastCheck: typeof parsed.lastCheck === "number" ? parsed.lastCheck : 0,
@@ -7417,8 +7851,8 @@ async function readState() {
   }
 }
 async function writeState(state) {
-  await fs16.mkdir(path15.dirname(STATE_FILE), { recursive: true });
-  await fs16.writeFile(STATE_FILE, JSON.stringify(state), "utf8");
+  await fs15.mkdir(path15.dirname(STATE_FILE), { recursive: true });
+  await fs15.writeFile(STATE_FILE, JSON.stringify(state), "utf8");
 }
 function getCurrentVersion() {
   return getPackageVersion();
@@ -7473,6 +7907,7 @@ async function checkForUpdate() {
 // src/tui/commands.ts
 var SLASH_COMMANDS = [
   { name: "auth", aliases: ["/connect", "/login"], description: "Connect your OpenAI account via browser OAuth", category: "auth" },
+  { name: "auth-gemini", aliases: ["/login-gemini", "/gemini"], description: "Connect your Google account via browser OAuth (Gemini)", category: "auth" },
   { name: "auth-codex", aliases: ["/import-codex"], description: "Import auth from existing Codex CLI", category: "auth" },
   { name: "auth-status", aliases: [], description: "Check auth connection status", category: "auth" },
   { name: "logout", aliases: [], description: "Clear stored auth", category: "auth" },
@@ -8331,7 +8766,7 @@ function useTerminalWidth() {
 import { startTransition } from "react";
 
 // src/lib/workspace/init-agents-md.ts
-import fs17 from "fs/promises";
+import fs16 from "fs/promises";
 import path16 from "path";
 var IGNORED_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
@@ -8371,7 +8806,7 @@ async function scanDirectoryShallow(dir, maxDepth = 2, depth = 0) {
   const results = [];
   if (depth > maxDepth) return results;
   try {
-    const entries = await fs17.readdir(dir, { withFileTypes: true });
+    const entries = await fs16.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (IGNORED_DIRS2.has(entry.name)) continue;
       if (entry.name.startsWith(".") && depth === 0 && entry.isDirectory()) continue;
@@ -8382,7 +8817,7 @@ async function scanDirectoryShallow(dir, maxDepth = 2, depth = 0) {
         const children = await scanDirectoryShallow(fullPath, maxDepth, depth + 1);
         results.push(...children);
       } else {
-        const stat = await fs17.stat(fullPath).catch(() => null);
+        const stat = await fs16.stat(fullPath).catch(() => null);
         results.push({ path: relativePath, size: stat?.size ?? 0, isDir: false });
       }
     }
@@ -8394,7 +8829,7 @@ async function readKeyFiles(dir) {
   const contents = {};
   for (const name of INTERESTING_FILES) {
     try {
-      const content = await fs17.readFile(path16.join(dir, name), "utf8");
+      const content = await fs16.readFile(path16.join(dir, name), "utf8");
       contents[name] = content.slice(0, 2e3);
     } catch {
     }
@@ -8480,7 +8915,7 @@ ${scanData.slice(0, 25e3)}`;
 
 // src/lib/preview/server.ts
 import http2 from "http";
-import fs18 from "fs";
+import fs17 from "fs";
 import path17 from "path";
 
 // src/lib/preview/latex-to-html.ts
@@ -8752,7 +9187,7 @@ function startPreviewServer(texPath) {
   let currentHash = "";
   function getContentHash() {
     try {
-      const content = fs18.readFileSync(resolved, "utf8");
+      const content = fs17.readFileSync(resolved, "utf8");
       return `${content.length}-${content.slice(0, 100)}-${content.slice(-100)}`;
     } catch {
       return "error";
@@ -8760,7 +9195,7 @@ function startPreviewServer(texPath) {
   }
   function renderPage() {
     try {
-      const latex = fs18.readFileSync(resolved, "utf8");
+      const latex = fs17.readFileSync(resolved, "utf8");
       const htmlContent = latexToHtml(latex);
       currentHash = getContentHash();
       return HTML_TEMPLATE.replace("{{CONTENT}}", htmlContent);
@@ -8807,7 +9242,7 @@ async function executeSlashCommand(cmd, args, ctx) {
     history,
     skills: skills2,
     workspaceFiles,
-    sessionId,
+    sessionId: sessionId2,
     sessionTokens,
     agentMode,
     addSystemMessage,
@@ -8846,6 +9281,23 @@ async function executeSlashCommand(cmd, args, ctx) {
       }
       break;
     }
+    case "auth-gemini": {
+      addSystemMessage("Opening browser for Google login...");
+      addSystemMessage("Note: Uses Gemini CLI credentials. Google may restrict third-party use.");
+      setBusy(true);
+      try {
+        const { loginWithGemini } = await import("./gemini-login-EYY3EFH4.js");
+        const result = await loginWithGemini({ homeDir });
+        setAuthStatus("connected");
+        addSystemMessage(`Connected Google account ${result.tokens.email}`);
+        addSystemMessage("Switch to Gemini: /config provider gemini");
+      } catch (err) {
+        addSystemMessage(`Auth failed: ${err instanceof Error ? err.message : String(err)}`);
+      } finally {
+        setBusy(false);
+      }
+      break;
+    }
     case "auth-codex": {
       addSystemMessage("Importing Codex CLI auth...");
       setBusy(true);
@@ -8934,7 +9386,7 @@ async function executeSlashCommand(cmd, args, ctx) {
         addSystemMessage("No workspace. Run /init first.");
         break;
       }
-      const { listSessions: listSessions2 } = await import("./sessions-GRES2MUV.js");
+      const { listSessions: listSessions2 } = await import("./sessions-KL4LUGD7.js");
       const foundSessions = await listSessions2(workspacePath);
       if (foundSessions.length === 0) {
         addSystemMessage("No previous sessions found.");
@@ -9544,7 +9996,7 @@ function App({
   const [screen, setScreen] = useState6("main");
   const [resumeSessions, setResumeSessions] = useState6([]);
   const [ctrlCPending, setCtrlCPending] = useState6(false);
-  const sessionId = useMemo3(() => crypto.randomUUID(), []);
+  const sessionId2 = useMemo3(() => crypto.randomUUID(), []);
   const deferredMessages = useDeferredValue(messages);
   const deferredPendingUpdates = useDeferredValue(pendingUpdates);
   const activityFrame = useAnimatedFrame(busy);
@@ -9715,7 +10167,7 @@ function App({
     history,
     skills: skills2,
     workspaceFiles,
-    sessionId,
+    sessionId: sessionId2,
     sessionTokens,
     agentMode,
     previewRef,
@@ -9743,7 +10195,7 @@ function App({
     if (pendingUpdates.length === 0 || !workspacePath) return;
     const [next, ...rest] = pendingUpdates;
     await applyProposedUpdate(workspacePath, next);
-    await appendSessionEvent(workspacePath, sessionId, {
+    await appendSessionEvent(workspacePath, sessionId2, {
       type: "update.accepted",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       payload: { key: next.key, summary: next.summary }
@@ -9758,7 +10210,7 @@ function App({
   function rejectNextPendingUpdate() {
     if (pendingUpdates.length === 0 || !workspacePath) return;
     const [next, ...rest] = pendingUpdates;
-    void appendSessionEvent(workspacePath, sessionId, {
+    void appendSessionEvent(workspacePath, sessionId2, {
       type: "update.rejected",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       payload: { key: next.key, summary: next.summary }
@@ -9822,7 +10274,7 @@ function App({
       summary: `Research charter: ${charter.researchQuestion}`
     };
     await applyProposedUpdate(workspacePath, charterUpdate);
-    await appendSessionEvent(workspacePath, sessionId, {
+    await appendSessionEvent(workspacePath, sessionId2, {
       type: "charter.approved",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       payload: { charterId: charter.id }
@@ -9835,7 +10287,7 @@ function App({
   }
   function rejectCharter() {
     if (!planningState.charter || !workspacePath) return;
-    void appendSessionEvent(workspacePath, sessionId, {
+    void appendSessionEvent(workspacePath, sessionId2, {
       type: "charter.rejected",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       payload: { charterId: planningState.charter.id }
@@ -10008,7 +10460,7 @@ function App({
       const workspace = await scanWorkspace(workspacePath);
       const workspaceContext = {
         workspaceDir: workspacePath,
-        runId: sessionId,
+        runId: sessionId2,
         workspaceFiles: Object.fromEntries(workspace.files.map((f) => [f.key, f.content])),
         availableKeys: workspace.files.map((f) => f.key),
         fileLabels: Object.fromEntries(workspace.files.map((f) => [f.key, f.label]))
@@ -10104,7 +10556,7 @@ function App({
       if (reviewRequired.length > 0) {
         startTransition2(() => setPendingUpdates((c) => [...c, ...reviewRequired]));
       }
-      await appendSessionEvent(workspacePath, sessionId, {
+      await appendSessionEvent(workspacePath, sessionId2, {
         type: "chat.turn",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         payload: {
@@ -10162,7 +10614,7 @@ ${error.stack}` : String(error)}` }
       const workspace = await scanWorkspace(workspacePath);
       const workspaceContext = {
         workspaceDir: workspacePath,
-        runId: sessionId,
+        runId: sessionId2,
         workspaceFiles: Object.fromEntries(workspace.files.map((f) => [f.key, f.content])),
         availableKeys: workspace.files.map((f) => f.key),
         fileLabels: Object.fromEntries(workspace.files.map((f) => [f.key, f.label]))
@@ -10202,7 +10654,7 @@ ${error.stack}` : String(error)}` }
         const charter = parseCharterYaml(result.detectedCharter);
         setPlanningState((prev) => ({ ...prev, status: "charter-review", charter }));
         if (workspacePath) {
-          await appendSessionEvent(workspacePath, sessionId, {
+          await appendSessionEvent(workspacePath, sessionId2, {
             type: "charter.generated",
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             payload: { charterId: charter.id, researchQuestion: charter.researchQuestion }
@@ -10541,7 +10993,7 @@ skills.command("validate").argument("[nameOrPath]").description("Validate one us
   await ensureOpenResearchConfig();
   const skillDir = nameOrPath ? path19.isAbsolute(nameOrPath) ? nameOrPath : path19.join(getOpenResearchSkillsDir(), nameOrPath) : getOpenResearchSkillsDir();
   const stat = await import("fs/promises").then(
-    (fs19) => fs19.stat(skillDir).catch(() => null)
+    (fs18) => fs18.stat(skillDir).catch(() => null)
   );
   if (!stat) {
     throw new Error(`Skill path not found: ${skillDir}`);