@codelia/runtime 0.1.13 → 0.1.16

package/dist/index.cjs

@@ -23,12 +23,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/runtime.ts
-var import_node_path15 = __toESM(require("path"), 1);
-var import_storage9 = require("@codelia/storage");
+var import_node_path16 = __toESM(require("path"), 1);
+var import_storage10 = require("@codelia/storage");
 
 // src/agent-factory.ts
 var import_node_fs14 = require("fs");
-var import_core17 = require("@codelia/core");
+var import_core18 = require("@codelia/core");
 var import_storage5 = require("@codelia/storage");
 
 // src/agents/context.ts
@@ -688,6 +688,10 @@ var DEFAULT_SKILLS_INITIAL_MAX_ENTRIES = 200;
 var DEFAULT_SKILLS_INITIAL_MAX_BYTES = 32 * 1024;
 var DEFAULT_SKILLS_SEARCH_DEFAULT_LIMIT = 8;
 var DEFAULT_SKILLS_SEARCH_MAX_LIMIT = 50;
+var DEFAULT_SEARCH_MODE = "auto";
+var DEFAULT_SEARCH_NATIVE_PROVIDERS = ["openai", "anthropic"];
+var DEFAULT_SEARCH_LOCAL_BACKEND = "ddg";
+var DEFAULT_SEARCH_BRAVE_API_KEY_ENV = "BRAVE_SEARCH_API_KEY";
 var readEnvValue = (key) => {
   const value = process.env[key];
   if (!value) return void 0;
@@ -778,6 +782,45 @@ var resolveSkillsConfig = async (workingDir) => {
   const effective = import_config.configRegistry.resolve([globalConfig, projectConfig]);
   return normalizeSkillsConfig(effective.skills);
 };
+var normalizeSearchConfig = (value) => {
+  const mode = value?.mode === "auto" || value?.mode === "native" || value?.mode === "local" ? value.mode : DEFAULT_SEARCH_MODE;
+  const providersRaw = value?.native?.providers ?? [
+    ...DEFAULT_SEARCH_NATIVE_PROVIDERS
+  ];
+  const providers = Array.from(
+    new Set(
+      providersRaw.map((entry) => entry.trim()).filter((entry) => entry.length > 0)
+    )
+  );
+  const searchContextSize = value?.native?.search_context_size;
+  const allowedDomains = value?.native?.allowed_domains?.length ? value.native.allowed_domains.map((entry) => entry.trim()).filter((entry) => entry.length > 0) : void 0;
+  const userLocation = value?.native?.user_location ? {
+    ...value.native.user_location.city ? { city: value.native.user_location.city } : {},
+    ...value.native.user_location.country ? { country: value.native.user_location.country } : {},
+    ...value.native.user_location.region ? { region: value.native.user_location.region } : {},
+    ...value.native.user_location.timezone ? { timezone: value.native.user_location.timezone } : {}
+  } : void 0;
+  const backend = value?.local?.backend === "ddg" || value?.local?.backend === "brave" ? value.local.backend : DEFAULT_SEARCH_LOCAL_BACKEND;
+  const braveApiKeyEnv = value?.local?.brave_api_key_env?.trim() || DEFAULT_SEARCH_BRAVE_API_KEY_ENV;
+  return {
+    mode,
+    native: {
+      providers: providers.length ? providers : [...DEFAULT_SEARCH_NATIVE_PROVIDERS],
+      ...searchContextSize ? { searchContextSize } : {},
+      ...allowedDomains && allowedDomains.length ? { allowedDomains } : {},
+      ...userLocation && Object.keys(userLocation).length ? { userLocation } : {}
+    },
+    local: {
+      backend,
+      braveApiKeyEnv
+    }
+  };
+};
+var resolveSearchConfig = async (workingDir) => {
+  const { globalConfig, projectConfig } = await loadConfigLayers(workingDir);
+  const effective = import_config.configRegistry.resolve([globalConfig, projectConfig]);
+  return normalizeSearchConfig(effective.search);
+};
 var normalizeMcpTimeoutMs = (value) => {
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
     return DEFAULT_MCP_REQUEST_TIMEOUT_MS;
@@ -813,6 +856,44 @@ var appendPermissionAllowRules = async (workingDir, rules) => {
   const configPath = resolveProjectConfigPath(workingDir);
   await (0, import_config_loader.appendPermissionAllowRules)(configPath, rules);
 };
+var hasDefinedGroup = (group, value) => {
+  switch (group) {
+    case "model":
+      return typeof value?.model?.name === "string" && value.model.name.trim().length > 0;
+    case "permissions":
+      return Array.isArray(value?.permissions?.allow) || Array.isArray(value?.permissions?.deny);
+    case "tui":
+      return typeof value?.tui?.theme === "string" && value.tui.theme.trim().length > 0;
+    default:
+      return false;
+  }
+};
+var resolveWriteTarget = async (workingDir, group) => {
+  const globalPath = resolveConfigPath();
+  const projectPath = resolveProjectConfigPath(workingDir);
+  const [globalConfig, projectConfig] = await Promise.all([
+    (0, import_config_loader.loadConfig)(globalPath),
+    (0, import_config_loader.loadConfig)(projectPath)
+  ]);
+  if (hasDefinedGroup(group, projectConfig)) {
+    return { scope: "project", path: projectPath };
+  }
+  if (hasDefinedGroup(group, globalConfig)) {
+    return { scope: "global", path: globalPath };
+  }
+  const defaultScope = import_config.CONFIG_GROUP_DEFAULT_WRITE_SCOPE[group];
+  return defaultScope === "project" ? { scope: "project", path: projectPath } : { scope: "global", path: globalPath };
+};
+var updateModel = async (workingDir, model) => {
+  const target = await resolveWriteTarget(workingDir, "model");
+  await (0, import_config_loader.updateModelConfig)(target.path, model);
+  return target;
+};
+var updateTuiTheme = async (workingDir, theme) => {
+  const target = await resolveWriteTarget(workingDir, "tui");
+  await (0, import_config_loader.updateTuiConfig)(target.path, { theme });
+  return target;
+};
 var resolveReasoningEffort = (value) => {
   return resolveModelLevelOption(value, "model.reasoning");
 };
@@ -961,6 +1042,14 @@ var sendRunContext = (runId, contextLeftPercent) => {
   };
   send(notify);
 };
+var sendRunDiagnostics = (params) => {
+  const notify = {
+    jsonrpc: "2.0",
+    method: "run.diagnostics",
+    params
+  };
+  send(notify);
+};
 
 // src/rpc/ui-requests.ts
 var requestUi = async (state, method, params) => {
@@ -4206,17 +4295,176 @@ ${reason} Use offset to read beyond line ${lastReadLine}.`;
   }
 });
 
-// src/tools/skill-load.ts
+// src/tools/search.ts
 var import_core11 = require("@codelia/core");
 var import_zod10 = require("zod");
-var SkillLoadInputSchema = import_zod10.z.object({
-  name: import_zod10.z.string().min(1).optional().describe("Exact skill name to load."),
-  path: import_zod10.z.string().min(1).optional().describe("Absolute or workspace-relative path to SKILL.md.")
+var normalizeDomain = (value) => value.trim().toLowerCase().replace(/\.+$/, "");
+var shouldKeepUrl = (url, allowedDomains) => {
+  if (!allowedDomains.length) return true;
+  try {
+    const parsed = new URL(url);
+    const host = parsed.hostname.toLowerCase();
+    return allowedDomains.some((domain) => {
+      const normalized = normalizeDomain(domain);
+      return host === normalized || host.endsWith(`.${normalized}`);
+    });
+  } catch {
+    return false;
+  }
+};
+var normalizeEntries = (entries, allowedDomains, maxResults) => {
+  return entries.filter((entry) => shouldKeepUrl(entry.url, allowedDomains)).slice(0, maxResults);
+};
+var parseDdg = (payload) => {
+  const results = [];
+  if (!payload || typeof payload !== "object") {
+    return results;
+  }
+  const record = payload;
+  const related = Array.isArray(record.RelatedTopics) ? record.RelatedTopics : [];
+  for (const topic of related) {
+    if (!topic || typeof topic !== "object") {
+      continue;
+    }
+    const typed = topic;
+    if (Array.isArray(typed.Topics)) {
+      for (const child of typed.Topics) {
+        if (!child || typeof child !== "object") continue;
+        const row = child;
+        const text2 = typeof row.Text === "string" ? row.Text : "";
+        const url2 = typeof row.FirstURL === "string" ? row.FirstURL : "";
+        if (!text2 || !url2) continue;
+        results.push({
+          title: text2.split(" - ")[0] ?? text2,
+          url: url2,
+          snippet: text2,
+          source: "ddg"
+        });
+      }
+      continue;
+    }
+    const text = typeof typed.Text === "string" ? typed.Text : "";
+    const url = typeof typed.FirstURL === "string" ? typed.FirstURL : "";
+    if (!text || !url) continue;
+    results.push({
+      title: text.split(" - ")[0] ?? text,
+      url,
+      snippet: text,
+      source: "ddg"
+    });
+  }
+  return results;
+};
+var parseBrave = (payload) => {
+  const results = [];
+  if (!payload || typeof payload !== "object") {
+    return results;
+  }
+  const record = payload;
+  const web = record.web;
+  if (!web || typeof web !== "object") {
+    return results;
+  }
+  const rows = Array.isArray(web.results) ? web.results : [];
+  for (const row of rows) {
+    if (!row || typeof row !== "object") continue;
+    const typed = row;
+    const title = typeof typed.title === "string" ? typed.title : "";
+    const url = typeof typed.url === "string" ? typed.url : "";
+    const snippet = typeof typed.description === "string" ? typed.description : "";
+    if (!title || !url) continue;
+    results.push({
+      title,
+      url,
+      snippet,
+      source: "brave"
+    });
+  }
+  return results;
+};
+var runDdgSearch = async (query, maxResults, allowedDomains) => {
+  const url = new URL("https://api.duckduckgo.com/");
+  url.searchParams.set("q", query);
+  url.searchParams.set("format", "json");
+  url.searchParams.set("no_html", "1");
+  url.searchParams.set("skip_disambig", "1");
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`ddg request failed: status=${response.status}`);
+  }
+  const payload = await response.json();
+  const parsed = parseDdg(payload);
+  return normalizeEntries(parsed, allowedDomains, maxResults);
+};
+var runBraveSearch = async (query, maxResults, allowedDomains, apiKey) => {
+  const url = new URL("https://api.search.brave.com/res/v1/web/search");
+  url.searchParams.set("q", query);
+  url.searchParams.set("count", String(maxResults));
+  const response = await fetch(url, {
+    headers: {
+      Accept: "application/json",
+      "X-Subscription-Token": apiKey
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`brave request failed: status=${response.status}`);
+  }
+  const payload = await response.json();
+  const parsed = parseBrave(payload);
+  return normalizeEntries(parsed, allowedDomains, maxResults);
+};
+var createSearchTool = (options) => (0, import_core11.defineTool)({
+  name: "search",
+  description: "Search the web and return concise source candidates.",
+  input: import_zod10.z.object({
+    query: import_zod10.z.string().min(1).describe("Search query."),
+    max_results: import_zod10.z.number().int().min(1).max(20).optional().describe("Max results. Default 5."),
+    backend: import_zod10.z.enum(["ddg", "brave"]).optional().describe("Search backend. Default comes from config."),
+    allowed_domains: import_zod10.z.array(import_zod10.z.string().min(1)).optional().describe("Optional allowlist of domains.")
+  }),
+  execute: async (input) => {
+    const backend = input.backend ?? options.defaultBackend;
+    const maxResults = input.max_results ?? 5;
+    const allowedDomains = input.allowed_domains?.map((entry) => entry.trim()).filter((entry) => entry.length > 0) ?? [];
+    try {
+      let results;
+      if (backend === "ddg") {
+        results = await runDdgSearch(input.query, maxResults, allowedDomains);
+      } else {
+        const apiKey = process.env[options.braveApiKeyEnv]?.trim();
+        if (!apiKey) {
+          return `Missing ${options.braveApiKeyEnv} for brave backend.`;
+        }
+        results = await runBraveSearch(
+          input.query,
+          maxResults,
+          allowedDomains,
+          apiKey
+        );
+      }
+      return {
+        query: input.query,
+        backend,
+        count: results.length,
+        results
+      };
+    } catch (error) {
+      return `Error running search: ${String(error)}`;
+    }
+  }
+});
+
+// src/tools/skill-load.ts
+var import_core12 = require("@codelia/core");
+var import_zod11 = require("zod");
+var SkillLoadInputSchema = import_zod11.z.object({
+  name: import_zod11.z.string().min(1).optional().describe("Exact skill name to load."),
+  path: import_zod11.z.string().min(1).optional().describe("Absolute or workspace-relative path to SKILL.md.")
 }).refine((value) => !!value.name || !!value.path, {
   message: "name or path is required",
   path: ["name"]
 });
-var createSkillLoadTool = (skillsResolverKey) => (0, import_core11.defineTool)({
+var createSkillLoadTool = (skillsResolverKey) => (0, import_core12.defineTool)({
   name: "skill_load",
   description: "Load full SKILL.md content by exact name or path.",
   input: SkillLoadInputSchema,
@@ -4262,15 +4510,15 @@ var createSkillLoadTool = (skillsResolverKey) => (0, import_core11.defineTool)({
 });
 
 // src/tools/skill-search.ts
-var import_core12 = require("@codelia/core");
-var import_zod11 = require("zod");
-var createSkillSearchTool = (skillsResolverKey) => (0, import_core12.defineTool)({
+var import_core13 = require("@codelia/core");
+var import_zod12 = require("zod");
+var createSkillSearchTool = (skillsResolverKey) => (0, import_core13.defineTool)({
   name: "skill_search",
   description: "Search installed local skills by name, description, or path.",
-  input: import_zod11.z.object({
-    query: import_zod11.z.string().min(1).describe("Search query text."),
-    limit: import_zod11.z.number().int().positive().optional().describe("Optional max result count (clamped by config)."),
-    scope: import_zod11.z.enum(["repo", "user"]).optional().describe("Optional scope filter.")
+  input: import_zod12.z.object({
+    query: import_zod12.z.string().min(1).describe("Search query text."),
+    limit: import_zod12.z.number().int().positive().optional().describe("Optional max result count (clamped by config)."),
+    scope: import_zod12.z.enum(["repo", "user"]).optional().describe("Optional scope filter.")
   }),
   execute: async (input, ctx) => {
     try {
@@ -4293,17 +4541,17 @@ var createSkillSearchTool = (skillsResolverKey) => (0, import_core12.defineTool)
 });
 
 // src/tools/todo-read.ts
-var import_core13 = require("@codelia/core");
-var import_zod12 = require("zod");
+var import_core14 = require("@codelia/core");
+var import_zod13 = require("zod");
 
 // src/tools/todo-store.ts
 var todoStore = /* @__PURE__ */ new Map();
 
 // src/tools/todo-read.ts
-var createTodoReadTool = (sandboxKey) => (0, import_core13.defineTool)({
+var createTodoReadTool = (sandboxKey) => (0, import_core14.defineTool)({
   name: "todo_read",
   description: "Read the in-session todo list.",
-  input: import_zod12.z.object({}),
+  input: import_zod13.z.object({}),
   execute: async (_input, ctx) => {
     const sandbox = await getSandboxContext(ctx, sandboxKey);
     const todos = todoStore.get(sandbox.sessionId) ?? [];
@@ -4316,17 +4564,17 @@ var createTodoReadTool = (sandboxKey) => (0, import_core13.defineTool)({
 });
 
 // src/tools/todo-write.ts
-var import_core14 = require("@codelia/core");
-var import_zod13 = require("zod");
-var createTodoWriteTool = (sandboxKey) => (0, import_core14.defineTool)({
+var import_core15 = require("@codelia/core");
+var import_zod14 = require("zod");
+var createTodoWriteTool = (sandboxKey) => (0, import_core15.defineTool)({
   name: "todo_write",
   description: "Replace the in-session todo list.",
-  input: import_zod13.z.object({
-    todos: import_zod13.z.array(
-      import_zod13.z.object({
-        content: import_zod13.z.string().describe("Todo item text."),
-        status: import_zod13.z.enum(["pending", "in_progress", "completed"]).describe("Todo status."),
-        activeForm: import_zod13.z.string().optional().describe("Optional in-progress phrasing for UI display.")
+  input: import_zod14.z.object({
+    todos: import_zod14.z.array(
+      import_zod14.z.object({
+        content: import_zod14.z.string().describe("Todo item text."),
+        status: import_zod14.z.enum(["pending", "in_progress", "completed"]).describe("Todo status."),
+        activeForm: import_zod14.z.string().optional().describe("Optional in-progress phrasing for UI display.")
       })
     )
   }),
@@ -4343,15 +4591,15 @@ var createTodoWriteTool = (sandboxKey) => (0, import_core14.defineTool)({
 });
 
 // src/tools/tool-output-cache.ts
-var import_core15 = require("@codelia/core");
-var import_zod14 = require("zod");
-var createToolOutputCacheTool = (store) => (0, import_core15.defineTool)({
+var import_core16 = require("@codelia/core");
+var import_zod15 = require("zod");
+var createToolOutputCacheTool = (store) => (0, import_core16.defineTool)({
   name: "tool_output_cache",
   description: "Read cached tool output by ref_id.",
-  input: import_zod14.z.object({
-    ref_id: import_zod14.z.string().describe("Tool output reference ID."),
-    offset: import_zod14.z.number().int().nonnegative().optional().describe("Optional 0-based line offset."),
-    limit: import_zod14.z.number().int().positive().optional().describe("Optional max number of lines to return.")
+  input: import_zod15.z.object({
+    ref_id: import_zod15.z.string().describe("Tool output reference ID."),
+    offset: import_zod15.z.number().int().nonnegative().optional().describe("Optional 0-based line offset."),
+    limit: import_zod15.z.number().int().positive().optional().describe("Optional max number of lines to return.")
   }),
   execute: async (input) => {
     if (!store.read) {
@@ -4367,16 +4615,16 @@ var createToolOutputCacheTool = (store) => (0, import_core15.defineTool)({
     }
   }
 });
-var createToolOutputCacheGrepTool = (store) => (0, import_core15.defineTool)({
+var createToolOutputCacheGrepTool = (store) => (0, import_core16.defineTool)({
   name: "tool_output_cache_grep",
   description: "Search cached tool output by ref_id.",
-  input: import_zod14.z.object({
-    ref_id: import_zod14.z.string().describe("Tool output reference ID."),
-    pattern: import_zod14.z.string().describe("Text or regex pattern to search for."),
-    regex: import_zod14.z.boolean().optional().describe("Interpret pattern as regex when true. Default false."),
-    before: import_zod14.z.number().int().nonnegative().optional().describe("Context lines before each match. Default 0."),
-    after: import_zod14.z.number().int().nonnegative().optional().describe("Context lines after each match. Default 0."),
-    max_matches: import_zod14.z.number().int().positive().optional().describe("Maximum number of matches to return.")
+  input: import_zod15.z.object({
+    ref_id: import_zod15.z.string().describe("Tool output reference ID."),
+    pattern: import_zod15.z.string().describe("Text or regex pattern to search for."),
+    regex: import_zod15.z.boolean().optional().describe("Interpret pattern as regex when true. Default false."),
+    before: import_zod15.z.number().int().nonnegative().optional().describe("Context lines before each match. Default 0."),
+    after: import_zod15.z.number().int().nonnegative().optional().describe("Context lines after each match. Default 0."),
+    max_matches: import_zod15.z.number().int().positive().optional().describe("Maximum number of matches to return.")
   }),
   execute: async (input) => {
     if (!store.grep) {
@@ -4399,14 +4647,14 @@ var createToolOutputCacheGrepTool = (store) => (0, import_core15.defineTool)({
 // src/tools/write.ts
 var import_node_fs13 = require("fs");
 var import_node_path12 = __toESM(require("path"), 1);
-var import_core16 = require("@codelia/core");
-var import_zod15 = require("zod");
-var createWriteTool = (sandboxKey) => (0, import_core16.defineTool)({
+var import_core17 = require("@codelia/core");
+var import_zod16 = require("zod");
+var createWriteTool = (sandboxKey) => (0, import_core17.defineTool)({
   name: "write",
   description: "Write text to a file, creating parent directories if needed.",
-  input: import_zod15.z.object({
-    file_path: import_zod15.z.string().describe("File path under the sandbox root."),
-    content: import_zod15.z.string().describe("UTF-8 text content to write.")
+  input: import_zod16.z.object({
+    file_path: import_zod16.z.string().describe("File path under the sandbox root."),
+    content: import_zod16.z.string().describe("UTF-8 text content to write.")
   }),
   execute: async (input, ctx) => {
     let resolved;
@@ -4435,6 +4683,7 @@ var createTools = (sandboxKey, agentsResolverKey, skillsResolverKey, options = {
   createAgentsResolveTool(sandboxKey, agentsResolverKey),
   createSkillSearchTool(skillsResolverKey),
   createSkillLoadTool(skillsResolverKey),
+  ...options.search ? [createSearchTool(options.search)] : [],
   createGlobSearchTool(sandboxKey),
   createGrepTool(sandboxKey),
   ...options.toolOutputCacheStore ? [
@@ -4483,9 +4732,9 @@ var normalizeLanguage = (value) => {
 };
 var languageFromFilePath = (filePath) => {
   if (!filePath) return void 0;
-  const path16 = filePath.trim().replace(/^["']|["']$/g, "");
-  if (!path16 || path16 === "/dev/null") return void 0;
-  const normalizedPath = path16.replace(/^a\//, "").replace(/^b\//, "");
+  const path17 = filePath.trim().replace(/^["']|["']$/g, "");
+  if (!path17 || path17 === "/dev/null") return void 0;
+  const normalizedPath = path17.replace(/^a\//, "").replace(/^b\//, "");
   const lastSlash = Math.max(
     normalizedPath.lastIndexOf("/"),
     normalizedPath.lastIndexOf("\\")
@@ -4556,6 +4805,25 @@ var envTruthy = (value) => {
   return normalized === "1" || normalized === "true";
 };
 var OPENROUTER_BASE_URL = "https://openrouter.ai/api/v1";
+var isNativeSearchProvider = (provider, allowedProviders) => allowedProviders.includes(provider);
+var buildHostedSearchToolDefinitions = (provider, options) => {
+  if (options.mode === "local" || !isNativeSearchProvider(provider, options.native.providers)) {
+    return [];
+  }
+  if (provider !== "openai" && provider !== "anthropic") {
+    return [];
+  }
+  return [
+    {
+      type: "hosted_search",
+      name: "web_search",
+      provider,
+      ...options.native.searchContextSize ? { search_context_size: options.native.searchContextSize } : {},
+      ...options.native.allowedDomains ? { allowed_domains: options.native.allowedDomains } : {},
+      ...options.native.userLocation ? { user_location: options.native.userLocation } : {}
+    }
+  ];
+};
 var buildOpenAiClientOptions = (authResolver, auth) => {
   if (auth.method === "api_key") {
     return { apiKey: auth.api_key };
@@ -4792,7 +5060,7 @@ var createAgentFactory = (state, options = {}) => {
       const agentsResolverKey = createAgentsResolverKey(agentsResolver);
       const skillsResolverKey = createSkillsResolverKey(skillsResolver);
       const toolOutputCacheStore = new import_storage5.ToolOutputCacheStoreImpl();
-      const localTools = createTools(
+      const baseLocalTools = createTools(
         sandboxKey,
         agentsResolverKey,
         skillsResolverKey,
@@ -4800,7 +5068,7 @@ var createAgentFactory = (state, options = {}) => {
           toolOutputCacheStore
         }
       );
-      const editTool = localTools.find(
+      const editTool = baseLocalTools.find(
         (tool) => tool.definition.name === "edit"
       );
       let mcpTools = [];
@@ -4823,9 +5091,6 @@ var createAgentFactory = (state, options = {}) => {
           (0, import_logger.log)(`failed to load mcp tools: ${String(error)}`);
         }
       }
-      const tools = [...localTools, ...mcpTools];
-      state.tools = tools;
-      state.toolDefinitions = tools.map((tool) => tool.definition);
       const baseSystemPrompt = await loadSystemPrompt(ctx.workingDir);
       const withAgentsContext = appendInitialAgentsContext(
         baseSystemPrompt,
@@ -4861,12 +5126,35 @@ var createAgentFactory = (state, options = {}) => {
       const authResolver = await AuthResolver.create(state, import_logger.log);
       const provider = await authResolver.resolveProvider(modelConfig.provider);
       const providerAuth = await authResolver.resolveProviderAuth(provider);
+      const searchConfig = await resolveSearchConfig(ctx.workingDir);
+      const hostedSearchDefinitions = buildHostedSearchToolDefinitions(
+        provider,
+        searchConfig
+      );
+      if (searchConfig.mode === "native" && hostedSearchDefinitions.length === 0) {
+        throw new Error(
+          `search.mode=native is enabled, but native search is unavailable for provider '${provider}'.`
+        );
+      }
+      const useLocalSearchTool = searchConfig.mode === "local" || searchConfig.mode === "auto" && hostedSearchDefinitions.length === 0;
+      const localSearchTools = useLocalSearchTool ? [
+        createSearchTool({
+          defaultBackend: searchConfig.local.backend,
+          braveApiKeyEnv: searchConfig.local.braveApiKeyEnv
+        })
+      ] : [];
+      const tools = [...baseLocalTools, ...localSearchTools, ...mcpTools];
+      state.tools = tools;
+      state.toolDefinitions = [
+        ...tools.map((tool) => tool.definition),
+        ...hostedSearchDefinitions
+      ];
       let llm;
       switch (provider) {
         case "openai": {
           const reasoningEffort = resolveReasoningEffort(modelConfig.reasoning);
           const textVerbosity = resolveTextVerbosity(modelConfig.verbosity);
-          llm = new import_core17.ChatOpenAI({
+          llm = new import_core18.ChatOpenAI({
             clientOptions: buildOpenAiClientOptions(authResolver, providerAuth),
             ...modelConfig.name ? { model: modelConfig.name } : {},
             ...reasoningEffort ? { reasoningEffort } : {},
@@ -4877,7 +5165,7 @@ var createAgentFactory = (state, options = {}) => {
         case "openrouter": {
           const reasoningEffort = resolveReasoningEffort(modelConfig.reasoning);
           const textVerbosity = resolveTextVerbosity(modelConfig.verbosity);
-          llm = new import_core17.ChatOpenAI({
+          llm = new import_core18.ChatOpenAI({
             clientOptions: buildOpenRouterClientOptions(providerAuth),
             ...modelConfig.name ? { model: modelConfig.name } : {},
             ...reasoningEffort ? { reasoningEffort } : {},
@@ -4886,7 +5174,7 @@ var createAgentFactory = (state, options = {}) => {
           break;
         }
         case "anthropic": {
-          llm = new import_core17.ChatAnthropic({
+          llm = new import_core18.ChatAnthropic({
             clientOptions: {
               apiKey: requireApiKeyAuth("Anthropic", providerAuth)
             },
@@ -4900,11 +5188,18 @@ var createAgentFactory = (state, options = {}) => {
       const modelRegistry = await buildModelRegistry(llm, {
         strict: provider !== "openrouter"
       });
-      const agent = new import_core17.Agent({
+      const totalBudgetTrimEnabled = envTruthy(
+        process.env.CODELIA_TOOL_OUTPUT_TOTAL_TRIM
+      );
+      const agent = new import_core18.Agent({
         llm,
         tools,
+        hostedTools: hostedSearchDefinitions,
         systemPrompt,
-        modelRegistry: modelRegistry ?? import_core17.DEFAULT_MODEL_REGISTRY,
+        modelRegistry: modelRegistry ?? import_core18.DEFAULT_MODEL_REGISTRY,
+        toolOutputCache: {
+          totalBudgetTrim: totalBudgetTrimEnabled
+        },
         services: { toolOutputCacheStore },
         canExecuteTool: async (call, rawArgs, toolCtx) => {
           const decision = permissionService.evaluate(
@@ -5606,8 +5901,8 @@ var parseAuthorizationServerMetadata = (value) => {
 var buildAuthorizationServerMetadataUrl = (issuer) => {
   try {
     const parsed = new URL(issuer);
-    const path16 = parsed.pathname === "/" ? "" : parsed.pathname;
-    const basePath = path16.startsWith("/") ? path16 : `/${path16}`;
+    const path17 = parsed.pathname === "/" ? "" : parsed.pathname;
+    const basePath = path17.startsWith("/") ? path17 : `/${path17}`;
     const metadataPath = `/.well-known/oauth-authorization-server${basePath}`;
     return new URL(metadataPath, `${parsed.origin}/`).toString();
   } catch {
@@ -6264,9 +6559,8 @@ var McpManager = class {
 };
 
 // src/rpc/handlers.ts
-var import_config_loader3 = require("@codelia/config-loader");
-var import_protocol8 = require("@codelia/protocol");
-var import_storage8 = require("@codelia/storage");
+var import_protocol9 = require("@codelia/protocol");
+var import_storage9 = require("@codelia/storage");
 
 // src/constants.ts
 var SERVER_NAME = "codelia-runtime";
@@ -6642,8 +6936,7 @@ var createHistoryHandlers = ({
 };
 
 // src/rpc/model.ts
-var import_config_loader2 = require("@codelia/config-loader");
-var import_core18 = require("@codelia/core");
+var import_core19 = require("@codelia/core");
 var import_model_metadata2 = require("@codelia/model-metadata");
 var import_protocol4 = require("@codelia/protocol");
 var isSupportedProvider = (provider) => provider === "openai" || provider === "anthropic" || provider === "openrouter";
@@ -6887,7 +7180,7 @@ var buildProviderModelList = async ({
     }
   }
   const models = sortModelsByReleaseDate(
-    (0, import_core18.listModels)(import_core18.DEFAULT_MODEL_REGISTRY, provider).map((model) => model.id),
+    (0, import_core19.listModels)(import_core19.DEFAULT_MODEL_REGISTRY, provider).map((model) => model.id),
     provider,
     providerEntries
   );
@@ -6984,19 +7277,19 @@ var createModelHandlers = ({
       return;
     }
     if (provider !== "openrouter") {
-      const spec = (0, import_core18.resolveModel)(import_core18.DEFAULT_MODEL_REGISTRY, name, provider);
+      const spec = (0, import_core19.resolveModel)(import_core19.DEFAULT_MODEL_REGISTRY, name, provider);
       if (!spec) {
         sendError(id, { code: import_protocol4.RPC_ERROR_CODE.INVALID_PARAMS, message: `unknown model: ${name}` });
         return;
       }
     }
     try {
-      const configPath = resolveConfigPath();
-      await (0, import_config_loader2.updateModelConfig)(configPath, { provider, name });
+      const workingDir = state.lastUiContext?.cwd ?? state.runtimeWorkingDir ?? process.cwd();
+      const target = await updateModel(workingDir, { provider, name });
       state.agent = null;
       const result = { provider, name };
       sendResult(id, result);
-      log2(`model.set ${provider}/${name}`);
+      log2(`model.set ${provider}/${name} scope=${target.scope} path=${target.path}`);
     } catch (error) {
       sendError(id, { code: import_protocol4.RPC_ERROR_CODE.RUNTIME_INTERNAL, message: String(error) });
     }
@@ -7008,7 +7301,7 @@ var createModelHandlers = ({
 var import_protocol5 = require("@codelia/protocol");
 
 // src/rpc/run-debug.ts
-var import_core19 = require("@codelia/core");
+var import_core20 = require("@codelia/core");
 var DEBUG_MAX_CONTENT_CHARS = 2e3;
 var DEBUG_MAX_LOG_CHARS = 2e4;
 var DEBUG_MAX_EVENT_RESULT_CHARS = 500;
@@ -7025,7 +7318,7 @@ var stringifyUnknown = (value) => {
   }
 };
 var contentToDebugText = (content, maxChars) => {
-  const text = (0, import_core19.stringifyContent)(content, {
+  const text = (0, import_core20.stringifyContent)(content, {
     mode: "log",
     joiner: "\n",
     includeOtherPayload: true
@@ -7307,6 +7600,28 @@ var buildSessionState = (sessionId, runId, messages, invokeSeq) => ({
   invoke_seq: invokeSeq,
   messages
 });
+var toTimestampMs = (value) => {
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+};
+var summarizeProviderMeta = (value) => {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value.length > 80 ? `${value.slice(0, 77)}...` : value;
+  }
+  if (Array.isArray(value)) {
+    return `array(len=${value.length})`;
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    if (keys.length === 0) return "object";
+    const shown = keys.slice(0, 4).join(",");
+    return keys.length > 4 ? `object(keys=${shown},...)` : `object(keys=${shown})`;
+  }
+  return typeof value;
+};
 var createRunHandlers = ({
   state,
   getAgent,
@@ -7440,12 +7755,77 @@ var createRunHandlers = ({
       const runAbortController = new AbortController();
       activeRunAbort = { runId, controller: runAbortController };
       const sessionStore = runEventStoreFactory.create({ runId, startedAt });
-      const sessionAppend = createSessionAppender(
+      const sessionAppenderRaw = createSessionAppender(
         sessionStore,
         (error, record) => {
           log2(`session-store error (${record.type}): ${String(error)}`);
         }
       );
+      const pendingLlmRequests = /* @__PURE__ */ new Map();
+      const emitRunDiagnostics = (params2) => {
+        if (!state.diagnosticsEnabled) return;
+        try {
+          sendRunDiagnostics(params2);
+        } catch (error) {
+          log2(`run diagnostics emit failed: ${String(error)}`);
+        }
+      };
+      const sessionAppend = (record) => {
+        if (state.diagnosticsEnabled) {
+          try {
+            if (record.type === "llm.request") {
+              const modelName = record.model?.name ?? record.input.model ?? "unknown";
+              pendingLlmRequests.set(record.seq, {
+                ts: record.ts,
+                provider: record.model?.provider,
+                model: modelName
+              });
+            }
+            if (record.type === "llm.response") {
+              const request = pendingLlmRequests.get(record.seq);
+              pendingLlmRequests.delete(record.seq);
+              const usage = record.output.usage ?? null;
+              const cacheReadTokens = usage?.input_cached_tokens ?? 0;
+              const cacheCreationTokens = usage?.input_cache_creation_tokens ?? 0;
+              const inputTokens = usage?.input_tokens ?? 0;
+              const hitState = usage ? cacheReadTokens > 0 ? "hit" : "miss" : "unknown";
+              const responseTsMs = toTimestampMs(record.ts);
+              const requestTsMs = request ? toTimestampMs(request.ts) : null;
+              const latencyMs = responseTsMs !== null && requestTsMs !== null ? Math.max(0, responseTsMs - requestTsMs) : 0;
+              const model = usage?.model ?? request?.model ?? "unknown";
+              const diagnostics = {
+                run_id: runId,
+                seq: record.seq,
+                ...request?.provider ? { provider: request.provider } : {},
+                model,
+                request_ts: request?.ts ?? record.ts,
+                response_ts: record.ts,
+                latency_ms: latencyMs,
+                stop_reason: record.output.stop_reason ?? null,
+                usage,
+                cache: {
+                  hit_state: hitState,
+                  cache_read_tokens: cacheReadTokens,
+                  cache_creation_tokens: cacheCreationTokens,
+                  cache_read_ratio: usage ? cacheReadTokens / Math.max(inputTokens, 1) : null
+                },
+                cost_usd: null,
+                provider_meta_summary: summarizeProviderMeta(
+                  record.output.provider_meta
+                )
+              };
+              emitRunDiagnostics({
+                run_id: runId,
+                kind: "llm_call",
+                call: diagnostics
+              });
+            }
+          } catch (error) {
+            log2(`run diagnostics build failed: ${String(error)}`);
+          }
+        }
+        sessionAppenderRaw(record);
+      };
       state.sessionAppend = sessionAppend;
       const session = {
         run_id: runId,
@@ -7498,6 +7878,13 @@ var createRunHandlers = ({
         let finalResponse;
         let sessionSaveChain = Promise.resolve();
         let lastSessionSaveAt = 0;
+        const emitRunSummaryDiagnostics = () => {
+          emitRunDiagnostics({
+            run_id: runId,
+            kind: "run_summary",
+            summary: runtimeAgent.getUsageSummary()
+          });
+        };
         const queueSessionSave = async (reason) => {
           sessionSaveChain = sessionSaveChain.then(async () => {
             if (!sessionId) return;
@@ -7592,6 +7979,7 @@ var createRunHandlers = ({
             normalizeRunHistoryAfterCancel(runId, runtimeAgent);
           }
           await queueSessionSave("terminal");
+          emitRunSummaryDiagnostics();
           const status = state.cancelRequested ? "cancelled" : "completed";
           emitRunStatus(runId, status);
           emitRunEnd(
@@ -7604,11 +7992,13 @@ var createRunHandlers = ({
           if (state.cancelRequested || isAbortLikeError(err)) {
             normalizeRunHistoryAfterCancel(runId, runtimeAgent);
             await queueSessionSave("cancelled");
+            emitRunSummaryDiagnostics();
             emitRunStatus(runId, "cancelled", err.message || "cancelled");
             emitRunEnd(runId, "cancelled", finalResponse);
             return;
           }
           await queueSessionSave("error");
+          emitRunSummaryDiagnostics();
           emitRunStatus(runId, "error", err.message);
           appendSession({
             type: "run.error",
@@ -7788,7 +8178,313 @@ var createToolHandlers = ({
   };
 };
 
+// src/rpc/shell.ts
+var import_node_crypto6 = __toESM(require("crypto"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
+var import_node_child_process5 = require("child_process");
+var import_storage8 = require("@codelia/storage");
+var import_protocol8 = require("@codelia/protocol");
+var DEFAULT_EXCERPT_LINES = 80;
+var MAX_INLINE_OUTPUT_BYTES = 64 * 1024;
+var COMMAND_PREVIEW_CHARS = 400;
+var truncateCommandPreview = (value) => {
+  const trimmed = value.trim();
+  if (trimmed.length <= COMMAND_PREVIEW_CHARS) return trimmed;
+  return `${trimmed.slice(0, COMMAND_PREVIEW_CHARS)}...[truncated]`;
+};
+var utf8ByteLength = (value) => Buffer.byteLength(value, "utf8");
+var truncateUtf8Prefix = (value, maxBytes) => {
+  if (maxBytes <= 0 || value.length === 0) return "";
+  let bytes = 0;
+  let out = "";
+  for (const ch of value) {
+    const next = utf8ByteLength(ch);
+    if (bytes + next > maxBytes) break;
+    out += ch;
+    bytes += next;
+  }
+  return out;
+};
+var truncateUtf8Suffix = (value, maxBytes) => {
+  if (maxBytes <= 0 || value.length === 0) return "";
+  let bytes = 0;
+  const chars = Array.from(value);
+  const out = [];
+  for (let idx = chars.length - 1; idx >= 0; idx -= 1) {
+    const ch = chars[idx];
+    const next = utf8ByteLength(ch);
+    if (bytes + next > maxBytes) break;
+    out.push(ch);
+    bytes += next;
+  }
+  out.reverse();
+  return out.join("");
+};
+var excerptByLines = (value) => {
+  const lines = value.split(/\r?\n/);
+  if (lines.length <= DEFAULT_EXCERPT_LINES * 2) {
+    return value;
+  }
+  const head = lines.slice(0, DEFAULT_EXCERPT_LINES);
+  const tail = lines.slice(lines.length - DEFAULT_EXCERPT_LINES);
+  const omitted = lines.length - head.length - tail.length;
+  return [...head, `...[${omitted} lines omitted]...`, ...tail].join("\n");
+};
+var excerptByBytes = (value, maxBytes) => {
+  if (utf8ByteLength(value) <= maxBytes) return value;
+  const marker = "\n...[truncated by size]...\n";
+  const markerBytes = utf8ByteLength(marker);
+  if (maxBytes <= markerBytes + 2) {
+    return truncateUtf8Prefix(value, maxBytes);
+  }
+  const budget = maxBytes - markerBytes;
+  const headBytes = Math.floor(budget / 2);
+  const tailBytes = budget - headBytes;
+  const head = truncateUtf8Prefix(value, headBytes);
+  const tail = truncateUtf8Suffix(value, tailBytes);
+  return `${head}${marker}${tail}`;
+};
+var needsInlineTruncation = (value) => value.split(/\r?\n/).length > DEFAULT_EXCERPT_LINES * 2 || utf8ByteLength(value) > MAX_INLINE_OUTPUT_BYTES;
+var excerptText = (value) => excerptByBytes(excerptByLines(value), MAX_INLINE_OUTPUT_BYTES);
+var isWithin2 = (basePath, candidatePath) => {
+  const relative = import_node_path15.default.relative(basePath, candidatePath);
+  return relative === "" || !relative.startsWith("..") && !import_node_path15.default.isAbsolute(relative);
+};
+var resolveShellCwd = (state, requestedCwd) => {
+  const workingDir = state.runtimeWorkingDir ?? process.cwd();
+  const rootDir = state.runtimeSandboxRoot ?? workingDir;
+  if (!requestedCwd) return workingDir;
+  const resolved = import_node_path15.default.resolve(workingDir, requestedCwd);
+  if (!isWithin2(rootDir, resolved)) {
+    return null;
+  }
+  return resolved;
+};
+var runShellWithUserShell = async (command, options) => {
+  if (process.platform === "win32") {
+    return runShellCommand(command, options);
+  }
+  const shellPath = process.env.SHELL?.trim() || "";
+  if (!shellPath) {
+    return runShellCommand(command, options);
+  }
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process5.spawn)(shellPath, ["-lc", command], {
+      cwd: options.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      signal: options.signal
+    });
+    let stdout = "";
+    let stderr = "";
+    let totalBytes = 0;
+    let settled = false;
+    let timedOut = false;
+    let timeoutHandle;
+    const finish = (handler) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutHandle) clearTimeout(timeoutHandle);
+      handler();
+    };
+    const consumeChunk = (chunk, stream) => {
+      const text = chunk.toString("utf8");
+      totalBytes += Buffer.byteLength(text, "utf8");
+      if (totalBytes > options.maxOutputBytes) {
+        const error = Object.assign(
+          new Error(
+            `Command output exceeded max buffer of ${options.maxOutputBytes} bytes`
+          ),
+          {
+            code: "MAXBUFFER",
+            stdout,
+            stderr,
+            killed: true,
+            signal: "SIGTERM"
+          }
+        );
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+        finish(() => reject(error));
+        return;
+      }
+      if (stream === "stdout") stdout += text;
+      else stderr += text;
+    };
+    child.stdout?.on("data", (chunk) => consumeChunk(chunk, "stdout"));
+    child.stderr?.on("data", (chunk) => consumeChunk(chunk, "stderr"));
+    child.on("error", (error) => {
+      const enriched = Object.assign(error, {
+        stdout,
+        stderr
+      });
+      finish(() => reject(enriched));
+    });
+    child.on("close", (code, signal) => {
+      if (timedOut) {
+        const timeoutError = Object.assign(
+          new Error(
+            `Command timed out after ${Math.trunc(options.timeoutMs / 1e3)}s`
+          ),
+          {
+            code: "ETIMEDOUT",
+            stdout,
+            stderr,
+            killed: true,
+            signal: signal ?? "SIGTERM"
+          }
+        );
+        finish(() => reject(timeoutError));
+        return;
+      }
+      if (code === 0) {
+        finish(() => resolve({ stdout, stderr }));
+        return;
+      }
+      const failure = Object.assign(
+        new Error(
+          `Command failed with exit code ${code ?? "unknown"}${signal ? ` signal ${signal}` : ""}`
+        ),
+        { code, stdout, stderr, killed: false, signal }
+      );
+      finish(() => reject(failure));
+    });
+    timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      setTimeout(() => {
+        try {
+          if (!child.killed) child.kill("SIGKILL");
+        } catch {
+        }
+      }, 2e3).unref();
+    }, options.timeoutMs);
+  });
+};
+var createShellHandlers = ({
+  state,
+  log: log2
+}) => {
+  const outputCache = new import_storage8.ToolOutputCacheStoreImpl();
+  const handleShellExec = async (id, params) => {
+    const command = params?.command?.trim() ?? "";
+    if (!command) {
+      sendError(id, {
+        code: import_protocol8.RPC_ERROR_CODE.INVALID_PARAMS,
+        message: "command is required"
+      });
+      return;
+    }
+    const requestedTimeout = params?.timeout_seconds ?? DEFAULT_TIMEOUT_SECONDS;
+    if (!Number.isFinite(requestedTimeout) || requestedTimeout <= 0) {
+      sendError(id, {
+        code: import_protocol8.RPC_ERROR_CODE.INVALID_PARAMS,
+        message: "timeout_seconds must be a positive number"
+      });
+      return;
+    }
+    const timeoutSeconds = Math.max(
+      1,
+      Math.min(Math.trunc(requestedTimeout), MAX_TIMEOUT_SECONDS)
+    );
+    const cwd = resolveShellCwd(state, params?.cwd);
+    if (!cwd) {
+      sendError(id, {
+        code: import_protocol8.RPC_ERROR_CODE.INVALID_PARAMS,
+        message: "cwd is outside sandbox root"
+      });
+      return;
+    }
+    const startedAt = Date.now();
+    const commandSummary = summarizeCommand(command);
+    const commandPreview = truncateCommandPreview(command);
+    log2(
+      `shell.exec.start origin=ui_bang cwd=${cwd} timeout_s=${timeoutSeconds} command="${commandSummary}"`
+    );
+    let rawStdout = "";
+    let rawStderr = "";
+    let exitCode = 0;
+    let signal = null;
+    try {
+      const result2 = await runShellWithUserShell(command, {
+        cwd,
+        timeoutMs: timeoutSeconds * 1e3,
+        maxOutputBytes: MAX_OUTPUT_BYTES
+      });
+      rawStdout = result2.stdout;
+      rawStderr = result2.stderr;
+    } catch (error) {
+      const execError = error;
+      rawStdout = execError.stdout ?? "";
+      rawStderr = execError.stderr ?? "";
+      exitCode = typeof execError.code === "number" ? execError.code : null;
+      signal = execError.signal ?? null;
+    }
+    const stdoutTruncated = needsInlineTruncation(rawStdout);
+    const stderrTruncated = needsInlineTruncation(rawStderr);
+    const stdout = stdoutTruncated ? excerptText(rawStdout) : rawStdout;
+    const stderr = stderrTruncated ? excerptText(rawStderr) : rawStderr;
+    const combinedTruncated = stdoutTruncated || stderrTruncated;
+    let stdoutCacheId;
+    let stderrCacheId;
+    if (stdoutTruncated && rawStdout.trim()) {
+      const saved = await outputCache.save({
+        tool_call_id: `shell_exec_stdout_${import_node_crypto6.default.randomUUID()}`,
+        tool_name: "shell.exec",
+        content: rawStdout
+      });
+      stdoutCacheId = saved.id;
+    }
+    if (stderrTruncated && rawStderr.trim()) {
+      const saved = await outputCache.save({
+        tool_call_id: `shell_exec_stderr_${import_node_crypto6.default.randomUUID()}`,
+        tool_name: "shell.exec",
+        content: rawStderr
+      });
+      stderrCacheId = saved.id;
+    }
+    const result = {
+      command_preview: commandPreview,
+      exit_code: exitCode,
+      signal,
+      stdout,
+      stderr,
+      truncated: {
+        stdout: stdoutTruncated,
+        stderr: stderrTruncated,
+        combined: combinedTruncated
+      },
+      duration_ms: Date.now() - startedAt,
+      ...stdoutCacheId ? { stdout_cache_id: stdoutCacheId } : {},
+      ...stderrCacheId ? { stderr_cache_id: stderrCacheId } : {}
+    };
+    sendResult(id, result);
+    log2(
+      `shell.exec.done origin=ui_bang duration_ms=${result.duration_ms} exit_code=${String(result.exit_code)} signal=${result.signal ?? "-"}`
+    );
+  };
+  return {
+    handleShellExec
+  };
+};
+
 // src/rpc/handlers.ts
+var SUPPORTED_TUI_THEMES = /* @__PURE__ */ new Set([
+  "codelia",
+  "ocean",
+  "forest",
+  "rose",
+  "sakura",
+  "mauve",
+  "plum",
+  "iris",
+  "crimson",
+  "wine"
+]);
 var createRuntimeHandlers = ({
   state,
   getAgent,
@@ -7798,14 +8494,14 @@ var createRuntimeHandlers = ({
   runEventStoreFactory: injectedRunEventStoreFactory,
   buildProviderModelList: injectedBuildProviderModelList
 }) => {
-  const sessionStateStore = injectedSessionStateStore ?? new import_storage8.SessionStateStoreImpl({
+  const sessionStateStore = injectedSessionStateStore ?? new import_storage9.SessionStateStoreImpl({
     onError: (error, context) => {
       log2(
         `session-state ${context.action} error${context.detail ? ` (${context.detail})` : ""}: ${String(error)}`
       );
     }
   });
-  const runEventStoreFactory = injectedRunEventStoreFactory ?? new import_storage8.RunEventStoreFactoryImpl();
+  const runEventStoreFactory = injectedRunEventStoreFactory ?? new import_storage9.RunEventStoreFactoryImpl();
   const mcpManager = injectedMcpManager ?? {
     start: async () => void 0,
     list: () => ({ servers: [] })
@@ -7893,10 +8589,15 @@ var createRuntimeHandlers = ({
       log2("startup onboarding skipped (model not selected)");
       return;
     }
-    const configPath = resolveConfigPath();
-    await (0, import_config_loader3.updateModelConfig)(configPath, { provider, name: selectedModel });
+    const workingDir = state.lastUiContext?.cwd ?? state.runtimeWorkingDir ?? process.cwd();
+    const modelTarget = await updateModel(workingDir, {
+      provider,
+      name: selectedModel
+    });
     state.agent = null;
-    log2(`startup onboarding completed: ${provider}/${selectedModel}`);
+    log2(
+      `startup onboarding completed: ${provider}/${selectedModel} scope=${modelTarget.scope} path=${modelTarget.path}`
+    );
   };
   const launchStartupOnboarding = () => {
     if (startupOnboardingStarted) {
@@ -7942,17 +8643,24 @@ var createRuntimeHandlers = ({
     state,
     getAgent
   });
+  const { handleShellExec } = createShellHandlers({
+    state,
+    log: log2
+  });
   const handleInitialize = (id, params) => {
     const result = {
       protocol_version: PROTOCOL_VERSION,
       server: { name: SERVER_NAME, version: SERVER_VERSION },
       server_capabilities: {
         supports_run_cancel: true,
+        supports_run_diagnostics: true,
+        supports_shell_exec: true,
         supports_ui_requests: true,
         supports_mcp_list: true,
         supports_skills_list: true,
         supports_context_inspect: true,
         supports_tool_call: true,
+        supports_theme_set: true,
         supports_permission_preflight_events: true
       }
     };
@@ -7968,9 +8676,43 @@ var createRuntimeHandlers = ({
       `ui.context.update cwd=${params.cwd ?? "-"} file=${params.active_file?.path ?? "-"}`
     );
   };
+  const handleThemeSet = async (id, params) => {
+    if (state.activeRunId) {
+      sendError(id, { code: import_protocol9.RPC_ERROR_CODE.RUNTIME_BUSY, message: "runtime busy" });
+      return;
+    }
+    const name = params?.name?.trim().toLowerCase();
+    if (!name) {
+      sendError(id, { code: import_protocol9.RPC_ERROR_CODE.INVALID_PARAMS, message: "theme name is required" });
+      return;
+    }
+    if (!SUPPORTED_TUI_THEMES.has(name)) {
+      sendError(id, {
+        code: import_protocol9.RPC_ERROR_CODE.INVALID_PARAMS,
+        message: `unsupported theme: ${name}`
+      });
+      return;
+    }
+    const workingDir = state.lastUiContext?.cwd ?? state.runtimeWorkingDir ?? process.cwd();
+    try {
+      const target = await updateTuiTheme(workingDir, name);
+      const result = {
+        name,
+        scope: target.scope,
+        path: target.path
+      };
+      sendResult(id, result);
+      log2(`theme.set ${name} scope=${target.scope} path=${target.path}`);
+    } catch (error) {
+      sendError(id, { code: import_protocol9.RPC_ERROR_CODE.RUNTIME_INTERNAL, message: String(error) });
+    }
+  };
   const handleAuthLogout = async (id, params) => {
     if (state.activeRunId) {
-      sendError(id, { code: import_protocol8.RPC_ERROR_CODE.RUNTIME_BUSY, message: "runtime busy" });
+      sendError(id, {
+        code: import_protocol9.RPC_ERROR_CODE.RUNTIME_BUSY,
+        message: "runtime busy"
+      });
       return;
     }
     const clearSession = params?.clear_session ?? true;
@@ -7978,7 +8720,7 @@ var createRuntimeHandlers = ({
       const supportsConfirm = !!state.uiCapabilities?.supports_confirm;
       if (!supportsConfirm) {
         sendError(id, {
-          code: import_protocol8.RPC_ERROR_CODE.RUNTIME_INTERNAL,
+          code: import_protocol9.RPC_ERROR_CODE.RUNTIME_INTERNAL,
           message: "UI confirmation is required for logout"
         });
         return;
@@ -8020,7 +8762,7 @@ var createRuntimeHandlers = ({
       log2(`auth.logout session_cleared=${clearSession}`);
     } catch (error) {
       sendError(id, {
-        code: import_protocol8.RPC_ERROR_CODE.RUNTIME_INTERNAL,
+        code: import_protocol9.RPC_ERROR_CODE.RUNTIME_INTERNAL,
         message: `auth logout failed: ${String(error)}`
       });
     }
@@ -8045,6 +8787,8 @@ var createRuntimeHandlers = ({
         return handleModelSet(req.id, req.params);
       case "tool.call":
         return handleToolCall(req.id, req.params);
+      case "shell.exec":
+        return handleShellExec(req.id, req.params);
       case "mcp.list":
         await mcpManager.start?.();
         return sendResult(
@@ -8055,8 +8799,13 @@ var createRuntimeHandlers = ({
         return handleSkillsList(req.id, req.params);
       case "context.inspect":
         return handleContextInspect(req.id, req.params);
+      case "theme.set":
+        return handleThemeSet(req.id, req.params);
       default:
-        return sendError(req.id, { code: import_protocol8.RPC_ERROR_CODE.METHOD_NOT_FOUND, message: "method not found" });
+        return sendError(req.id, {
+          code: import_protocol9.RPC_ERROR_CODE.METHOD_NOT_FOUND,
+          message: "method not found"
+        });
     }
   };
   const handleNotification = (note) => {
@@ -8083,7 +8832,7 @@ var createRuntimeHandlers = ({
 };
 
 // src/runtime-state.ts
-var import_node_crypto6 = __toESM(require("crypto"), 1);
+var import_node_crypto7 = __toESM(require("crypto"), 1);
 var RuntimeState = class {
   runSeq = /* @__PURE__ */ new Map();
   uiRequestCounter = 0;
@@ -8106,11 +8855,12 @@ var RuntimeState = class {
   loadedSkillVersions = /* @__PURE__ */ new Map();
   runtimeWorkingDir = null;
   runtimeSandboxRoot = null;
+  diagnosticsEnabled = false;
   nextRunId() {
-    return import_node_crypto6.default.randomUUID();
+    return import_node_crypto7.default.randomUUID();
   }
   nextSessionId() {
-    return import_node_crypto6.default.randomUUID();
+    return import_node_crypto7.default.randomUUID();
   }
   beginRun(runId, uiContext) {
     this.activeRunId = runId;
@@ -8199,13 +8949,19 @@ var RuntimeState = class {
 };
 
 // src/runtime.ts
+var envTruthy2 = (value) => {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true";
+};
 var startRuntime = () => {
   void (async () => {
     const state = new RuntimeState();
-    const workingDir = process.env.CODELIA_SANDBOX_ROOT ? import_node_path15.default.resolve(process.env.CODELIA_SANDBOX_ROOT) : process.cwd();
+    state.diagnosticsEnabled = envTruthy2(process.env.CODELIA_DIAGNOSTICS);
+    const workingDir = process.env.CODELIA_SANDBOX_ROOT ? import_node_path16.default.resolve(process.env.CODELIA_SANDBOX_ROOT) : process.cwd();
     state.runtimeWorkingDir = workingDir;
     state.runtimeSandboxRoot = workingDir;
-    const sessionStateStore = new import_storage9.SessionStateStoreImpl({
+    const sessionStateStore = new import_storage10.SessionStateStoreImpl({
       onError: (error, context) => {
         (0, import_logger.log)(
           `Error: session-state ${context.action} error${context.detail ? ` (${context.detail})` : ""}: ${String(error)}`