@oxbit/cli 0.10.1 → 0.11.1

package/agent/dist/index.js

@@ -1,39 +1,12 @@
 #!/usr/bin/env node
 import { parseArgs } from "node:util";
 import { createInterface } from "node:readline";
-import { mkdir, readFile as readFile$1, writeFile as writeFile$1, chmod, rename, stat, rm, readdir, realpath, unlink, open, access } from "node:fs/promises";
+import { mkdir, readFile as readFile$1, writeFile as writeFile$1, chmod, rename, stat, rm, readdir, realpath, unlink, open, access, cp } from "node:fs/promises";
 import { join, dirname, isAbsolute, sep, basename, resolve } from "node:path";
 import { randomBytes, createHash, randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
 import { createServer } from "node:http";
-const count = (...values) => values.find((value2) => Number.isSafeInteger(value2) && value2 > 0);
-async function readText$1(models2, request, signal) {
-  let text = "";
-  for await (const chunk of models2.stream(request, signal)) text += chunk;
-  return text;
-}
-async function listModels(models2, endpoint, signal) {
-  const body = JSON.parse(await readText$1(models2, { ...endpoint, method: "GET", path: "/v1/models" }, signal));
-  if (!Array.isArray(body?.data)) throw new Error("The model list has no data array");
-  return body.data.filter((item) => typeof item?.id === "string" && item.id).slice(0, 1e3).map((item) => ({
-    id: item.id,
-    name: typeof item.display_name === "string" ? item.display_name : typeof item.name === "string" ? item.name : item.id,
-    contextWindow: count(item.max_input_tokens, item.context_length),
-    maxOutput: count(item.max_tokens, item.top_provider?.max_completion_tokens)
-  }));
-}
-function modelError(error) {
-  const { status, body } = error ?? {};
-  if (typeof status !== "number") return error instanceof Error ? error : new Error(String(error));
-  let detail = typeof body === "string" ? body.trim().slice(0, 1e3) : "";
-  try {
-    const parsed = JSON.parse(detail);
-    detail = parsed?.error?.message ?? parsed?.message ?? detail;
-  } catch {
-  }
-  return new Error(`Model API error ${status}${detail ? `: ${detail}` : ""}`);
-}
 async function* lines(chunks) {
   let buffer = "";
   for await (const chunk of chunks) {
@@ -76,6 +49,137 @@ async function* jsonEvents(chunks) {
     if (value2 && typeof value2 === "object") yield { ...event && !value2.type ? { type: event } : {}, ...value2 };
   }
 }
+function replayable(items) {
+  const kept = items.filter((item) => item.type !== "reasoning" || item.encrypted_content);
+  return kept.length === items.length ? items : kept.map((item) => item.type === "reasoning" ? item : Object.fromEntries(Object.entries(item).filter(([key]) => key !== "id")));
+}
+function responsesBody({ model, system, turns, tools, effort }, replay2) {
+  const input2 = [];
+  for (const turn of turns) {
+    if (turn.role === "user") input2.push({ type: "message", role: "user", content: [{ type: "input_text", text: turn.text }] });
+    else if (turn.role === "tool")
+      for (const result of turn.results) input2.push({ type: "function_call_output", call_id: result.id, output: result.output });
+    else if (turn.native && replay2.includes(turn.native.api)) input2.push(...replayable(turn.native.items));
+    else {
+      if (turn.text) input2.push({ type: "message", role: "assistant", content: turn.text });
+      for (const call of turn.calls) input2.push({ type: "function_call", call_id: call.id, name: call.name, arguments: call.arguments });
+    }
+  }
+  return {
+    model,
+    instructions: system,
+    input: input2,
+    stream: true,
+    store: false,
+    ...tools.length ? { tools: tools.map((tool) => ({ type: "function", ...tool, strict: false })) } : {},
+    ...effort ? { reasoning: { effort, summary: "auto" } } : {}
+  };
+}
+const openaiResponses = {
+  request: (input2) => ({ method: "POST", path: "/v1/responses", body: responsesBody(input2, ["openai"]) }),
+  async *events(chunks) {
+    const items = [];
+    for await (const event of jsonEvents(chunks)) {
+      switch (event.type) {
+        case "response.output_text.delta":
+          if (event.delta) yield { type: "text", text: event.delta };
+          break;
+        case "response.reasoning_summary_text.delta":
+        case "response.reasoning_text.delta":
+          if (event.delta) yield { type: "reasoning", text: event.delta };
+          break;
+        case "response.reasoning_summary_part.added":
+          if (event.summary_index > 0) yield { type: "reasoning", text: "\n\n" };
+          break;
+        case "response.output_item.done":
+          items[event.output_index ?? items.length] = event.item;
+          if (event.item?.type === "function_call")
+            yield { type: "tool_call", call: { id: event.item.call_id, name: event.item.name, arguments: event.item.arguments ?? "" } };
+          break;
+        case "response.completed":
+        case "response.incomplete": {
+          const { usage, incomplete_details: incomplete } = event.response ?? {};
+          if (usage) yield { type: "usage", input: usage.input_tokens ?? 0, output: usage.output_tokens ?? 0 };
+          const native = items.filter(Boolean);
+          const reason = native.some((item) => item.type === "function_call") ? "tool_use" : event.type === "response.completed" ? "end_turn" : incomplete?.reason === "content_filter" ? "refusal" : "max_tokens";
+          yield { type: "stop", reason, native };
+          return;
+        }
+        case "response.failed":
+          throw new Error(event.response?.error?.message ?? "The model response failed");
+        case "error":
+          throw new Error(event.message ?? "The model stream failed");
+      }
+    }
+  }
+};
+const CHATGPT_CLIENT_VERSION = "0.162.1";
+const CHATGPT_MODELS_PATH = `/codex/models?client_version=${CHATGPT_CLIENT_VERSION}`;
+const WINDOW = { contextWindow: 272e3 };
+const CHATGPT_MODELS = [
+  { id: "gpt-6.1-sol", name: "GPT-6.1-Sol", ...WINDOW },
+  { id: "gpt-6-astra", name: "GPT-6-Astra", ...WINDOW },
+  { id: "gpt-6-sol", name: "GPT-6-Sol", ...WINDOW },
+  { id: "gpt-6-luna", name: "GPT-6-Luna", ...WINDOW },
+  { id: "gpt-5.6-sol", name: "GPT-5.6-Sol", ...WINDOW },
+  { id: "gpt-5.6-terra", name: "GPT-5.6-Terra", ...WINDOW },
+  { id: "gpt-5.6-luna", name: "GPT-5.6-Luna", ...WINDOW },
+  { id: "gpt-5.5", name: "GPT-5.5", ...WINDOW }
+];
+const chatgptResponses = {
+  request: (input2) => ({
+    method: "POST",
+    path: "/codex/responses",
+    body: {
+      ...responsesBody({ ...input2, system: input2.system || "You are a helpful assistant." }, ["openai", "chatgpt"]),
+      include: ["reasoning.encrypted_content"],
+      tool_choice: "auto"
+    }
+  }),
+  events: openaiResponses.events
+};
+const count = (...values) => values.find((value2) => Number.isSafeInteger(value2) && value2 > 0);
+async function readText$1(models2, request, signal) {
+  let text = "";
+  for await (const chunk of models2.stream(request, signal)) text += chunk;
+  return text;
+}
+async function listModels(models2, endpoint, signal) {
+  if (endpoint.api === "chatgpt") return listChatGPTModels(models2, signal);
+  const body = JSON.parse(await readText$1(models2, { ...endpoint, method: "GET", path: "/v1/models" }, signal));
+  if (!Array.isArray(body?.data)) throw new Error("The model list has no data array");
+  return body.data.filter((item) => typeof item?.id === "string" && item.id).slice(0, 1e3).map((item) => ({
+    id: item.id,
+    name: typeof item.display_name === "string" ? item.display_name : typeof item.name === "string" ? item.name : item.id,
+    contextWindow: count(item.max_input_tokens, item.context_length),
+    maxOutput: count(item.max_tokens, item.top_provider?.max_completion_tokens)
+  }));
+}
+async function listChatGPTModels(models2, signal) {
+  try {
+    const body = JSON.parse(await readText$1(models2, { api: "chatgpt", method: "GET", path: CHATGPT_MODELS_PATH }, signal));
+    const listed = (Array.isArray(body?.models) ? body.models : []).filter((item) => typeof item?.slug === "string" && item.slug && item.visibility === "list").sort((a, b) => (Number(a.priority) || 0) - (Number(b.priority) || 0)).map((item) => ({
+      id: item.slug,
+      name: typeof item.display_name === "string" && item.display_name ? item.display_name : item.slug,
+      contextWindow: count(item.context_window)
+    }));
+    if (listed.length) return listed;
+  } catch (error) {
+    if (signal?.aborted) throw error;
+  }
+  return CHATGPT_MODELS.map((model) => ({ ...model }));
+}
+function modelError(error) {
+  const { status: status2, body } = error ?? {};
+  if (typeof status2 !== "number") return error instanceof Error ? error : new Error(String(error));
+  let detail = typeof body === "string" ? body.trim().slice(0, 1e3) : "";
+  try {
+    const parsed = JSON.parse(detail);
+    detail = parsed?.error?.message ?? parsed?.message ?? detail;
+  } catch {
+  }
+  return new Error(`Model API error ${status2}${detail ? `: ${detail}` : ""}`);
+}
 const OUTPUT_LIMIT$1 = 1e5;
 const BASH_TIMEOUT = 12e4;
 const BASH_MAX_TIMEOUT = 6e5;
@@ -250,7 +354,7 @@ const updatePlan = {
     return "Plan updated";
   }
 };
-const terminalText = (result, status) => [(result?.output ?? "").replace(/\s+$/, ""), result?.truncated ? "[Output truncated to the last bytes]" : "", `[${status}]`].filter(Boolean).join("\n");
+const terminalText = (result, status2) => [(result?.output ?? "").replace(/\s+$/, ""), result?.truncated ? "[Output truncated to the last bytes]" : "", `[${status2}]`].filter(Boolean).join("\n");
 const bash = {
   spec: {
     name: "bash",
@@ -296,8 +400,8 @@ const bash = {
     try {
       const exit = await Promise.race([context.request("terminal/wait_for_exit", terminal), interrupted]);
       const result = await context.request("terminal/output", terminal);
-      const status = exit?.signal ? `Killed by ${exit.signal}` : `Exit code ${exit?.exitCode ?? "unknown"}`;
-      const text = terminalText(result, status);
+      const status2 = exit?.signal ? `Killed by ${exit.signal}` : `Exit code ${exit?.exitCode ?? "unknown"}`;
+      const text = terminalText(result, status2);
       if (exit?.exitCode !== 0) throw new Error(text);
       return text;
     } catch (error) {
@@ -339,7 +443,7 @@ async function runTool(call, context, tools = TOOLS, gate = {}) {
   let args = typeof parsed === "string" ? {} : parsed;
   const tool = tools.find((item) => item.spec.name === call.name);
   const toolCallId = call.id;
-  const update = (status, output2) => context.update({ sessionUpdate: "tool_call_update", toolCallId, status, rawOutput: output2.slice(0, 8e3) });
+  const update = (status2, output2) => context.update({ sessionUpdate: "tool_call_update", toolCallId, status: status2, rawOutput: output2.slice(0, 8e3) });
   const where = locations(context.root, args);
   context.update({
     sessionUpdate: "tool_call",
@@ -486,73 +590,6 @@ async function streamStep({ adapter, models: models2, endpoint, input: input2, s
   }
   return result;
 }
-function replayable(items) {
-  const kept = items.filter((item) => item.type !== "reasoning" || item.encrypted_content);
-  return kept.length === items.length ? items : kept.map((item) => item.type === "reasoning" ? item : Object.fromEntries(Object.entries(item).filter(([key]) => key !== "id")));
-}
-const openaiResponses = {
-  request({ model, system: system2, turns, tools, effort }) {
-    const input2 = [];
-    for (const turn of turns) {
-      if (turn.role === "user") input2.push({ type: "message", role: "user", content: [{ type: "input_text", text: turn.text }] });
-      else if (turn.role === "tool")
-        for (const result of turn.results) input2.push({ type: "function_call_output", call_id: result.id, output: result.output });
-      else if (turn.native?.api === "openai") input2.push(...replayable(turn.native.items));
-      else {
-        if (turn.text) input2.push({ type: "message", role: "assistant", content: turn.text });
-        for (const call of turn.calls) input2.push({ type: "function_call", call_id: call.id, name: call.name, arguments: call.arguments });
-      }
-    }
-    return {
-      method: "POST",
-      path: "/v1/responses",
-      body: {
-        model,
-        instructions: system2,
-        input: input2,
-        stream: true,
-        store: false,
-        ...tools.length ? { tools: tools.map((tool) => ({ type: "function", ...tool, strict: false })) } : {},
-        ...effort ? { reasoning: { effort, summary: "auto" } } : {}
-      }
-    };
-  },
-  async *events(chunks) {
-    const items = [];
-    for await (const event of jsonEvents(chunks)) {
-      switch (event.type) {
-        case "response.output_text.delta":
-          if (event.delta) yield { type: "text", text: event.delta };
-          break;
-        case "response.reasoning_summary_text.delta":
-        case "response.reasoning_text.delta":
-          if (event.delta) yield { type: "reasoning", text: event.delta };
-          break;
-        case "response.reasoning_summary_part.added":
-          if (event.summary_index > 0) yield { type: "reasoning", text: "\n\n" };
-          break;
-        case "response.output_item.done":
-          items[event.output_index ?? items.length] = event.item;
-          if (event.item?.type === "function_call")
-            yield { type: "tool_call", call: { id: event.item.call_id, name: event.item.name, arguments: event.item.arguments ?? "" } };
-          break;
-        case "response.completed":
-        case "response.incomplete": {
-          const { usage, incomplete_details: incomplete } = event.response ?? {};
-          if (usage) yield { type: "usage", input: usage.input_tokens ?? 0, output: usage.output_tokens ?? 0 };
-          const native = items.filter(Boolean);
-          const reason = native.some((item) => item.type === "function_call") ? "tool_use" : event.type === "response.completed" ? "end_turn" : incomplete?.reason === "content_filter" ? "refusal" : "max_tokens";
-          yield { type: "stop", reason, native };
-          return;
-        }
-        case "response.failed":
-          throw new Error(event.response?.error?.message ?? "The model response failed");
-        case "error":
-          throw new Error(event.message ?? "The model stream failed");
-      }
-    }
-  }
-};
 const STOP$1 = { stop: "end_turn", tool_calls: "tool_use", function_call: "tool_use", length: "max_tokens", content_filter: "refusal" };
 function mergeDetails(details, fragments) {
   if (!Array.isArray(fragments)) return;
@@ -566,8 +603,8 @@ function mergeDetails(details, fragments) {
   }
 }
 const chatCompletions = {
-  request({ model, system: system2, turns, tools, effort }) {
-    const messages2 = [{ role: "system", content: system2 }];
+  request({ model, system, turns, tools, effort }) {
+    const messages2 = [{ role: "system", content: system }];
     for (const turn of turns) {
       if (turn.role === "user") messages2.push({ role: "user", content: turn.text });
       else if (turn.role === "tool")
@@ -643,7 +680,7 @@ const STOP = {
   model_context_window_exceeded: "max_tokens",
   refusal: "refusal"
 };
-const input = (text) => {
+const input$1 = (text) => {
   try {
     const value2 = JSON.parse(text || "{}");
     return value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : {};
@@ -652,7 +689,7 @@ const input = (text) => {
   }
 };
 const anthropicMessages = {
-  request({ model, system: system2, turns, tools, effort, maxTokens }) {
+  request({ model, system, turns, tools, effort, maxTokens }) {
     const messages2 = [];
     const add = (role, content) => {
       const last = messages2.at(-1);
@@ -666,7 +703,7 @@ const anthropicMessages = {
       else if (turn.native?.api === "anthropic") add("assistant", structuredClone(turn.native.items));
       else add("assistant", [
         ...turn.text ? [{ type: "text", text: turn.text }] : [],
-        ...turn.calls.map((call) => ({ type: "tool_use", id: call.id, name: call.name, input: input(call.arguments) }))
+        ...turn.calls.map((call) => ({ type: "tool_use", id: call.id, name: call.name, input: input$1(call.arguments) }))
       ]);
     }
     return {
@@ -674,7 +711,7 @@ const anthropicMessages = {
       path: "/v1/messages",
       body: {
         model,
-        system: system2,
+        system,
         messages: messages2,
         stream: true,
         max_tokens: maxTokens ?? DEFAULT_MAX_TOKENS,
@@ -719,7 +756,7 @@ const anthropicMessages = {
           const block2 = blocks[event.index];
           if (block2?.type !== "tool_use") break;
           const text = json2.get(event.index) || "{}";
-          block2.input = input(text);
+          block2.input = input$1(text);
           yield { type: "tool_call", call: { id: block2.id, name: block2.name, arguments: text } };
           break;
         }
@@ -798,6 +835,7 @@ Unfinished tasks and next steps, including the step in progress.
 Constraints and preferences the user stated.
 Keep exact file paths, commands, identifiers and error messages.`;
 const chars = (turn) => turn.role === "user" ? turn.text.length : turn.role === "assistant" ? turn.text.length + turn.calls.reduce((sum, call) => sum + call.name.length + call.arguments.length, 0) : turn.results.reduce((sum, result) => sum + result.output.length, 0);
+const estimateTokens = (turns) => Math.ceil(turns.reduce((sum, turn) => sum + chars(turn), 0) / 4);
 const clip$1 = (text, max) => text.length > max ? `${text.slice(0, max)}
 [${text.length - max} more characters]` : text;
 function pruneToolOutputs(turns) {
@@ -860,10 +898,15 @@ class Compaction {
   /** Set when shouldCompact returns true; its absence in compact() means a manual run. */
   pending = /* @__PURE__ */ new Map();
   usable = /* @__PURE__ */ new Map();
-  /** Tokens a request can use before compaction: the window minus min(reserve, maxOutput or 32000, window / 4). */
+  /** Tokens a request can use before compaction: `percent` of the window, else the window minus min(reserve, maxOutput or 32000, window / 4). */
   threshold(contextWindow, maxOutput) {
+    const percent = this.options.percent;
+    if (typeof percent === "number" && percent >= 50 && percent <= 95) return Math.floor(contextWindow * percent / 100);
     return contextWindow - Math.min(this.options.reserve ?? 2e4, maxOutput ?? DEFAULT_MAX_OUTPUT, Math.floor(contextWindow / 4));
   }
+  autoThreshold(contextWindow, maxOutput) {
+    return this.options.auto === false ? void 0 : this.threshold(contextWindow, maxOutput);
+  }
   /** Due when the last request's input plus output reaches the threshold. turn.ts does not pass `maxOutput` yet. */
   shouldCompact(session, usage, contextWindow, maxOutput) {
     if (!contextWindow) return false;
@@ -931,11 +974,12 @@ Additional focus: ${focus}` : "");
 const ADAPTERS = {
   openai: openaiResponses,
   "openai-compatible": chatCompletions,
-  anthropic: anthropicMessages
+  anthropic: anthropicMessages,
+  chatgpt: chatgptResponses
 };
 const MAX_STEPS = 64;
 const CONTEXT_LIMIT$1 = 1e4;
-const system = (root, reviewed, shell) => [
+const basePrompt = (root, reviewed, shell) => [
   `You are Oxbit Agent, a coding agent inside the Oxbit editor. You work in the workspace "${root.split("/").pop()}" through tools.`,
   "Paths are relative to the workspace root. Read a file before you edit it. edit_file replaces an exact string; write_file replaces a whole file.",
   ...reviewed ? ["The user reviews each write before it is saved; a rejected write returns an error, so ask what to change instead of retrying it."] : [],
@@ -991,7 +1035,7 @@ ${text}
   }
   async system() {
     const sections = await Promise.all((this.host.extensions?.context ?? []).map((provider2) => provider2.system(this.session)));
-    const base = system(this.session.cwd, this.host.capabilities.fs, this.host.capabilities.terminal);
+    const base = basePrompt(this.session.cwd, this.host.capabilities.fs, this.host.capabilities.terminal);
     return [base, ...this.session.context, ...sections].filter((section) => !!section).join("\n\n");
   }
   async run(models2, endpoint) {
@@ -1031,6 +1075,7 @@ ${text}
         }
       });
       usage = result.usage ?? usage;
+      if (result.usage) session.usage = result.usage;
       const calls = result.turn.calls;
       const context = {
         root: session.cwd,
@@ -1108,6 +1153,7 @@ ${text}
     const before = await this.hook("PreCompact", { trigger, custom_instructions: typeof focus === "string" ? focus : "" });
     if (before.block || this.halt) return false;
     this.session.turns = await compactor.compact(this.session, summarize, this.signal);
+    this.session.usage = void 0;
     await this.hook("PostCompact", { trigger });
     return true;
   }
@@ -1156,6 +1202,125 @@ async function generateTitle(host, session, signal) {
     return void 0;
   }
 }
+const estimate = (text) => Math.ceil(text.length / 4);
+const slug = (label) => label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "section";
+async function contextUsage(host, session, signal) {
+  const providers = host.extensions?.context ?? [];
+  const sections = await Promise.all(providers.map((provider2) => provider2.system(session)));
+  const labeled = /* @__PURE__ */ new Map();
+  let other = session.context.reduce((sum, text) => sum + estimate(text), 0);
+  providers.forEach((provider2, index) => {
+    const tokens = estimate(sections[index] ?? "");
+    if (!provider2.label) {
+      other += tokens;
+      return;
+    }
+    const category = labeled.get(provider2.label) ?? { id: slug(provider2.label), label: provider2.label, tokens: 0 };
+    category.tokens += tokens;
+    labeled.set(provider2.label, category);
+  });
+  const builtin = new Set(builtinTools(host.capabilities).map((tool) => tool.spec.name));
+  const tools = await new PromptTurn(host, session, signal).tools();
+  const specs = (inside) => tools.filter((tool) => builtin.has(tool.spec.name) === inside).reduce((sum, tool) => sum + estimate(JSON.stringify(tool.spec)), 0);
+  const categories = [
+    { id: "system", label: "System prompt", tokens: estimate(basePrompt(session.cwd, host.capabilities.fs, host.capabilities.terminal)) },
+    ...labeled.values(),
+    { id: "context", label: "Other context", tokens: other },
+    { id: "tools", label: "Built-in tools", tokens: specs(true) },
+    { id: "mcp", label: "MCP and extension tools", tokens: specs(false) },
+    { id: "messages", label: "Messages", tokens: estimateTokens(session.turns) }
+  ];
+  const used = categories.reduce((sum, category) => sum + category.tokens, 0);
+  const info = session.catalog.find((model) => model.id === session.model);
+  const window = info?.contextWindow;
+  const threshold = window ? host.extensions?.compactor?.autoThreshold?.(window, info?.maxOutput) : void 0;
+  return {
+    model: session.model,
+    estimated: true,
+    categories,
+    used,
+    ...window ? { window, free: Math.max(0, (threshold ?? window) - used) } : {},
+    ...info?.maxOutput ? { maxOutput: info.maxOutput } : {},
+    ...window && threshold !== void 0 ? { threshold, buffer: Math.max(0, window - Math.max(threshold, used)) } : {},
+    ...session.usage ? { reported: { ...session.usage } } : {}
+  };
+}
+function contextGrid(usage, cells = 200) {
+  if (!usage.window) return [];
+  const scale = cells / Math.max(usage.window, usage.used);
+  const grid = [];
+  let sum = 0;
+  for (const category of usage.categories) {
+    sum += category.tokens;
+    const end = Math.min(cells, Math.max(Math.round(sum * scale), category.tokens ? grid.length + 1 : grid.length));
+    while (grid.length < end) grid.push(category.id);
+  }
+  const buffer = usage.threshold === void 0 ? cells : Math.max(grid.length, Math.round(usage.threshold * scale));
+  while (grid.length < buffer) grid.push("free");
+  while (grid.length < cells) grid.push("buffer");
+  return grid;
+}
+const formatTokens = (tokens) => tokens < 1e3 ? String(tokens) : tokens < 1e6 ? `${+(tokens / 1e3).toFixed(1)}k` : `${+(tokens / 1e6).toFixed(2)}M`;
+const formatPercent = (tokens, window) => `${(tokens / window * 100).toFixed(1)}%`;
+const COLUMNS = 20;
+const GLYPHS = {
+  system: "#",
+  instructions: "=",
+  skills: "+",
+  context: "~",
+  tools: "*",
+  mcp: "%",
+  messages: "@",
+  free: ".",
+  buffer: "x"
+};
+const SPARE = ["&", "$", "o", "^"];
+function contextLegend(usage) {
+  let spare = 0;
+  const rows = usage.categories.map((category) => ({
+    id: category.id,
+    glyph: GLYPHS[category.id] ?? SPARE[spare++ % SPARE.length],
+    label: category.label,
+    tokens: category.tokens
+  }));
+  if (usage.free !== void 0) rows.push({ id: "free", glyph: GLYPHS.free, label: "Free space", tokens: usage.free });
+  if (usage.buffer !== void 0) rows.push({ id: "buffer", glyph: GLYPHS.buffer, label: "Auto-compact buffer", tokens: usage.buffer });
+  return rows;
+}
+function contextNotes(usage) {
+  const model = usage.model || "no model";
+  const header = usage.window ? `Context usage for ${model}: ${formatTokens(usage.used)} of ${formatTokens(usage.window)} tokens (${formatPercent(usage.used, usage.window)}).` : `Context usage for ${model}: about ${formatTokens(usage.used)} tokens. The context window of this model is unknown.`;
+  const footer = [
+    ...usage.window ? [usage.threshold === void 0 ? "Auto compaction is off." : `Auto compaction runs at ${formatTokens(usage.threshold)} tokens (${formatPercent(usage.threshold, usage.window)}).`] : [],
+    ...usage.reported ? [`Provider count for the last request: ${formatTokens(usage.reported.input + usage.reported.output)} tokens (${formatTokens(usage.reported.input)} input, ${formatTokens(usage.reported.output)} output).`] : [],
+    "Category counts are estimates at 4 characters per token."
+  ];
+  return { header, footer };
+}
+function renderContextUsage(usage) {
+  const legend = contextLegend(usage);
+  const glyphs = new Map(legend.map((row) => [row.id, row.glyph]));
+  const grid = contextGrid(usage);
+  const rows = [];
+  for (let index = 0; index < grid.length; index += COLUMNS) rows.push(grid.slice(index, index + COLUMNS).map((id2) => glyphs.get(id2)).join(" "));
+  const width = Math.max(...legend.map((row) => row.label.length));
+  const counts = legend.map((row) => formatTokens(row.tokens));
+  const digits = Math.max(...counts.map((count2) => count2.length));
+  const lines2 = legend.map((row, index) => `${row.glyph} ${row.label.padEnd(width)}  ${counts[index].padStart(digits)}` + (usage.window ? `  ${formatPercent(row.tokens, usage.window).padStart(6)}` : ""));
+  const { header, footer } = contextNotes(usage);
+  return [header, "", "```text", ...rows.length ? [...rows, ""] : [], ...lines2, "```", "", footer.join(" ")].join("\n");
+}
+function contextCommand(host, session) {
+  return {
+    name: "context",
+    description: "Show context window usage",
+    run: async (_args, context) => {
+      const usage = await contextUsage(host, session, context.signal);
+      context.update({ sessionUpdate: "agent_message_chunk", content: { type: "text", text: renderContextUsage(usage) }, _meta: { oxbit: { context: usage } } });
+      return { done: "end_turn" };
+    }
+  };
+}
 const EFFORTS = ["default", "low", "medium", "high"];
 const COMMAND = /^\/([\w:.-]+)(?:\s+([\s\S]*))?$/;
 const id = (params, key) => {
@@ -1245,7 +1410,7 @@ class Agent {
       currentValue: modeOf(session.meta),
       options: MODES.map(({ id: id2, name }) => ({ value: id2, name }))
     };
-    return session.catalog.length ? [models2, reasoning, mode] : [reasoning, mode];
+    return [...session.catalog.length ? [models2] : [], reasoning, mode, ...this.host.configOptions?.(session) ?? []];
   }
   state(session) {
     return {
@@ -1265,7 +1430,7 @@ class Agent {
     if (cwd !== normalize(this.host.root) && !this.host.filesystemFor) throw new Error(`This agent serves ${this.host.root} only`);
     return cwd;
   }
-  /** The host catalog or `GET /v1/models`, with `model` first when the list lacks it. */
+  /** The host catalog or `listModels`, with `model` first when the list lacks it. */
   async models(model) {
     const listed = this.host.catalog ? Promise.resolve().then(() => this.host.catalog()) : this.catalog ??= listModels(this.service(), this.host.endpoint());
     const catalog = await listed.catch(() => {
@@ -1371,13 +1536,14 @@ class Agent {
     this.host.update(sessionId, { sessionUpdate: "current_mode_update", currentModeId: modeId });
     return {};
   }
-  setConfigOption(sessionId, configId, value2) {
+  async setConfigOption(sessionId, configId, value2) {
     const session = this.session(sessionId);
     if (configId === "model") return this.setModel(sessionId, value2);
     if (configId === "mode") {
       this.setMode(sessionId, value2);
       return { configOptions: this.options(session) };
     }
+    if (configId !== "reasoning" && await this.host.setConfigOption?.(session, configId, value2)) return { configOptions: this.options(session) };
     if (configId !== "reasoning" || !EFFORTS.includes(value2)) throw new Error("Unknown agent setting");
     session.effort = value2;
     return { configOptions: this.options(session) };
@@ -1459,7 +1625,7 @@ ${submit.additionalContext.slice(0, CONTEXT_LIMIT$1)}`;
   }
   async commandList(session) {
     const lists = await Promise.all((this.host.extensions?.commands ?? []).map((provider2) => provider2.commands(session)));
-    return lists.flat();
+    return [contextCommand(this.host, session), ...lists.flat()];
   }
   commandContext(session, turn) {
     return {
@@ -1529,12 +1695,12 @@ function hookSourcePaths(home, project, options = {}) {
   if (options.codex) paths.push({ dialect: "codex", path: `${home}/.codex/hooks.json` }, { dialect: "codex", path: `${project}/.codex/hooks.json` });
   return paths;
 }
-const isObject = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+const isObject$1 = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 const quote = (value2) => `'${value2.replace(/'/g, `'\\''`)}'`;
 function parse(source, warn) {
-  const hooks = isObject(source.config) ? source.config.hooks : void 0;
+  const hooks = isObject$1(source.config) ? source.config.hooks : void 0;
   if (hooks === void 0) return [];
-  if (!isObject(hooks)) {
+  if (!isObject$1(hooks)) {
     warn(`${source.path}: "hooks" must be an object`);
     return [];
   }
@@ -1542,19 +1708,22 @@ function parse(source, warn) {
   for (const [event, groups] of Object.entries(hooks)) {
     if (!EVENTS.has(event) || !Array.isArray(groups)) continue;
     for (const group of groups) {
-      for (const entry of isObject(group) && Array.isArray(group.hooks) ? group.hooks : []) {
-        if (!isObject(entry) || entry.type !== "command" || typeof entry.command !== "string" || !entry.command) {
-          warn(`${source.path}: skipped a ${isObject(entry) ? entry.type ?? "untyped" : "malformed"} ${event} hook; Oxbit runs command hooks only`);
+      for (const entry of isObject$1(group) && Array.isArray(group.hooks) ? group.hooks : []) {
+        if (!isObject$1(entry) || entry.type !== "command" || typeof entry.command !== "string" || !entry.command) {
+          warn(`${source.path}: skipped a ${isObject$1(entry) ? entry.type ?? "untyped" : "malformed"} ${event} hook; Oxbit runs command hooks only`);
           continue;
         }
         const args = Array.isArray(entry.args) ? entry.args.filter((arg) => typeof arg === "string") : void 0;
         const seconds = typeof entry.timeout === "number" && entry.timeout > 0 ? entry.timeout : event === "UserPromptSubmit" ? 30 : 600;
+        const matcher = typeof group.matcher === "string" ? group.matcher : "";
+        const command = args ? [entry.command, ...args].map(quote).join(" ") : entry.command;
         handlers.push({
+          id: [source.dialect, source.path, event, matcher, command].join("|"),
           dialect: source.dialect,
           path: source.path,
           event,
-          matcher: typeof group.matcher === "string" ? group.matcher : "",
-          command: args ? [entry.command, ...args].map(quote).join(" ") : entry.command,
+          matcher,
+          command,
           timeoutMs: seconds * 1e3,
           rule: typeof entry.if === "string" ? entry.if : void 0,
           async: entry.async === true,
@@ -1565,6 +1734,11 @@ function parse(source, warn) {
   }
   return handlers;
 }
+function listHooks(sources) {
+  const warnings = [];
+  const hooks = sources.flatMap((source) => parse(source, (message2) => warnings.push(message2))).map(({ id: id2, dialect, path: path2, event, matcher, command }) => ({ id: id2, dialect, path: path2, event, matcher, command }));
+  return { hooks, warnings };
+}
 function matchesHook(matcher, values) {
   if (!matcher || matcher === "*") return true;
   if (/^[\w\- ,|]+$/.test(matcher)) return matcher.split(/[|,]/).map((name) => name.trim()).some((name) => values.includes(name));
@@ -1594,7 +1768,7 @@ function ruleAllows(rule, names, input2) {
 }
 function fromJson(event, json2) {
   const outcome = {};
-  const specific = isObject(json2.hookSpecificOutput) ? json2.hookSpecificOutput : {};
+  const specific = isObject$1(json2.hookSpecificOutput) ? json2.hookSpecificOutput : {};
   if (json2.continue === false) outcome.continue = false;
   if (typeof json2.stopReason === "string") outcome.stopReason = json2.stopReason;
   if (typeof json2.systemMessage === "string") outcome.systemMessage = json2.systemMessage;
@@ -1608,7 +1782,7 @@ function fromJson(event, json2) {
     outcome.block = true;
     if (typeof json2.reason === "string") outcome.reason = json2.reason;
   }
-  if (isObject(specific.updatedInput)) outcome.updatedInput = specific.updatedInput;
+  if (isObject$1(specific.updatedInput)) outcome.updatedInput = specific.updatedInput;
   if (typeof specific.additionalContext === "string") outcome.additionalContext = specific.additionalContext;
   return outcome;
 }
@@ -1650,14 +1824,14 @@ function createHookRunner(options) {
     warn(message2);
   };
   const handlersOf = (source) => {
-    if (!isObject(source.config)) return parse(source, warnOnce);
+    if (!isObject$1(source.config)) return parse(source, warnOnce);
     let handlers = cache.get(source.config);
     if (!handlers) cache.set(source.config, handlers = parse(source, warnOnce));
     return handlers;
   };
-  async function runOne(handler, event, input2, signal) {
+  async function runOne(handler2, event, input2, signal) {
     const name = typeof input2.tool_name === "string" ? input2.tool_name : void 0;
-    const alias = name && handler.dialect !== "oxbit" ? CLAUDE_TOOL_NAMES[name]?.[0] : void 0;
+    const alias = name && handler2.dialect !== "oxbit" ? CLAUDE_TOOL_NAMES[name]?.[0] : void 0;
     const stdin = {
       transcript_path: options.transcriptPath?.(String(input2.session_id ?? "")) ?? "",
       ...input2,
@@ -1666,25 +1840,25 @@ function createHookRunner(options) {
     const cwd = String(input2.cwd ?? "");
     const controller = new AbortController();
     const abort = () => controller.abort();
-    const timer = setTimeout(abort, handler.timeoutMs);
+    const timer = setTimeout(abort, handler2.timeoutMs);
     signal.addEventListener("abort", abort, { once: true });
     const killed = new Promise((resolve2) => controller.signal.addEventListener("abort", () => resolve2({ code: null, stdout: "", stderr: "" }), { once: true }));
-    const label = `${handler.path}: ${event} hook "${handler.command}"`;
+    const label = `${handler2.path}: ${event} hook "${handler2.command}"`;
     const failed2 = (detail) => {
       warn(`${label} ${detail}`);
-      return handler.failBlocks && BLOCKING.has(event) && !signal.aborted ? { block: true, reason: `${label} ${detail}` } : {};
+      return handler2.failBlocks && BLOCKING.has(event) && !signal.aborted ? { block: true, reason: `${label} ${detail}` } : {};
     };
     try {
-      const result = await Promise.race([options.exec(handler.command, {
+      const result = await Promise.race([options.exec(handler2.command, {
         stdin: JSON.stringify(stdin),
         cwd,
         env: { CLAUDE_PROJECT_DIR: cwd, OXBIT_PROJECT_DIR: cwd },
-        timeoutMs: handler.timeoutMs,
+        timeoutMs: handler2.timeoutMs,
         signal: controller.signal
       }), killed]);
-      if (result.code === null) return signal.aborted ? {} : failed2(`timed out after ${handler.timeoutMs / 1e3} s`);
+      if (result.code === null) return signal.aborted ? {} : failed2(`timed out after ${handler2.timeoutMs / 1e3} s`);
       if (result.code === 2) {
-        const reason = result.stderr.trim() || `Blocked by ${handler.command}`;
+        const reason = result.stderr.trim() || `Blocked by ${handler2.command}`;
         if (BLOCKING.has(event)) return { block: true, reason };
         warn(`${label} exited with 2: ${reason}`);
         return {};
@@ -1694,7 +1868,7 @@ function createHookRunner(options) {
       if (stdout.startsWith("{")) {
         try {
           const json2 = JSON.parse(stdout);
-          if (isObject(json2)) return fromJson(event, json2);
+          if (isObject$1(json2)) return fromJson(event, json2);
         } catch {
         }
       }
@@ -1713,21 +1887,21 @@ function createHookRunner(options) {
     async run(event, input2, signal) {
       if (signal.aborted) return {};
       const sources = typeof options.sources === "function" ? await options.sources(String(input2.cwd ?? "")) : options.sources;
-      if (sources.some((source) => isObject(source.config) && source.config.disableAllHooks === true)) return {};
+      if (sources.some((source) => isObject$1(source.config) && source.config.disableAllHooks === true)) return {};
       const tool = TOOL_EVENTS.has(event) && typeof input2.tool_name === "string" ? input2.tool_name : void 0;
       const names = tool ? [tool, ...CLAUDE_TOOL_NAMES[tool] ?? []] : void 0;
       const field = MATCH_FIELD[event];
       const values = names ?? (field && typeof input2[field] === "string" ? [input2[field]] : void 0);
       const selected = /* @__PURE__ */ new Map();
-      for (const handler of sources.flatMap(handlersOf)) {
-        if (handler.event !== event || values && !matchesHook(handler.matcher, values)) continue;
-        if (handler.rule !== void 0 && !(names && ruleAllows(handler.rule, names, isObject(input2.tool_input) ? input2.tool_input : {}))) continue;
-        const key = `${handler.command}\0${handler.rule ?? ""}`;
-        if (!selected.has(key)) selected.set(key, handler);
+      for (const handler2 of sources.flatMap(handlersOf)) {
+        if (handler2.event !== event || values && !matchesHook(handler2.matcher, values) || options.skip?.(handler2)) continue;
+        if (handler2.rule !== void 0 && !(names && ruleAllows(handler2.rule, names, isObject$1(input2.tool_input) ? input2.tool_input : {}))) continue;
+        const key = `${handler2.command}\0${handler2.rule ?? ""}`;
+        if (!selected.has(key)) selected.set(key, handler2);
       }
-      const outcomes = await Promise.all([...selected.values()].map((handler) => {
-        if (!handler.async) return runOne(handler, event, input2, signal);
-        void runOne(handler, event, input2, signal);
+      const outcomes = await Promise.all([...selected.values()].map((handler2) => {
+        if (!handler2.async) return runOne(handler2, event, input2, signal);
+        void runOne(handler2, event, input2, signal);
         return {};
       }));
       return mergeOutcomes(event, outcomes);
@@ -1771,7 +1945,7 @@ Before you decide the goal is achieved, treat completion as unproven:
 Blocked audit:
 - Call update_goal with status "blocked" only after the same blocker has repeated for three consecutive goal turns and you cannot progress without the user or an external change.
 - Do not mark the goal blocked because the work is hard, slow or uncertain. Use status "paused" only when the user asks for it.`;
-const describe = (goal) => [
+const describe$1 = (goal) => [
   `Goal (${goal.status.replace("_", " ")}): ${goal.objective}`,
   `${goal.continuations} continuations. ${budgetLines(goal)}`,
   ...goal.note ? [`Note: ${goal.note}`] : []
@@ -1805,7 +1979,7 @@ function createGoal(options) {
     async run(args, context) {
       const { session } = context;
       const goal = goalOf(session.meta);
-      if (!args) return done(context, goal ? describe(goal) : "No goal is set. Start one with /goal <objective>.");
+      if (!args) return done(context, goal ? describe$1(goal) : "No goal is set. Start one with /goal <objective>.");
       if (args === "clear") {
         delete session.meta.goal;
         publish(session);
@@ -1930,8 +2104,8 @@ function createLoop(options) {
     return loop?.status === "running" && owners.has(session.id) ? loop : void 0;
   };
   const publish = (session, loop) => statusUpdate(options, session.id, "loop", loop.status === "running" ? { status: loop.status, iteration: loop.iteration, max: loop.max, ...loop.intervalMs ? { interval: format(loop.intervalMs) } : {} } : null);
-  const finish = (session, loop, status, text) => {
-    loop.status = status;
+  const finish = (session, loop, status2, text) => {
+    loop.status = status2;
     delete loop.nextDelayMs;
     owners.delete(session.id);
     publish(session, loop);
@@ -2077,21 +2251,28 @@ class Instructions {
     this.options = options;
   }
   options;
-  /** Global files, then from the git root (or cwd) down to cwd the first non-empty AGENTS.override.md, AGENTS.md or CLAUDE.md. */
-  async load(cwd) {
+  label = "Instructions";
+  /** The global and Claude files whether or not they exist, then the project files that load, without repeated paths. */
+  async candidates(cwd) {
     const { files, global, claude } = this.options;
     const dirs = ancestors(cwd, await findGitRoot(files, cwd) ?? cwd).reverse();
+    const own = async (path2, scope) => path2 ? { path: path2, scope, text: (await readText(files, path2))?.text } : void 0;
     const found = [
-      ...await Promise.all([global, claude].map((path2) => path2 ? readText(files, path2) : void 0)),
-      ...await Promise.all(dirs.map((dir) => firstOf(files, dir)))
+      ...await Promise.all([own(global, "global"), own(claude, "claude")]),
+      ...(await Promise.all(dirs.map((dir) => firstOf(files, dir)))).map((file2) => file2 && { ...file2, scope: "project" })
     ];
     return found.filter((file2, index) => !!file2 && found.findIndex((other) => other?.path === file2.path) === index);
   }
+  /** Global files, then from the git root (or cwd) down to cwd the first non-empty AGENTS.override.md, AGENTS.md or CLAUDE.md. */
+  async load(cwd) {
+    return (await this.candidates(cwd)).flatMap(({ path: path2, text }) => text === void 0 ? [] : [{ path: path2, text }]);
+  }
   async system(session) {
     const sections = [];
     let used = 0;
     let skipped = 0;
     for (const file2 of await this.load(session.cwd)) {
+      if (this.options.skip?.(file2.path)) continue;
       const room = Math.min(FILE_LIMIT, TOTAL_LIMIT - used);
       if (room <= 0) {
         skipped++;
@@ -2112,7 +2293,8 @@ ${clipped.text}${clipped.clipped ? `
   }
 }
 const KEY = /^([\w-]+):(?:[ \t]+(.*))?$/;
-const NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const NAME$1 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const isSkillName = (name) => name.length <= 64 && NAME$1.test(name);
 const OUTPUT_LIMIT = 1e5;
 const scalar = (text) => {
   const quoted = /^(["'])(.*)\1\s*(?:#.*)?$/s.exec(text);
@@ -2168,7 +2350,7 @@ function toSkill(text, path2, folder, warnings) {
   }
   const name = string2("name") || folder;
   if (!string2("name")) warnings.push(`${path2}: the frontmatter has no name, so the skill uses the directory name ${folder}`);
-  if (name.length > 64 || !NAME.test(name)) warnings.push(`${path2}: the name ${name} breaks the Agent Skills rules (a-z, 0-9 and single hyphens, 64 characters at most)`);
+  if (!isSkillName(name)) warnings.push(`${path2}: the name ${name} breaks the Agent Skills rules (a-z, 0-9 and single hyphens, 64 characters at most)`);
   else if (name !== folder) warnings.push(`${path2}: the name ${name} differs from the directory name ${folder}`);
   if (description.length > 1024) warnings.push(`${path2}: the description is longer than 1024 characters`);
   const tools = data["allowed-tools"];
@@ -2215,6 +2397,7 @@ class Skills {
     this.options = options;
   }
   options;
+  label = "Skills";
   sets = /* @__PURE__ */ new Map();
   /** Scans the user roots, then .agents/skills and .claude/skills from cwd up to the git root. The first skill with a name wins. */
   async discover(cwd) {
@@ -2243,8 +2426,11 @@ class Skills {
     this.sets.set(cwd, set);
     return set;
   }
+  shown(skills) {
+    return this.options.hidden ? skills.filter((skill) => !this.options.hidden(skill.name)) : skills;
+  }
   async system(session) {
-    const visible = (await this.discover(session.cwd)).skills.filter((skill) => skill.model);
+    const visible = this.shown((await this.discover(session.cwd)).skills).filter((skill) => skill.model);
     if (!visible.length) return void 0;
     return [
       "Skills hold instructions for specific tasks. When a task matches a skill's description, call the skill tool with its name before you act and follow the instructions it returns.",
@@ -2254,7 +2440,7 @@ class Skills {
     ].join("\n");
   }
   async tools(session) {
-    const { skills } = this.sets.get(session.cwd) ?? await this.discover(session.cwd);
+    const skills = this.shown((this.sets.get(session.cwd) ?? await this.discover(session.cwd)).skills);
     return skills.length ? [this.tool(skills)] : [];
   }
   tool(skills) {
@@ -2303,7 +2489,7 @@ ${files.map((file2) => `- ${file2}`).join("\n")}` : ""));
     if (!set) void this.discover(session.cwd).catch(() => {
     });
     const list2 = { name: "skills", description: "List skills and skill warnings", run: (_args, context) => this.list(context) };
-    return [list2, ...(set?.skills ?? []).filter((skill) => skill.user && skill.name !== list2.name).map((skill) => ({
+    return [list2, ...this.shown(set?.skills ?? []).filter((skill) => skill.user && skill.name !== list2.name).map((skill) => ({
       name: skill.name,
       description: skill.description.slice(0, 200),
       hint: skill.hint,
@@ -2354,7 +2540,7 @@ function parseMcpJson(text, scope, env = {}, source = ".mcp.json") {
   }
   const entries = body?.mcpServers;
   if (!entries || typeof entries !== "object" || Array.isArray(entries)) return { servers: [], warnings: [`${source} has no "mcpServers" object`] };
-  const servers = [];
+  const servers2 = [];
   for (const [name, entry] of Object.entries(entries)) {
     if (!entry || typeof entry !== "object" || entry.enabled === false || entry.disabled === true) continue;
     const missing = /* @__PURE__ */ new Set();
@@ -2370,7 +2556,7 @@ function parseMcpJson(text, scope, env = {}, source = ".mcp.json") {
         continue;
       }
       const args = Array.isArray(entry.args) ? entry.args.filter((arg) => typeof arg === "string") : [];
-      servers.push({
+      servers2.push({
         name,
         scope,
         type: "stdio",
@@ -2384,7 +2570,7 @@ function parseMcpJson(text, scope, env = {}, source = ".mcp.json") {
         warnings.push(`MCP server "${name}" in ${source} has no url`);
         continue;
       }
-      servers.push({
+      servers2.push({
         name,
         scope,
         type: type === "sse" ? "sse" : "http",
@@ -2398,11 +2584,11 @@ function parseMcpJson(text, scope, env = {}, source = ".mcp.json") {
     }
     for (const variable of missing) warnings.push(`MCP server "${name}" references \${${variable}}, which is not set`);
   }
-  return { servers, warnings };
+  return { servers: servers2, warnings };
 }
 const pairs = (value2) => Array.isArray(value2) ? Object.fromEntries(value2.filter((item) => typeof item?.name === "string" && typeof item?.value === "string").map((item) => [item.name, item.value])) : strings(value2);
 function parseAcpServers(list2) {
-  const servers = [];
+  const servers2 = [];
   const warnings = [];
   for (const entry of Array.isArray(list2) ? list2 : []) {
     const name = typeof entry?.name === "string" && entry.name ? entry.name : void 0;
@@ -2411,11 +2597,11 @@ function parseAcpServers(list2) {
       continue;
     }
     if (entry.type === "http" || entry.type === "sse") {
-      if (typeof entry.url === "string" && entry.url) servers.push({ name, scope: "session", type: entry.type, url: entry.url, headers: pairs(entry.headers) });
+      if (typeof entry.url === "string" && entry.url) servers2.push({ name, scope: "session", type: entry.type, url: entry.url, headers: pairs(entry.headers) });
       else warnings.push(`MCP server "${name}" from the client has no url`);
     } else if (entry.type === void 0 || entry.type === "stdio") {
       if (typeof entry.command === "string" && entry.command)
-        servers.push({
+        servers2.push({
           name,
           scope: "session",
           type: "stdio",
@@ -2426,7 +2612,7 @@ function parseAcpServers(list2) {
       else warnings.push(`MCP server "${name}" from the client has no command`);
     } else warnings.push(`MCP server "${name}" from the client uses the "${entry.type}" transport, which Oxbit Agent does not support`);
   }
-  return { servers, warnings };
+  return { servers: servers2, warnings };
 }
 function mergeServers(...lists) {
   const byName = /* @__PURE__ */ new Map();
@@ -2435,11 +2621,11 @@ function mergeServers(...lists) {
 }
 const MODERN_ERROR_CODES = /* @__PURE__ */ new Set([-32020, -32021, -32022]);
 class McpError extends Error {
-  constructor(message2, code, data, status) {
+  constructor(message2, code, data, status2) {
     super(message2);
     this.code = code;
     this.data = data;
-    this.status = status;
+    this.status = status2;
   }
   code;
   data;
@@ -2580,7 +2766,7 @@ async function bodyText(response, limit = ERROR_BODY_LIMIT) {
   }
   return text.slice(0, limit);
 }
-const httpError = (status, body, message2 = `HTTP ${status}`) => Object.assign(new Error(message2), { status, body });
+const httpError = (status2, body, message2 = `HTTP ${status2}`) => Object.assign(new Error(message2), { status: status2, body });
 function base64url(bytes) {
   let binary = "";
   for (const byte of bytes) binary += String.fromCharCode(byte);
@@ -2639,14 +2825,14 @@ class HttpTransport {
     for (const [key, value2] of Object.entries(extra)) headers.set(key, value2);
     return headers;
   }
-  async exchange(init, signal, use) {
+  async exchange(init, signal, use2) {
     const controller = new AbortController();
     const abort = () => controller.abort();
     signal?.addEventListener("abort", abort, { once: true });
     if (signal?.aborted) abort();
     this.controllers.add(controller);
     try {
-      return await use(await this.fetch(this.url, { ...init, signal: controller.signal }));
+      return await use2(await this.fetch(this.url, { ...init, signal: controller.signal }));
     } catch (error) {
       if (controller.signal.aborted && !(error instanceof McpError)) throw new McpError("The MCP request was cancelled");
       throw error;
@@ -3124,8 +3310,6 @@ function renderResult(result) {
 }
 const CLIENT_INFO = { name: "oxbit-agent", version: "1" };
 const message$1 = (error) => error instanceof Error ? error.message : String(error);
-const sessionKey = (session) => `${session.cwd}
-${JSON.stringify(session.meta.mcpServers ?? null)}`;
 class McpTools {
   constructor(options) {
     this.options = options;
@@ -3144,7 +3328,7 @@ class McpTools {
       const text = await this.options.read(path2).catch((error) => void warnings.push(`${path2}: ${message$1(error)}`));
       if (text === void 0) return;
       const parsed = parseMcpJson(text, scope, this.options.env ?? {}, path2);
-      lists.push(parsed.servers);
+      lists.push(this.options.skip ? parsed.servers.filter((server) => !this.options.skip(server)) : parsed.servers);
       warnings.push(...parsed.warnings);
     };
     if (this.options.globalConfig) await load(this.options.globalConfig, "global");
@@ -3155,19 +3339,21 @@ class McpTools {
       const names = text === void 0 ? [] : parseMcpJson(text, "project", {}, project).servers.map((server) => server.name);
       if (names.length) warnings.push(`${project} is not trusted, so its servers are off: ${names.join(", ")}.${this.options.trustHint ? ` ${this.options.trustHint}` : ""}`);
     }
-    const acp2 = parseAcpServers(session.meta.mcpServers);
-    lists.push(acp2.servers);
-    warnings.push(...acp2.warnings);
+    const acp = parseAcpServers(session.meta.mcpServers);
+    lists.push(acp.servers);
+    warnings.push(...acp.warnings);
     return { servers: mergeServers(...lists), warnings };
   }
   async state(session) {
-    const key = sessionKey(session);
-    const current = this.sessions.get(session.id);
-    if (current?.key === key) return current;
     const pending = this.loading.get(session.id) ?? (async () => {
-      const { servers, warnings } = await this.configure(session);
-      const state = { key, cwd: session.cwd, servers: servers.map((config) => ({ config, tools: 0, excluded: 0 })), warnings, closed: false, active: 0 };
+      const { servers: servers2, warnings } = await this.configure(session);
+      const key = JSON.stringify([session.cwd, servers2]);
       const previous = this.sessions.get(session.id);
+      if (previous?.key === key) {
+        previous.warnings = warnings;
+        return previous;
+      }
+      const state = { key, cwd: session.cwd, servers: servers2.map((config) => ({ config, tools: 0, excluded: 0 })), warnings, closed: false, active: 0 };
       this.sessions.set(session.id, state);
       if (previous) await this.shut(previous);
       return state;
@@ -3308,10 +3494,11 @@ class McpTools {
       ...server.error ? { error: server.error } : {}
     })) };
   }
+  /** The /mcp status text: one line per server of the last tools() call, then warnings. */
   report(sessionId) {
-    const { servers, warnings } = this.status(sessionId);
-    const lines2 = servers.length ? [`MCP servers (${servers.length}):`] : ["No MCP servers are configured for this session."];
-    for (const server of servers) {
+    const { servers: servers2, warnings } = this.status(sessionId);
+    const lines2 = servers2.length ? [`MCP servers (${servers2.length}):`] : ["No MCP servers are configured for this session."];
+    for (const server of servers2) {
       const detail = server.state === "connected" ? `connected, ${server.tools} tools${server.excluded ? `, ${server.excluded} left out` : ""}` : server.state === "failed" ? `failed: ${server.error}` : server.state;
       lines2.push(`- ${server.name} (${server.scope}, ${server.type}${server.version ? `, ${server.version}` : ""}): ${detail}`);
     }
@@ -3594,7 +3781,7 @@ const PLAN_ERRORS = {
   subscription_sharing_invalid_user: "ChatGPT could not validate this account. Sign in with ChatGPT again.",
   subscription_sharing_route_not_supported: "ChatGPT plan usage does not support this request route."
 };
-function describePlanError(status, body) {
+function describePlanError(status2, body) {
   let parsed;
   try {
     parsed = JSON.parse(body);
@@ -3603,7 +3790,7 @@ function describePlanError(status, body) {
   }
   const code = parsed?.error?.code;
   const known = typeof code === "string" ? PLAN_ERRORS[code] : void 0;
-  const text = known ?? (code === "subscription_sharing_unsupported_capability" ? `ChatGPT plan usage does not support ${parsed.error.param ?? "a field in this request"}.` : typeof parsed?.detail === "string" ? `ChatGPT plan request rejected (${status}): ${parsed.detail}` : void 0);
+  const text = known ?? (code === "subscription_sharing_unsupported_capability" ? `ChatGPT plan usage does not support ${parsed.error.param ?? "a field in this request"}.` : typeof parsed?.detail === "string" ? `ChatGPT plan request rejected (${status2}): ${parsed.detail}` : void 0);
   return text ? JSON.stringify({ error: { message: text, code } }) : body;
 }
 const STORE_KEY = "chatgpt";
@@ -4066,6 +4253,7 @@ function serveStdio({ input: input2, output, factory, log }) {
     void server.peer.idle().then(() => server.close()).then(resolve2);
   }));
 }
+const stringList = (value2) => Array.isArray(value2) ? value2.filter((item) => typeof item === "string") : [];
 const agentHome = (env = process.env) => env.OXBIT_AGENT_HOME || join(homedir(), ".oxbit", "agent");
 function agentPaths(home) {
   return {
@@ -4113,8 +4301,14 @@ class AgentConfig {
   settings;
   paths;
   static async load(home = agentHome()) {
-    const settings = await readJson(agentPaths(home).settings, {});
-    return new AgentConfig(home, settings && typeof settings === "object" ? settings : {});
+    const config = new AgentConfig(home, {});
+    await config.reload();
+    return config;
+  }
+  /** Reads settings.json again. */
+  async reload() {
+    const settings = await readJson(this.paths.settings, {});
+    this.settings = settings && typeof settings === "object" ? settings : {};
   }
   /** Creates the home and skills directories. */
   async ensure() {
@@ -4217,7 +4411,7 @@ class FileCatalogCache {
   }
 }
 function agentVersion() {
-  return "0.10.1";
+  return "0.11.1";
 }
 const clone = (message2) => JSON.parse(JSON.stringify(message2));
 class MemoryConnection {
@@ -4288,10 +4482,10 @@ class MemoryConnection {
     return () => void this.listeners.delete(listener);
   }
   /** One handler at a time. Without one, permission prompts resolve as "cancelled". */
-  onPermission(handler) {
-    this.permission = handler;
+  onPermission(handler2) {
+    this.permission = handler2;
     return () => {
-      if (this.permission === handler) this.permission = void 0;
+      if (this.permission === handler2) this.permission = void 0;
     };
   }
   close() {
@@ -4299,14 +4493,14 @@ class MemoryConnection {
   }
   async serve(method, params) {
     if (method !== "session/request_permission") throw Object.assign(new Error(`Method not found: ${method}`), { code: -32601 });
-    const handler = this.permission;
-    if (!handler) return { outcome: { outcome: "cancelled" } };
+    const handler2 = this.permission;
+    if (!handler2) return { outcome: { outcome: "cancelled" } };
     const controller = new AbortController();
     const set = this.waiting.get(params.sessionId) ?? /* @__PURE__ */ new Set();
     this.waiting.set(params.sessionId, set.add(controller));
     const cancelled = new Promise((resolve2) => controller.signal.addEventListener("abort", () => resolve2({ outcome: "cancelled" }), { once: true }));
     try {
-      return { outcome: await Promise.race([handler(params, controller.signal), cancelled]) };
+      return { outcome: await Promise.race([handler2(params, controller.signal), cancelled]) };
     } finally {
       set.delete(controller);
       if (!set.size) this.waiting.delete(params.sessionId);
@@ -4611,12 +4805,13 @@ function nodeMcp(config, log) {
     env: process.env,
     trustProject: (cwd) => projectTrusted(config.paths.settings, cwd),
     trustHint: `Add the project path to "trustedProjects" in ${config.paths.settings} to run them.`,
+    skip: (server) => stringList(config.settings.disabledMcpServers).includes(server.name),
     clientInfo: { name: "oxbit-agent", version: agentVersion() }
   });
 }
 const PROVIDER_IDS = PROVIDERS.map((spec) => spec.id);
 const LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
-const OLLAMA = "http://127.0.0.1:11434";
+const OLLAMA$1 = "http://127.0.0.1:11434";
 const DETECTED = ["anthropic", "openai", "openrouter"];
 function normalizeBase(input2) {
   let url;
@@ -4642,7 +4837,7 @@ async function chatgptSignedIn(auth) {
 const keyFor = async (spec, input2, baseUrl) => !!(await input2.auth.get(apiKeySlot(spec.id, baseUrl)) || spec.env && input2.env[spec.env]);
 function baseFor(spec, settings, env) {
   const own = settings.providers?.[spec.id]?.baseUrl;
-  const configured = spec.id === "ollama" ? own || env.OLLAMA_HOST || OLLAMA : spec.id === "openai-compatible" ? own || env.OXBIT_AGENT_BASE_URL : spec.id === "openrouter" ? own : void 0;
+  const configured = spec.id === "ollama" ? own || env.OLLAMA_HOST || OLLAMA$1 : spec.id === "openai-compatible" ? own || env.OXBIT_AGENT_BASE_URL : spec.id === "openrouter" ? own : void 0;
   if (spec.id === "openai-compatible" && !configured) throw new Error('Set providers["openai-compatible"].baseUrl in settings.json or OXBIT_AGENT_BASE_URL');
   return configured ? normalizeBase(configured) : void 0;
 }
@@ -4661,8 +4856,10 @@ async function selectProvider(input2) {
   const { settings, env } = input2;
   const signedIn = await chatgptSignedIn(input2.auth);
   let detected;
+  const disabled = stringList(settings.disabledProviders);
   if (!input2.provider && !settings.provider)
     for (const id2 of DETECTED) {
+      if (disabled.includes(id2)) continue;
       if (await keyFor(providerSpec(id2), input2) || id2 === "openai" && signedIn) {
         detected = id2;
         break;
@@ -4690,7 +4887,7 @@ function missingKey(choice) {
 }
 const VALID_ID = /^[\w.-]{1,128}$/;
 const HEADER_LIMIT = 16 * 1024 * 1024;
-async function firstLine$1(file2) {
+async function firstLine$2(file2) {
   const handle = await open(file2, "r");
   try {
     const chunks = [];
@@ -4770,7 +4967,7 @@ class JsonlSessionStore {
     const records = [];
     for (const name of names.filter((item) => item.endsWith(".jsonl"))) {
       try {
-        const head = summary(JSON.parse(await firstLine$1(join(dir, name))));
+        const head = summary(JSON.parse(await firstLine$2(join(dir, name))));
         if (head && head.cwd === cwd) records.push(head);
       } catch {
       }
@@ -5007,6 +5204,9 @@ function undoCommands(store) {
   };
   return { commands: () => [undo, redo] };
 }
+const SETTINGS_COMMANDS = ["config", "skills", "hooks", "mcp", "instructions", "providers"];
+const settingsOf = (config) => config.settings;
+const compactAt$1 = (value2) => typeof value2 === "number" && value2 >= 50 && value2 <= 95 ? value2 : void 0;
 const nodeFiles = {
   async list(path2) {
     const entries = await readdir(path2, { withFileTypes: true }).catch(() => []);
@@ -5048,9 +5248,10 @@ const nodeHookExec = (command, { stdin, cwd, env, timeoutMs, signal }) => new Pr
   });
   child.on("close", finish);
 });
-function hookSources(config, settings, home, log) {
+function hookSources(config, home, log) {
   const cache = /* @__PURE__ */ new Map();
   return async (cwd) => {
+    const settings = settingsOf(config);
     const paths = hookSourcePaths(home, cwd, { claude: settings.claudeHooks === true, codex: settings.codexHooks === true });
     paths[0] = { ...paths[0], path: config.paths.settings };
     const sources = await Promise.all(paths.map(async ({ dialect, path: path2 }) => {
@@ -5071,151 +5272,344 @@ function hookSources(config, settings, home, log) {
     return sources.filter((source) => !!source);
   };
 }
-function coreExtensions(config, update, options = {}) {
-  const settings = config.settings;
-  const { home = homedir(), log } = options;
-  const instructions = new Instructions({
+function instructionsFor(config, home) {
+  return new Instructions({
     files: nodeFiles,
     global: config.paths.instructions,
-    claude: settings.claudeInstructions ? join(home, ".claude", "CLAUDE.md") : void 0,
-    append: typeof settings.appendSystemPrompt === "string" ? settings.appendSystemPrompt : void 0
+    get claude() {
+      return settingsOf(config).claudeInstructions ? join(home, ".claude", "CLAUDE.md") : void 0;
+    },
+    get append() {
+      const append = settingsOf(config).appendSystemPrompt;
+      return typeof append === "string" ? append : void 0;
+    },
+    skip: (path2) => stringList(settingsOf(config).disabledInstructions).includes(path2)
+  });
+}
+function skillsFor(config, home) {
+  return new Skills({
+    files: nodeFiles,
+    roots: [config.paths.skills, join(home, ".agents", "skills"), join(home, ".claude", "skills")],
+    hidden: (name) => stringList(settingsOf(config).disabledSkills).includes(name)
+  });
+}
+function coreExtensions(config, update, options = {}) {
+  const { home = homedir(), log } = options;
+  const instructions = instructionsFor(config, home);
+  const skills = skillsFor(config, home);
+  const reserved = new Set(SETTINGS_COMMANDS);
+  const compaction = new Compaction({
+    get auto() {
+      return settingsOf(config).autoCompact !== false;
+    },
+    get percent() {
+      return compactAt$1(settingsOf(config).autoCompactAt);
+    }
   });
-  const skills = new Skills({ files: nodeFiles, roots: [config.paths.skills, join(home, ".agents", "skills"), join(home, ".claude", "skills")] });
-  const compaction = new Compaction({ auto: settings.autoCompact !== false });
   const control = controlExtensions({ update });
   return {
     context: [instructions, ...control.context, skills],
     tools: [...control.tools, skills],
-    commands: [compaction, ...control.commands, { commands: async (session) => (await skills.discover(session.cwd), skills.commands(session)) }],
+    commands: [compaction, ...control.commands, { commands: async (session) => (await skills.discover(session.cwd), skills.commands(session).filter((command) => !reserved.has(command.name))) }],
     continuations: control.continuations,
     compactor: compaction,
-    hooks: createHookRunner({ sources: hookSources(config, settings, home, log), exec: nodeHookExec, onWarning: log })
+    hooks: createHookRunner({
+      sources: hookSources(config, home, log),
+      exec: nodeHookExec,
+      onWarning: log,
+      skip: (hook) => stringList(settingsOf(config).disabledHooks).includes(hook.id)
+    })
   };
 }
-const MAX_BYTES = 1024 * 1024;
-const WRITE_OPTIONS = [
-  { optionId: "allow", name: "Allow", kind: "allow_once" },
-  { optionId: "allow_always", name: "Allow edits for this session", kind: "allow_always" },
-  { optionId: "reject", name: "Reject", kind: "reject_once" }
-];
-const absolutePath = (params) => {
-  const path2 = params.path;
-  if (typeof path2 !== "string" || !isAbsolute(path2) || path2.includes("\0")) throw new Error("ACP paths must be absolute");
-  return path2;
+const userHome = (deps) => deps.home ?? homedir();
+async function setListed(config, key, value2, listed) {
+  const list2 = stringList(config.settings[key]).filter((item) => item !== value2);
+  if (listed) list2.push(value2);
+  await config.saveSettings({ [key]: list2.length ? list2 : void 0 });
+}
+const unknownRow = (rowId) => new Error(`Unknown setting ${rowId}`);
+const tilde = (path2, home) => path2 === home ? "~" : path2.startsWith(`${home}/`) ? `~${path2.slice(home.length)}` : path2;
+const firstLine$1 = (text, max = 80) => {
+  const line = text.split("\n").map((part) => part.trim()).find((part) => part) ?? "";
+  return line.length > max ? `${line.slice(0, max - 1)}…` : line;
 };
-class LocalClient {
-  constructor(ask) {
-    this.ask = ask;
-  }
-  ask;
-  terminals = new Terminals();
-  trusted = /* @__PURE__ */ new Set();
-  async readTextFile(params) {
-    const text = await readFile$1(absolutePath(params), "utf8");
-    const start = (params.line ?? 1) - 1;
-    const content = params.line !== void 0 || params.limit !== void 0 ? text.split("\n").slice(start, params.limit ? start + params.limit : void 0).join("\n") : text;
-    if (Buffer.byteLength(content) > MAX_BYTES) throw new Error("File content exceeds 1 MiB; request a smaller line range");
-    return { content };
+const warningRows = (warnings) => warnings.map((warning, index) => ({ id: `warning:${index}`, section: "Warnings", label: warning }));
+const PERCENTS = [50, 60, 70, 80, 90];
+const MODE_OPTIONS = MODES.map(({ id: id2, name }) => ({ value: id2, name }));
+const ON_OFF = [{ value: "on", name: "On" }, { value: "off", name: "Off" }];
+const FLAGS = {
+  "auto-compact": { key: "autoCompact", label: "Auto-compact", detail: "Summarize the conversation when the context window fills", on: true },
+  "claude-instructions": { key: "claudeInstructions", label: "Load ~/.claude/CLAUDE.md", detail: "After the global AGENTS.md" },
+  "claude-hooks": { key: "claudeHooks", label: "Claude hooks", detail: "~/.claude/settings.json and the project's .claude settings files" },
+  "codex-hooks": { key: "codexHooks", label: "Codex hooks", detail: "~/.codex/hooks.json and the project's .codex/hooks.json" },
+  "all-project-mcp": { key: "trustProjectMcp", label: "MCP servers in every project", detail: "Run .mcp.json servers without trusting each folder" }
+};
+const flagOn = (config, id2) => {
+  const flag = FLAGS[id2];
+  return flag.on ? config.settings[flag.key] !== false : config.settings[flag.key] === true;
+};
+const flagRow = (config, id2, section) => ({ id: id2, section, label: FLAGS[id2].label, detail: FLAGS[id2].detail, enabled: flagOn(config, id2) });
+async function setFlag(config, id2, enabled) {
+  await config.saveSettings({ [FLAGS[id2].key]: enabled });
+  return { message: `${FLAGS[id2].label} is ${enabled ? "on" : "off"}` };
+}
+function compactAt(config) {
+  const value2 = config.settings.autoCompactAt;
+  return typeof value2 === "number" && value2 >= 50 && value2 <= 95 ? String(value2) : "default";
+}
+function compactOptions(config) {
+  const percents = [.../* @__PURE__ */ new Set([...PERCENTS, Number(compactAt(config)) || 50])].sort((a, b) => a - b);
+  return [{ value: "default", name: "Default" }, ...percents.map((percent) => ({ value: String(percent), name: `${percent}%` }))];
+}
+async function setCompactAt(config, value2) {
+  const percent = value2 === "default" ? void 0 : Number(value2.replace(/%$/, ""));
+  if (percent !== void 0 && !(Number.isInteger(percent) && percent >= 50 && percent <= 95)) throw new Error("Compact at takes default or a percent from 50 to 95");
+  await config.saveSettings({ autoCompactAt: percent });
+  return { message: percent ? `Auto-compact starts at ${percent}% of the context window` : "Auto-compact uses the default threshold" };
+}
+const configPanel = {
+  async panel({ config }, { cwd }) {
+    const listed = stringList(config.settings.trustedProjects).includes(cwd);
+    const trusted = await projectTrusted(config.paths.settings, cwd);
+    const how = !trusted ? `Off for ${cwd}` : listed ? `Trusted: ${cwd}` : config.settings.trustProjectMcp === true ? "Trusted because MCP servers run in every project" : "Trusted through a parent folder";
+    return { id: "config", title: "Config", rows: [
+      {
+        id: "mode",
+        section: "Permissions",
+        label: "Permission mode",
+        detail: "Saved for new sessions and applied to this one",
+        choice: { value: config.settings.mode ?? "ask", options: MODE_OPTIONS }
+      },
+      flagRow(config, "auto-compact", "Context"),
+      { id: "compact-at", section: "Context", label: "Compact at", detail: "Share of the context window", choice: { value: compactAt(config), options: compactOptions(config) } },
+      flagRow(config, "claude-instructions", "Instructions"),
+      flagRow(config, "claude-hooks", "Hooks"),
+      flagRow(config, "codex-hooks", "Hooks"),
+      { id: "project-mcp", section: "MCP", label: "Project MCP servers for this folder", detail: how, enabled: trusted },
+      flagRow(config, "all-project-mcp", "MCP")
+    ] };
+  },
+  async toggle({ config }, rowId, enabled, { cwd }) {
+    if (rowId in FLAGS) return setFlag(config, rowId, enabled);
+    if (rowId !== "project-mcp") throw unknownRow(rowId);
+    await setListed(config, "trustedProjects", cwd, enabled);
+    const still = !enabled && await projectTrusted(config.paths.settings, cwd);
+    return { message: enabled ? `MCP servers in ${cwd}/.mcp.json run from the next turn` : still ? `Removed ${cwd}; this folder stays trusted through another setting` : `MCP servers in ${cwd}/.mcp.json are off` };
+  },
+  async choose({ config }, rowId, value2) {
+    if (rowId === "compact-at") return setCompactAt(config, value2);
+    if (rowId !== "mode") throw unknownRow(rowId);
+    const mode = MODES.find((item) => item.id === value2);
+    if (!mode) throw new Error(`Unknown mode ${value2}. Use one of: ${MODES.map((item) => item.id).join(", ")}`);
+    await config.saveSettings({ mode: mode.id });
+    return { mode: mode.id, message: `Permission mode: ${mode.name}` };
   }
-  async writeTextFile(params) {
-    const path2 = absolutePath(params);
-    if (typeof params.content !== "string") throw new Error("Invalid content");
-    const sessionId = String(params.sessionId ?? "");
-    if (!params._meta?.oxbit?.mode && !this.trusted.has(sessionId)) {
-      const oldText = await readFile$1(path2, "utf8").catch(() => null);
-      const response = await this.ask({ sessionId, options: WRITE_OPTIONS, toolCall: {
-        toolCallId: params.toolCallId ?? `write-${Date.now()}`,
-        title: `Write ${path2}`,
-        kind: "edit",
-        status: "pending",
-        locations: [{ path: path2 }],
-        content: [{ type: "diff", path: path2, oldText, newText: params.content }]
-      } });
-      const choice = response?.outcome?.outcome === "selected" ? response.outcome.optionId : void 0;
-      if (choice === "allow_always") this.trusted.add(sessionId);
-      else if (choice !== "allow") throw new Error("The user rejected this write");
+};
+function compactConfigOptions(config) {
+  return {
+    configOptions: () => [
+      { id: "auto-compact", name: "Auto-compact", type: "select", currentValue: flagOn(config, "auto-compact") ? "on" : "off", options: ON_OFF },
+      { id: "compact-at", name: "Compact at", type: "select", currentValue: compactAt(config), options: compactOptions(config) }
+    ],
+    async setConfigOption(configId, value2) {
+      if (configId === "auto-compact" && (value2 === "on" || value2 === "off")) await setFlag(config, "auto-compact", value2 === "on");
+      else if (configId === "compact-at") await setCompactAt(config, value2);
+      else return false;
+      return true;
     }
-    await mkdir(dirname(path2), { recursive: true });
-    await writeFile$1(path2, params.content);
-    return {};
-  }
-  dispose() {
-    this.terminals.dispose();
-  }
+  };
 }
-function routeRequests(link, local) {
-  return (method, params) => {
-    const capabilities = link.capabilities();
-    if (method === "fs/read_text_file") return capabilities.fs?.readTextFile ? link.request(method, params) : local.readTextFile(params);
-    if (method === "fs/write_text_file") return capabilities.fs?.writeTextFile ? link.request(method, params) : local.writeTextFile(params);
-    if (method.startsWith("terminal/")) return capabilities.terminal ? link.request(method, params) : local.terminals.handle(method, params);
-    if (method === "oxbit/diagnostics" && !capabilities._meta?.oxbit?.diagnostics)
-      return Promise.reject(new Error("Language diagnostics are unavailable here. Run the project's type checker or linter with bash."));
-    return link.request(method, params);
-  };
-}
-function nodeHost(setup, link) {
-  const { root, config, provider: provider2, log } = setup;
-  const { runtime } = provider2;
-  const local = new LocalClient((params) => link.request("session/request_permission", params));
-  const mcp = nodeMcp(config, log);
-  let catalog;
-  const snapshots = snapshotStores(config.paths.snapshots, log);
-  const filesystems = /* @__PURE__ */ new Map();
-  const filesystemFor = (cwd) => {
-    let filesystem = filesystems.get(cwd);
-    if (!filesystem) filesystems.set(cwd, filesystem = nodeFilesystem(cwd, { ripgrep: setup.ripgrep }));
-    return filesystem;
-  };
-  const core = coreExtensions(config, (sessionId, update) => link.update(sessionId, update), { home: setup.userHome, log });
-  const extensions = {
-    sessions: new JsonlSessionStore(config.paths.sessions),
-    snapshots,
-    ...core,
-    ...setup.extensions,
-    context: [...core.context ?? [], ...setup.extensions?.context ?? []],
-    tools: [...core.tools ?? [], mcp, ...setup.extensions?.tools ?? []],
-    commands: [undoCommands(snapshots), ...core.commands ?? [], mcp, ...setup.extensions?.commands ?? []],
-    continuations: [...core.continuations ?? [], ...setup.extensions?.continuations ?? []],
-    hooks: mcp.hooks(setup.extensions?.hooks ?? core.hooks)
-  };
-  const host = {
-    models: () => {
-      if (setup.models) return setup.models;
-      if (!provider2.ready) throw missingKey(provider2);
-      return runtime.models();
-    },
-    endpoint: () => runtime.endpoint(),
-    ...setup.models ? {} : { catalog: () => catalog ??= runtime.catalog().catch((error) => {
-      catalog = void 0;
-      throw error;
-    }) },
-    model: () => provider2.model,
-    saveModel: (model) => {
-      provider2.model = model;
-      const providers = config.settings.providers ?? {};
-      config.saveSettings({ providers: { ...providers, [provider2.id]: { ...providers[provider2.id], model } } }).catch((error) => log?.(`Could not save the model: ${error.message}`));
-    },
-    get capabilities() {
-      return { fs: true, terminal: true, diagnostics: !!link.capabilities()._meta?.oxbit?.diagnostics, mcp: { http: true, sse: true } };
-    },
-    filesystem: filesystemFor(root),
-    filesystemFor,
-    root,
-    update: (sessionId, update) => link.update(sessionId, update),
-    request: routeRequests(link, local),
-    generateTitles: setup.generateTitles,
-    extensions
-  };
-  const dispose = async () => {
-    local.dispose();
-    await mcp.closeAll();
-  };
-  return { host, local, mcp, dispose };
-}
-const agentFactory = (setup) => (link) => {
-  const { host, dispose } = nodeHost(setup, link);
-  return { agent: new Agent(host), host, dispose };
+async function parsedHooks(deps, cwd) {
+  const sources = await hookSources(deps.config, userHome(deps))(cwd);
+  const off = sources.find((source) => source.config?.disableAllHooks === true);
+  return { ...listHooks(sources), off: off?.path };
+}
+const hooksPanel = {
+  async panel(deps, { cwd }) {
+    const home = userHome(deps);
+    const { hooks, warnings, off } = await parsedHooks(deps, cwd);
+    const disabled = new Set(stringList(deps.config.settings.disabledHooks));
+    const rows = [
+      flagRow(deps.config, "claude-hooks", "Sources"),
+      flagRow(deps.config, "codex-hooks", "Sources"),
+      ...hooks.map((hook) => ({
+        id: hook.id,
+        section: "Hooks",
+        label: `${hook.event} ${hook.matcher}`.trim(),
+        detail: `${hook.command} · ${tilde(hook.path, home)}`,
+        enabled: !disabled.has(hook.id)
+      }))
+    ];
+    if (!hooks.length) rows.push({ id: "none", section: "Hooks", label: "No command hooks in the loaded files" });
+    rows.push(...warningRows(warnings));
+    return {
+      id: "hooks",
+      title: "Hooks",
+      rows,
+      footer: off ? `disableAllHooks in ${tilde(off, home)} turns every hook off.` : `Hooks come from ${tilde(deps.config.paths.settings, home)} and the project's .oxbit/settings.json.`
+    };
+  },
+  async toggle(deps, rowId, enabled, { cwd }) {
+    if (rowId === "claude-hooks" || rowId === "codex-hooks") return setFlag(deps.config, rowId, enabled);
+    const hook = (await parsedHooks(deps, cwd)).hooks.find((item) => item.id === rowId);
+    if (!hook && !stringList(deps.config.settings.disabledHooks).includes(rowId)) throw unknownRow(rowId);
+    await setListed(deps.config, "disabledHooks", rowId, !enabled);
+    return { message: `${hook ? `${hook.event} hook "${hook.command}"` : "The hook"} is ${enabled ? "on" : "off"}` };
+  }
+};
+const SECTIONS = { global: "Global files", claude: "Global files", project: "Project files" };
+const instructionsPanel = {
+  async panel(deps, { cwd }) {
+    const home = userHome(deps);
+    const append = deps.config.settings.appendSystemPrompt;
+    const prompt = typeof append === "string" ? append : "";
+    const disabled = new Set(stringList(deps.config.settings.disabledInstructions));
+    const files = await instructionsFor(deps.config, home).candidates(cwd);
+    const rows = [
+      {
+        id: "prompt",
+        section: "Global prompt",
+        label: "Global prompt",
+        detail: firstLine$1(prompt) || "none",
+        actions: [{ id: "edit", label: "Edit", inputs: [{ label: "Text added after the instruction files (empty clears it)", value: prompt }] }]
+      },
+      ...files.map((file2) => ({
+        id: file2.path,
+        section: SECTIONS[file2.scope],
+        label: tilde(file2.path, home),
+        ...file2.text === void 0 ? { detail: "not found" } : { detail: firstLine$1(file2.text), enabled: !disabled.has(file2.path) }
+      }))
+    ];
+    return { id: "instructions", title: "Instructions", rows, footer: "Changes apply to the next turn's system prompt." };
+  },
+  async toggle(deps, rowId, enabled, { cwd }) {
+    const files = await instructionsFor(deps.config, userHome(deps)).candidates(cwd);
+    const known = files.some((file2) => file2.path === rowId && file2.text !== void 0) || stringList(deps.config.settings.disabledInstructions).includes(rowId);
+    if (!known) throw unknownRow(rowId);
+    await setListed(deps.config, "disabledInstructions", rowId, !enabled);
+    return { message: `${tilde(rowId, userHome(deps))} is ${enabled ? "on" : "off"}` };
+  },
+  async act({ config }, rowId, actionId, inputs) {
+    if (rowId !== "prompt" || actionId !== "edit") throw unknownRow(`${rowId} ${actionId}`);
+    const text = inputs[0] ?? "";
+    await config.saveSettings({ appendSystemPrompt: text.trim() ? text : void 0 });
+    return { message: text.trim() ? "Saved the global prompt" : "Cleared the global prompt" };
+  }
+};
+const NAME = /^[\w-]+$/;
+const isObject = (value2) => typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+function splitCommandLine(line) {
+  const words = [];
+  let word = "", quote2 = "", started = false;
+  for (let index = 0; index < line.length; index++) {
+    const char = line[index];
+    if (quote2) {
+      if (char === quote2) quote2 = "";
+      else if (char === "\\" && quote2 === '"' && index + 1 < line.length) word += line[++index];
+      else word += char;
+    } else if (char === '"' || char === "'") [quote2, started] = [char, true];
+    else if (char === "\\" && index + 1 < line.length) [word, started] = [word + line[++index], true];
+    else if (/\s/.test(char)) {
+      if (started) words.push(word);
+      [word, started] = ["", false];
+    } else [word, started] = [word + char, true];
+  }
+  if (quote2) throw new Error("The command line has an unclosed quote");
+  if (started) words.push(word);
+  return words;
+}
+function serverEntry(input2) {
+  const text = input2.trim();
+  if (/^https?:\/\//i.test(text)) {
+    if (!URL.canParse(text)) throw new Error(`Invalid URL: ${text}`);
+    return { type: "http", url: text };
+  }
+  const [command, ...args] = splitCommandLine(text);
+  if (!command) throw new Error("Enter a URL or a command line");
+  return { command, args };
+}
+const describe = (entry) => {
+  if (!isObject(entry)) return "invalid entry";
+  const off = entry.enabled === false || entry.disabled === true ? ", off in the file" : "";
+  if (typeof entry.url === "string") return `${typeof entry.type === "string" ? entry.type : "http"} ${entry.url}${off}`;
+  const args = Array.isArray(entry.args) ? entry.args.filter((arg) => typeof arg === "string") : [];
+  return `stdio ${[entry.command, ...args].join(" ")}${off}`;
+};
+async function servers(path2) {
+  try {
+    const body = await readJson(path2, {});
+    const entries = isObject(body) && isObject(body.mcpServers) ? body.mcpServers : {};
+    return { body: isObject(body) ? body : {}, entries };
+  } catch (error) {
+    return { body: {}, entries: {}, error: error.message };
+  }
+}
+async function writeServers(config, change) {
+  const { body, entries, error } = await servers(config.paths.mcp);
+  if (error) throw new Error(error);
+  const next = { ...entries };
+  change(next);
+  await writeJson(config.paths.mcp, { ...body, mcpServers: next }, 384);
+}
+const mcpPanel = {
+  async panel(deps, { cwd }) {
+    const { config } = deps;
+    const home = userHome(deps);
+    const disabled = new Set(stringList(config.settings.disabledMcpServers));
+    const user = await servers(config.paths.mcp);
+    const projectPath = join(cwd, ".mcp.json");
+    const project = await servers(projectPath);
+    const trust = await projectTrusted(config.paths.settings, cwd) ? "this folder is trusted" : "this folder is not trusted; turn on Project MCP servers in /config";
+    const rows = [
+      ...Object.entries(user.entries).map(([name, entry]) => ({
+        id: `user:${name}`,
+        section: `User · ${tilde(config.paths.mcp, home)}`,
+        label: name,
+        detail: describe(entry),
+        enabled: !disabled.has(name),
+        actions: [{ id: "remove", label: "Remove" }]
+      })),
+      ...Object.entries(project.entries).map(([name, entry]) => ({
+        id: `project:${name}`,
+        section: `Project · ${tilde(projectPath, home)}`,
+        label: name,
+        detail: `${describe(entry)} · ${trust}`,
+        enabled: !disabled.has(name)
+      })),
+      { id: "add", section: "Add", label: "Add server", detail: `Saved in ${tilde(config.paths.mcp, home)}`, actions: [{
+        id: "add",
+        label: "Add server",
+        inputs: [{ label: "Name", placeholder: "github" }, { label: "URL or command line", placeholder: "https://example.com/mcp or npx -y @scope/server" }]
+      }] },
+      ...[user.error, project.error].filter((error) => !!error).map((error, index) => ({ id: `warning:${index}`, section: "Warnings", label: error }))
+    ];
+    return { id: "mcp", title: "MCP servers", rows, footer: "Changes apply on the next turn." };
+  },
+  async toggle({ config }, rowId, enabled) {
+    const name = /^(?:user|project):(.+)$/.exec(rowId)?.[1];
+    if (!name) throw unknownRow(rowId);
+    await setListed(config, "disabledMcpServers", name, !enabled);
+    return { message: `${name} is ${enabled ? "on" : "off"} from the next turn` };
+  },
+  async act({ config }, rowId, actionId, inputs) {
+    if (rowId === "add" && actionId === "add") {
+      const name2 = inputs[0]?.trim() ?? "";
+      if (!NAME.test(name2)) throw new Error("Use a server name with letters, digits, - and _");
+      const entry = serverEntry(inputs[1] ?? "");
+      await writeServers(config, (entries) => {
+        if (name2 in entries) throw new Error(`${config.paths.mcp} already has a server named ${name2}`);
+        entries[name2] = entry;
+      });
+      return { message: `Added ${name2}; it connects on the next turn` };
+    }
+    const name = rowId.startsWith("user:") ? rowId.slice("user:".length) : void 0;
+    if (!name || actionId !== "remove") throw unknownRow(`${rowId} ${actionId}`);
+    await writeServers(config, (entries) => {
+      if (!(name in entries)) throw new Error(`${config.paths.mcp} has no server named ${name}`);
+      delete entries[name];
+    });
+    return { message: `Removed ${name}` };
+  }
 };
 const nodeLoopback = {
   listen: (port, path2) => new Promise((resolve2, reject) => {
@@ -5230,10 +5624,10 @@ const nodeLoopback = {
       let answered = false;
       const request = {
         query: Object.fromEntries(url.searchParams),
-        respond(status, html) {
+        respond(status2, html) {
           if (answered) return;
           answered = true;
-          res.writeHead(status, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" }).end(html);
+          res.writeHead(status2, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" }).end(html);
         }
       };
       const [waiter] = waiting;
@@ -5275,7 +5669,51 @@ const nodeLoopback = {
 class UsageError extends Error {
 }
 const SIGN_IN_TIMEOUT_MS = 10 * 6e4;
-const fetchOf = (io) => io.fetch ?? ((url, init) => fetch(url, init));
+const fetchOr = (custom) => custom ?? ((url, init) => fetch(url, init));
+async function apiKeyChoice(input2, id2) {
+  const spec = providerSpec(id2);
+  if (!spec) throw new UsageError(`Unknown provider ${id2}`);
+  if (!spec.methods.some((method) => method.id === "api-key")) throw new UsageError(`${spec.name} does not use an API key`);
+  return selectProvider({ ...input2, provider: spec.id, method: "api-key" });
+}
+async function saveApiKey(config, choice, key) {
+  await choice.runtime.models().keys.save(choice.runtime.endpoint(), key);
+  const own = config.settings.providers?.[choice.id];
+  if (own?.method && own.method !== "api-key")
+    await config.saveSettings({ providers: { ...config.settings.providers, [choice.id]: { ...own, method: "api-key" } } });
+}
+async function removeApiKeys(auth, input2, id2) {
+  const removed = [];
+  const drop = async (slot) => {
+    if (!await auth.get(slot)) return;
+    await auth.delete(slot);
+    removed.push(slot.slice("apikey:".length));
+  };
+  const spec = id2 === void 0 ? void 0 : providerSpec(id2);
+  if (id2 !== void 0 && !spec) throw new UsageError(`Unknown provider ${id2}`);
+  const base = spec?.id === "openai-compatible" ? input2.settings.providers?.[spec.id]?.baseUrl || input2.env.OXBIT_AGENT_BASE_URL : void 0;
+  if (spec && spec.id !== "openai-compatible") await drop(apiKeySlot(spec.id));
+  else if (base) await drop(apiKeySlot("openai-compatible", normalizeBase(base)));
+  else for (const slot of await auth.keys()) if (slot.startsWith(spec ? `apikey:${spec.id} ` : "apikey:")) await drop(slot);
+  return removed;
+}
+async function signOutChatGPT(auth, fetch2) {
+  if (!await chatgptSignedIn(auth)) return void 0;
+  return (await new ChatGPTAuth({ fetch: fetch2, store: auth }).signOut()).revoked;
+}
+async function signInChatGPT({ config, auth, fetch: fetch2, signal, open: open2, paste }) {
+  const chatgpt = new ChatGPTAuth({ fetch: fetch2, store: auth });
+  const record = await chatgpt.record();
+  const account = await chatgpt.signIn({ loopback: nodeLoopback, account: record.active, paste, signal, open: (address) => {
+    const url = new URL(address);
+    url.searchParams.delete("id_token_hint");
+    return open2(url.toString());
+  } });
+  if (!planEnabled(account)) return { account, enabled: false };
+  const providers = config.settings.providers ?? {};
+  await config.saveSettings({ ...config.settings.provider ? {} : { provider: "openai" }, providers: { ...providers, openai: { ...providers.openai, method: "chatgpt" } } });
+  return { account, enabled: true };
+}
 async function readAll(stream) {
   let text = "";
   for await (const chunk of stream) text += chunk;
@@ -5345,48 +5783,39 @@ async function login({ config, auth, io, input: input2 }, rest) {
   if (!input2.provider) return void io.stdout.write(methodList()), 0;
   const spec = providerSpec(input2.provider);
   if (!spec) throw new UsageError(`Unknown provider ${input2.provider}`);
-  if (!spec.methods.some((method) => method.id === "api-key")) throw new UsageError(`${spec.name} does not use an API key`);
-  const choice = await selectProvider({ ...input2, method: "api-key" });
+  const choice = await apiKeyChoice(input2, spec.id);
   const key = (await readSecret(io, `${spec.methods.find((method) => method.id === "api-key").label}: `)).trim();
   if (!key) throw new UsageError("No API key on stdin");
-  await choice.runtime.models().keys.save(choice.runtime.endpoint(), key);
-  const own = config.settings.providers?.[spec.id];
-  if (own?.method && own.method !== "api-key")
-    await config.saveSettings({ providers: { ...config.settings.providers, [spec.id]: { ...own, method: "api-key" } } });
+  await saveApiKey(config, choice, key);
   io.stdout.write(`Saved the ${spec.name} API key in ${auth.path}
 `);
   return 0;
 }
 async function loginChatGPT({ config, auth, io }) {
-  const chatgpt = new ChatGPTAuth({ fetch: fetchOf(io), store: auth });
-  const record = await chatgpt.record();
   let noBrowser;
   const failed2 = new Promise((resolve2) => noBrowser = resolve2);
   io.stderr.write(`${CHATGPT_LABELS.signIn}
 `);
-  const account = await chatgpt.signIn({
-    loopback: nodeLoopback,
-    account: record.active,
-    open: async (address) => {
-      const url = new URL(address);
-      url.searchParams.delete("id_token_hint");
+  const { account, enabled } = await signInChatGPT({
+    config,
+    auth,
+    fetch: fetchOr(io.fetch),
+    open: async (url) => {
       io.stderr.write(`Open this page to sign in:
 ${url}
 `);
-      if (await (io.open ?? ((target) => openBrowser(target, io.env)))(url.toString())) return;
-      io.stderr.write(`No browser opened. After you sign in, paste the address the browser lands on (it starts with ${url.searchParams.get("redirect_uri")}):
+      if (await (io.open ?? ((target) => openBrowser(target, io.env)))(url)) return;
+      io.stderr.write(`No browser opened. After you sign in, paste the address the browser lands on (it starts with ${new URL(url).searchParams.get("redirect_uri")}):
 `);
       noBrowser();
     },
     paste: (signal) => failed2.then(() => pastedLine(io.stdin, signal)),
     signal: AbortSignal.timeout(SIGN_IN_TIMEOUT_MS)
   });
-  if (!planEnabled(account)) {
+  if (!enabled) {
     io.stderr.write("You are signed in, but ChatGPT plan use was not allowed. Run oxbit-agent login chatgpt again and allow it, or use an OpenAI API key.\n");
     return 1;
   }
-  const providers = config.settings.providers ?? {};
-  await config.saveSettings({ ...config.settings.provider ? {} : { provider: "openai" }, providers: { ...providers, openai: { ...providers.openai, method: "chatgpt" } } });
   io.stdout.write(`${CHATGPT_LABELS.welcome}${account.email ? ` (${account.email})` : ""}.
 ${CHATGPT_LABELS.manage}: ${CHATGPT.usageUrl}
 `);
@@ -5397,28 +5826,10 @@ ${CHATGPT_LABELS.manage}: ${CHATGPT.usageUrl}
 async function logout({ auth, io, input: input2 }, rest) {
   if (rest.length > 1) throw new UsageError(`Unexpected argument ${rest[1]}`);
   const target = rest[0] ?? input2.provider;
-  const removed = [];
-  const signOut = async () => {
-    if (!await chatgptSignedIn(auth)) return;
-    const { revoked } = await new ChatGPTAuth({ fetch: fetchOf(io), store: auth }).signOut();
-    removed.push(revoked ? "ChatGPT" : "ChatGPT (signed out here; OpenAI did not confirm the revocation)");
-  };
-  const drop = async (slot) => {
-    if (!await auth.get(slot)) return;
-    await auth.delete(slot);
-    removed.push(slot.slice("apikey:".length));
-  };
-  if (target === "chatgpt") await signOut();
-  else if (target) {
-    const spec = providerSpec(target);
-    if (!spec) throw new UsageError(`Unknown provider ${target}`);
-    const base = spec.id === "openai-compatible" ? input2.settings.providers?.[spec.id]?.baseUrl || input2.env.OXBIT_AGENT_BASE_URL : void 0;
-    if (spec.id !== "openai-compatible") await drop(apiKeySlot(spec.id));
-    else if (base) await drop(apiKeySlot(spec.id, normalizeBase(base)));
-    else for (const slot of await auth.keys()) if (slot.startsWith(`apikey:${spec.id} `)) await drop(slot);
-  } else {
-    for (const slot of await auth.keys()) if (slot.startsWith("apikey:")) await drop(slot);
-    await signOut();
+  const removed = target === "chatgpt" ? [] : await removeApiKeys(auth, input2, target);
+  if (!target || target === "chatgpt") {
+    const revoked = await signOutChatGPT(auth, fetchOr(io.fetch));
+    if (revoked !== void 0) removed.push(revoked ? "ChatGPT" : "ChatGPT (signed out here; OpenAI did not confirm the revocation)");
   }
   io.stdout.write(removed.length ? `Removed ${removed.join(", ")}
 ` : "Nothing to remove\n");
@@ -5438,6 +5849,509 @@ async function models({ io, input: input2 }) {
   }
   return 0;
 }
+const OLLAMA = "http://127.0.0.1:11434";
+const input = (deps) => ({ settings: deps.config.settings, env: deps.env, auth: deps.auth, fetch: deps.fetch });
+const has = (spec, method) => spec.methods.some((item) => item.id === method);
+function baseOf(spec, deps) {
+  const own = deps.config.settings.providers?.[spec.id]?.baseUrl;
+  const base = spec.id === "openai-compatible" ? own || deps.env.OXBIT_AGENT_BASE_URL : spec.id === "ollama" ? own || deps.env.OLLAMA_HOST || OLLAMA : own;
+  try {
+    return base ? normalizeBase(base) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function status(spec, deps, signedIn) {
+  const parts = [];
+  const current = deps.provider();
+  if (current.id === spec.id) parts.push(current.runtime.method === "chatgpt" ? "in use with your ChatGPT plan" : "in use");
+  if (spec.id === "openai" && signedIn) parts.push("signed in with ChatGPT");
+  const base = baseOf(spec, deps);
+  let saved = false;
+  if (spec.id === "openai-compatible" && !base) parts.push("no base URL");
+  else if (has(spec, "api-key")) {
+    saved = !!await deps.auth.get(apiKeySlot(spec.id, base));
+    const env = spec.env && deps.env[spec.env] ? spec.env : void 0;
+    parts.push(saved ? "API key saved" : env ? `key from ${env}` : has(spec, "none") ? "no key needed" : "no key");
+  } else parts.push("no key needed");
+  if (base && spec.id !== "openrouter") parts.push(base);
+  if (spec.id === "anthropic") parts.push("Claude Console API key");
+  if (stringList(deps.config.settings.disabledProviders).includes(spec.id)) parts.push("disabled");
+  return { text: parts.join(", "), saved };
+}
+async function apply(deps, id2, message2) {
+  if (deps.rebuild) {
+    await deps.rebuild(id2);
+    return { message: message2, reloaded: true };
+  }
+  return { message: `${message2}. It applies after the agent restarts.` };
+}
+async function use(deps, spec) {
+  const { config } = deps;
+  await selectProvider({ ...input(deps), provider: spec.id });
+  const previous = config.settings.provider ?? deps.provider().id;
+  const providers = { ...config.settings.providers };
+  if (config.settings.model && !providers[previous]?.model) providers[previous] = { ...providers[previous], model: config.settings.model };
+  await config.saveSettings({ provider: spec.id, model: void 0, providers });
+  return apply(deps, spec.id, `Using ${spec.name}`);
+}
+async function signIn(deps, context) {
+  const signal = AbortSignal.any([context.signal, AbortSignal.timeout(SIGN_IN_TIMEOUT_MS)]);
+  const { account, enabled } = await signInChatGPT({ config: deps.config, auth: deps.auth, fetch: fetchOr(deps.fetch), signal, open: async (url) => {
+    context.progress(`Open this page to sign in: ${url}`);
+    if (!await (deps.open ?? ((target) => openBrowser(target, deps.env)))(url)) context.progress(`No browser opened. Open this page to sign in: ${url}`);
+  } });
+  if (!enabled) throw new Error("You are signed in, but ChatGPT plan use was not allowed. Sign in again and allow it, or use an OpenAI API key.");
+  return `${CHATGPT_LABELS.welcome}${account.email ? ` (${account.email})` : ""}`;
+}
+const providersPanel = {
+  async panel(deps) {
+    const signedIn = await chatgptSignedIn(deps.auth);
+    const disabled = stringList(deps.config.settings.disabledProviders);
+    const rows = await Promise.all(PROVIDERS.map(async (spec) => {
+      const inUse = deps.provider().id === spec.id;
+      const { text, saved } = await status(spec, deps, signedIn);
+      const reloads = inUse || void 0;
+      const actions = inUse ? [] : [{ id: "use", label: "Use this provider", reloads: true }];
+      if (has(spec, "api-key")) actions.push({ id: "key", label: "Set API key", inputs: [{ label: spec.methods.find((item) => item.id === "api-key").label, secret: true }], reloads });
+      if (saved) actions.push({ id: "remove-key", label: "Remove API key", reloads });
+      if (has(spec, "chatgpt")) actions.push(signedIn ? { id: "signout", label: "Sign out of ChatGPT", reloads } : { id: "chatgpt", label: "Sign in with ChatGPT", reloads });
+      if (spec.id === "openai-compatible") actions.push({
+        id: "base-url",
+        label: "Base URL",
+        reloads,
+        inputs: [{ label: "Base URL (empty clears it)", placeholder: "https://llm.example.com", value: deps.config.settings.providers?.[spec.id]?.baseUrl ?? "" }]
+      });
+      return { id: spec.id, section: "Providers", label: spec.name, detail: text, enabled: !disabled.includes(spec.id), actions };
+    }));
+    return { id: "providers", title: "Providers", rows, footer: "Unchecked providers are skipped when settings name no provider; --provider and Use still pick them." };
+  },
+  async toggle({ config }, rowId, enabled) {
+    const spec = providerSpec(rowId);
+    if (!spec) throw unknownRow(rowId);
+    await setListed(config, "disabledProviders", spec.id, !enabled);
+    return { message: `${spec.name} is ${enabled ? "on" : "off"} for automatic selection` };
+  },
+  async act(deps, rowId, actionId, inputs, context) {
+    const spec = providerSpec(rowId);
+    if (!spec) throw unknownRow(rowId);
+    const inUse = deps.provider().id === spec.id;
+    const done = (message2) => inUse ? apply(deps, spec.id, message2) : Promise.resolve({ message: message2 });
+    switch (actionId) {
+      case "use":
+        return use(deps, spec);
+      case "key": {
+        const key = inputs[0]?.trim();
+        if (!key) throw new Error("The API key is empty");
+        await saveApiKey(deps.config, await apiKeyChoice(input(deps), spec.id), key);
+        return done(`Saved the ${spec.name} API key in ${deps.auth.path}`);
+      }
+      case "remove-key": {
+        const removed = await removeApiKeys(deps.auth, input(deps), spec.id);
+        return done(removed.length ? `Removed the ${spec.name} API key` : "No saved key to remove");
+      }
+      case "chatgpt": {
+        if (spec.id !== "openai") break;
+        return done(await signIn(deps, context));
+      }
+      case "signout": {
+        const revoked = await signOutChatGPT(deps.auth, fetchOr(deps.fetch));
+        if (revoked === void 0) return { message: "Not signed in with ChatGPT" };
+        return done(revoked ? "Signed out of ChatGPT" : "Signed out here; OpenAI did not confirm the revocation");
+      }
+      case "base-url": {
+        if (spec.id !== "openai-compatible") break;
+        const value2 = inputs[0]?.trim();
+        const baseUrl = value2 ? normalizeBase(value2) : void 0;
+        const providers = deps.config.settings.providers ?? {};
+        await deps.config.saveSettings({ providers: { ...providers, [spec.id]: { ...providers[spec.id], baseUrl } } });
+        return done(baseUrl ? `Base URL: ${baseUrl}` : "Cleared the base URL");
+      }
+    }
+    throw unknownRow(`${rowId} ${actionId}`);
+  }
+};
+const exists = (path2) => stat(path2).then(() => true, () => false);
+const skillName = (rowId) => rowId.startsWith("skill:") ? rowId.slice("skill:".length) : void 0;
+const expandPath = (input2, cwd, home) => resolve(cwd, input2 === "~" ? home : input2.startsWith("~/") ? join(home, input2.slice(2)) : input2);
+async function newSkill({ config }, name, description) {
+  const summary2 = description.replace(/\s+/g, " ").trim();
+  if (!isSkillName(name)) throw new Error("Use a skill name with a-z, 0-9 and single hyphens, 64 characters at most");
+  if (!summary2) throw new Error("Add a description: what the skill does and when to use it");
+  if (summary2.length > 1024) throw new Error("The description is longer than 1024 characters");
+  const dir = join(config.paths.skills, name);
+  if (await exists(dir)) throw new Error(`${dir} already exists`);
+  await mkdir(dir, { recursive: true });
+  const path2 = join(dir, "SKILL.md");
+  await writeFile$1(path2, `---
+name: ${name}
+description: ${JSON.stringify(summary2)}
+---
+
+# ${name}
+
+Write the steps for this skill here.
+`, { flag: "wx" });
+  return { message: `Created ${path2}` };
+}
+async function importSkill(deps, input2, cwd) {
+  if (!input2.trim()) throw new Error("Enter the path of a folder that contains SKILL.md");
+  const source = expandPath(input2.trim(), cwd, userHome(deps));
+  const text = await readOptional(join(source, "SKILL.md"));
+  if (text === void 0) throw new Error(`${source} has no SKILL.md`);
+  const description = parseFrontmatter(text).data.description;
+  if (typeof description !== "string" || !description.trim()) throw new Error(`${join(source, "SKILL.md")} has no description in its frontmatter`);
+  const target = join(deps.config.paths.skills, basename(source));
+  if (await exists(target)) throw new Error(`${target} already exists`);
+  await mkdir(deps.config.paths.skills, { recursive: true });
+  await cp(source, target, { recursive: true, errorOnExist: true, force: false });
+  return { message: `Imported ${basename(source)} into ${target}` };
+}
+const skillsPanel = {
+  async panel(deps, { cwd }) {
+    const home = userHome(deps);
+    const { skills, warnings } = await skillsFor(deps.config, home).discover(cwd);
+    const hidden = new Set(stringList(deps.config.settings.disabledSkills));
+    const rows = skills.map((skill) => {
+      const enabled = !hidden.has(skill.name);
+      return {
+        id: `skill:${skill.name}`,
+        section: "Skills",
+        label: skill.name,
+        detail: firstLine$1(skill.description, 120) || tilde(skill.path, home),
+        enabled,
+        ...enabled && skill.user ? { actions: [{ id: "use", label: `Use /${skill.name}` }] } : {}
+      };
+    });
+    if (!rows.length) rows.push({ id: "none", section: "Skills", label: "No skills found" });
+    const folder = tilde(deps.config.paths.skills, home);
+    rows.push(
+      { id: "new", section: "Add", label: "New skill", detail: `Creates ${folder}/<name>/SKILL.md`, actions: [{
+        id: "new",
+        label: "New skill",
+        inputs: [{ label: "Name", placeholder: "release-notes" }, { label: "Description", placeholder: "What the skill does and when to use it" }]
+      }] },
+      { id: "import", section: "Add", label: "Import a skill folder", detail: `Copies a folder with SKILL.md into ${folder}`, actions: [{
+        id: "import",
+        label: "Import",
+        inputs: [{ label: "Folder with SKILL.md", placeholder: "~/Downloads/review" }]
+      }] },
+      ...warningRows(warnings)
+    );
+    return { id: "skills", title: "Skills", rows, footer: "Unchecked skills leave the catalog, the skill tool and the slash commands." };
+  },
+  async toggle({ config }, rowId, enabled) {
+    const name = skillName(rowId);
+    if (!name) throw unknownRow(rowId);
+    await setListed(config, "disabledSkills", name, !enabled);
+    return { message: `${name} is ${enabled ? "on" : "off"}` };
+  },
+  async act(deps, rowId, actionId, inputs, { cwd }) {
+    if (rowId === "new" && actionId === "new") return newSkill(deps, inputs[0]?.trim() ?? "", inputs[1] ?? "");
+    if (rowId === "import" && actionId === "import") return importSkill(deps, inputs[0] ?? "", cwd);
+    const name = skillName(rowId);
+    if (name && actionId === "use") return { draft: `/${name} ` };
+    throw unknownRow(`${rowId} ${actionId}`);
+  }
+};
+const HELP = {
+  config: { description: "Show or change agent settings", hint: "<setting> <value>", usage: [
+    "`/config <setting> <value>`, for example `/config auto-compact off`, `/config compact-at 80` or `/config mode full-auto`"
+  ] },
+  skills: { description: "List skills; turn one on or off, create one or import a folder", hint: "enable|disable|new|import ...", usage: [
+    "`/skills enable <name|number>`, `/skills disable <name|number>`",
+    "`/skills new <name> <description>`",
+    "`/skills import <folder with SKILL.md>`"
+  ] },
+  hooks: { description: "List command hooks and turn them on or off", hint: "enable|disable <number>", usage: [
+    "`/hooks enable <number>`, `/hooks disable <number>`",
+    "`/config claude-hooks on`, `/config codex-hooks on` load Claude Code and Codex hook files"
+  ] },
+  mcp: { description: "Show MCP servers; add, remove, turn on or off, or reconnect them", hint: "add|remove|enable|disable|reload ...", usage: [
+    "`/mcp add <name> <url or command line>`, `/mcp remove <name>`",
+    "`/mcp enable <name>`, `/mcp disable <name>`",
+    "`/mcp reload` reconnects the servers"
+  ] },
+  instructions: { description: "List instruction files and the global prompt", hint: "enable|disable|prompt ...", usage: [
+    "`/instructions enable <number|path>`, `/instructions disable <number|path>`",
+    "`/instructions prompt <text>` sets the global prompt; without text it clears it"
+  ] },
+  providers: { description: "List model providers; pick one, or sign in or out of ChatGPT", hint: "use|enable|disable|login|signout ...", usage: [
+    "`/providers use <id>` saves the provider for the next start",
+    "`/providers enable <id>`, `/providers disable <id>` for automatic selection",
+    "`/providers login chatgpt`, `/providers signout`",
+    "API keys: run `oxbit-agent login --provider <id>` in a terminal, or use /providers in the oxbit-agent terminal UI"
+  ] }
+};
+const ON = /* @__PURE__ */ new Set(["on", "true", "yes", "enable", "enabled", "1"]);
+const OFF = /* @__PURE__ */ new Set(["off", "false", "no", "disable", "disabled", "0"]);
+const split = (text) => {
+  const match = /^(\S+)(?:\s+([\s\S]*))?$/.exec(text.trim());
+  return match ? [match[1], match[2]?.trim() ?? ""] : ["", ""];
+};
+function rowText(row, keys) {
+  const box = row.enabled === void 0 ? "" : row.enabled ? "[x] " : "[ ] ";
+  const choice = row.choice ? `: ${row.choice.value} (${row.choice.options.map((option) => option.value).join(", ")})` : "";
+  return `${box}${row.label}${keys ? ` \`${row.id}\`` : ""}${choice}${row.detail ? ` · ${row.detail}` : ""}`;
+}
+function panelText(panel, usage, keys = false) {
+  const lines2 = [`## ${panel.title}`];
+  let section;
+  panel.rows.forEach((row, index) => {
+    if (row.section !== section && (section = row.section)) lines2.push("", `**${section}**`);
+    lines2.push(`${index + 1}. ${rowText(row, keys)}`);
+  });
+  if (panel.footer) lines2.push("", panel.footer);
+  lines2.push("", "**Usage**", ...usage.map((line) => `- ${line}`));
+  return lines2.join("\n");
+}
+function findRow(panel, key, cwd) {
+  const rows = panel.rows;
+  const found = /^\d+$/.test(key) ? rows[Number(key) - 1] : rows.find((row) => row.id === key) ?? rows.find((row) => row.id.endsWith(`:${key}`)) ?? rows.find((row) => row.label.toLowerCase() === key.toLowerCase()) ?? rows.find((row) => row.id === resolve(cwd, key));
+  if (!found) throw new Error(`No ${key} in ${panel.title}. Run /${panel.id} to list them.`);
+  return found;
+}
+const switchOf = (value2) => {
+  const word = value2.toLowerCase();
+  if (ON.has(word)) return true;
+  if (OFF.has(word)) return false;
+  throw new Error(`Use on or off, not ${value2 || "nothing"}`);
+};
+function settingsCommands(manager, mcp) {
+  const say = (context, text) => context.update({ sessionUpdate: "agent_message_chunk", content: { type: "text", text } });
+  const panelContext = (context) => ({ cwd: context.session.cwd, sessionId: context.session.id, signal: context.signal, progress: (text) => say(context, `${text}
+
+`) });
+  const applied = (change, context) => {
+    if (change.mode) {
+      context.session.meta.mode = change.mode;
+      context.update({ sessionUpdate: "current_mode_update", currentModeId: change.mode });
+    }
+    return [change.message, change.draft && `Type ${change.draft.trim()} to use it.`].filter((part) => !!part).join("\n") || "Done";
+  };
+  const status2 = async (context, reload) => {
+    if (!mcp) return "";
+    if (reload) await mcp.close(context.session.id);
+    await mcp.tools(context.session);
+    return mcp.report(context.session.id);
+  };
+  async function run2(id2, args, context) {
+    const at = panelContext(context);
+    const panel = () => manager.panel(id2, at);
+    const toggle = async (key, enabled) => applied(await manager.toggle(id2, findRow(await panel(), key, at.cwd).id, enabled, at), context);
+    const act = async (rowId, actionId, inputs = []) => applied(await manager.act(id2, rowId, actionId, inputs, at), context);
+    const [verb, rest] = split(args);
+    const word = verb.toLowerCase();
+    if (!verb) return [id2 === "mcp" ? await status2(context, false) : "", panelText(await panel(), HELP[id2].usage, id2 === "config" || id2 === "providers")].filter((part) => !!part).join("\n\n");
+    if (word === "enable" || word === "disable") return toggle(rest, word === "enable");
+    if (id2 === "config") {
+      const row = findRow(await panel(), verb, at.cwd);
+      if (row.choice) {
+        const value2 = row.choice.options.find((option) => [option.value, option.name].some((name) => name.toLowerCase() === rest.toLowerCase().replace(/%$/, "")));
+        return applied(await manager.choose(id2, row.id, value2?.value ?? rest, at), context);
+      }
+      if (row.enabled === void 0) throw new Error(`${row.label} has no on or off setting`);
+      return applied(await manager.toggle(id2, row.id, switchOf(rest), at), context);
+    }
+    if (id2 === "skills" && word === "new") return act("new", "new", split(rest));
+    if (id2 === "skills" && word === "import") return act("import", "import", [rest]);
+    if (id2 === "instructions" && word === "prompt") return act("prompt", "edit", [rest]);
+    if (id2 === "mcp" && word === "add") return act("add", "add", split(rest));
+    if (id2 === "mcp" && word === "remove") return act(`user:${rest}`, "remove");
+    if (id2 === "mcp" && word === "reload") return status2(context, true);
+    if (id2 === "providers" && word === "use") return act(findRow(await panel(), rest, at.cwd).id, "use");
+    if (id2 === "providers" && word === "signout") return act("openai", "signout");
+    if (id2 === "providers" && word === "login" && rest.toLowerCase() === "chatgpt") return act("openai", "chatgpt");
+    throw new Error(`Unknown /${id2} command. Usage:
+${HELP[id2].usage.map((line) => `- ${line}`).join("\n")}`);
+  }
+  const commands = SETTINGS_COMMANDS.map((id2) => ({
+    name: id2,
+    description: HELP[id2].description,
+    hint: HELP[id2].hint,
+    run: async (args, context) => {
+      let text;
+      try {
+        text = await run2(id2, args, context);
+      } catch (error) {
+        if (context.signal.aborted) return { done: "cancelled" };
+        text = error instanceof Error ? error.message : String(error);
+      }
+      say(context, text);
+      return { done: "end_turn" };
+    }
+  }));
+  return { commands: () => commands };
+}
+const PANELS = {
+  config: configPanel,
+  skills: skillsPanel,
+  hooks: hooksPanel,
+  mcp: mcpPanel,
+  instructions: instructionsPanel,
+  providers: providersPanel
+};
+const handler = (id2) => {
+  const panel = Object.hasOwn(PANELS, id2) ? PANELS[id2] : void 0;
+  if (!panel) throw new Error(`Unknown settings panel ${id2}`);
+  return panel;
+};
+const unsupported = (id2, what) => new Error(`The ${id2} panel has nothing to ${what}`);
+function createSettingsManager(deps) {
+  return {
+    panel: (id2, context) => handler(id2).panel(deps, context),
+    async toggle(id2, rowId, enabled, context) {
+      const panel = handler(id2);
+      if (!panel.toggle) throw unsupported(id2, "turn on or off");
+      return panel.toggle(deps, rowId, enabled, context);
+    },
+    async choose(id2, rowId, value2, context) {
+      const panel = handler(id2);
+      if (!panel.choose) throw unsupported(id2, "choose");
+      return panel.choose(deps, rowId, value2, context);
+    },
+    async act(id2, rowId, actionId, inputs, context) {
+      const panel = handler(id2);
+      if (!panel.act) throw unsupported(id2, "run");
+      return panel.act(deps, rowId, actionId, inputs, context);
+    }
+  };
+}
+const MAX_BYTES = 1024 * 1024;
+const WRITE_OPTIONS = [
+  { optionId: "allow", name: "Allow", kind: "allow_once" },
+  { optionId: "allow_always", name: "Allow edits for this session", kind: "allow_always" },
+  { optionId: "reject", name: "Reject", kind: "reject_once" }
+];
+const absolutePath = (params) => {
+  const path2 = params.path;
+  if (typeof path2 !== "string" || !isAbsolute(path2) || path2.includes("\0")) throw new Error("ACP paths must be absolute");
+  return path2;
+};
+class LocalClient {
+  constructor(ask) {
+    this.ask = ask;
+  }
+  ask;
+  terminals = new Terminals();
+  trusted = /* @__PURE__ */ new Set();
+  async readTextFile(params) {
+    const text = await readFile$1(absolutePath(params), "utf8");
+    const start = (params.line ?? 1) - 1;
+    const content = params.line !== void 0 || params.limit !== void 0 ? text.split("\n").slice(start, params.limit ? start + params.limit : void 0).join("\n") : text;
+    if (Buffer.byteLength(content) > MAX_BYTES) throw new Error("File content exceeds 1 MiB; request a smaller line range");
+    return { content };
+  }
+  async writeTextFile(params) {
+    const path2 = absolutePath(params);
+    if (typeof params.content !== "string") throw new Error("Invalid content");
+    const sessionId = String(params.sessionId ?? "");
+    if (!params._meta?.oxbit?.mode && !this.trusted.has(sessionId)) {
+      const oldText = await readFile$1(path2, "utf8").catch(() => null);
+      const response = await this.ask({ sessionId, options: WRITE_OPTIONS, toolCall: {
+        toolCallId: params.toolCallId ?? `write-${Date.now()}`,
+        title: `Write ${path2}`,
+        kind: "edit",
+        status: "pending",
+        locations: [{ path: path2 }],
+        content: [{ type: "diff", path: path2, oldText, newText: params.content }]
+      } });
+      const choice = response?.outcome?.outcome === "selected" ? response.outcome.optionId : void 0;
+      if (choice === "allow_always") this.trusted.add(sessionId);
+      else if (choice !== "allow") throw new Error("The user rejected this write");
+    }
+    await mkdir(dirname(path2), { recursive: true });
+    await writeFile$1(path2, params.content);
+    return {};
+  }
+  dispose() {
+    this.terminals.dispose();
+  }
+}
+function routeRequests(link, local) {
+  return (method, params) => {
+    const capabilities = link.capabilities();
+    if (method === "fs/read_text_file") return capabilities.fs?.readTextFile ? link.request(method, params) : local.readTextFile(params);
+    if (method === "fs/write_text_file") return capabilities.fs?.writeTextFile ? link.request(method, params) : local.writeTextFile(params);
+    if (method.startsWith("terminal/")) return capabilities.terminal ? link.request(method, params) : local.terminals.handle(method, params);
+    if (method === "oxbit/diagnostics" && !capabilities._meta?.oxbit?.diagnostics)
+      return Promise.reject(new Error("Language diagnostics are unavailable here. Run the project's type checker or linter with bash."));
+    return link.request(method, params);
+  };
+}
+function nodeHost(setup, link) {
+  const { root, config, provider: provider2, log } = setup;
+  const { runtime } = provider2;
+  const local = new LocalClient((params) => link.request("session/request_permission", params));
+  const mcp = nodeMcp(config, log);
+  let catalog;
+  const snapshots = snapshotStores(config.paths.snapshots, log);
+  const filesystems = /* @__PURE__ */ new Map();
+  const filesystemFor = (cwd) => {
+    let filesystem = filesystems.get(cwd);
+    if (!filesystem) filesystems.set(cwd, filesystem = nodeFilesystem(cwd, { ripgrep: setup.ripgrep }));
+    return filesystem;
+  };
+  const core = coreExtensions(config, (sessionId, update) => link.update(sessionId, update), { home: setup.userHome, log });
+  const settings = setup.settings ?? createSettingsManager({
+    config,
+    auth: new FileAuthStore(config.paths.auth),
+    env: process.env,
+    home: setup.userHome ?? homedir(),
+    provider: () => provider2
+  });
+  const compactOptions2 = compactConfigOptions(config);
+  const extensions = {
+    sessions: new JsonlSessionStore(config.paths.sessions),
+    snapshots,
+    ...core,
+    ...setup.extensions,
+    context: [...core.context ?? [], ...setup.extensions?.context ?? []],
+    tools: [...core.tools ?? [], mcp, ...setup.extensions?.tools ?? []],
+    commands: [undoCommands(snapshots), settingsCommands(settings, mcp), ...core.commands ?? [], ...setup.extensions?.commands ?? []],
+    continuations: [...core.continuations ?? [], ...setup.extensions?.continuations ?? []],
+    hooks: mcp.hooks(setup.extensions?.hooks ?? core.hooks)
+  };
+  const host = {
+    models: () => {
+      if (setup.models) return setup.models;
+      if (!provider2.ready) throw missingKey(provider2);
+      return runtime.models();
+    },
+    endpoint: () => runtime.endpoint(),
+    ...setup.models ? {} : { catalog: () => catalog ??= runtime.catalog().catch((error) => {
+      catalog = void 0;
+      throw error;
+    }) },
+    model: () => provider2.model,
+    saveModel: (model) => {
+      provider2.model = model;
+      const providers = config.settings.providers ?? {};
+      config.saveSettings({ providers: { ...providers, [provider2.id]: { ...providers[provider2.id], model } } }).catch((error) => log?.(`Could not save the model: ${error.message}`));
+    },
+    get capabilities() {
+      return { fs: true, terminal: true, diagnostics: !!link.capabilities()._meta?.oxbit?.diagnostics, mcp: { http: true, sse: true } };
+    },
+    filesystem: filesystemFor(root),
+    filesystemFor,
+    root,
+    update: (sessionId, update) => link.update(sessionId, update),
+    request: routeRequests(link, local),
+    generateTitles: setup.generateTitles,
+    configOptions: compactOptions2.configOptions,
+    setConfigOption: (_session, configId, value2) => compactOptions2.setConfigOption(configId, value2),
+    extensions
+  };
+  const dispose = async () => {
+    local.dispose();
+    await mcp.closeAll();
+  };
+  return { host, local, mcp, dispose };
+}
+const agentFactory = (setup) => (link) => {
+  const { host, dispose } = nodeHost(setup, link);
+  return { agent: new Agent(host), host, dispose };
+};
 const firstLine = (text) => String(text ?? "").trim().split("\n")[0].slice(0, 200);
 async function runPrint(options) {
   const { connection, stdout, stderr } = options;
@@ -5559,8 +6473,6 @@ ${USAGE}`);
     const commandContext = { config, auth, io, input: input2 };
     const [command, ...rest] = positionals;
     switch (command) {
-      case "acp":
-        return await acp(config, await selectProvider(input2), io, log);
       case "models":
         return await models(commandContext);
       case "login":
@@ -5568,43 +6480,55 @@ ${USAGE}`);
       case "logout":
         return await logout(commandContext, rest);
     }
-    const provider2 = await selectProvider(input2);
-    const setup = (generateTitles, quiet = false) => ({ root: io.cwd, config, generateTitles, log: quiet ? void 0 : log, provider: provider2 });
+    let provider2 = await selectProvider(input2);
+    const deps = { config, auth, env: io.env, fetch: io.fetch, open: io.open, provider: () => provider2 };
+    const settings = createSettingsManager(deps);
+    const setup = (generateTitles, quiet = false) => ({ root: io.cwd, config, generateTitles, log: quiet ? void 0 : log, provider: provider2, settings });
+    if (command === "acp") {
+      await serveStdio({ input: io.stdin, output: io.stdout, factory: agentFactory(setup(true)), log });
+      return 0;
+    }
     const sessionId = await resumeId(config, values, io.cwd);
     const mode = values.mode ?? config.settings.mode;
     if (values.print !== void 0) {
       if (positionals.length) throw new UsageError(`Unexpected argument ${positionals[0]}`);
       const prompt = values.print === "-" ? (await readAll(io.stdin)).trim() : values.print;
       if (!prompt) throw new UsageError("The prompt is empty");
-      const connection2 = await MemoryConnection.open(agentFactory(setup(false)));
+      const connection = await MemoryConnection.open(agentFactory(setup(false)));
       const abort = new AbortController();
       const interrupt = () => abort.abort();
       process.once("SIGINT", interrupt);
       try {
-        return await runPrint({ connection: connection2, prompt, sessionId, mode, model: values.model, stdout: io.stdout, stderr: io.stderr, signal: abort.signal });
+        return await runPrint({ connection, prompt, sessionId, mode, model: values.model, stdout: io.stdout, stderr: io.stderr, signal: abort.signal });
       } finally {
         process.off("SIGINT", interrupt);
-        await connection2.close();
+        await connection.close();
       }
     }
     if (!io.stdout.isTTY) throw new UsageError("stdout is not a terminal. Use -p <prompt> for one reply or `oxbit-agent acp` for ACP");
-    const tui = await import("./assets/index-BrBnidfI.js");
-    const connected = setup(true, true);
-    const connection = await MemoryConnection.open(agentFactory(connected));
+    const [tui, memory] = await Promise.all([import("./assets/index-T_6HaJx-.js"), import("./assets/memory-Bdy8hvTl.js")]);
+    const label = () => ({ provider: provider2.runtime.label, usingChatGPTPlan: provider2.runtime.method === "chatgpt" });
+    const panels = createSettingsManager({ ...deps, rebuild: async (id2) => {
+      await config.reload();
+      const next = await selectProvider({ ...input2, settings: config.settings, provider: id2, model: id2 === provider2.id ? provider2.model : void 0 });
+      const connection = await MemoryConnection.open(agentFactory({ ...setup(true, true), provider: next }));
+      provider2 = next;
+      await adapter.replace(connection, label());
+    } });
+    const adapter = memory.memoryTuiConnection(await MemoryConnection.open(agentFactory(setup(true, true))), { ...label(), mode, settings: panels });
     try {
-      return await tui.runTui({
-        connection,
+      const { sessionId: last } = await tui.run(adapter, {
         cwd: io.cwd,
         sessionId,
         prompt: positionals.join(" ") || void 0,
-        mode,
         version: agentVersion(),
-        providerLabel: connected.provider.runtime.label,
-        usingChatGPTPlan: connected.provider.runtime.method === "chatgpt",
-        historyPath: config.paths.history
+        history: memory.fileHistory(config.paths.history)
       });
+      if (last) io.stderr.write(`Resume this session with: oxbit-agent -r ${last}
+`);
+      return 0;
     } finally {
-      await connection.close();
+      await adapter.connection.close();
     }
   } catch (error) {
     io.stderr.write(`oxbit-agent: ${error instanceof Error ? error.message : String(error)}
@@ -5623,13 +6547,14 @@ async function resumeId(config, values, cwd) {
   if (values.resume && !await store.load(values.resume)) throw new Error(`No saved session ${values.resume}`);
   return values.resume;
 }
-async function acp(config, provider2, io, log) {
-  await serveStdio({ input: io.stdin, output: io.stdout, factory: agentFactory({ root: io.cwd, config, provider: provider2, log }), log });
-  return 0;
-}
 void main(process.argv.slice(2), { stdin: process.stdin, stdout: process.stdout, stderr: process.stderr, env: process.env, cwd: process.cwd() }).then((code) => process.stdout.write("", () => process.exit(code)));
 export {
   MODES as M,
+  contextGrid as a,
+  contextNotes as b,
+  contextLegend as c,
+  formatPercent as d,
+  formatTokens as f,
   walkFiles as w
 };
 //# sourceMappingURL=index.js.map