open-research 1.0.0 → 1.1.0

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,25 +24,32 @@ 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";
 
 // src/cli.ts
-import React6 from "react";
+import React7 from "react";
 import path19 from "path";
 import { Command } from "commander";
 import { render } from "ink";
@@ -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.");
@@ -478,55 +470,6 @@ async function loginWithBrowser(options) {
 // src/lib/llm/config.ts
 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.";
@@ -645,44 +588,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 +632,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 +682,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 +695,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 +720,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 +737,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 +768,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 +790,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,25 +828,25 @@ function formatDateTime(value) {
 }
 
 // src/lib/cli/version.ts
-var PACKAGE_VERSION = "1.0.0";
+var PACKAGE_VERSION = "1.1.0";
 function getPackageVersion() {
   return PACKAGE_VERSION;
 }
 
 // src/tui/app.tsx
 import path18 from "path";
-import {
+import React6, {
   startTransition as startTransition2,
   useDeferredValue,
   useEffect as useEffect4,
-  useMemo as useMemo3,
+  useMemo as useMemo4,
   useRef as useRef2,
-  useState as useState6
+  useState as useState7
 } from "react";
-import { Box as Box5, Static, Text as Text5, useApp, useInput as useInput4 } from "ink";
+import { Box as Box5, Static, Text as Text5, useApp, useInput as useInput5 } from "ink";
 
 // src/tui/text-input.tsx
-import { useState, useEffect, useRef } from "react";
+import { useState, useEffect, useLayoutEffect, useRef } from "react";
 import { Box, Text, useInput, useStdout, measureElement } from "ink";
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
@@ -2055,30 +1994,37 @@ function TextInput({
       pasteMapRef.current.clear();
     }
   }, [originalValue]);
-  useEffect(() => {
-    const fallbackWidth = stdout.columns ?? 0;
-    if (!containerRef.current) {
-      if (fallbackWidth > 0) {
-        setInputWidth((current) => current === fallbackWidth ? current : fallbackWidth);
-      }
-      return;
-    }
-    const measuredWidth = measureElement(containerRef.current).width;
-    const nextWidth = measuredWidth > 0 ? measuredWidth : fallbackWidth;
-    if (nextWidth > 0) {
-      setInputWidth((current) => current === nextWidth ? current : nextWidth);
-    }
-  });
+  useLayoutEffect(() => {
+    setInputWidth((current) => {
+      const fallbackWidth = typeof stdout.columns === "number" && stdout.columns > 0 ? stdout.columns : current;
+      if (!containerRef.current) {
+        return fallbackWidth > 0 && fallbackWidth !== current ? fallbackWidth : current;
+      }
+      const measuredWidth = measureElement(containerRef.current).width;
+      const nextWidth = measuredWidth > 0 ? measuredWidth : fallbackWidth;
+      if (nextWidth > 0 && nextWidth !== current) {
+        return nextWidth;
+      }
+      return current;
+    });
+  }, [stdout.columns]);
   function pasteBadge(entry) {
     return applyThemeColor(source_default.dim, accentColor, `[Pasted text #${entry.id} +${entry.lineCount} lines]`);
   }
-  function getSlashCommandEnd() {
-    if (!originalValue.startsWith("/")) return 0;
-    const spaceIdx = originalValue.indexOf(" ");
-    return spaceIdx === -1 ? originalValue.length : spaceIdx;
+  function getSlashCommandRange() {
+    let slashIdx = originalValue.lastIndexOf("/");
+    while (slashIdx > 0 && originalValue[slashIdx - 1] !== " ") {
+      slashIdx = originalValue.lastIndexOf("/", slashIdx - 1);
+    }
+    if (slashIdx === -1) return { start: 0, end: 0 };
+    const afterSlash = originalValue.indexOf(" ", slashIdx);
+    const end = afterSlash === -1 ? originalValue.length : afterSlash;
+    return { start: slashIdx, end };
   }
   function buildRendered() {
-    const cmdEnd = getSlashCommandEnd();
+    const cmdRange = getSlashCommandRange();
+    const hasCmd = cmdRange.end > cmdRange.start;
+    const inCmd = (idx) => hasCmd && idx >= cmdRange.start && idx < cmdRange.end;
     if (showCursor && focus) {
       if (originalValue.length === 0) return source_default.inverse(" ");
       const pasteIds2 = [...pasteMapRef.current.keys()].sort((a, b) => a - b);
@@ -2097,12 +2043,12 @@ function TextInput({
         } else if (i2 === cursorOffset) {
           if (char === "\n") {
             result2 += source_default.inverse(" ") + "\n";
-          } else if (cmdEnd > 0 && i2 < cmdEnd) {
+          } else if (inCmd(i2)) {
             result2 += applyThemeColor(source_default.inverse, accentColor, char);
           } else {
             result2 += source_default.inverse(char);
           }
-        } else if (cmdEnd > 0 && i2 < cmdEnd) {
+        } else if (inCmd(i2)) {
           result2 += applyThemeColor(source_default, accentColor, char);
         } else {
           result2 += char;
@@ -2123,7 +2069,7 @@ function TextInput({
         const entry = pasteIdx < pasteIds.length ? pasteMapRef.current.get(pasteIds[pasteIdx]) : void 0;
         pasteIdx++;
         result += entry ? pasteBadge(entry) : "";
-      } else if (cmdEnd > 0 && i < cmdEnd) {
+      } else if (inCmd(i)) {
         result += applyThemeColor(source_default, accentColor, char);
       } else {
         result += char;
@@ -2355,7 +2301,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 +2332,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 +2350,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")
     });
   }
 }
@@ -2434,12 +2380,7 @@ var OPENAI_MODEL_MAP = {
   "gpt-5.4": "gpt-5.4",
   "gpt-5.4-mini": "gpt-5.4-mini",
   "openai/gpt-5.4": "gpt-5.4",
-  "openai/gpt-5.4-mini": "gpt-5.4-mini",
-  "google/gemini-3-flash-preview": "gpt-5.4",
-  "google/gemini-3.1-pro": "gpt-5.4",
-  "google/gemini-3.1-flash-lite-preview": "gpt-5.4-mini",
-  "google/gemini-2.5-flash-lite": "gpt-5.4-mini",
-  "google/gemini-2.5-flash": "gpt-5.4-mini"
+  "openai/gpt-5.4-mini": "gpt-5.4-mini"
 };
 function resolveOpenAIModel(model) {
   return OPENAI_MODEL_MAP[model ?? "gpt-5.4"] ?? "gpt-5.4";
@@ -2563,14 +2504,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 +3026,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 +3524,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
@@ -3219,14 +3651,24 @@ var TOOL_SCHEMAS = [
     type: "function",
     function: {
       name: "write_new_file",
-      description: "Create a new workspace file.",
+      description: [
+        "Create a new workspace file. The key determines where the file is placed:",
+        "- `note:<descriptive-slug>` \u2192 notes/<slug>.md \u2014 analysis, summaries, briefs, memos",
+        "- `paper:<descriptive-slug>` \u2192 papers/<slug>.tex \u2014 LaTeX drafts and manuscripts",
+        "- `experiment:<descriptive-slug>` \u2192 experiments/<slug>.json \u2014 experiment configs and results",
+        "- `source:<descriptive-slug>` \u2192 sources/<slug>.md \u2014 extracted source material",
+        "- `path:<relative/path.ext>` \u2192 exact path \u2014 scripts, configs, data files, any custom location",
+        "Use path: for code files (e.g. `path:scripts/analyze.py`, `path:data/results.csv`).",
+        "Use descriptive slugs, not UUIDs: `note:transformer-scaling-laws` not `note:abc123`.",
+        'Use the folder param to organize within managed directories (e.g. folder: "lit-review").'
+      ].join(" "),
       parameters: {
         type: "object",
         properties: {
-          key: { type: "string" },
-          label: { type: "string" },
+          key: { type: "string", description: "File key with prefix determining placement: note:<slug>, paper:<slug>, experiment:<slug>, source:<slug>, or path:<relative/path>" },
+          label: { type: "string", description: "Human-readable display name for the file" },
           content: { type: "string" },
-          folder: { type: "string" }
+          folder: { type: "string", description: "Optional subfolder within the managed directory for organization" }
         },
         required: ["key", "label", "content"],
         additionalProperties: false
@@ -3377,32 +3819,56 @@ var TOOL_SCHEMAS = [
     type: "function",
     function: {
       name: "ask_user",
-      description: "Ask the user a question and wait for their response. Use this when you need clarification, a decision between options, or confirmation before proceeding. Provide clear options when possible. The user can also type a custom answer.",
+      description: "Ask the user one or more questions and wait for their responses. Use when you need clarification, a decision, or confirmation before proceeding. You can batch up to 4 related questions in a single call \u2014 the user answers them all at once. Provide predefined options when possible. The user can arrow-key select or type a custom answer.",
       parameters: {
         type: "object",
         properties: {
+          questions: {
+            type: "array",
+            minItems: 1,
+            maxItems: 4,
+            items: {
+              type: "object",
+              properties: {
+                question: {
+                  type: "string",
+                  description: "Clear, specific question. State what you need to know and why."
+                },
+                options: {
+                  type: "array",
+                  items: {
+                    type: "object",
+                    properties: {
+                      label: { type: "string", description: "Short option label (1-5 words)" },
+                      description: { type: "string", description: "One-sentence explanation of what this choice means" }
+                    },
+                    required: ["label", "description"]
+                  },
+                  description: "Predefined options. Include 2-5 choices. The user can also type a custom answer."
+                }
+              },
+              required: ["question"]
+            },
+            description: "One or more questions to ask. Batch related questions together (max 4)."
+          },
+          // Legacy single-question support (backward compat)
           question: {
             type: "string",
-            description: "The question to ask the user."
+            description: "Single question (shorthand). Use 'questions' array for multiple."
           },
           options: {
             type: "array",
             items: {
               type: "object",
               properties: {
-                label: { type: "string", description: "Short option label (1-5 words)." },
-                description: { type: "string", description: "One-sentence description of this option." }
+                label: { type: "string" },
+                description: { type: "string" }
               },
               required: ["label", "description"]
             },
-            description: "Predefined options for the user to choose from."
-          },
-          allow_custom: {
-            type: "boolean",
-            description: "Whether the user can type a custom answer. Default: true."
+            description: "Options for single question (shorthand)."
           }
         },
-        required: ["question"],
         additionalProperties: false
       }
     }
@@ -3668,7 +4134,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 +4198,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 +4263,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 +4271,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 +4335,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 +4353,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 +4362,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 +4420,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 +4435,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 +4447,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}`;
     }
@@ -4116,36 +4582,52 @@ function clearPendingQuestion() {
 function resetPendingQuestions() {
   pendingQuestions = [];
 }
+function normalizeQuestions(args) {
+  if (args.questions && args.questions.length > 0) {
+    return args.questions.slice(0, 4);
+  }
+  if (args.question) {
+    return [{ question: args.question, options: args.options }];
+  }
+  return [];
+}
 async function executeAskUser(args, signal) {
-  const questionId = crypto.randomUUID();
-  const question = {
-    id: questionId,
-    question: args.question,
-    options: (args.options ?? []).map((o) => ({
-      label: o.label,
-      description: o.description
-    })),
-    allowCustom: args.allow_custom ?? true
-  };
-  const answerPromise = new Promise((resolve, reject) => {
-    pendingQuestions.push({ question, resolve });
-    if (signal) {
-      const onAbort = () => {
-        pendingQuestions = pendingQuestions.filter((q) => q.question.id !== questionId);
-        reject(new Error("Question cancelled \u2014 user interrupted."));
-      };
-      if (signal.aborted) {
-        onAbort();
-        return;
+  const items = normalizeQuestions(args);
+  if (items.length === 0) {
+    return "Error: no question provided.";
+  }
+  const answers = [];
+  for (const item of items) {
+    const questionId = crypto.randomUUID();
+    const question = {
+      id: questionId,
+      question: item.question,
+      options: (item.options ?? []).map((o) => ({
+        label: o.label,
+        description: o.description
+      })),
+      allowCustom: true
+    };
+    const answer = await new Promise((resolve, reject) => {
+      pendingQuestions.push({ question, resolve });
+      if (signal) {
+        const onAbort = () => {
+          pendingQuestions = pendingQuestions.filter((q) => q.question.id !== questionId);
+          reject(new Error("Question cancelled \u2014 user interrupted."));
+        };
+        if (signal.aborted) {
+          onAbort();
+          return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
       }
-      signal.addEventListener("abort", onAbort, { once: true });
-    }
-  });
-  const answer = await answerPromise;
-  if (answer.isCustom) {
-    return `User answered: "${answer.answer}"`;
+    });
+    const prefix = items.length > 1 ? `Q${answers.length + 1}: "${item.question}" \u2192 ` : "";
+    answers.push(
+      answer.isCustom ? `${prefix}User answered: "${answer.answer}"` : `${prefix}User selected: "${answer.answer}"`
+    );
   }
-  return `User selected: "${answer.answer}"`;
+  return answers.join("\n");
 }
 
 // src/lib/agent/tools/search-workspace.ts
@@ -4242,8 +4724,15 @@ function normalizeDbBackedKey(key) {
   }
   return `${prefix}:${crypto.randomUUID()}`;
 }
+var VALID_PREFIXES = ["note:", "paper:", "experiment:", "source:", "path:"];
 function executeWriteNewFile(args, ctx) {
   const normalizedKey = normalizeDbBackedKey(args.key);
+  if (!VALID_PREFIXES.some((p) => normalizedKey.startsWith(p))) {
+    return {
+      result: `Error: Key "${normalizedKey}" is missing a required prefix. Use one of: note:<slug>, paper:<slug>, experiment:<slug>, source:<slug>, or path:<relative/path>. Example: note:${normalizedKey}`,
+      update: null
+    };
+  }
   if (normalizedKey in ctx.workspaceFiles) {
     return {
       result: `Error: File "${normalizedKey}" already exists. Use update_existing_file to modify it.`,
@@ -4274,6 +4763,7 @@ function executeUpdateExistingFile(args, ctx) {
     };
   }
   const mode = args.mode ?? "rewrite";
+  const oldContent = ctx.workspaceFiles[args.key];
   if (mode === "rewrite") {
     const content = args.content;
     if (content == null) {
@@ -4287,6 +4777,7 @@ function executeUpdateExistingFile(args, ctx) {
       type: "edit",
       key: args.key,
       content,
+      oldContent,
       summary: args.summary
     };
     return {
@@ -4350,6 +4841,7 @@ ${preview}`,
     type: "edit",
     key: args.key,
     content: currentContent,
+    oldContent,
     summary: autoSummary
   };
   return {
@@ -4391,7 +4883,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 +4894,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 +6081,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 +6090,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 +6102,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 +6207,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 +6268,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 +6309,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 +6319,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 +6453,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 +6532,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 +6594,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 +6810,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 +6820,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 +6828,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 +7162,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.
 
@@ -6857,6 +7352,17 @@ ${skill.prompt}`).join("\n\n");
     "- Redirect large outputs to files. Read selectively \u2014 don't dump entire datasets into responses.",
     "- Always wrap file paths in backticks: `notes/brief.md`, `experiments/analysis.py:42`.",
     "",
+    "## Workspace Organization",
+    "The workspace has managed directories. When creating files with `write_new_file`, use the correct key prefix:",
+    "- `note:<slug>` \u2192 `notes/` \u2014 analysis write-ups, literature reviews, meeting notes, briefs",
+    "- `paper:<slug>` \u2192 `papers/` \u2014 LaTeX manuscripts and drafts",
+    "- `experiment:<slug>` \u2192 `experiments/` \u2014 experiment definitions, configs, results",
+    "- `source:<slug>` \u2192 `sources/` \u2014 extracted text from papers, articles, datasets",
+    "- `path:<relative/path>` \u2192 exact location \u2014 scripts, code, CSV data, configs, anything else",
+    "Use descriptive slugs that read naturally: `note:scaling-law-comparison`, `experiment:ablation-dropout-rates`, `path:scripts/parse-arxiv.py`.",
+    "Use the `folder` param to group related files: e.g. key `note:gpt4-findings` with folder `lit-review` creates `notes/lit-review/gpt4-findings.md`.",
+    "Never use bare keys without a prefix \u2014 they end up in `artifacts/` which is not user-facing.",
+    "",
     `## Workspace
 Root: ${process.cwd()}`,
     skillText
@@ -6881,7 +7387,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 +7401,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 +7502,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,31 +7661,33 @@ 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) {
+  const folder = update.folder;
+  const sub = (dir, name, ext) => folder ? `${dir}/${folder}/${name}${ext}` : `${dir}/${name}${ext}`;
   if (update.key.startsWith("path:")) {
     return update.key.slice(5);
   }
   if (update.key.startsWith("note:")) {
-    return `notes/${update.key.slice(5)}.md`;
+    return sub("notes", update.key.slice(5), ".md");
   }
   if (update.key.startsWith("paper:")) {
-    return `papers/${update.key.slice(6)}.tex`;
+    return sub("papers", update.key.slice(6), ".tex");
   }
   if (update.key.startsWith("experiment:")) {
-    return `experiments/${update.key.slice(11)}.json`;
+    return sub("experiments", update.key.slice(11), ".json");
   }
   if (update.key.startsWith("source:")) {
-    return `sources/${update.key.slice(7)}.md`;
+    return sub("sources", update.key.slice(7), ".md");
   }
   return `artifacts/${update.key}.md`;
 }
 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 +7905,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 +7913,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 +7925,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 +7981,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" },
@@ -7579,6 +8088,14 @@ function getUnifiedSuggestions(partial, allSkills) {
   }));
   return [...cmdHits, ...skillHits];
 }
+function extractSlashTrigger(text) {
+  const lastSlash = text.lastIndexOf("/");
+  if (lastSlash === -1) return null;
+  if (lastSlash > 0 && text[lastSlash - 1] !== " ") return null;
+  const after = text.slice(lastSlash + 1);
+  if (after.includes(" ")) return null;
+  return { partial: after.toLowerCase(), start: lastSlash };
+}
 function extractAtMention(text) {
   const lastAt = text.lastIndexOf("@");
   if (lastAt === -1) return null;
@@ -7603,7 +8120,9 @@ function truncate3(value, max = 96) {
 }
 
 // src/tui/components.tsx
-import { Box as Box4, Text as Text4 } from "ink";
+import { memo, useMemo as useMemo3, useState as useState4 } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput4 } from "ink";
+import { structuredPatch } from "diff";
 
 // src/tui/layout.ts
 var DEFAULT_TERMINAL_WIDTH = 80;
@@ -7611,11 +8130,19 @@ var MIN_TERMINAL_WIDTH = 20;
 function getTerminalWidth(columns) {
   return Math.max(MIN_TERMINAL_WIDTH, columns ?? process.stdout.columns ?? DEFAULT_TERMINAL_WIDTH);
 }
-function getObservedTerminalWidth(...columns) {
+function normalizeObservedTerminalWidth(fallbackWidth, ...columns) {
   const observed = columns.filter((value) => typeof value === "number" && Number.isFinite(value) && value > 0);
-  if (observed.length === 0) return DEFAULT_TERMINAL_WIDTH;
+  if (observed.length === 0) {
+    return Math.max(MIN_TERMINAL_WIDTH, fallbackWidth);
+  }
   return Math.max(MIN_TERMINAL_WIDTH, Math.min(...observed));
 }
+function getObservedTerminalWidth(...columns) {
+  return normalizeObservedTerminalWidth(DEFAULT_TERMINAL_WIDTH, ...columns);
+}
+function getStableObservedTerminalWidth(currentWidth, ...columns) {
+  return normalizeObservedTerminalWidth(currentWidth, ...columns);
+}
 function insetWidth(width, inset) {
   return Math.max(1, width - inset);
 }
@@ -7731,7 +8258,7 @@ function renderInline(text, codeColor = source_default.cyan, linkColor = source_
 }
 
 // src/tui/components.tsx
-import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 var GUTTER = {
   user: "\u203A",
   agent: "\u25AA",
@@ -7755,7 +8282,12 @@ function borderedContentWidth(width) {
 function wrapText(value, width) {
   return wrapAnsi(value, Math.max(1, width), { trim: false, hard: true });
 }
-function UserMessage({ text, width }) {
+function Divider({ width, color }) {
+  const theme = useTheme();
+  const w = insetWidth(resolveWidth(width), 4);
+  return /* @__PURE__ */ jsx4(Text4, { color: color ?? theme.muted, dimColor: true, children: "\u2500".repeat(Math.max(1, w)) });
+}
+var UserMessage = memo(function UserMessage2({ text, turnNumber, width }) {
   const theme = useTheme();
   const contentWidth = resolveWidth(width);
   const bodyWidth = indentedWidth(contentWidth);
@@ -7766,12 +8298,18 @@ function UserMessage({ text, width }) {
         GUTTER.user,
         " "
       ] }),
-      /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.accent, children: "you" })
+      /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.accent, children: "you" }),
+      typeof turnNumber === "number" && /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, children: [
+        " ",
+        GUTTER.system,
+        " #",
+        turnNumber
+      ] })
     ] }),
     /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, width: bodyWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.text, wrap: "wrap", children: wrappedText }) })
   ] });
-}
-function AgentMessage({ text, width }) {
+});
+var AgentMessage = memo(function AgentMessage2({ text, width }) {
   const contentWidth = resolveWidth(width);
   const bodyWidth = indentedWidth(contentWidth);
   const theme = useTheme();
@@ -7787,6 +8325,20 @@ function AgentMessage({ text, width }) {
     ] }),
     /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, width: bodyWidth, children: /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: wrappedText }) })
   ] });
+});
+function ThinkingIndicator({ frame, width }) {
+  const theme = useTheme();
+  const contentWidth = resolveWidth(width);
+  return /* @__PURE__ */ jsxs3(Box4, { marginBottom: 1, width: contentWidth, children: [
+    /* @__PURE__ */ jsxs3(Text4, { color: theme.secondary, bold: true, children: [
+      GUTTER.agent,
+      " "
+    ] }),
+    /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, children: [
+      frame,
+      " thinking..."
+    ] })
+  ] });
 }
 function TaskPanel({
   tasks: tasks2,
@@ -7819,7 +8371,7 @@ function TaskPanel({
     ] })
   ] });
 }
-function ToolActivitySummary({
+var ToolActivitySummary = memo(function ToolActivitySummary2({
   summary,
   tools,
   expanded = false,
@@ -7827,43 +8379,50 @@ function ToolActivitySummary({
 }) {
   const theme = useTheme();
   const contentWidth = indentedWidth(resolveWidth(width));
+  const innerWidth = indentedWidth(contentWidth, 4);
   if (expanded) {
-    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", marginLeft: 2, marginBottom: 0, width: contentWidth, children: [
-      /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: [
-        GUTTER.tool,
-        " ",
-        summary
-      ] }),
-      tools.map((t, i) => {
-        const dur = t.durationMs ? ` (${(t.durationMs / 1e3).toFixed(1)}s)` : "";
-        const prefix = i === tools.length - 1 ? "\u2514" : "\u251C";
-        return /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: [
-          "  ",
-          prefix,
-          " ",
-          GUTTER.success,
+    return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "row", marginLeft: 2, marginBottom: 0, width: contentWidth, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: "\u2502 " }),
+      /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", width: innerWidth, children: [
+        /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: [
+          GUTTER.tool,
           " ",
-          t.description,
-          dur
-        ] }, i);
-      })
+          summary
+        ] }),
+        tools.map((t, i) => {
+          const dur = t.durationMs ? ` (${(t.durationMs / 1e3).toFixed(1)}s)` : "";
+          const prefix = i === tools.length - 1 ? "\u2514" : "\u251C";
+          return /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: [
+            "  ",
+            prefix,
+            " ",
+            GUTTER.success,
+            " ",
+            t.description,
+            dur
+          ] }, i);
+        })
+      ] })
     ] });
   }
   const lastTarget = tools.length > 0 ? tools[tools.length - 1].description : "";
   const hint = tools.length > 1 ? " (ctrl+o to expand)" : "";
-  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", marginLeft: 2, marginBottom: 0, width: contentWidth, children: [
-    /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: [
-      GUTTER.tool,
-      " ",
-      summary,
-      hint
-    ] }),
-    lastTarget && tools.length > 1 && /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: [
-      "  \u2514 ",
-      lastTarget
+  return /* @__PURE__ */ jsxs3(Box4, { flexDirection: "row", marginLeft: 2, marginBottom: 0, width: contentWidth, children: [
+    /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: "\u2502 " }),
+    /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", width: innerWidth, children: [
+      /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: [
+        GUTTER.tool,
+        " ",
+        summary,
+        hint
+      ] }),
+      lastTarget && tools.length > 1 && /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: [
+        "  \u2514 ",
+        lastTarget
+      ] })
     ] })
   ] });
-}
+});
 function SubAgentIndicator({
   agentType,
   goal,
@@ -7912,23 +8471,30 @@ function SubAgentIndicator({
     }
   );
 }
-function SystemMessage({ text, width }) {
+var SystemMessage = memo(function SystemMessage2({ text, width }) {
   const theme = useTheme();
   const contentWidth = resolveWidth(width);
   const indentedContentWidth = indentedWidth(contentWidth);
   const wrappedIndentedText = wrapText(text, indentedContentWidth);
   const wrappedText = wrapText(text, contentWidth);
-  if (text.trimStart().startsWith("\u2713") || text.trimStart().startsWith("\u2717")) {
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith("\u2713") || trimmed.startsWith("\u2717")) {
     return /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, width: indentedContentWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: wrappedIndentedText }) });
   }
-  if (text.includes("compacted") || text.includes("Context")) {
+  if (trimmed.startsWith("Error:") || trimmed.startsWith("Failed:")) {
+    return /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, width: indentedContentWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.error, wrap: "wrap", children: wrapText(`${GUTTER.error} ${text.trim()}`, indentedContentWidth) }) });
+  }
+  if (trimmed.includes("\u25CA remembered:") || trimmed.includes("\u25CA ontology") || trimmed.includes("\u25CA learned:")) {
+    return /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, width: indentedContentWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.accent, dimColor: true, wrap: "wrap", children: wrapText(text.trim(), indentedContentWidth) }) });
+  }
+  if (text.includes("compacted") || text.includes("Context compacted")) {
     return /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, width: indentedContentWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.warning, dimColor: true, wrap: "wrap", children: wrapText(`${GUTTER.system} ${text.trim()}`, indentedContentWidth) }) });
   }
-  if (text.trimStart().startsWith(">")) {
+  if (trimmed.startsWith(">")) {
     return /* @__PURE__ */ jsx4(Box4, { width: contentWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: wrappedText }) });
   }
   return /* @__PURE__ */ jsx4(Box4, { width: contentWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, wrap: "wrap", children: wrapText(`${GUTTER.system} ${text.trim()}`, contentWidth) }) });
-}
+});
 function PromptPrefix({
   busy,
   frame,
@@ -7947,25 +8513,131 @@ function PromptPrefix({
     " "
   ] });
 }
+var MAX_DIFF_LINES = 16;
+function computeDiffLines(oldContent, newContent, fileName) {
+  if (oldContent == null) {
+    const lines = newContent.split("\n");
+    return lines.slice(0, MAX_DIFF_LINES + 4).map((l) => ({ type: "add", text: l }));
+  }
+  const patch = structuredPatch(fileName, fileName, oldContent, newContent, "", "", { context: 2 });
+  const result = [];
+  for (const hunk of patch.hunks) {
+    if (result.length > 0) {
+      result.push({ type: "ctx", text: "\xB7\xB7\xB7" });
+    }
+    for (const line of hunk.lines) {
+      if (line.startsWith("+")) {
+        result.push({ type: "add", text: line.slice(1) });
+      } else if (line.startsWith("-")) {
+        result.push({ type: "del", text: line.slice(1) });
+      } else {
+        result.push({ type: "ctx", text: line.slice(1) });
+      }
+    }
+  }
+  return result;
+}
 function PendingUpdateCard({
   count,
   summary,
+  fileName,
+  updateType,
+  oldContent,
+  newContent,
+  active,
+  onAccept,
+  onReject,
+  onFeedback,
   width
 }) {
   const theme = useTheme();
   const contentWidth = resolveWidth(width);
-  const bodyWidth = indentedWidth(borderedContentWidth(contentWidth));
+  const innerWidth = borderedContentWidth(contentWidth);
+  const bodyWidth = indentedWidth(innerWidth);
+  const diffLines = useMemo3(
+    () => computeDiffLines(oldContent, newContent, fileName),
+    [oldContent, newContent, fileName]
+  );
+  const truncated = diffLines.length > MAX_DIFF_LINES;
+  const visibleLines = truncated ? diffLines.slice(0, MAX_DIFF_LINES) : diffLines;
+  const additions = diffLines.filter((l) => l.type === "add").length;
+  const deletions = diffLines.filter((l) => l.type === "del").length;
+  const options = [
+    { label: "Accept", description: "Apply this update" },
+    { label: "Reject", description: "Discard this update" }
+  ];
+  const totalItems = options.length + 1;
+  const feedbackIndex = options.length;
+  const [selectedIndex, setSelectedIndex] = useState4(0);
+  const [mode, setMode] = useState4("selecting");
+  const [feedbackText, setFeedbackText] = useState4("");
+  useInput4((input2, key) => {
+    if (!active || mode !== "selecting") return;
+    if (key.upArrow) {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((i) => Math.min(totalItems - 1, i + 1));
+      return;
+    }
+    if (key.return) {
+      if (selectedIndex === 0) {
+        onAccept();
+        return;
+      }
+      if (selectedIndex === 1) {
+        onReject();
+        return;
+      }
+      if (selectedIndex === feedbackIndex) {
+        setMode("typing");
+        setFeedbackText("");
+      }
+      return;
+    }
+  }, { isActive: active && mode === "selecting" });
+  useInput4((input2, key) => {
+    if (!active || mode !== "typing") return;
+    if (key.escape) {
+      setMode("selecting");
+      setFeedbackText("");
+      return;
+    }
+    if (key.return) {
+      if (feedbackText.trim()) {
+        onFeedback(feedbackText.trim());
+        setFeedbackText("");
+        setMode("selecting");
+      }
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setFeedbackText((t) => t.slice(0, -1));
+      return;
+    }
+    if (key.ctrl && input2 === "u") {
+      setFeedbackText("");
+      return;
+    }
+    if (!key.ctrl && !key.meta && !key.tab && input2.length === 1 && input2 >= " ") {
+      setFeedbackText((t) => t + input2);
+    }
+  }, { isActive: active && mode === "typing" });
+  const isFeedbackSelected = selectedIndex === feedbackIndex;
+  const lineNumWidth = Math.max(3, String(diffLines.length).length + 1);
+  const diffContentWidth = Math.max(1, bodyWidth - lineNumWidth - 3);
   return /* @__PURE__ */ jsxs3(
     Box4,
     {
       borderStyle: "single",
-      borderColor: theme.pending,
+      borderColor: theme.warning,
       paddingX: 1,
-      marginBottom: 1,
+      marginBottom: 0,
       flexDirection: "column",
       width: contentWidth,
       children: [
-        /* @__PURE__ */ jsxs3(Box4, { width: borderedContentWidth(contentWidth), children: [
+        /* @__PURE__ */ jsxs3(Box4, { width: innerWidth, children: [
           /* @__PURE__ */ jsxs3(Text4, { color: theme.pending, bold: true, children: [
             GUTTER.pending,
             " "
@@ -7977,13 +8649,70 @@ function PendingUpdateCard({
             " awaiting review"
           ] })
         ] }),
-        /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, width: bodyWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, wrap: "wrap", children: summary }) }),
-        /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, marginTop: 0, width: bodyWidth, children: /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: [
-          /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.secondary, children: "a" }),
-          " accept  ",
-          /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.error, children: "r" }),
-          " reject"
-        ] }) })
+        /* @__PURE__ */ jsxs3(Box4, { marginLeft: 2, marginTop: 0, width: bodyWidth, children: [
+          /* @__PURE__ */ jsx4(Text4, { color: theme.muted, wrap: "wrap", children: summary }),
+          /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: "  " }),
+          additions > 0 && /* @__PURE__ */ jsxs3(Text4, { color: theme.secondary, children: [
+            "+",
+            additions
+          ] }),
+          additions > 0 && deletions > 0 && /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: " " }),
+          deletions > 0 && /* @__PURE__ */ jsxs3(Text4, { color: theme.error, children: [
+            "-",
+            deletions
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", marginLeft: 2, marginTop: 1, width: bodyWidth, children: [
+          visibleLines.map((line, i) => {
+            const prefix = line.type === "add" ? "+" : line.type === "del" ? "-" : " ";
+            const color = line.type === "add" ? theme.secondary : line.type === "del" ? theme.error : theme.muted;
+            const dimmed = line.type === "ctx";
+            const displayText = truncateToWidth(line.text, diffContentWidth);
+            return /* @__PURE__ */ jsxs3(Text4, { color, dimColor: dimmed, wrap: "truncate-end", children: [
+              prefix,
+              " ",
+              displayText
+            ] }, i);
+          }),
+          truncated && /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, children: [
+            "  \xB7\xB7\xB7 ",
+            diffLines.length - MAX_DIFF_LINES,
+            " more lines"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", marginLeft: 2, marginTop: 1, width: bodyWidth, children: [
+          options.map((opt, idx) => {
+            const isSelected = active && mode === "selecting" && idx === selectedIndex;
+            const optColor = idx === 0 ? theme.secondary : theme.error;
+            return /* @__PURE__ */ jsx4(Box4, { width: bodyWidth, children: isSelected ? /* @__PURE__ */ jsxs3(Fragment, { children: [
+              /* @__PURE__ */ jsx4(Text4, { inverse: true, bold: true, color: theme.accent, children: " \u203A " }),
+              /* @__PURE__ */ jsx4(Text4, { inverse: true, bold: true, children: " " + opt.label + " " }),
+              /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, children: [
+                " \u2014 ",
+                opt.description
+              ] })
+            ] }) : /* @__PURE__ */ jsxs3(Fragment, { children: [
+              /* @__PURE__ */ jsx4(Text4, { color: theme.muted, children: "   " }),
+              /* @__PURE__ */ jsx4(Text4, { color: optColor, children: opt.label }),
+              /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, children: [
+                " \u2014 ",
+                opt.description
+              ] })
+            ] }) }, opt.label);
+          }),
+          mode === "typing" ? /* @__PURE__ */ jsxs3(Box4, { width: bodyWidth, children: [
+            /* @__PURE__ */ jsx4(Text4, { color: theme.accent, bold: true, children: " \u203A " }),
+            /* @__PURE__ */ jsx4(Text4, { color: theme.text, children: feedbackText }),
+            /* @__PURE__ */ jsx4(Text4, { color: theme.accent, children: "\u2588" })
+          ] }) : /* @__PURE__ */ jsx4(Box4, { width: bodyWidth, children: active && isFeedbackSelected ? /* @__PURE__ */ jsxs3(Fragment, { children: [
+            /* @__PURE__ */ jsx4(Text4, { inverse: true, bold: true, color: theme.accent, children: " \u203A " }),
+            /* @__PURE__ */ jsx4(Text4, { inverse: true, bold: true, color: theme.muted, children: " Give feedback... " })
+          ] }) : /* @__PURE__ */ jsxs3(Fragment, { children: [
+            /* @__PURE__ */ jsx4(Text4, { color: theme.muted, children: "   " }),
+            /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: "Give feedback..." })
+          ] }) })
+        ] }),
+        /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, marginTop: 0, width: bodyWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: mode === "typing" ? "Type your feedback \xB7 Enter submit \xB7 Esc back" : active ? "\u2191/\u2193 select \xB7 Enter confirm" : "Waiting..." }) })
       ]
     }
   );
@@ -7991,12 +8720,67 @@ function PendingUpdateCard({
 function QuestionCard({
   question,
   options,
+  active,
+  onSelect,
   width
 }) {
   const theme = useTheme();
   const contentWidth = resolveWidth(width);
   const innerWidth = borderedContentWidth(contentWidth);
   const bodyWidth = indentedWidth(innerWidth);
+  const hasOptions = options.length > 0;
+  const totalItems = hasOptions ? options.length + 1 : 0;
+  const customIndex = options.length;
+  const [selectedIndex, setSelectedIndex] = useState4(0);
+  const [mode, setMode] = useState4(hasOptions ? "selecting" : "typing");
+  const [customText, setCustomText] = useState4("");
+  useInput4((input2, key) => {
+    if (!active || mode !== "selecting" || !hasOptions) return;
+    if (key.upArrow) {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setSelectedIndex((i) => Math.min(totalItems - 1, i + 1));
+      return;
+    }
+    if (key.return) {
+      if (selectedIndex < options.length) {
+        const picked = options[selectedIndex];
+        if (picked) onSelect(picked.label, false);
+      } else {
+        setMode("typing");
+        setCustomText("");
+      }
+      return;
+    }
+  }, { isActive: active && mode === "selecting" });
+  useInput4((input2, key) => {
+    if (!active || mode !== "typing") return;
+    if (key.escape && hasOptions) {
+      setMode("selecting");
+      setCustomText("");
+      return;
+    }
+    if (key.return) {
+      if (customText.trim()) {
+        onSelect(customText.trim(), true);
+      }
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setCustomText((t) => t.slice(0, -1));
+      return;
+    }
+    if (key.ctrl && input2 === "u") {
+      setCustomText("");
+      return;
+    }
+    if (!key.ctrl && !key.meta && !key.tab && input2.length === 1 && input2 >= " ") {
+      setCustomText((t) => t + input2);
+    }
+  }, { isActive: active && mode === "typing" });
+  const isCustomSelected = selectedIndex === customIndex;
   return /* @__PURE__ */ jsxs3(
     Box4,
     {
@@ -8015,18 +8799,38 @@ function QuestionCard({
           /* @__PURE__ */ jsx4(Text4, { bold: true, color: theme.warning, children: "Agent needs your input" })
         ] }),
         /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, marginTop: 0, width: bodyWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.text, wrap: "wrap", children: question }) }),
-        options.length > 0 && /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", marginLeft: 2, marginTop: 1, width: bodyWidth, children: options.map((opt, idx) => /* @__PURE__ */ jsxs3(Box4, { width: bodyWidth, children: [
-          /* @__PURE__ */ jsx4(Text4, { color: theme.accent, bold: true, children: idx + 1 }),
-          /* @__PURE__ */ jsxs3(Text4, { color: theme.text, wrap: "wrap", children: [
-            " ",
-            opt.label
-          ] }),
-          /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: [
-            " \u2014 ",
-            opt.description
-          ] })
-        ] }, opt.label)) }),
-        /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, marginTop: 0, width: bodyWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: options.length > 0 ? "Type number or custom answer" : "Type your answer" }) })
+        /* @__PURE__ */ jsxs3(Box4, { flexDirection: "column", marginLeft: 2, marginTop: 1, width: bodyWidth, children: [
+          options.map((opt, idx) => {
+            const isSelected = active && mode === "selecting" && idx === selectedIndex;
+            return /* @__PURE__ */ jsx4(Box4, { width: bodyWidth, children: isSelected ? /* @__PURE__ */ jsxs3(Fragment, { children: [
+              /* @__PURE__ */ jsx4(Text4, { inverse: true, bold: true, color: theme.accent, children: " \u203A " }),
+              /* @__PURE__ */ jsx4(Text4, { inverse: true, bold: true, children: " " + opt.label + " " }),
+              /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, children: [
+                " \u2014 ",
+                opt.description
+              ] })
+            ] }) : /* @__PURE__ */ jsxs3(Fragment, { children: [
+              /* @__PURE__ */ jsx4(Text4, { color: theme.muted, children: "   " }),
+              /* @__PURE__ */ jsx4(Text4, { color: theme.text, children: opt.label }),
+              /* @__PURE__ */ jsxs3(Text4, { color: theme.muted, dimColor: true, children: [
+                " \u2014 ",
+                opt.description
+              ] })
+            ] }) }, opt.label);
+          }),
+          mode === "typing" ? /* @__PURE__ */ jsxs3(Box4, { width: bodyWidth, children: [
+            /* @__PURE__ */ jsx4(Text4, { color: theme.accent, bold: true, children: " \u203A " }),
+            /* @__PURE__ */ jsx4(Text4, { color: theme.text, children: customText }),
+            /* @__PURE__ */ jsx4(Text4, { color: theme.accent, children: "\u2588" })
+          ] }) : /* @__PURE__ */ jsx4(Box4, { width: bodyWidth, children: active && isCustomSelected ? /* @__PURE__ */ jsxs3(Fragment, { children: [
+            /* @__PURE__ */ jsx4(Text4, { inverse: true, bold: true, color: theme.accent, children: " \u203A " }),
+            /* @__PURE__ */ jsx4(Text4, { inverse: true, bold: true, color: theme.muted, children: " Custom answer... " })
+          ] }) : /* @__PURE__ */ jsxs3(Fragment, { children: [
+            /* @__PURE__ */ jsx4(Text4, { color: theme.muted, children: "   " }),
+            /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: "Custom answer..." })
+          ] }) })
+        ] }),
+        /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, marginTop: 0, width: bodyWidth, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, wrap: "wrap", children: mode === "typing" ? "Type your answer \xB7 Enter submit \xB7 Esc back" : active ? "\u2191/\u2193 select \xB7 Enter confirm" : "Waiting..." }) })
       ]
     }
   );
@@ -8221,22 +9025,22 @@ function FooterBar({
 var STREAM_FLUSH_PATTERN = /[.!?]\s|\n|^#{1,3}\s|^[-*]\s/m;
 var STREAM_FLUSH_INTERVAL_MS = 80;
 function splitMessagesForRender(messages, busy) {
-  if (!busy || messages.length === 0) {
+  if (messages.length === 0) {
     return {
       staticMessages: messages,
       dynamicMessages: []
     };
   }
   const last = messages[messages.length - 1];
-  if (!last || last.role !== "assistant") {
+  if (last && (last.role === "assistant" ? busy : !busy && last.role === "system")) {
     return {
-      staticMessages: messages,
-      dynamicMessages: []
+      staticMessages: messages.slice(0, -1),
+      dynamicMessages: [last]
     };
   }
   return {
-    staticMessages: messages.slice(0, -1),
-    dynamicMessages: [last]
+    staticMessages: messages,
+    dynamicMessages: []
   };
 }
 function createSentenceStreamBuffer({
@@ -8285,10 +9089,10 @@ function createSentenceStreamBuffer({
 }
 
 // src/tui/hooks/use-animated-frame.ts
-import { useState as useState4, useEffect as useEffect2 } from "react";
+import { useState as useState5, useEffect as useEffect2 } from "react";
 var SPINNER_FRAMES = ["\u25D0", "\u25D3", "\u25D1", "\u25D2"];
 function useAnimatedFrame(active) {
-  const [index, setIndex] = useState4(0);
+  const [index, setIndex] = useState5(0);
   useEffect2(() => {
     if (!active) {
       setIndex(0);
@@ -8301,28 +9105,49 @@ function useAnimatedFrame(active) {
 }
 
 // src/tui/hooks/use-terminal-width.ts
-import { useState as useState5, useEffect as useEffect3 } from "react";
+import { useState as useState6, useEffect as useEffect3 } from "react";
 import { useStdout as useStdout2 } from "ink";
+var RESIZE_DEBOUNCE_MS = 50;
 function useTerminalWidth() {
   const { stdout } = useStdout2();
-  const [terminalWidth, setTerminalWidth] = useState5(
+  const [terminalWidth, setTerminalWidth] = useState6(
     () => getObservedTerminalWidth(stdout.columns, process.stdout.columns)
   );
   useEffect3(() => {
     const stream = stdout;
-    const updateWidth = () => {
-      const nextWidth = getObservedTerminalWidth(stream.columns, process.stdout.columns);
-      setTerminalWidth((current) => current === nextWidth ? current : nextWidth);
+    let resizeTimer = null;
+    const commitWidth = () => {
+      setTerminalWidth((current) => {
+        const nextWidth = getStableObservedTerminalWidth(current, stream.columns, process.stdout.columns);
+        return current === nextWidth ? current : nextWidth;
+      });
     };
-    updateWidth();
+    const scheduleWidthUpdate = () => {
+      if (resizeTimer) {
+        clearTimeout(resizeTimer);
+      }
+      resizeTimer = setTimeout(() => {
+        resizeTimer = null;
+        commitWidth();
+      }, RESIZE_DEBOUNCE_MS);
+    };
+    commitWidth();
     if (typeof stream.on === "function") {
-      stream.on("resize", updateWidth);
+      stream.on("resize", scheduleWidthUpdate);
       return () => {
+        if (resizeTimer) {
+          clearTimeout(resizeTimer);
+        }
         if (typeof stream.off === "function") {
-          stream.off("resize", updateWidth);
+          stream.off("resize", scheduleWidthUpdate);
         }
       };
     }
+    return () => {
+      if (resizeTimer) {
+        clearTimeout(resizeTimer);
+      }
+    };
   }, [stdout]);
   return terminalWidth;
 }
@@ -8331,7 +9156,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 +9196,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 +9207,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 +9219,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 +9305,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 +9577,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 +9585,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 +9632,7 @@ async function executeSlashCommand(cmd, args, ctx) {
     history,
     skills: skills2,
     workspaceFiles,
-    sessionId,
+    sessionId: sessionId2,
     sessionTokens,
     agentMode,
     addSystemMessage,
@@ -8846,6 +9671,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 +9776,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.");
@@ -9484,22 +10326,36 @@ function parseCharterYaml(raw) {
 
 // src/tui/helpers/render-message.tsx
 import { jsx as jsx5 } from "react/jsx-runtime";
-function renderConversationMessage(message, key, expanded = false, width) {
-  if (message.role === "system") {
-    if (message.text.startsWith("__tool_summary__")) {
-      try {
-        const data = JSON.parse(message.text.slice("__tool_summary__".length));
-        return /* @__PURE__ */ jsx5(ToolActivitySummary, { summary: data.summary, tools: data.tools, expanded, width }, key);
-      } catch {
-        return null;
+function renderConversationMessages(messages, expanded, width) {
+  const elements = [];
+  let turnCount = 0;
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    const key = `msg-${i}`;
+    if (message.role === "user" && i > 0) {
+      const prev = messages[i - 1];
+      if (prev && prev.role !== "user") {
+        elements.push(/* @__PURE__ */ jsx5(Divider, { width }, `div-${i}`));
+      }
+    }
+    if (message.role === "user") {
+      turnCount++;
+      elements.push(/* @__PURE__ */ jsx5(UserMessage, { text: message.text, turnNumber: turnCount, width }, key));
+    } else if (message.role === "system") {
+      if (message.text.startsWith("__tool_summary__")) {
+        try {
+          const data = JSON.parse(message.text.slice("__tool_summary__".length));
+          elements.push(/* @__PURE__ */ jsx5(ToolActivitySummary, { summary: data.summary, tools: data.tools, expanded, width }, key));
+        } catch {
+        }
+      } else {
+        elements.push(/* @__PURE__ */ jsx5(SystemMessage, { text: message.text, width }, key));
       }
+    } else {
+      elements.push(/* @__PURE__ */ jsx5(AgentMessage, { text: message.text, width }, key));
     }
-    return /* @__PURE__ */ jsx5(SystemMessage, { text: message.text, width }, key);
   }
-  if (message.role === "user") {
-    return /* @__PURE__ */ jsx5(UserMessage, { text: message.text, width }, key);
-  }
-  return /* @__PURE__ */ jsx5(AgentMessage, { text: message.text, width }, key);
+  return elements;
 }
 
 // src/tui/app.tsx
@@ -9510,55 +10366,84 @@ function App({
 }) {
   const app = useApp();
   const abortRef = useRef2(null);
-  const [input2, setInput] = useState6("");
-  const [composerFocused, setComposerFocused] = useState6(true);
-  const [busy, setBusy] = useState6(false);
-  const [authStatus, setAuthStatus] = useState6(initialState.authStatus);
-  const [workspacePath, setWorkspacePath] = useState6(initialState.workspacePath);
-  const [workspaceFiles, setWorkspaceFiles] = useState6([]);
-  const [skills2, setSkills] = useState6([]);
-  const [messages, setMessages] = useState6([]);
-  const [messageRenderVersion, setMessageRenderVersion] = useState6(0);
-  const [history, setHistory] = useState6([]);
-  const [activeSkills, setActiveSkills] = useState6([]);
-  const [pendingUpdates, setPendingUpdates] = useState6(initialState.pendingUpdates);
-  const [statusLine, setStatusLine] = useState6("");
-  const [currentToolActivity, setCurrentToolActivity] = useState6("");
-  const [turnToolCount, setTurnToolCount] = useState6(0);
-  const [subAgentProgress, setSubAgentProgress] = useState6(null);
-  const [toolActivityExpanded, setToolActivityExpanded] = useState6(false);
-  const [taskPanelVisible, setTaskPanelVisible] = useState6(true);
-  const [taskVersion, setTaskVersion] = useState6(0);
+  const [input2, setInput] = useState7("");
+  const [composerFocused, setComposerFocused] = useState7(true);
+  const [busy, setBusy] = useState7(false);
+  const [authStatus, setAuthStatus] = useState7(initialState.authStatus);
+  const [workspacePath, setWorkspacePath] = useState7(initialState.workspacePath);
+  const [workspaceFiles, setWorkspaceFiles] = useState7([]);
+  const [skills2, setSkills] = useState7([]);
+  const [messages, setMessages] = useState7([]);
+  const [history, setHistory] = useState7([]);
+  const [activeSkills, setActiveSkills] = useState7([]);
+  const [pendingUpdates, setPendingUpdates] = useState7(initialState.pendingUpdates);
+  const [statusLine, setStatusLine] = useState7("");
+  const [activeToolActivities, setActiveToolActivities] = useState7({});
+  const [turnToolCount, setTurnToolCount] = useState7(0);
+  const [subAgentProgress, setSubAgentProgress] = useState7({});
+  const [toolActivityExpanded, setToolActivityExpanded] = useState7(false);
+  const [taskPanelVisible, setTaskPanelVisible] = useState7(true);
+  const [taskVersion, setTaskVersion] = useState7(0);
   const turnToolLogRef = useRef2([]);
-  const [sessionTokens, setSessionTokens] = useState6(() => createSessionUsage());
-  const [tokenDisplay, setTokenDisplay] = useState6("");
-  const [showSuggestions, setShowSuggestions] = useState6(false);
-  const [agentMode, setAgentMode] = useState6("manual-review");
-  const [planningState, setPlanningState] = useState6({
+  const [sessionTokens, setSessionTokens] = useState7(() => createSessionUsage());
+  const [tokenDisplay, setTokenDisplay] = useState7("");
+  const [showSuggestions, setShowSuggestions] = useState7(false);
+  const [agentMode, setAgentMode] = useState7("manual-review");
+  const [planningState, setPlanningState] = useState7({
     status: "idle",
     planningHistory: []
   });
-  const [theme, setTheme] = useState6("dark");
-  const [config, setConfig] = useState6(null);
-  const [cursorToEnd, setCursorToEnd] = useState6(0);
-  const [screen, setScreen] = useState6("main");
-  const [resumeSessions, setResumeSessions] = useState6([]);
-  const [ctrlCPending, setCtrlCPending] = useState6(false);
-  const sessionId = useMemo3(() => crypto.randomUUID(), []);
-  const deferredMessages = useDeferredValue(messages);
+  const [theme, setTheme] = useState7("dark");
+  const [config, setConfig] = useState7(null);
+  const [cursorToEnd, setCursorToEnd] = useState7(0);
+  const [messageRenderVersion, setMessageRenderVersion] = useState7(0);
+  const [screen, setScreen] = useState7("main");
+  const [resumeSessions, setResumeSessions] = useState7([]);
+  const [ctrlCPending, setCtrlCPending] = useState7(false);
+  const sessionId2 = useMemo4(() => crypto.randomUUID(), []);
   const deferredPendingUpdates = useDeferredValue(pendingUpdates);
+  const visiblePendingUpdates = deferredPendingUpdates.length > 0 ? deferredPendingUpdates : pendingUpdates;
   const activityFrame = useAnimatedFrame(busy);
   const terminalWidth = useTerminalWidth();
   const contentWidth = insetWidth(terminalWidth, 2);
   const panelInnerWidth = insetWidth(contentWidth, 4);
   const panelBodyWidth = insetWidth(panelInnerWidth, 2);
-  const [agentQuestion, setAgentQuestion] = useState6(null);
+  const [agentQuestion, setAgentQuestion] = useState7(null);
   const previewRef = useRef2(null);
   const ctrlCTimerRef = useRef2(null);
-  const isHome = deferredMessages.length === 0 && !busy;
-  const { staticMessages, dynamicMessages } = useMemo3(
-    () => splitMessagesForRender(deferredMessages, busy),
-    [busy, deferredMessages]
+  const isHome = messages.length === 0 && !busy;
+  const { staticMessages, dynamicMessages } = useMemo4(
+    () => splitMessagesForRender(messages, busy),
+    [busy, messages]
+  );
+  const staticRenderItems = useMemo4(
+    () => renderConversationMessages(staticMessages, toolActivityExpanded, contentWidth),
+    [contentWidth, staticMessages, toolActivityExpanded]
+  );
+  const dynamicRenderItems = useMemo4(
+    () => renderConversationMessages(dynamicMessages, toolActivityExpanded, contentWidth),
+    [contentWidth, dynamicMessages, toolActivityExpanded]
+  );
+  const showThinking = busy && (messages.length === 0 || messages[messages.length - 1]?.role !== "assistant");
+  const activeToolDescriptions = useMemo4(
+    () => Object.values(activeToolActivities),
+    [activeToolActivities]
+  );
+  const currentToolActivity = useMemo4(() => {
+    if (activeToolDescriptions.length === 0) {
+      return "";
+    }
+    if (activeToolDescriptions.length === 1 && turnToolCount === 0) {
+      return activeToolDescriptions[0] ?? "";
+    }
+    if (activeToolDescriptions.length === 1) {
+      return "Running 1 tool";
+    }
+    return `Running ${activeToolDescriptions.length} tools in parallel`;
+  }, [activeToolDescriptions, turnToolCount]);
+  const visibleSubAgents = useMemo4(
+    () => Object.values(subAgentProgress),
+    [subAgentProgress]
   );
   const hasWorkspace = workspacePath !== null;
   const hasAuth = authStatus === "connected";
@@ -9571,7 +10456,7 @@ function App({
       const pending = getPendingQuestion();
       if (pending && (!agentQuestion || pending.question.id !== agentQuestion.question.id)) {
         setAgentQuestion(pending);
-        setComposerFocused(true);
+        setComposerFocused(false);
       }
     }, 200);
     return () => clearInterval(interval);
@@ -9626,15 +10511,16 @@ function App({
       }
     };
   }, []);
-  const [selectedSuggestion, setSelectedSuggestion] = useState6(-1);
-  const atMention = useMemo3(() => extractAtMention(input2), [input2]);
-  const suggestions = useMemo3(() => {
+  const [selectedSuggestion, setSelectedSuggestion] = useState7(-1);
+  const atMention = useMemo4(() => extractAtMention(input2), [input2]);
+  const slashTrigger = useMemo4(() => extractSlashTrigger(input2), [input2]);
+  const suggestions = useMemo4(() => {
     if (atMention) {
       return getFileSuggestions(atMention.partial, workspaceFiles);
     }
-    if (!input2.startsWith("/")) return [];
-    return getUnifiedSuggestions(input2, skills2);
-  }, [input2, skills2, atMention, workspaceFiles]);
+    if (!slashTrigger) return [];
+    return getUnifiedSuggestions(`/${slashTrigger.partial}`, skills2);
+  }, [input2, skills2, atMention, slashTrigger, workspaceFiles]);
   useEffect4(() => {
     setSelectedSuggestion(-1);
   }, [suggestions.length, input2]);
@@ -9643,8 +10529,9 @@ function App({
     if (s.kind === "file" && atMention) {
       const before = input2.slice(0, atMention.start);
       setInput(`${before}@${s.path} `);
-    } else if (s.kind === "command" || s.kind === "skill") {
-      setInput(`/${s.name}`);
+    } else if ((s.kind === "command" || s.kind === "skill") && slashTrigger) {
+      const before = input2.slice(0, slashTrigger.start);
+      setInput(`${before}/${s.name}`);
     }
     setSelectedSuggestion(-1);
     setCursorToEnd((c) => c + 1);
@@ -9701,10 +10588,8 @@ function App({
     });
   }
   function replaceMessages(nextMessages) {
-    startTransition2(() => {
-      setMessageRenderVersion((current) => current + 1);
-      setMessages(nextMessages);
-    });
+    setMessages(nextMessages);
+    setMessageRenderVersion((current) => current + 1);
   }
   const slashCtx = {
     homeDir,
@@ -9715,7 +10600,7 @@ function App({
     history,
     skills: skills2,
     workspaceFiles,
-    sessionId,
+    sessionId: sessionId2,
     sessionTokens,
     agentMode,
     previewRef,
@@ -9743,7 +10628,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 +10643,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 }
@@ -9768,6 +10653,19 @@ function App({
       addSystemMessage(`Rejected: ${next.summary}`);
     });
   }
+  function feedbackOnPendingUpdate(feedback) {
+    if (pendingUpdates.length === 0 || !workspacePath) return;
+    const [next, ...rest] = pendingUpdates;
+    void appendSessionEvent(workspacePath, sessionId2, {
+      type: "update.rejected",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: { key: next.key, summary: next.summary, feedback }
+    });
+    startTransition2(() => {
+      setPendingUpdates(rest);
+      addSystemMessage(`Feedback on "${next.summary}": ${feedback}`);
+    });
+  }
   function clearCtrlCPending() {
     if (ctrlCTimerRef.current) {
       clearTimeout(ctrlCTimerRef.current);
@@ -9822,7 +10720,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 +10733,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 }
@@ -9843,7 +10741,7 @@ function App({
     setPlanningState({ status: "idle", planningHistory: [] });
     addSystemMessage("Charter cancelled. Planning reset.");
   }
-  useInput4((key, inputKey) => {
+  useInput5((key, inputKey) => {
     if (inputKey.ctrl && key === "c") {
       if (busy) {
         clearCtrlCPending();
@@ -9916,14 +10814,7 @@ function App({
           return;
         }
       }
-      if (key === "a" && pendingUpdates.length > 0) {
-        void acceptNextPendingUpdate();
-        return;
-      }
-      if (key === "r" && pendingUpdates.length > 0) {
-        rejectNextPendingUpdate();
-        return;
-      }
+      if (pendingUpdates.length > 0 && !agentQuestion || agentQuestion) return;
       if (key === "i" || key.length === 1 && !inputKey.ctrl && !inputKey.meta && !inputKey.tab) {
         setComposerFocused(true);
         if (key !== "i") setInput((c) => c + key);
@@ -9935,24 +10826,9 @@ function App({
     if (handleDropdownSelect()) return;
     const trimmed = value.trim();
     if (!trimmed) return;
-    if (agentQuestion) {
-      const options = agentQuestion.question.options;
-      const numChoice = parseInt(trimmed, 10);
-      if (!isNaN(numChoice) && numChoice >= 1 && numChoice <= options.length) {
-        const picked = options[numChoice - 1];
-        addSystemMessage(`> ${picked.label}`);
-        agentQuestion.resolve({ questionId: agentQuestion.question.id, answer: picked.label, isCustom: false });
-      } else {
-        addSystemMessage(`> ${trimmed}`);
-        agentQuestion.resolve({ questionId: agentQuestion.question.id, answer: trimmed, isCustom: true });
-      }
-      clearPendingQuestion();
-      setAgentQuestion(null);
-      setInput("");
-      return;
-    }
+    if (agentQuestion) return;
     if (busy) return;
-    if (trimmed.startsWith("/") && !trimmed.includes(" ") && applyAutocomplete()) {
+    if (dropdownVisible && applyAutocomplete()) {
       return;
     }
     setInput("");
@@ -9995,9 +10871,11 @@ function App({
     if (!workspacePath) return;
     turnToolLogRef.current = [];
     setTurnToolCount(0);
-    setSubAgentProgress(null);
+    setActiveToolActivities({});
+    setSubAgentProgress({});
     const controller = new AbortController();
     let streamBuffer = null;
+    let focusPendingReviewOnComplete = false;
     abortRef.current = controller;
     setBusy(true);
     startTransition2(() => {
@@ -10008,7 +10886,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]))
@@ -10037,9 +10915,16 @@ function App({
         onToolActivity: (activity) => {
           streamBuffer?.flush();
           if (activity.type === "tool_start") {
-            setCurrentToolActivity(activity.description ?? activity.name);
+            setActiveToolActivities((current) => ({
+              ...current,
+              [activity.toolCallId]: activity.description ?? activity.name
+            }));
           } else {
-            setCurrentToolActivity("");
+            setActiveToolActivities((current) => {
+              const next = { ...current };
+              delete next[activity.toolCallId];
+              return next;
+            });
             turnToolLogRef.current.push({
               name: activity.name,
               description: activity.description ?? activity.name,
@@ -10053,9 +10938,16 @@ function App({
         },
         onSubAgentProgress: (progress) => {
           if (progress.status === "done") {
-            setSubAgentProgress(null);
+            setSubAgentProgress((current) => {
+              const next = { ...current };
+              delete next[progress.agentId];
+              return next;
+            });
           } else {
-            setSubAgentProgress({ ...progress });
+            setSubAgentProgress((current) => ({
+              ...current,
+              [progress.agentId]: { ...progress }
+            }));
           }
         },
         onMemoryExtracted: (mems) => {
@@ -10102,9 +10994,10 @@ function App({
         }
       }
       if (reviewRequired.length > 0) {
-        startTransition2(() => setPendingUpdates((c) => [...c, ...reviewRequired]));
+        focusPendingReviewOnComplete = true;
+        setPendingUpdates((current) => [...current, ...reviewRequired]);
       }
-      await appendSessionEvent(workspacePath, sessionId, {
+      await appendSessionEvent(workspacePath, sessionId2, {
         type: "chat.turn",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         payload: {
@@ -10134,8 +11027,10 @@ ${error.stack}` : String(error)}` }
     } finally {
       streamBuffer?.dispose();
       abortRef.current = null;
+      setActiveToolActivities({});
+      setSubAgentProgress({});
       setBusy(false);
-      setComposerFocused(true);
+      setComposerFocused(!focusPendingReviewOnComplete);
       if (controller.signal.aborted) {
         addSystemMessage("Agent interrupted.");
       }
@@ -10162,7 +11057,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 +11097,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 }
@@ -10242,10 +11137,10 @@ ${error.stack}` : String(error)}` }
   else statusParts.push("no workspace");
   if (skills2.length > 0) statusParts.push(`${skills2.length} skills`);
   statusParts.push(agentMode);
-  if (deferredPendingUpdates.length > 0) statusParts.push(`${deferredPendingUpdates.length} pending`);
+  if (pendingUpdates.length > 0) statusParts.push(`${pendingUpdates.length} pending`);
   const themeColors = getThemeColors(theme);
-  const statusColor = busy ? themeColors.warning : ctrlCPending ? themeColors.warning : !hasAuth ? themeColors.error : deferredPendingUpdates.length > 0 ? themeColors.pending : themeColors.secondary;
-  const configItems = useMemo3(() => [
+  const statusColor = busy ? themeColors.warning : ctrlCPending ? themeColors.warning : !hasAuth ? themeColors.error : pendingUpdates.length > 0 ? themeColors.pending : themeColors.secondary;
+  const configItems = useMemo4(() => [
     { key: "defaults.model", label: "Model", values: [...getAvailableModels()], current: config?.defaults.model ?? "gpt-5.4" },
     { key: "theme", label: "Theme", values: [...themeValues], current: theme },
     { key: "defaults.reasoningEffort", label: "Reasoning effort", values: ["low", "medium", "high", "xhigh"], current: config?.defaults.reasoningEffort ?? "medium" },
@@ -10279,11 +11174,8 @@ ${error.stack}` : String(error)}` }
       onSelect: async (session) => {
         try {
           const restored = await loadSessionHistory(workspacePath, session.id);
-          startTransition2(() => {
-            setMessageRenderVersion((current) => current + 1);
-            setMessages(restored.messages);
-            setHistory(restored.llmHistory);
-          });
+          replaceMessages(restored.messages);
+          startTransition2(() => setHistory(restored.llmHistory));
           addSystemMessage(`Resumed session (${session.turnCount} turns). Continue where you left off.`);
         } catch (err) {
           addSystemMessage(`Failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -10316,23 +11208,28 @@ ${error.stack}` : String(error)}` }
         width: contentWidth
       }
     ),
-    deferredMessages.length > 0 && /* @__PURE__ */ jsxs4(Box5, { flexDirection: "column", marginBottom: 1, width: contentWidth, children: [
-      /* @__PURE__ */ jsx6(Static, { items: staticMessages, children: (message, idx) => renderConversationMessage(message, `static-msg-${idx}`, toolActivityExpanded, contentWidth) }, `conversation-static-${messageRenderVersion}-${toolActivityExpanded ? "e" : "c"}`),
-      dynamicMessages.map(
-        (message, idx) => renderConversationMessage(message, `dynamic-msg-${staticMessages.length + idx}`, toolActivityExpanded, contentWidth)
-      )
-    ] }),
-    subAgentProgress && /* @__PURE__ */ jsx6(
+    staticRenderItems.length > 0 && /* @__PURE__ */ jsx6(
+      Static,
+      {
+        items: staticRenderItems,
+        children: (item, index) => /* @__PURE__ */ jsx6(React6.Fragment, { children: item }, `conversation-static-item-${messageRenderVersion}-${index}`)
+      },
+      `conversation-static-${messageRenderVersion}`
+    ),
+    dynamicRenderItems.length > 0 && /* @__PURE__ */ jsx6(Box5, { flexDirection: "column", marginBottom: 1, width: contentWidth, children: dynamicRenderItems }),
+    showThinking && /* @__PURE__ */ jsx6(ThinkingIndicator, { frame: activityFrame, width: contentWidth }),
+    visibleSubAgents.map((progress) => /* @__PURE__ */ jsx6(
       SubAgentIndicator,
       {
-        agentType: subAgentProgress.agentType,
-        goal: subAgentProgress.goal,
-        currentTool: subAgentProgress.currentTool,
-        toolCount: subAgentProgress.toolCount,
+        agentType: progress.agentType,
+        goal: progress.goal,
+        currentTool: progress.currentTool,
+        toolCount: progress.toolCount,
         frame: activityFrame,
         width: contentWidth
-      }
-    ),
+      },
+      progress.agentId
+    )),
     taskPanelVisible && getVisibleTasks().length > 0 && /* @__PURE__ */ jsx6(
       TaskPanel,
       {
@@ -10341,11 +11238,28 @@ ${error.stack}` : String(error)}` }
         width: contentWidth
       }
     ),
-    deferredPendingUpdates.length > 0 && /* @__PURE__ */ jsx6(
+    visiblePendingUpdates.length > 0 && /* @__PURE__ */ jsx6(
       PendingUpdateCard,
       {
-        count: deferredPendingUpdates.length,
-        summary: truncate3(deferredPendingUpdates[0].summary, Math.max(24, insetWidth(contentWidth, 8))),
+        count: pendingUpdates.length,
+        summary: truncate3(visiblePendingUpdates[0].summary, Math.max(24, insetWidth(contentWidth, 8))),
+        fileName: visiblePendingUpdates[0].key,
+        updateType: visiblePendingUpdates[0].type,
+        oldContent: visiblePendingUpdates[0].oldContent,
+        newContent: visiblePendingUpdates[0].content,
+        active: !composerFocused && !agentQuestion,
+        onAccept: () => {
+          void acceptNextPendingUpdate();
+          if (pendingUpdates.length <= 1) setComposerFocused(true);
+        },
+        onReject: () => {
+          rejectNextPendingUpdate();
+          if (pendingUpdates.length <= 1) setComposerFocused(true);
+        },
+        onFeedback: (fb) => {
+          feedbackOnPendingUpdate(fb);
+          if (pendingUpdates.length <= 1) setComposerFocused(true);
+        },
         width: contentWidth
       }
     ),
@@ -10389,7 +11303,23 @@ ${error.stack}` : String(error)}` }
       ] }) })
     ] }),
     dropdownVisible && /* @__PURE__ */ jsx6(SuggestionDropdown, { width: contentWidth, items: suggestions, selectedIndex: selectedSuggestion }),
-    agentQuestion && /* @__PURE__ */ jsx6(QuestionCard, { width: contentWidth, question: agentQuestion.question.question, options: agentQuestion.question.options }),
+    agentQuestion && /* @__PURE__ */ jsx6(
+      QuestionCard,
+      {
+        width: contentWidth,
+        question: agentQuestion.question.question,
+        options: agentQuestion.question.options,
+        active: !composerFocused,
+        onSelect: (answer, isCustom) => {
+          addSystemMessage(`> ${answer}`);
+          agentQuestion.resolve({ questionId: agentQuestion.question.id, answer, isCustom });
+          clearPendingQuestion();
+          const nextQuestion = getPendingQuestion();
+          setAgentQuestion(nextQuestion);
+          setComposerFocused(nextQuestion === null);
+        }
+      }
+    ),
     /* @__PURE__ */ jsx6(Box5, { borderStyle: "round", borderColor: agentQuestion ? themeColors.warning : composerFocused ? themeColors.borderFocused : themeColors.borderDefault, paddingX: 1, flexDirection: "column", width: contentWidth, children: /* @__PURE__ */ jsxs4(Box5, { children: [
       /* @__PURE__ */ jsx6(PromptPrefix, { busy, frame: activityFrame, hasQuestion: !!agentQuestion, mode: agentMode }),
       /* @__PURE__ */ jsx6(
@@ -10405,7 +11335,7 @@ ${error.stack}` : String(error)}` }
           cursorToEnd,
           accentColor: themeColors.accent,
           mutedColor: themeColors.muted,
-          placeholder: agentQuestion ? "Type your answer..." : !hasAuth ? "Type /auth or /config apikey" : !hasWorkspace ? "Type /init to create workspace" : busy ? "Draft your next message while the agent works" : "Ask a question or type / for commands"
+          placeholder: agentQuestion ? "Answer in the card above" : !hasAuth ? "Type /auth or /config apikey" : !hasWorkspace ? "Type /init to create workspace" : pendingUpdates.length > 0 && composerFocused ? "Esc to review updates, or keep drafting" : busy ? "Draft your next message while the agent works" : "Ask a question or type / for commands"
         }
       )
     ] }) }),
@@ -10434,6 +11364,35 @@ ${error.stack}` : String(error)}` }
   ] }) });
 }
 
+// src/tui/ink-stdout.ts
+function getStableDimension(current, fallback) {
+  return typeof current === "number" && current > 0 ? current : fallback;
+}
+function createStableInkStdout(stdout, options) {
+  const forceFullRedraw = options?.forceFullRedraw ?? process.env.OPEN_RESEARCH_FORCE_FULL_REDRAW === "1";
+  let lastRows = getStableDimension(stdout.rows, 24);
+  let lastColumns = getStableDimension(stdout.columns, 80);
+  return new Proxy(stdout, {
+    get(target, prop, receiver) {
+      if (prop === "rows") {
+        if (forceFullRedraw) {
+          return 0;
+        }
+        const rows = Reflect.get(target, prop, receiver);
+        lastRows = getStableDimension(rows, lastRows);
+        return lastRows;
+      }
+      if (prop === "columns") {
+        const columns = Reflect.get(target, prop, receiver);
+        lastColumns = getStableDimension(columns, lastColumns);
+        return lastColumns;
+      }
+      const value = Reflect.get(target, prop, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+
 // src/cli.ts
 var program = new Command();
 program.name("open-research").version(getPackageVersion()).description("Local-first research CLI powered by OpenAI account auth or API keys.").argument("[workspacePath]", "Optional workspace path to open").action(async (workspacePath) => {
@@ -10442,7 +11401,7 @@ program.name("open-research").version(getPackageVersion()).description("Local-fi
   const project = await loadWorkspaceProject(target);
   const hasProvider = await hasConfiguredProvider();
   render(
-    React6.createElement(App, {
+    React7.createElement(App, {
       initialState: {
         authStatus: hasProvider ? "connected" : "missing",
         workspacePath: project ? target : null,
@@ -10450,7 +11409,10 @@ program.name("open-research").version(getPackageVersion()).description("Local-fi
         pendingUpdates: []
       }
     }),
-    { exitOnCtrlC: false }
+    {
+      exitOnCtrlC: false,
+      stdout: createStableInkStdout(process.stdout)
+    }
   );
 });
 program.command("init").argument("[workspacePath]").description("Initialize an Open Research workspace.").action(async (workspacePath) => {
@@ -10541,7 +11503,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}`);